מכשירי מגע

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

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

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

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

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

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

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

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

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

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

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

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

במקומות אחרים באנדרואיד, כמו ב- MotionEvent API, כלי מכונה לעתים קרובות מצביע .

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

  • 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 כדי לציין שהכלי נמצא רק בטווח ומרחף.
  • התקני מגע בודד משתמשים באירועי הקלט הבאים של לינוקס:
    • ABS_X : (נדרש) מדווח על קואורדינטת ה-X של הכלי.
    • ABS_Y : (REQUIRED) מדווח על קואורדינטת ה-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_DOUBLETAP BTN_TOOL_RUBBER , BTN_TOOL_BRUSH , BTN_TOOL_PENCIL , BTN_TOOL_AIRBRUSH , BTN_TOOL_MOUSE , BTN_TOOL_LENS , BTN_TOOL_TRIPLETAP BTN_TOOL_QUADTAP :( אופציונלי) מדווח על סוג הכלי .
  • התקני ריבוי מגע משתמשים באירועי הקלט הבאים של לינוקס:
    • 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'. עיין בתיעוד פרוטוקול Linux multi-touch לפרטים נוספים.
    • 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_TRIPLETAP BTN_TOOL_QUADTAP :( BTN_TOOL_DOUBLETAP ) מדווח על סוג הכלי .
  • אם מוגדרים צירים גם עבור פרוטוקול הנגיעה הבודדת וגם עבור הפרוטוקול הרב-מגע, אזי נעשה שימוש רק בצירי הרב-מגע ומתעלמים מצירי הנגיעה הבודדת.

  • ערכי המינימום והמקסימום של הצירים 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 תומך גם בפרוטוקול ריבוי מגע 'A' וגם 'B'. מנהלי התקנים חדשים צריכים להשתמש בפרוטוקול 'B' אבל אחד מהם עובד.

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

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

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

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

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

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

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

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

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

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

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

  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 מרמז שהערכים מדויקים ל-+/- יחידה אחת.
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 , המערכת מזהה אוטומטית את סוג המכשיר בהתאם לאלגוריתם הסיווג.

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

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

touch.orientationAware

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

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

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

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

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

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

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

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

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

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

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

מגע.הטיה.גודל

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

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

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

touch.size.isSummed

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

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

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

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

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

מכשירי מגע מסוימים, במיוחד מכשירי "חצי-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 = none | physical | amplitude | default

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

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

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

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

  • If the value is default , the system uses the physical calibration if the pressure axis available, otherwise uses none .

touch.pressure.scale

Definition: touch.pressure.scale = <a non-negative floating point number>

Specifies a constant scale factor used in the calibration.

The default value is 1.0 / raw.pressure.max .

Calculation

The calculation of the pressure field depends on the specified calibration parameters.

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 and tilt fields

The orientation field describes the orientation of the touch and tool as an angular measurement. An orientation of 0 indicates that the major axis is oriented vertically, -PI/2 indicates that the major axis is oriented to the left, PI/2 indicates that the major axis is oriented to the right. When a stylus tool is present, the orientation range can be described in a full circle range from -PI or PI .

The tilt field describes the inclination of the tool as an angular measurement. A tilt of 0 indicates that the tool is perpendicular to the surface. A tilt of PI/2 indicates that the tool is flat on the surface.

touch.orientation.calibration

Definition: touch.orientation.calibration = none | interpolated | vector | default

Specifies the kind of measurement used by the touch driver to report the orientation.

  • If the value is none , the orientation is unknown so it is set to 0.
  • If the value is interpolated , the orientation is linearly interpolated such that a raw value of raw.orientation.min maps to -PI/2 and a raw value of raw.orientation.max maps to PI/2 . The center value of (raw.orientation.min + raw.orientation.max) / 2 maps to 0 .
  • If the value is vector , the orientation is interpreted as a packed vector consisiting of two signed 4-bit fields. This representation is used on Atmel Object Based Protocol parts. When decoded, the vector yields an orientation angle and confidence magnitude. The confidence magnitude is used to scale the size information, unless it is geometric.
  • If the value is default , the system uses the interpolated calibration if the orientation axis available, otherwise uses none .

Calculation

The calculation of the orientation and tilt fields depends on the specified calibration parameters and available input.

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 field

The distance field describes the distance between the tool and the touch device surface. A value of 0.0 indicates direct contact and larger values indicate increasing distance from the surface.

touch.distance.calibration

Definition: touch.distance.calibration = none | scaled | default

Specifies the kind of measurement used by the touch driver to report the distance.

  • If the value is none , the distance is unknown so it is set to 0.

  • If the value is scaled , the reported distance is multiplied by a constant scale factor.

  • If the value is default , the system uses the scaled calibration if the distance axis available, otherwise uses none .

touch.distance.scale

Definition: touch.distance.scale = <a non-negative floating point number>

Specifies a constant scale factor used in the calibration.

The default value is 1.0 .

Calculation

The calculation of the distance field depends on the specified calibration parameters.

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

Example

# 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

Compatibility notes

