מכשירי מגע

ב-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 (באמצעות EVIOCGPROP ioctl), סוג המכשיר מוגדר כמסך מגע. התנאי הזה מניח שמכשירי מגע עם קלט ישיר מחוברים למסך שגם הוא מחובר.
• אם המכשיר לקליטת נתונים מדווח על נוכחות של מאפיין הקלט INPUT_PROP_POINTER (דרך EVIOCGPROP ioctl), סוג המכשיר מוגדר כ-pointer.
• אם המכשיר לקליטת נתונים מדווח על נוכחות של הצירים היחסיים REL_X או REL_Y, סוג המכשיר מוגדר כלוח מגע. התנאי הזה פותר את הבעיה של חוסר הבהירות במכשירים לקליטת נתונים שכוללים גם עכבר וגם לוח מגע. במקרה כזה, לוח המגע לא משמש לשליטה בסמן כי העכבר כבר שולט בו.
• אחרת, סוג המכשיר מוגדר כ-pointer. ברירת המחדל הזו מבטיחה שלוחות מגע שלא הוגדרה להם מטרה מיוחדת אחרת שולטים בסמן.

כפתורים

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

אפשר להשתמש בכפתורים הבאים:

• ‫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: (אופציונלי) מדווח על מזהה המשבצת של הכלי, כשמשתמשים בפרוטוקול B של Linux לריבוי מגע. פרטים נוספים זמינים במסמכי התיעוד של פרוטוקול ריבוי מגע של 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, אם הם מדווחים בכלל, חייבים להיות שונים מאפס כשהכלי נוגע במכשיר, ואפס אחרת כדי לציין שהכלי מרחף.

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

• הערכים שמדווחים על ידי 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 צריך לקבל לפחות מידע חלקי על אופי הכלי, למשל אם הוא נוגע או לפחות מה סוג הכלי. אם אין מידע זמין, המערכת מניחה שהכלי לא פעיל (מחוץ לטווח).

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

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

  יכול להיות שתצטרכו לבצע את השינויים הבאים:

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

    בגרסאות קודמות של Android, אירועי "up" דווחו על ידי שליחת ערך לחץ של 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. אם לחצו על הקודם או על הבא או שחררו אותם, 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 מציין שהערכים מדויקים עד +/- יחידה אחת.

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.

• אם הערך הוא 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

שדות size, ‏ toolMinor, ‏ toolMajor, ‏ touchMinor, ‏ touchMajor

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

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

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

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

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

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

מכשירים עם מסך מגע מודדים או מדווחים על גודל המגע וגודל הכלי בדרכים שונות. ההטמעה הנוכחית תומכת בשלושה סוגים שונים של מדידות: קוטר, שטח ותיבה תוחמת (bounding box) גיאומטרית ביחידות שטח.

<touch.size.calibration< h4=""></touch.size.calibration<>

הגדרה: 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 = <מספר לא שלילי עם נקודה צפה>

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

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

touch.size.bias

הגדרה: touch.size.bias = <מספר נקודה צפה לא שלילי>

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

ערך ברירת המחדל הוא 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, ההנחה היא שציר הלחץ מודד את עוצמת האות, שקשורה לגודל המגע וללחץ שמופעל.

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

touch.pressure.scale

הגדרה: touch.pressure.scale = <מספר לא שלילי עם נקודה צפה>

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

ערך ברירת המחדל הוא 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 Object Based Protocol. אחרי פענוח, הווקטור מניב זווית כיוון ורמת ודאות. עוצמת הסמך משמשת לשינוי קנה המידה של פרטי הגודל, אלא אם מדובר במידע גיאומטרי.
• אם הערך הוא 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 = <מספר לא שלילי עם נקודה צפה>

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

ערך ברירת המחדל הוא 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 Sandwich 4.0. צריך לעדכן את כל קובצי התצורה של מכשירים לקליטת נתונים במכשירי מגע כדי להשתמש במאפייני התצורה החדשים.

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

קובצי מפה של מקשים וירטואליים

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

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

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

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

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

תחביר

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

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

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

• ‫0x01: קוד גרסה. חייב תמיד להיות 0x01.
• <Linux key code>: קוד המקש ב-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,‏ centerY של 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 היא אופציונלית. עם זאת, אם המכשיר תומך ב-4K, ודאו שהרזולוציה מוגדרת בצורה נכונה.

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. כדי להפעיל את התכונה באופן סופי, מוסיפים את פקודת sysprop המתאימה לקובץ init**rc:

   setprop persist.device_config.input_native_boot.palm_rejection_enabled 1
   

קריאה נוספת

• פרוטוקול ריבוי מגע של Linux