מכשירי מגע

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

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

לחצנים

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

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

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

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

• אם הערך הוא 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 non-negative floating point number>

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

ערך ברירת המחדל הוא 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 = <a non-negative floating point number>

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

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

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

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

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

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

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