The configuration properties for touch devices changed significantly in Android Ice Cream Sandwich 4.0. All input device configuration files for touch devices must be updated to use the new configuration properties.

Older touch device drivers might also need to be updated.

Virtual key map files

Touch devices are often used to implement virtual keys.

There are several ways of doing this, depending on the capabilities of the touch controller. Some touch controllers can be directly configured to implement soft keys by setting firmware registers. Other times it is desirable to perform the mapping from touch coordinates to key codes in software.

When virtual keys are implemented in software, the kernel must export a virtual key map file called virtualkeys.<devicename> as a board property. For example, if the touch screen device drivers reports its name as "touchyfeely" then the virtual key map file must have the path /sys/board_properties/virtualkeys.touchyfeely .

A virtual key map file describes the coordinates and Linux key codes of virtual keys on the touch screen.

In addition to the virtual key map file, there must be a corresponding key layout file and key character map file to map the Linux key codes to Android key codes and to specify the type of the keyboard device (usually SPECIAL_FUNCTION ).

Syntax

A virtual key map file is a plain text file consisting of a sequence of virtual key layout descriptions either separated by newlines or by colons.

Comment lines begin with '#' and continue to the end of the line.

Each virtual key is described by 6 colon-delimited components:

  • 0x01 : A version code. Must always be 0x01 .
  • <Linux key code>: The Linux key code of the virtual key.
  • <centerX>: The X pixel coordinate of the center of the virtual key.
  • <centerY>: The Y pixel coordinate of the center of the virtual key.
  • <width>: The width of the virtual key in pixels.
  • <height>: The height of the virtual key in pixels.

All coordinates and sizes are specified in terms of the display coordinate system.

Here is a virtual key map file all written on one line.

# 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

The same virtual key map file can also be written on multiple lines.

# 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

In the above example, the touch screen has a resolution of 480x800. Accordingly, all of the virtual keys have a <centerY> coordinate of 835, which is a little bit below the visible area of the touch screen.

The first key has a Linux scan code of 158 ( KEY_BACK ), centerX of 55 , centerY of 835 , width of 90 , and height of 55 .

Example

Virtual key map file: /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

Key layout file: /system/usr/keylayout/touchyfeely.kl .

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

Key character map file: /system/usr/keychars/touchyfeely.kcm .

type SPECIAL_FUNCTION

Indirect multi-touch pointer gestures

In pointer mode, the system interprets the following gestures:

  • Single finger tap: click.
  • Single finger motion: move the pointer.
  • Single finger motion plus button presses: drag the pointer.
  • Two finger motion both fingers moving in the same direction: drag the area under the pointer in that direction. The pointer itself does not move.
  • Two finger motion both fingers moving towards each other or apart in different directions: pan/scale/rotate the area surrounding the pointer. The pointer itself does not move.
  • Multiple finger motion: freeform gesture.

Palm rejection

As of Android 13, the system can automatically reject inputs from palms when the built-in framework is enabled. In-house, custom-built solutions are still supported, though they might need to be modified to return the TOOL_TYPE_PALM flag when a palm is detected. The built-in framework also works in conjunction with custom solutions.

The actual model looks at the first 90 ms of gesture data, at the current pointer, and at the surrounding pointers, then considers how far away from the display edge the touches are. It then determines, on a per-pointer basis, which of the pointers are palms. It also takes into account the size of each contact, as reported by touchMajor and touchMinor . The Android framework then removes the pointers that are marked as palms from the touch stream.

If a pointer was already sent to the apps, then the system either:

  • (If there are other active pointers) Cancels the pointer with ACTION_POINTER_UP and FLAG_CANCELED set.
  • (If this is the only pointer) Cancels the pointer with ACTION_CANCEL .

A public API, MotionEvent.FLAG_CANCELED , indicates that the current event shouldn't trigger user action. This flag is set for both ACTION_CANCEL and ACTION_POINTER_UP .

If the palm pointer wasn't sent to apps, then the system simply drops the pointer.

Enable palm rejection

  1. In your touch driver, use the input_abs_set_res macro to set the resolutions for the following fields (units are pixels per mm ):
    • ABS_MT_POSITION_X
    • ABS_MT_POSITION_Y
    • ABS_MT_TOUCH_MAJOR
    • ABS_MT_TOUCH_MINOR

    Support for ABS_MT_TOUCH_MINOR is optional. However, if your device does support it, make sure the resolution is set correctly.

  2. To confirm the fields are set correctly, run:
        $ adb shell getevent -li
  3. To enable the feature during runtime, run:
        $ adb shell device_config put input_native_boot palm_rejection_enabled 1
  4. Restart the system_server process. 
         $ adb shell stop && adb shell start
  5. Confirm that adb shell dumpsys input shows that there are palm rejectors inside UnwantedInteractionBlocker . If it doesn't, check the input-related logs to find clues on what might be misconfigured.

    See the following example for reference:

    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. To permanently enable the feature, add the corresponding sysprop command in your init**rc file:

    setprop persist.device_config.input_native_boot.palm_rejection_enabled 1

Further reading