מכשירי מגע

Android תומך במגוון מסכי מגע ורפידות מגע, כולל טאבלטים מבוססי סטיילוס.

מסכי מגע הם מכשירי מגע שמשויכים לצג, למשל נראה שהמשתמש מבצע מניפולציות ישירות על פריטים במסך.

לוחות מגע הם מכשירי מגע שלא משויכים למסך, כמו טאבלט דיגיטלי. לוחות מגע משמשים בדרך כלל להצבעה או מיקום עקיף מוחלט או שליטה שמבוססת על תנועה בממשק משתמש.

מכשירי מגע יכולים לכלול לחצנים שהפונקציות שלהם דומות ללחצני עכבר.

לפעמים ניתן לשנות מכשירי מגע באמצעות מגוון כלים שונים כמו אצבעות או סטיילוס, בהתאם לטכנולוגיה של חיישן המגע הבסיסי.

לפעמים נעשה שימוש במכשירי מגע כדי להטמיע מפתחות וירטואליים. לדוגמה, ב- במכשירי Android מסוימים, אזור החיישן של מסך המגע נמשך מעבר לקצה המסך משמש לשתי מטרות כחלק מלוח מקשים עם רגישות למגע.

בשל המגוון הגדול של מכשירי מגע, Android מסתמך על מספר גדול של מאפייני תצורה כדי לתאר את המאפיינים ואת ההתנהגות הרצויה של כל מכשיר.

סיווג של מכשירי מגע

מכשיר לקליטת נתונים מסווג כמכשיר עם ריבוי מגע אם שני התנאים הבאים מתקיימים התנאים הבאים מתקיימים:

• מכשיר הקלט מדווח על הנוכחות של ABS_MT_POSITION_X וגם ABS_MT_POSITION_Y צירים מוחלטים.
• במכשיר לקליטת נתונים אין לחצנים של בקר משחקים. התנאי הזה פתרון של אי בהירות לגבי משחקים מסוימים שמדווחים על צירים עם קודים שחופפת לאלה של הצירים MT.

מכשיר לקליטת נתונים מסווג כמכשיר עם נגיעה אחת אם שני מוגדרים התנאים הבאים:

• המכשיר לקליטת נתונים לא מסווג כמכשיר רב-מגע. מכשיר לקליטת נתונים מסווג כמכשיר עם נגיעה אחת או כמכשיר עם מגע מרובה, אף פעם לא גם וגם.
• מכשיר הקלט מדווח על הנוכחות של הערכים המוחלטים ABS_X ו-ABS_Y הצירים והנוכחות של קוד המפתח BTN_TOUCH.

כשמכשיר קלט מסווג כמכשיר מגע, הנוכחות מהמפתחות הווירטואליים נקבעים באמצעות ניסיון לטעון את קובץ מפת המפתחות הווירטואליים עבור המכשיר. אם יש מפת מפתחות וירטואליים, הפריסה של המקשים גם הקובץ של המכשיר נטען. מידע נוסף זמין בקטע [קובצי מפת מפתחות וירטואליים](#virtual-key-map-files) כדי לקבל מידע על המיקום והפורמט של הקבצים האלה.

בשלב הבא המערכת טוענת את קובץ התצורה של מכשיר המגע.

כל מכשירי המגע המובנים צריכים לכלול קובצי תצורה של מכשיר קלט. אם לא קיים קובץ תצורה של מכשיר קלט, המערכת בוחר הגדרות ברירת מחדל שמתאימות לשימוש כללי ציוד היקפי למגע, כמו מסכי מגע חיצוניים מסוג USB או Bluetooth HID או משטחי מגע. ברירות המחדל האלה לא מיועדות למסכי מגע מובנים עלולות להוביל להתנהגות שגויה.

לאחר טעינת התצורה של מכשיר הקלט, המערכת מסווגת להשתמש במכשיר כמסך מגע, לוח מגע או מצביע.

• מכשיר מסך מגע משמש לביצוע מניפולציה ישירה של אובייקטים מסך. המשתמש נוגע ישירות במסך, כך שהמערכת לא דורשת עלויות נוספות כדי לציין שהאובייקטים שעברו שינוי ועיבוד.
• מכשיר עם לוח מגע מספק מידע על המיקום המוחלט לאפליקציה שעוסקת בנגיעות באזור חיישן נתון. זה יכול להיות שימושי לטאבלטים דיגיטליים.
• מכשיר מצביע משמש למניפולציה עקיפה של אובייקטים באמצעות סמן. אצבעות יתפרשו כמצביע לכמה נקודות מגע תנועות. כלים אחרים, כמו סטיילוס, מפורשים באמצעות מיקומים מוחלטים. צפייה סמן עקיף ממספר נקודות מגע לקבלת מידע נוסף,.

הכללים הבאים משמשים לסיווג של מכשיר הקלט כמסך מגע, לוח מגע או התקן מצביע.

• אם המאפיין touch.deviceType מוגדר, סוג המכשיר הוא מוגדר כפי שמצוין.
• אם מכשיר הקלט מדווח על נוכחות INPUT_PROP_DIRECT מאפיין הקלט (באמצעות ioctl EVIOCGPROP), סוג המכשיר הוא מוגדר למסך מגע. התנאי הזה מניח שנגיעה ישירה של מכשירים מחוברים למסך שמחובר גם כן.
• אם מכשיר הקלט מדווח על נוכחות INPUT_PROP_POINTER מאפיין הקלט (באמצעות ioctl EVIOCGPROP), ואז סוג המכשיר מוגדר ל-pointer.
• אם מכשיר הקלט מדווח על הנוכחות של REL_X או של REL_Y צירים יחסיים, סוג המכשיר מוגדר כמשטח מגע. התנאי הזה לפתרון של אי בהירות לגבי מכשירי קלט שמורכבים גם מעכבר וגם לוח מגע. במקרה הזה, לוח המגע לא משמש לשליטה את הסמן כי העכבר כבר שולט בו.
• אחרת, סוג המכשיר מוגדר כמצביע. ברירת המחדל הזאת מבטיחה משטחי מגע שלא הוקצו לאף מטרה מיוחדת אחרת לשלוט בסמן.

לחצנים

לחצנים הם פקדים אופציונליים שאפליקציות יכולות להשתמש בהם כדי לבצע פונקציות נוספות. הלחצנים במכשירי מגע פועלים באופן דומה ללחצנים ומשמשים בעיקר במכשירי מגע מסוג מצביע בסטיילוס.

הלחצנים הבאים נתמכים:

• BTN_LEFT: בוצע מיפוי לMotionEvent.BUTTON_PRIMARY.
• BTN_RIGHT: בוצע מיפוי לMotionEvent.BUTTON_SECONDARY.
• BTN_MIDDLE: בוצע מיפוי לMotionEvent.BUTTON_MIDDLE.
• BTN_BACK ו-BTN_SIDE: בוצע מיפוי לMotionEvent.BUTTON_BACK. לחיצה על הלחצן הזה גם מסינתזת לחיצה על מקש עם קוד המפתח KeyEvent.KEYCODE_BACK
• BTN_FORWARD ו-BTN_EXTRA: ממופה ל MotionEvent.BUTTON_FORWARD. לחיצה על הלחצן הזה גם מסינתזת לחיצה על מקש עם קוד המפתח KeyEvent.KEYCODE_FORWARD.
• BTN_STYLUS: בוצע מיפוי לMotionEvent.BUTTON_SECONDARY.
• BTN_STYLUS2: בוצע מיפוי לMotionEvent.BUTTON_TERTIARY.

כלים וסוגי כלים

כלי הוא אצבע, סטיילוס או מכשיר אחר שמשמש לאינטראקציה מכשיר המגע. חלק ממכשירי המגע יכולים להבחין בין שונים של כלים.

במקומות אחרים ב-Android, כמו ב-API של MotionEvent, לרוב משתמשים בכלי למצביע.

סוגי הכלים הבאים נתמכים:

• BTN_TOOL_FINGER ו-MT_TOOL_FINGER: ממופה ל MotionEvent.TOOL_TYPE_FINGER.
• BTN_TOOL_PEN ו-MT_TOOL_PEN: ממופה ל MotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_RUBBER: בוצע מיפוי לMotionEvent.TOOL_TYPE_ERASER.
• BTN_TOOL_BRUSH: בוצע מיפוי לMotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_PENCIL: בוצע מיפוי לMotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_AIRBRUSH: בוצע מיפוי לMotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_MOUSE: בוצע מיפוי לMotionEvent.TOOL_TYPE_MOUSE.
• BTN_TOOL_LENS: בוצע מיפוי לMotionEvent.TOOL_TYPE_MOUSE.
• BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP וגם BTN_TOOL_QUADTAP: בוצע מיפוי לMotionEvent.TOOL_TYPE_FINGER.

כלים של העברת העכבר לעומת מגע

הכלים יכולים להיות במגע עם מכשיר המגע או בטווח, כשמעבירים את העכבר מעל מעליו. לא כל מכשירי המגע יכולים לזהות את הנוכחות של כלי מעבירים את העכבר מעל למכשיר המגע. מכשירים כן, כמו מכשירי סטיילוס מבוססי RF, יכול בדרך כלל לזהות מתי הכלי נמצא בטווח מוגבל של כלי הדיגיטציה.

הרכיב InputReader מבדיל בין נגיעה בכלים לבין ריחוף עם העכבר הכלים שלנו. כמו כן, אפליקציות נוגעים בכלים של מגע וכלים שמזיזים את העכבר מעל האפליקציות בדרכים שונות.

כלי מגע מדווחים לאפליקציות כאירועי מגע באמצעות MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE, MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN וגם MotionEvent.ACTION_POINTER_UP.

כלים של העברת העכבר מדווחים לאפליקציות כאירועי תנועה גנריים באמצעות MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE ו-MotionEvent.ACTION_HOVER_EXIT.

דרישות לגבי מנהלי ההתקנים של מכשירי מגע

• מנהלי התקנים של מכשירי מגע צריכים לתעד רק את הצירים וקודי המפתחות של הצירים ובלחצנים שבהם הם תומכים. רישום צירים או קודי מפתח לא נתמכים עלול לבלבל את האלגוריתם של סיווג המכשירים או לגרום למערכת לזהות את היכולות של המכשיר. לדוגמה, אם המכשיר מדווח על קוד מפתח אחד (BTN_TOUCH), המערכת מתבססת על ההנחה ש-BTN_TOUCH תמיד משמש כדי לציין אם הכלי נוגעים במסך. לכן, אין להשתמש ב-BTN_TOUCH כדי לציין שהכלי נמצא רק בטווח ומרחף.
• במכשירים עם מגע יחיד משתמשים באירועי הקלט הבאים של Linux:
  
  • ABS_X: (חובה) מדווח על קואורדינטת ה-X של הכלי.
  • ABS_Y: (חובה) מדווח על קואורדינטת ה-Y של הכלי.
  • ABS_PRESSURE: (אופציונלי) מדווח על הלחץ הפיזי שהופעל על הקצה של הכלי או של עוצמת האות של מגע המגע.
  • ABS_TOOL_WIDTH: (אופציונלי) מדווח על השטח או הרוחב של חוצה המקטעים במגע במגע או של הכלי עצמו.
  • ABS_DISTANCE: (אופציונלי) מדווח על המרחק של הכלי מהשטח. של מכשיר המגע.
  • ABS_TILT_X: (אופציונלי) מדווח על ההטיה של הכלי מפני השטח של מכשיר המגע לאורך ציר ה-X.
  • ABS_TILT_Y: (אופציונלי) מדווח על ההטיה של הכלי מפני השטח של מכשיר המגע לאורך ציר ה-Y.
  • BTN_TOUCH: (חובה) מציין אם הכלי נוגע במכשיר.
  • BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_BACK BTN_SIDE, BTN_FORWARD, BTN_EXTRA, BTN_STYLUS, BTN_STYLUS2: (אופציונלי) מצבים של דוחות.
  • BTN_TOOL_FINGER, BTN_TOOL_PEN, BTN_TOOL_RUBBER BTN_TOOL_BRUSH, BTN_TOOL_PENCIL, BTN_TOOL_AIRBRUSH, BTN_TOOL_MOUSE, BTN_TOOL_LENS, BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP, BTN_TOOL_QUADTAP: (אופציונלי) מדווח סוג הכלי.
• במכשירי מולטי מגע נעשה שימוש באירועי הקלט הבאים של Linux:
  
  • ABS_MT_POSITION_X: (חובה) מדווח על קואורדינטת ה-X של הכלי.
  • ABS_MT_POSITION_Y: (חובה) מדווח על קואורדינטת ה-Y של הכלי.
  • ABS_MT_PRESSURE: (אופציונלי) מדווח על הלחץ הפיזי שהופעל על קצה הכלי או עוצמת האות של מגע המגע.
  • ABS_MT_TOUCH_MAJOR: (אופציונלי) מדווח על האזור חוצה-המקטעים של מגע במגע, או האורך של המימד הארוך יותר של מגע במגע.
  • ABS_MT_TOUCH_MINOR: (אופציונלי) מדווח על האורך של המאפיין הקצר יותר של איש הקשר במגע. אין להשתמש בציר הזה אם הערך ABS_MT_TOUCH_MAJOR הוא לדווח על מדידת שטח.
  • ABS_MT_WIDTH_MAJOR: (אופציונלי) מדווח על האזור חוצה-המקטעים של הכלי עצמו, או אורך המימד הארוך יותר של הכלי עצמו. אל תשתמשו בציר הזה אלא אם אתם יודעים מה המידות של הכלי עצמו.
  • ABS_MT_WIDTH_MINOR: (אופציונלי) מדווח על האורך של המאפיין הקצר יותר של הכלי עצמו. אין להשתמש בציר הזה אם מתבצע דיווח על ABS_MT_WIDTH_MAJOR מדידת שטח או אם המידות של הכלי עצמו לא ידועות.
  • ABS_MT_ORIENTATION: (אופציונלי) מדווח על הכיוון של הכלי.
  • ABS_MT_DISTANCE: (אופציונלי) מדווח על המרחק של הכלי מהמקומות של מכשיר המגע.
  • ABS_MT_TOOL_TYPE: (אופציונלי) מדווח סוג הכלי בתור MT_TOOL_FINGER או MT_TOOL_PEN.
  • ABS_MT_TRACKING_ID: (אופציונלי) מדווח על המזהה לצורכי מעקב של הכלי. המזהה לצורכי מעקב הוא מספר שלם שרירותי ולא שלילי שמשמש לזיהוי ולעקוב אחרי כל כלי באופן עצמאי כשיש כמה כלים פעילים. לדוגמה, כשמספר אצבעות נוגעות במכשיר, צריך להקצות לכל אצבע מזהה לצורכי מעקב שנמצא בשימוש כל עוד האצבע נשארת במגע. מזהים לצורכי מעקב אם הכלים המשויכים אליהם יוצאים מהטווח.
  • ABS_MT_SLOT: (אופציונלי) מדווח על מזהה המיקום של הכלי, כשמשתמשים באופרטור פרוטוקול 'ריבוי מגע' של Linux 'B'. אפשר לעיין במסמכי התיעוד של הפרוטוקול Multi-Touch ב-Linux. אפשר לקבל פרטים נוספים.
  • BTN_TOUCH: (חובה) מציין אם הכלי נוגע במכשיר.
  • BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_BACK BTN_SIDE, BTN_FORWARD, BTN_EXTRA, BTN_STYLUS, BTN_STYLUS2: (אופציונלי) מצבים של דוחות.
  • BTN_TOOL_FINGER, BTN_TOOL_PEN, BTN_TOOL_RUBBER BTN_TOOL_BRUSH, BTN_TOOL_PENCIL, BTN_TOOL_AIRBRUSH, BTN_TOOL_MOUSE, BTN_TOOL_LENS, BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP, BTN_TOOL_QUADTAP: (אופציונלי) מדווח סוג הכלי.
• אם מוגדרים צירים לפרוטוקול נגיעה יחידה וגם לפרוטוקול מרובה מגע, אז נעשה שימוש רק בצירים לכמה נקודות מגע ומתעלמים מהצירים בנגיעה אחת.

• ערכי המינימום והמקסימום של ABS_X, ABS_Y, ABS_MT_POSITION_X, וצירים ABS_MT_POSITION_Y מגדירים את גבולות האזור הפעיל של המכשיר ביחידות משטח ספציפיות למכשיר. במקרה של מסך מגע, האזור הפעיל מתאר את החלק במכשיר המגע שמכסה בפועל את המסך.

  במסך מגע, המערכת מבצעת אינטרפולציה אוטומטית של המגע שדווח את המיקומים ביחידות המשטח כדי להשיג את מיקומי המגע בפיקסלים במסך אתם צריכים לבצע את החישוב הבא:

      displayX = (x - minX) * displayWidth / (maxX - minX + 1)
      displayY = (y - minY) * displayHeight / (maxY - minY + 1)
      

  מסך המגע עשוי לדווח על נגיעות מחוץ לאזור הפעיל שדווח.

  נגיעות שמתחילות מחוץ לאזור הפעיל לא נשלחות לאפליקציות אבל ניתן להשתמש בו למפתחות וירטואליים.

  נגיעות שמופעלות בתוך האזור הפעיל, או שנכנסות לתצוגה ויוצאות ממנה הפריטים מועברים לאפליקציות. כתוצאה מכך, אם נגיעה מתחילה בתוך את גבולות האפליקציה ואז עובר אל מחוץ לאזור הפעיל, האפליקציה עלול לקבל אירועי מגע עם קואורדינטות תצוגה שהן שליליות או מעבר גבולות התצוגה. ככה זה אמור להיות.

  מכשיר מגע לעולם לא יצמיד קואורדינטות מגע לגבולות אזור. אם מגע יוצא מהאזור הפעיל, יש לדווח על כך שהוא נמצא מחוץ לאזור או לא לדווח עליו כלל.

  לדוגמה, אם האצבע של המשתמש נוגעת ליד הפינה השמאלית העליונה של במסך מגע, הוא עשוי לדווח על קואורדינטה של (minX, minY). אם האצבע ממשיכה כדי לנוע מחוץ לאזור הפעיל, מסך המגע אמור להתחיל לדיווח על קואורדינטות עם רכיבים קטנים מ-minX ו-minY, כמו (minX - 2, minY - 3), או שהדיווח על המגע אמור להפסיק להיות לחלוטין. במילים אחרות, מסך המגע לא אמור לדווח (minX, minY) כשהאצבע של המשתמש באמת נוגעת מחוץ לאזור הפעיל.

  הצמדת קואורדינטות המגע לקצה המסך יוצרת תחום קשיח סביב קצה המסך, שמונע מהמערכת לעקוב בצורה חלקה אחרי תנועות שנכנסות לגבולות של אזור התצוגה או יוצאים ממנו.

• הערכים שדווחו על ידי ABS_PRESSURE או ABS_MT_PRESSURE, אם הם מדווחות בכלל, חייבות להיות לא אפס כשהכלי נוגע במכשיר ו-0 כדי לציין שהכלי מעביר את העכבר מעליו.

  פרטי הלחץ לדיווח הוא אופציונלי, אבל מומלץ מאוד. אפליקציות יכולות להשתמש בנתוני לחץ כדי להטמיע שרטוט רגיש ללחץ ואפקטים אחרים.

• הערכים שדווחו על ידי ABS_TOOL_WIDTH, ABS_MT_TOUCH_MAJOR, ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MAJOR, או הערך ABS_MT_WIDTH_MINOR לא צריך להיות אפס כשהכלי נוגע במכשיר ועד אפס אחר, אבל זה לא חובה. לדוגמה, ייתכן שמכשיר המגע יוכל למדוד את גודל המגע עם האצבעות אנשי קשר אבל לא אנשי קשר עם סטיילוס.

  פרטי גודל הדיווח הם אופציונליים, אבל מומלצים מאוד. אפליקציות יכולות להשתמש בנתוני לחץ כדי להטמיע שרטוט רגיש לגודל ואפקטים אחרים.

• הערכים שדווחו על ידי ABS_DISTANCE או ABS_MT_DISTANCE צריכים להיות מתקרב לאפס כשהכלי נוגע במכשיר. המרחק יכול להיות לא אפס גם כשהכלי נמצא במגע ישיר. הערכים המדויקים שדווחו תלויים באופן שבו החומרה מודדת מרחק.

  המידע על המרחק לדיווח הוא אופציונלי, אבל מומלץ עבור במכשירי סטיילוס.

• הערכים שדווחו על ידי ABS_TILT_X ועל ידי ABS_TILT_Y צריכים להיות אפס כשהכלי מאונך למכשיר. הטיה שאינה אפס מציינת שהכלי מחזיק בשיפוע.

  ההנחה היא שזוויות ההטיה לאורך הצירים X ו-Y נקובות במעלות ממאנך. נקודת האמצע (באורך מושלם) ניתנת ב-(max + min) / 2 בכל ציר. ערכים קטנים יותר מנקודת האמצע שמייצג הטיה למעלה או שמאלה, ערכים שגדולים מנקודת האמצע שמייצגים הטיה למטה או ימינה.

  הפונקציה InputReader ממירה את רכיבי ההטיה X ו-Y למאונכים זווית הטיה בטווח של 0 עד PI / 2 רדיאנים וזווית כיוון מישורית בטווח של -PI עד PI רדיאנים. הייצוג הזה גורם תיאור כיוון שתואם למה שמשמש לתיאור נגיעות באצבע.

  המידע על הטיה בדיווח הוא אופציונלי, אבל מומלץ למכשירי סטיילוס.

• אם סוג הכלי מדווח על ידי ABS_MT_TOOL_TYPE, הוא מחליף כל כלי סוג פרטי שדווח על ידי BTN_TOOL_*. אם אין בכלל מידע זמין על סוגי כלי, ברירת המחדל של סוג הכלי היא MotionEvent.TOOL_TYPE_FINGER

• המערכת קובעת אם כלי מסוים פעיל לפי התנאים הבאים:

  • כשמשתמשים בפרוטוקול נגיעה אחת, הכלי פעיל אם הוא BTN_TOUCH, או הערך BTN_TOOL_* הוא 1.

    התנאי הזה רומז על כך ש-InputReader צריך לכלול לפחות חלק מידע על אופי הכלי, בין שהוא נוגע, או לפחות את סוג הכלי שלו. אם לא קיים מידע זמין, ההנחה היא שהכלי לא פעיל (מחוץ לטווח).

  • כשמשתמשים בפרוטוקול רב המגע 'A', הכלי פעיל בכל פעם שהוא מופיעה בדוח הסנכרון האחרון. כשהכלי מפסיק להופיע לסנכרן דוחות והוא מפסיק להיות קיים.
  • כשמשתמשים בפרוטוקול רב המגע 'ב', הכלי פעיל כל עוד יש בו משבצת פעילה. אחרי שהחריץ הוסר, הכלי כבר לא קיים.
• בהתאם לתנאים הבאים, נקבע שכלי מסוים מעביר את העכבר מעליו:
  
  • אם הכלי הוא BTN_TOOL_MOUSE או BTN_TOOL_LENS, אז הכלי לא מעביר את העכבר מעליו, גם אם אחד מהתנאים הבאים מתקיים.
  • אם הכלי פעיל והנהג מדווח על פרטי לחץ, והלחץ המדווח הוא אפס, אז הכלי מרחף.
  • אם הכלי פעיל והנהג תומך בקוד המפתח BTN_TOUCH הערך של BTN_TOUCH הוא אפס, ואז הכלי מעביר את העכבר מעליו.
• InputReader תומך בפרוטוקול רב-מגע 'A' ו-B. נהגים חדשים צריך להשתמש באות B אבל שניהם עובדים.

• החל מ-Android 4.0, ייתכן שצריך לשנות את מנהלי ההתקנים של מסך המגע כדי לעמוד בדרישות של מפרט פרוטוקול הקלט של Linux.

  יכול להיות שיידרשו השינויים הבאים:

  • כשכלי הופך ללא פעיל (האצבע עוברת 'למעלה'), הוא אמור להפסיק להופיע בדוחות הבאים בנושא סנכרון עם מספר נקודות מגע. כשכל הכלים מפסיקים להיות פעילים (כל האצבעות עוברות 'למעלה'), הנהג צריך לשלוח חבילת דוח סנכרון ריקה, כמו SYN_MT_REPORT ואחריו SYN_REPORT.

    גרסאות קודמות של Android צפויות "למעלה" אירועים שידווחו על ידי שליחה ערך לחץ של 0. ההתנהגות הקודמת לא הייתה תואמת מפרט פרוטוקול הקלט של Linux ואינו נתמך יותר.

  • יש לדווח על מידע על לחץ פיזי או על עוצמת האות באמצעות ABS_MT_PRESSURE

    גרסאות קודמות של Android אוחזרו פרטי לחץ החל מ-ABS_MT_TOUCH_MAJOR. ההתנהגות הקודמת לא הייתה תואמת מפרט פרוטוקול הקלט של Linux ואינו נתמך יותר.

  • דיווח על גודל המגע צריך להתבצע באמצעות ABS_MT_TOUCH_MAJOR.

    גרסאות קודמות של Android אוחזרו פרטי מידות מ- ABS_MT_TOOL_MAJOR ההתנהגות הקודמת לא הייתה תואמת מפרט פרוטוקול הקלט של Linux ואינו נתמך יותר.

  מנהלי התקנים של מכשירי מגע כבר לא צריכים התאמות אישיות ספציפיות ל-Android. מערכת Android יכולה לתמוך בפרוטוקול הקלט הרגיל של Linux, מגוון רחב יותר של ציוד היקפי למגע, כמו מכשיר ממשק אנושי (HID) חיצוני מולטי-טאץ' מסכי מגע באמצעות מנהלי התקנים.

פעולת מכשיר מגע

בהמשך מוצג סיכום קצר של פעולת מכשיר המגע ב-Android.

1. EventHub קורא אירועים גולמיים מהנהג/ת evdev.
2. InputReader צורך את האירועים הגולמיים ומעדכנת את המצב הפנימי לגבי את המיקום ומאפיינים אחרים של כל כלי. הוא גם עוקב אחרי מצבי הלחצן.
3. אם בוצעה לחיצה או שחרור על ידי לחיצה על BACK או FORWARD, האפליקציה InputReader שולחת התראה אל InputDispatcher על האירוע המרכזי.
4. InputReader קובע אם בוצעה לחיצה על מקש וירטואלי. אם כן, הוא מודיע ל-InputDispatcher על האירוע המרכזי.
5. InputReader קובע אם המגע הופעל בתוך גבולות התצוגה. אם כן, תישלח הודעה אל InputDispatcher על אירוע המגע.
6. אם אין כלים לנגיעה אבל יש לפחות כלי אחד להעברת העכבר, InputReader מודיע ל-InputDispatcher על האירוע של העברת העכבר.
7. אם סוג מכשיר המגע הוא מצביע, InputReader מעביר את הסמן זיהוי תנועה, מזיז את הסמן והנקודות בהתאם ומודיע InputDispatcher על אירוע המצביע.
8. האפליקציה InputDispatcher משתמשת בפונקציה WindowManagerPolicy כדי לקבוע אם צריך לשלוח את האירועים ואם הם צריכים להוציא את המכשיר ממצב שינה. לאחר מכן, InputDispatcher מעביר את האירועים לאפליקציות המתאימות.

תצורת מכשיר המגע

התנהגות מכשיר המגע נקבעת לפי הצירים, הלחצנים, מאפייני הקלט, הגדרת המכשיר לקליטת נתונים, מפת המפתחות הווירטואליים ופריסת המפתחות.

בקטעים הבאים יש פרטים נוספים על הקבצים השתתפות בהגדרת המקלדת:

• הזנת קובצי תצורה של המכשיר
• קובצי מפת מפתחות וירטואליים

מאפיינים

המערכת מסתמכת על מאפיינים רבים של תצורת מכשיר קלט כדי להגדיר ולכייל את ההתנהגות של מכשיר המגע.

אחת הסיבות לכך היא שהרבה פעמים מנהלי ההתקנים של מכשירי מגע מדווחים את המאפיינים של נגיעות כשמשתמשים ביחידות ספציפיות למכשיר.

לדוגמה, במכשירי מגע רבים מודדים את אזור המגע במגע באמצעות קנה מידה פנימי ספציפי למכשיר, כמו המספר הכולל של חיבורי חיישנים שהופעלו על ידי המגע. ערך הגודל הגולמי הזה להיות חסרת משמעות לאפליקציות, כי הן צריכות לדעת על הגודל הפיזי ומאפיינים אחרים של צמתים החיישנים של מכשירי המגע.

המערכת משתמשת בפרמטרים של כיול שמקודדים בתצורת מכשיר הקלט כדי לפענח, לשנות ולנרמל את הערכים שמדווחים על ידי המגע למכשיר לייצוג רגיל פשוט יותר שאפליקציות יכולות להבין.

מוסכמות התיעוד

למטרות תיעוד, אנחנו משתמשים במוסכמות הבאות כדי לתאר הערכים שבהם המערכת משתמשת במהלך תהליך הכיול.

ערכי ציר גולמיים

הביטויים הבאים מציינים את הערכים הגולמיים שמדווחים על ידי המגע מנהל התקן של המכשיר כאירועים של EV_ABS.

raw.x

הערך של הציר ABS_X או ABS_MT_POSITION_X.

raw.y

הערך של הציר ABS_Y או ABS_MT_POSITION_Y.

raw.pressure

הערך של הציר ABS_PRESSURE או ABS_MT_PRESSURE, או 0 אם לא זמינים.

raw.touchMajor

הערך של ציר ABS_MT_TOUCH_MAJOR, או 0 אם הוא לא זמין.

raw.touchMinor

הערך של ציר ABS_MT_TOUCH_MINOR, או raw.touchMajor אם לא זמינים.

raw.toolMajor

הערך של הציר ABS_TOOL_WIDTH או ABS_MT_WIDTH_MAJOR, או 0 אם לא זמינים.

raw.toolMinor

הערך של ציר ABS_MT_WIDTH_MINOR, או raw.toolMajor אם הוא לא זמינים.

raw.orientation

הערך של ציר ABS_MT_ORIENTATION, או 0 אם הוא לא זמין.

raw.distance

הערך של הציר ABS_DISTANCE או ABS_MT_DISTANCE, או 0 אם לא זמינים.

raw.tiltX

הערך של ציר ABS_TILT_X, או 0 אם הוא לא זמין.

raw.tiltY

הערך של ציר ABS_TILT_Y, או 0 אם הוא לא זמין.

טווחי צירים גולמיים

הביטויים הבאים מציינים את הגבולות של ערכים גולמיים. הם התקבלו באמצעות קריאה ל-EVIOCGABS ioctl לכל ציר.

raw.*.min

הערך המינימלי הכולל של הציר הגולמי.

raw.*.max

הערך המקסימלי הכולל של הציר הגולמי.

raw.*.range

שווה ערך ל-raw.*.max - raw.*.min.

raw.*.fuzz

הדיוק של הציר הגולמי. לדוגמה: fuzz = 1 מעיד שהערכים מדויקים ליחידה אחת (+/- 1).

raw.width

הרוחב הכולל של אזור המגע, שווה ערך ל-raw.x.range + 1.

raw.height

הגובה הכולל של אזור המגע, שווה ערך ל-raw.y.range + 1.

טווחי פלט

הביטויים הבאים מציינים את המאפיינים של מערכת הקואורדינטות של הפלט. המערכת משתמשת באינטרפולציה ליניארית כדי לתרגם את פרטי מיקום המגע מ: את יחידות המשטח המשמשות את מכשיר המגע ביחידות הפלט מדווחות לאפליקציות כמו פיקסלים של מסך.

output.width

רוחב הפלט. במסכי מגע (שמשויכים למסך), הוא רוחב התצוגה בפיקסלים. למשטחי מגע (לא משויכים למסך), רוחב הפלט שווה ל-raw.width, שמציין שאין אינטרפולציה לביצוע.

output.height

גובה הפלט. במסכי מגע (שמשויכים למסך), הוא גובה התצוגה בפיקסלים. למשטחי מגע (לא משויכים למסך), גובה הפלט שווה ל-raw.height, שמציין שאין אינטרפולציה שבוצעו.

output.diag

אורך האלכסון של מערכת הקואורדינטות של הפלט, שווה ערך ל- sqrt(output.width ^2 + output.height ^2).

הגדרה בסיסית

מממפה של קלט המגע משתמש במאפייני תצורה רבים במכשיר הקלט את קובץ התצורה כדי לציין ערכי כיול. הטבלה הבאה מתארת כמה מאפייני תצורה למטרה כללית. כל שאר המאפיינים מתוארים בסעיפים הבאים וגם בשדות שבהם הם משמשים לכיול.

touch.deviceType

הגדרה: touch.deviceType = touchScreen | touchPad | pointer | default

ההגדרה הזאת קובעת את סוג מכשיר המגע.

• אם הערך הוא touchScreen, מכשיר המגע משויך למסך מגע באמצעות מסך.

• אם הערך הוא touchPad, מכשיר המגע הוא משטח מגע שלא משויך באמצעות מסך.

• אם הערך הוא pointer, מכשיר המגע הוא משטח מגע שלא משויך במסך, והתנועות שלו משמשות תנועות עקיפות של מצביע עם כמה נקודות מגע.

• אם הערך הוא default, המערכת תזהה באופן אוטומטי את סוג המכשיר בהתאם לאלגוריתם הסיווג.

פרטים נוספים זמינים בקטע סיווג על האופן שבו סוג המכשיר משפיע על ההתנהגות של מכשיר המגע.

ב-Android 3 ובגרסאות קודמות, כל מכשירי המגע מניחים שהם מסכי מגע.

touch.orientationAware

הגדרה: touch.orientationAware = 0 | 1

המדיניות הזו מציינת אם מכשיר המגע יגיב לשינויי כיוון התצוגה.

• אם הערך הוא 1, מיקומי המגע שמדווחים על ידי מכשיר המגע מסובבים בכל פעם שכיוון המסך משתנה.

• אם הערך הוא 0, מיקומי המגע שדווחו על ידי מכשיר המגע חסינים כדי להציג שינויים בכיוון.

ערך ברירת המחדל הוא 1 אם המכשיר הוא מסך מגע, 0 אחרת.

המערכת יוצרת הבחנה בין מסכי מגע ומסכים פנימיים וחיצוניים. מסך מגע פנימי עם מוּדעוּת לכיוון מסוים מסתובב על סמך הכיוון של המסך הפנימי. מסך מגע חיצוני עם זיהוי כיוון מסתובב בהתאם לכיוון של המסך החיצוני.

המוּדעוּת לכיוון המיקום משמשת לתמיכה בסיבוב של מסכי מגע במכשירים כמו Nexus One. לדוגמה, כשהמכשיר מסובב ב-90 מעלות בכיוון השעון מהכיוון הטבעי שלו, המיקומים המוחלטים של המגע ממופים מחדש שנגיעה בפינה השמאלית העליונה של מערכת הקואורדינטות המוחלטת של מסך המגע מדווח כנגיעה בפינה השמאלית העליונה של מערכת הקואורדינטות המסובבת של המסך. כך נדווח על נגיעות באמצעות אותה מערכת קואורדינטות שבהן משתמשים כדי לשרטט את האלמנטים החזותיים שלהם.

לפני Honeycomb, ההנחה היא שכל מכשירי המגע מודעים לכיוון מסוים.

touch.gestureMode

הגדרה: touch.gestureMode = pointer | spots | default

קביעת מצב המצגת לתנועות של מצביע העכבר. מאפיין ההגדרות האישיות הזה רלוונטית רק כשמכשיר המגע הוא מסוג מצביע.

• אם הערך הוא pointer, התנועות של לוח המגע מוצגות באמצעות סמן בדומה לסמן העכבר.

• אם הערך הוא spots, התנועות של לוח המגע מוצגות על ידי עוגן שמייצג את מרכז התנועה וסדרה של נקודות מעגלות שמייצגים את המיקום של אצבעות בודדות.

ערך ברירת המחדל הוא pointer כשמאפיין הקלט INPUT_PROP_SEMI_MT מוגדר, או spots אחרת.

שדות X ו-Y

השדות X ו-Y מספקים מידע על המיקום במרכז של אזור המגע.

חישוב

החישוב פשוט: פרטי המיקום ממנהל המגע הם עבר אינטרפולציה לינארית למערכת הקואורדינטות של הפלט.

xScale = output.width / raw.width
yScale = output.height / raw.height

If not orientation aware or screen rotation is 0 degrees:
output.x = (raw.x - raw.x.min) * xScale
output.y = (raw.y - raw.y.min) * yScale
Else If rotation is 90 degrees:
    output.x = (raw.y - raw.y.min) * yScale
    output.y = (raw.x.max - raw.x) * xScale
Else If rotation is 180 degrees:
    output.x = (raw.x.max - raw.x) * xScale
    output.y = (raw.y.max - raw.y) * yScale
Else If rotation is 270 degrees:
    output.x = (raw.y.max - raw.y) * yScale
    output.y = (raw.x - raw.x.min) * xScale
End If

TouchMajor, TouchMinor, ToolMajor, ToolMinor, שדות גודל

השדות touchMajor ו-touchMinor מתארים את המאפיינים המשוערים. של אזור המגע ביחידות הפלט (בפיקסלים).

השדות toolMajor ו-toolMinor מתארים את המאפיינים המשוערים. של הכלי עצמו ביחידות פלט (פיקסלים).

השדה size מתאר את הגודל המנורמל של המגע ביחס ל את המגע הגדול ביותר שמכשיר המגע יכול לחוש. הקטן ביותר הגודל האפשרי המנורמל הוא 0.0 (ללא מגע או שאינו ניתן למדידה), והגודל הגדול ביותר הגודל האפשרי המנורמל הוא 1.0 (שטח החיישן רווי).

אם אפשר למדוד גם את האורך המשוער וגם את הרוחב, אז את השדה touchMajor מציין את המאפיין הארוך יותר והשדה touchMinor מציין את המאפיין הקצר יותר של אזור הקשר. כשאפשר למדוד רק את הקוטר המשוער של שטח המגע, אז השדות touchMajor ו-touchMinor שווים.

באופן דומה, השדה toolMajor מציין את המאפיין הארוך יותר toolMinor מציין את המימד הקצר יותר של האזור חוצה המקטעים של הכלי.

אם גודל המגע לא זמין אבל גודל הכלי זמין, אז גודל הכלי מוגדר שווה לגודל המגע. לעומת זאת, אם גודל הכלי לא זמין אבל גודל המגע זמין, גודל המגע מוגדר שווה לגודל הכלי.

מכשירי מגע מודדים את גודל המגע וגודל הכלי בדרכים שונות או מדווחים עליהם. ההטמעה הנוכחית תומכת בשלושה סוגים שונים של מדידות: קוטר, שטח ותיבה תוחמת גאומטרית ביחידות פני שטח.

הגדרה: touch.size.calibration = none | geometric | diameter | area | default

מציין את סוג המדידה שמשמש את מנהל המגע לדיווח על גודל המגע וגודל הכלי.

• אם הערך הוא none, הגודל מוגדר כאפס.

• אם הערך הוא geometric, ההנחה היא שהגודל יצוין באותו יחידות שטח כמו המיקום, כך שקנה המידה שלו יהיה זהה.

• אם הערך הוא diameter, ההנחה היא שהגודל הוא פרופורציונלי הקוטר (רוחב) של המגע או הכלי.

• אם הערך הוא area, ההנחה היא שהגודל הוא פרופורציונלי האזור של המגע או הכלי.

• אם הערך הוא default, המערכת תשתמש בכיול geometric אם הציר raw.touchMajor או raw.toolMajor זמין, אחרת נעשה בו שימוש כיול none.

touch.size.scale.

הגדרה: touch.size.scale = <a מספר נקודה צפה (floating-point) לא שלילי>

מציינת גורם לקביעת קנה מידה קבוע שמשמש לכיול.

ערך ברירת המחדל הוא 1.0.

touch.size.bias

הגדרה: touch.size.bias = <a מספר נקודה צפה (floating-point) לא שלילי>

מציינת ערך של הטיה קבועה שנעשה בו שימוש בכיול.

ערך ברירת המחדל הוא 0.0.

touch.size.isSummed

הגדרה: touch.size.isSummed = 0 | 1

מציינת אם המידה מדווחת כסכום המידות של כל המידות אנשי קשר פעילים, או מדווח בנפרד לגבי כל איש קשר.

• אם הערך הוא 1, הגודל המדווח מחולק במספר אנשי הקשר לפני השימוש.

• אם הערך הוא 0, המערכת תשתמש בגודל שדווח כפי שהוא.

ערך ברירת המחדל הוא 0.

חלק ממכשירי המגע, בעיקר "Semi-MT" לא יכולים להבחין מאפיינים נפרדים של מספר אנשי קשר כדי שהם מדווחים על מדידת גודל שמייצג את השטח או הרוחב הכולל שלהם. יש להגדיר את המאפיין הזה רק כ- 1 למכשירים כאלה. אם יש ספק, כדאי להגדיר את הערך כ-0.

חישוב

החישוב של הערכים touchMajor, touchMinor, toolMajor toolMinor, ו-size תלויים בפרמטרים של הכיול שצוינו.

If raw.touchMajor and raw.toolMajor are available:
    touchMajor = raw.touchMajor
    touchMinor = raw.touchMinor
    toolMajor = raw.toolMajor
    toolMinor = raw.toolMinor
Else If raw.touchMajor is available:
    toolMajor = touchMajor = raw.touchMajor
    toolMinor = touchMinor = raw.touchMinor
Else If raw.toolMajor is available:
    touchMajor = toolMajor = raw.toolMajor
    touchMinor = toolMinor = raw.toolMinor
Else
    touchMajor = toolMajor = 0
    touchMinor = toolMinor = 0
    size = 0
End If

size = avg(touchMajor, touchMinor)

If touch.size.isSummed == 1:
    touchMajor = touchMajor / numberOfActiveContacts
    touchMinor = touchMinor / numberOfActiveContacts
    toolMajor = toolMajor / numberOfActiveContacts
    toolMinor = toolMinor / numberOfActiveContacts
    size = size / numberOfActiveContacts
End If

If touch.size.calibration == "none":
    touchMajor = toolMajor = 0
    touchMinor = toolMinor = 0
    size = 0
Else If touch.size.calibration == "geometric":
    outputScale = average(output.width / raw.width, output.height / raw.height)
    touchMajor = touchMajor * outputScale
    touchMinor = touchMinor * outputScale
    toolMajor = toolMajor * outputScale
    toolMinor = toolMinor * outputScale
Else If touch.size.calibration == "area":
    touchMajor = sqrt(touchMajor)
    touchMinor = touchMajor
    toolMajor = sqrt(toolMajor)
    toolMinor = toolMajor
Else If touch.size.calibration == "diameter":
    touchMinor = touchMajor
    toolMinor = toolMajor
End If

If touchMajor != 0:
    output.touchMajor = touchMajor * touch.size.scale + touch.size.bias
Else
    output.touchMajor = 0
End If

If touchMinor != 0:
    output.touchMinor = touchMinor * touch.size.scale + touch.size.bias
Else
    output.touchMinor = 0
End If

If toolMajor != 0:
    output.toolMajor = toolMajor * touch.size.scale + touch.size.bias
Else
    output.toolMajor = 0
End If

If toolMinor != 0:
    output.toolMinor = toolMinor * touch.size.scale + touch.size.bias
Else
    output.toolMinor = 0
End If

output.size = size

שדה לחץ

השדה pressure מתאר את הלחץ הפיזי המשוער שחל על מכשיר מגע כערך מנורמל בין 0.0 (ללא מגע) ל-1.0 (לחץ רגיל).

לחץ של אפס מציין שהכלי מרחף.

touch.pressure.calibration

הגדרה: touch.pressure.calibration = none | physical | amplitude | default

מציין את סוג המדידה שמשמש את מנהל המגע לדיווח על הלחץ.

• אם הערך הוא none, הלחץ לא ידוע ולכן הוא מוגדר ל-1.0 נגיעה ו-0.0 בעת העברת העכבר.

• אם הערך הוא physical, ההנחה היא שציר הלחץ מודד את עוצמה פיזית של לחץ שמופעלת על לוח המגע.

• אם הערך הוא amplitude, ההנחה היא שציר הלחץ מודד את האות משרעת (amplitude), שקשורה לגודל של איש הקשר וללחץ שמופעל.

• אם הערך הוא default, המערכת תשתמש בכיול physical אם ציר הלחץ הזמין, אחרת משתמש ב-none.

Touch.pressure.scale

הגדרה: touch.pressure.scale = <a מספר נקודה צפה (floating-point) לא שלילי>

מציינת גורם לקביעת קנה מידה קבוע שמשמש לכיול.

ערך ברירת המחדל הוא 1.0 / raw.pressure.max.

חישוב

החישוב של השדה pressure תלוי בפרמטרים של הכיול שצוינו.

If touch.pressure.calibration == "physical" or "amplitude":
    output.pressure = raw.pressure * touch.pressure.scale
Else
    If hovering:
        output.pressure = 0
    Else
        output.pressure = 1
    End If
End If

שדות כיוון והטיה

השדה orientation מתאר את הכיוון של המגע והכלי ומדידה זוויתית. כיוון של 0 מציין שהציר הראשי במאונך, -PI/2 מציין שהציר הראשי מכוון לשמאל, PI/2 מציין שהציר הראשי מכוון לימין. כשסטיילוס קיים, ניתן לתאר את טווח הכיוונים בטווח מלא של מעגלים מ--PI או PI.

בשדה tilt מתוארת נטייה של הכלי כמדידה זוויתית. הטיה של 0 מציינת שהכלי מאונך לפני השטח. הטיה של PI/2 מציינת שהכלי שטוח על פני השטח.

touch.orientation.calibration

הגדרה: touch.orientation.calibration = none | interpolated | vector | default

מציינת את סוג המדידה שמשמש את מנהל המגע לדיווח על הכיוון.

• אם הערך הוא none, הכיוון לא ידוע ולכן הוא מוגדר ל-0.
• אם הערך הוא interpolated, הכיוון מתבצע באופן לינארי הערך הגולמי של raw.orientation.min ממופה אל -PI/2 וערך גולמי של raw.orientation.max מפותה לPI/2. הערך המרכזי של (raw.orientation.min + raw.orientation.max) / 2 ממופה ל0.
• אם הערך הוא vector, הכיוון מתפרש כייצוג וקטור ארוז של שני שדות חתומים של 4 ביט. הייצוג הזה נמצא בשימוש בפרוטוקול מבוסס אובייקטים של Atmel חלקים. לאחר הפענוח, הווקטור מניב זווית וודאות הכיוון גודל. מידת הסמך משמשת להתאמה של נתוני הגודל, אלא אם הוא גאומטרי.
• אם הערך הוא default, המערכת משתמשת בכיול interpolated אם ציר הכיוון זמין, אחרת המערכת תשתמש ב-none.

חישוב

החישוב של השדות orientation ו-tilt תלוי שצוינו בפרמטרים של כיול ובקלט זמין.

If touch.tiltX and touch.tiltY are available:
    tiltXCenter = average(raw.tiltX.min, raw.tiltX.max)
    tiltYCenter = average(raw.tiltY.min, raw.tiltY.max)
    tiltXAngle = (raw.tiltX - tiltXCenter) * PI / 180
    tiltYAngle = (raw.tiltY - tiltYCenter) * PI / 180
    output.orientation = atan2(-sin(tiltXAngle), sinf(tiltYAngle))
    output.tilt = acos(cos(tiltXAngle) * cos(tiltYAngle))
Else If touch.orientation.calibration == "interpolated":
    center = average(raw.orientation.min, raw.orientation.max)
    output.orientation = PI / (raw.orientation.max - raw.orientation.min)
    output.tilt = 0
Else If touch.orientation.calibration == "vector":
    c1 = (raw.orientation & 0xF0) >> 4
    c2 = raw.orientation & 0x0F

    If c1 != 0 or c2 != 0:
        If c1 >= 8 Then c1 = c1 - 16
        If c2 >= 8 Then c2 = c2 - 16
        angle = atan2(c1, c2) / 2
        confidence = sqrt(c1*c1 + c2*c2)

        output.orientation = angle

        If touch.size.calibration == "diameter" or "area":
            scale = 1.0 + confidence / 16
            output.touchMajor *= scale
            output.touchMinor /= scale
            output.toolMajor *= scale
            output.toolMinor /= scale
        End If
    Else
        output.orientation = 0
    End If
    output.tilt = 0
Else
    output.orientation = 0
    output.tilt = 0
End If

If orientation aware:
    If screen rotation is 90 degrees:
        output.orientation = output.orientation - PI / 2
    Else If screen rotation is 270 degrees:
        output.orientation = output.orientation + PI / 2
    End If
End If

שדה מרחק

בשדה distance מתואר המרחק בין הכלי לבין מכשיר המגע פלטפורמה. הערך 0.0 מציין קשר ישיר, וערכים גדולים יותר מציינים במרחק הולך וגובר מפני השטח.

touch.distance.calibration

הגדרה: touch.distance.calibration = none | scaled | default

מציין את סוג המדידה שמשמש את מנהל המגע לדיווח על המרחק.

• אם הערך הוא none, המרחק לא ידוע ולכן הוא מוגדר ל-0.

• אם הערך הוא scaled, המרחק המדווח מוכפל ב- שגורם לקביעת קנה מידה קבוע.

• אם הערך הוא default, המערכת תשתמש בכיול scaled אם ציר המרחק זמין. אחרת, ייעשה שימוש ב-none.

touch.distance.scale

הגדרה: touch.distance.scale = <a מספר נקודה צפה (floating-point) לא שלילי>

מציינת גורם לקביעת קנה מידה קבוע שמשמש לכיול.

ערך ברירת המחדל הוא 1.0.

חישוב

החישוב של השדה distance תלוי בכיול שצוין .

If touch.distance.calibration == "scaled":
    output.distance = raw.distance * touch.distance.scale
Else
    output.distance = 0
End If

דוגמה

# Input device configuration file for a touch screen that supports pressure,
# size and orientation. The pressure and size scale factors were obtained
# by measuring the characteristics of the device itself and deriving
# useful approximations based on the resolution of the touch sensor and the
# display.
#
# Note that these parameters are specific to a particular device model.
# Different parameters need to be used for other devices.

# Basic Parameters
touch.deviceType = touchScreen
touch.orientationAware = 1

# Size
# Based on empirical measurements, we estimate the size of the contact
# using size = sqrt(area) * 28 + 0.
touch.size.calibration = area
touch.size.scale = 28
touch.size.bias = 0
touch.size.isSummed = 0

# Pressure
# Driver reports signal strength as pressure.
#
# A normal index finger touch typically registers about 80 signal strength
# units although we don't expect these values to be accurate.
touch.pressure.calibration = amplitude
touch.pressure.scale = 0.0125

# Orientation
touch.orientation.calibration = vector

הערות בנושא תאימות

מאפייני התצורה של מכשירי מגע השתנו באופן משמעותי .Android Ice Cream סנדוויץ' 4.0 כל קובצי התצורה של מכשיר הקלט למגע צריך לעדכן את המכשירים כדי להשתמש במאפיינים החדשים של מערך הגדרות אישיות.

יכול להיות שמנהלי התקנים ישנים יותר למכשירי מגע נדרשים גם כן עודכן.

קובצי מפת מפתחות וירטואליים

ניתן להשתמש במכשירי מגע כדי להטמיע מפתחות וירטואליים.

יש כמה דרכים לעשות זאת, בהתאם ליכולות של שלט רחוק מגע. ניתן להגדיר בקרי מגע מסוימים באופן ישיר להטמיע אותם מקשים רכים על ידי הגדרת רישומי קושחה. במקרים אחרים רצוי לבצע את המיפוי מקואורדינטות של מגע לקודי מפתחות בתוכנה.

כשמטמיעים מפתחות וירטואליים בתוכנה, הליבה צריכה לייצא מפת מפתחות וירטואליים שנקרא virtualkeys.<devicename> כנכס לוח. לדוגמה, אם מנהלי ההתקנים של מכשירי מסך המגע מדווחים על שם המכשיר כ"טעיתי" לאחר מכן קובץ המפה של המפתח הווירטואלי חייב לכלול נתיב /sys/board_properties/virtualkeys.touchyfeely

קובץ מפה של מפתח וירטואלי מתאר את הקואורדינטות ואת הקודים של מפתחות Linux של מפתחות וירטואליים במסך המגע.

בנוסף לקובץ המפה של המפתח הווירטואלי, חייבת להיות פריסת מפתח תואמת של קובץ מפת התווים של הקובץ והמפתח כדי למפות את קודי המפתח של Linux לקודי מפתח של Android כדי לציין את סוג המקלדת (בדרך כלל SPECIAL_FUNCTION).

תחביר

קובץ מפה של מפתח וירטואלי הוא קובץ טקסט פשוט שמורכב מרצף של מפתח וירטואלי תיאורי פריסה, שמופרדים באמצעות שורות חדשות או באמצעות נקודתיים.

שורות התגובה מתחילות בתו '#' וממשיכים עד לסוף השורה.

כל מפתח וירטואלי מתואר באמצעות 6 רכיבים המופרדים בנקודתיים:

• 0x01: קוד גרסה. תמיד חייב להיות 0x01.
• <קוד מפתח של Linux>: קוד המפתח של Linux של המפתח הווירטואלי.
• <centerX>: קואורדינטת ה-X פיקסל של מרכז המפתח הווירטואלי.
• <centerY>: קואורדינטת הפיקסלים של Y של מרכז המפתח הווירטואלי.
• <width>: הרוחב של המפתח הווירטואלי בפיקסלים.
• <height>: הגובה של המפתח הווירטואלי בפיקסלים.

כל הקואורדינטות והגדלים מצוינים מבחינת מערכת הקואורדינטות של התצוגה.

הנה קובץ מפה עם מפתח וירטואלי שכתוב בשורה אחת.

# All on one line
0x01:158:55:835:90:55:0x01:139:172:835:125:55:0x01:102:298:835:115:55:0x01:217:412:835:95:55

אפשר גם לכתוב את אותו קובץ מפה של מפתח וירטואלי בכמה קווים.

# One key per line
0x01:158:55:835:90:55
0x01:139:172:835:125:55
0x01:102:298:835:115:55
0x01:217:412:835:95:55

בדוגמה שלמעלה, הרזולוציה של מסך המגע היא 480x800. בהתאם לכך, כל למפתחות הווירטואליים יש <centerY> של 835, שנמצא מעט מתחת האזור הגלוי של מסך המגע.

למפתח הראשון יש קוד סריקה של Linux, 158 (KEY_BACK),, centerX של 55, באמצע 835, רוחב של 90 וגובה של 55.

דוגמה

קובץ מפת מפתח וירטואלי: /sys/board_properties/virtualkeys.touchyfeely.

0x01:158:55:835:90:55
0x01:139:172:835:125:55
0x01:102:298:835:115:55
0x01:217:412:835:95:55

קובץ פריסת מקשים: /system/usr/keylayout/touchyfeely.kl.

key 158 BACK
key 139 MENU
key 172 HOME
key 217 SEARCH

קובץ מפת תווים מרכזי: /system/usr/keychars/touchyfeely.kcm.

type SPECIAL_FUNCTION

תנועות עקיפות של סמן העכבר עם מספר נקודות מגע

במצב מצביע, המערכת מפרשת את התנועות הבאות:

• הקשה עם אצבע אחת: לחיצה.
• תנועה של אצבע אחת: מזיזים את הסמן.
• תנועות באצבע אחת + לחיצות על לחצן: גוררים את הסמן.
• תנועה עם שתי אצבעות שזזות באותו כיוון: גוררים את האזור שמתחת לסמן בכיוון הזה. הסמן עצמו לא זז.
• תנועות של שתי אצבעות בתנועה של שתי האצבעות או זו לצד זו בכיוונים שונים: להזיז/לשנות את הגודל/לסובב את האזור שמקיף את הסמן. הסמן עצמו לא זז.
• תנועות אצבע מרובות: תנועה חופשית.

דחייה של כף היד

החל מ-Android 13, המערכת יכולה לדחות באופן אוטומטי קלטים מכף היד כשהמסגרת המובנית מופעלת. יש עדיין תמיכה בפתרונות פנימיים ובהתאמה אישית, אם כי יכול להיות שצריך לשנות אותם כדי להחזיר את הדגל TOOL_TYPE_PALM לאחר קבלת כף יד כשמתבצע זיהוי. המסגרת המובנית פועלת גם בשילוב עם פתרונות מותאמים אישית.

המודל עצמו בוחן את 90 האלפיות השנייה של נתוני התנועה, בנקודת הזמן הנוכחית ובמצב את המצביעים שמסביב, ואז מביאה בחשבון את המרחק מקצה התצוגה של הנגיעות. לאחר מכן הוא קובע, על בסיס כל מצביע, אילו מהסמנים הם כפות ידיים. הוא גם לוקח חשבון גודל כל איש קשר, כפי שדווח על ידי touchMajor וגם touchMinor. לאחר מכן, האפליקציה של Android מסירה את המצביעים שמסומנים כ- כפות הידיים מזרם המגע.

אם מצביע כבר נשלח לאפליקציות, המערכת:

• (אם יש מצביעים פעילים אחרים) ביטול הסמן באמצעות ACTION_POINTER_UP ו-FLAG_CANCELED הוגדרו.
• (אם זה הסמן היחיד) ביטול של הסמן באמצעות ACTION_CANCEL.

ממשק API ציבורי, MotionEvent.FLAG_CANCELED, מציין האירוע לא אמור לגרום לפעולת משתמש. הסימון הזה מוגדר עבור ACTION_CANCEL ו-ACTION_POINTER_UP.

אם הסמן של כף היד לא נשלח לאפליקציות, המערכת פשוט תשחרר אותו.

הפעלת דחייה של כף היד

1. במנהל המגע, משתמשים פקודות מאקרו input_abs_set_res כדי להגדיר את הרזולוציות בשדות הבאים (היחידות פיקסלים למ"מ):
   • ABS_MT_POSITION_X
   • ABS_MT_POSITION_Y
   • ABS_MT_TOUCH_MAJOR
   • ABS_MT_TOUCH_MINOR

   התמיכה ב-ABS_MT_TOUCH_MINOR היא אופציונלית. אבל אם המכשיר תומכים בו, צריך לוודא שהרזולוציה מוגדרת בצורה נכונה.

2. כדי לוודא שהשדות מוגדרים בצורה תקינה, מריצים את הפקודה:

       $ adb shell getevent -li
   

3. כדי להפעיל את התכונה במהלך סביבת זמן הריצה, מריצים את הפקודה:

       $ adb shell device_config put input_native_boot palm_rejection_enabled 1
   

4. צריך להתחיל מחדש את התהליך system_server.

        $ adb shell stop && adb shell start
       

5. צריך לאשר שב-adb shell dumpsys input מוצג שיש בפנים דוחי כף יד UnwantedInteractionBlocker. אם לא, עליכם לבדוק את היומנים שקשורים לקלט כדי למצוא רמזים לגבי מה שעשוי להיות מוגדר באופן שגוי.

   אפשר להיעזר בדוגמה הבאה:

   UnwantedInteractionBlocker:
     mEnablePalmRejection: true
     isPalmRejectionEnabled (flag value): true
     mPalmRejectors:
       deviceId = 3:
         mDeviceInfo:
           max_x = 
           max_y = 
           x_res = 11.00
           y_res = 11.00
           major_radius_res = 1.00
           minor_radius_res = 1.00
           minor_radius_supported = true
           touch_major_res = 1
           touch_minor_res = 1
         mSlotState:
           mSlotsByPointerId:
   
           mPointerIdsBySlot:
   
         mSuppressedPointerIds: {}
   

6. כדי להפעיל את התכונה באופן קבוע, הוסף את פקודת ה-syspro המתאימה init**rc file:

   setprop persist.device_config.input_native_boot.palm_rejection_enabled 1
   

קריאה נוספת

• Linux פרוטוקול מולטי טאץ'