टच डिवाइस

Android, कई तरह की टच स्क्रीन और टच पैड के साथ काम करता है. इनमें स्टाइलस वाले डिजिटाइज़र टैबलेट भी शामिल हैं.

टच स्क्रीन, टच डिवाइस होते हैं. ये डिसप्ले से जुड़े होते हैं, ताकि उपयोगकर्ता को स्क्रीन पर मौजूद आइटम को सीधे तौर पर मैनेज करने का एहसास हो.

टच पैड ऐसे टच डिवाइस होते हैं जो किसी डिसप्ले से जुड़े नहीं होते. जैसे, डिजिटाइज़र टैबलेट. टच पैड का इस्तेमाल आम तौर पर, किसी यूज़र इंटरफ़ेस को इंगित करने, पूरी तरह से अप्रत्यक्ष पोज़िशनिंग करने या जेस्चर पर आधारित कंट्रोल करने के लिए किया जाता है.

टच डिवाइसों में ऐसे बटन हो सकते हैं जिनके फ़ंक्शन माउस बटन से मिलते-जुलते होते हैं.

टच डिवाइसों को कई तरह के टूल का इस्तेमाल करके मैनिप्युलेट किया जा सकता है. जैसे, उंगलियों या स्टाइलस का इस्तेमाल करके. यह टच सेंसर की टेक्नोलॉजी पर निर्भर करता है.

कभी-कभी टच डिवाइसों का इस्तेमाल, वर्चुअल बटन लागू करने के लिए किया जाता है. उदाहरण के लिए, कुछ Android डिवाइसों पर, टच स्क्रीन सेंसर का एरिया डिसप्ले के किनारे से ज़्यादा बड़ा होता है. साथ ही, यह टच सेंसिटिव कीपैड के हिस्से के तौर पर दो काम करता है.

टच डिवाइसों की बहुत सारी वैरायटी होने की वजह से, Android कई कॉन्फ़िगरेशन प्रॉपर्टी पर निर्भर करता है. इससे, हर डिवाइस की विशेषताओं और उसके काम करने के तरीके के बारे में पता चलता है.

टच डिवाइस की कैटगरी तय करना

किसी इनपुट डिवाइस को मल्टी-टच डिवाइस के तौर पर तब ही वर्गीकृत किया जाता है, जब ये दोनों शर्तें पूरी होती हैं:

  • इनपुट डिवाइस, ABS_MT_POSITION_X और ABS_MT_POSITION_Y ऐब्सोलूट ऐक्सिस की मौजूदगी की जानकारी देता है.
  • इनपुट डिवाइस में गेमपैड बटन नहीं हैं. इस शर्त से, कुछ गेमपैड से जुड़ी एक समस्या हल हो जाती है. ये गेमपैड, ऐसे कोड के साथ ऐक्सिस की जानकारी देते हैं जो MT ऐक्सिस के कोड से ओवरलैप होते हैं.

किसी इनपुट डिवाइस को सिंगल-टच डिवाइस के तौर पर तब ही कैटगरी में रखा जाता है, जब ये दोनों शर्तें पूरी होती हैं:

  • इनपुट डिवाइस को मल्टी-टच डिवाइस के तौर पर नहीं रखा गया है. किसी इनपुट डिवाइस को सिंगल-टच डिवाइस या मल्टी-टच डिवाइस के तौर पर ही कैटगरी में रखा जाता है, कभी दोनों के तौर पर नहीं.
  • इनपुट डिवाइस, ABS_X और ABS_Y कुल ऐक्सिस की मौजूदगी और BTN_TOUCH कुंजी कोड की मौजूदगी की रिपोर्ट देता है.

जब किसी इनपुट डिवाइस को टच डिवाइस के तौर पर चुना जाता है, तब वर्चुअल बटन की मौजूदगी का पता लगाने के लिए, डिवाइस के वर्चुअल बटन की मैप फ़ाइल को लोड करने की कोशिश की जाती है. अगर कोई वर्चुअल कुंजी मैप उपलब्ध है, तो डिवाइस के लिए 'की लेआउट' फ़ाइल भी लोड हो जाती है. इन फ़ाइलों की जगह और फ़ॉर्मैट के बारे में जानने के लिए, [वर्चुअल की मैप फ़ाइलें](#virtual-key-map-files) देखें.

इसके बाद, सिस्टम टच डिवाइस के लिए इनपुट डिवाइस कॉन्फ़िगरेशन फ़ाइल लोड करता है.

डिवाइस में पहले से मौजूद सभी टच डिवाइसों में, इनपुट डिवाइस की कॉन्फ़िगरेशन फ़ाइलें होनी चाहिए. अगर इनपुट डिवाइस की कोई कॉन्फ़िगरेशन फ़ाइल मौजूद नहीं है, तो सिस्टम एक डिफ़ॉल्ट कॉन्फ़िगरेशन चुनता है. यह कॉन्फ़िगरेशन, सामान्य तौर पर इस्तेमाल होने वाले टच डिवाइसों के लिए सही होता है. जैसे, एक्सटर्नल यूएसबी या ब्लूटूथ एचआईडी टच स्क्रीन या टच पैड. ये डिफ़ॉल्ट सेटिंग, डिवाइस में पहले से मौजूद टच स्क्रीन के लिए नहीं बनाई गई हैं. इनकी वजह से, डिवाइस का गलत तरीके से काम करना शुरू हो सकता है.

इनपुट डिवाइस का कॉन्फ़िगरेशन लोड होने के बाद, सिस्टम इनपुट डिवाइस को टच स्क्रीन, टच पैड या पॉइंटर डिवाइस के तौर पर बांटता है.

  • टच स्क्रीन डिवाइस का इस्तेमाल, स्क्रीन पर मौजूद आइटम को सीधे तौर पर मैनेज करने के लिए किया जाता है. उपयोगकर्ता सीधे स्क्रीन को छूता है, इसलिए सिस्टम को उन ऑब्जेक्ट के बारे में बताने के लिए, किसी और सुविधा की ज़रूरत नहीं होती जिन्हें मैनेज किया जा रहा है.
  • टच पैड डिवाइस का इस्तेमाल, किसी सेंसर के इलाके पर किए गए टच के बारे में ऐप्लिकेशन को सटीक जगह की जानकारी देने के लिए किया जाता है. यह डिजिटाइज़र टैबलेट के लिए मददगार हो सकता है.
  • पॉइंटर डिवाइस का इस्तेमाल, स्क्रीन पर मौजूद आइटम को कर्सर का इस्तेमाल करके, अप्रत्यक्ष तौर पर मैनेज करने के लिए किया जाता है. उंगलियों को मल्टी-टच पॉइंटर के तौर पर समझा जाता है. स्टाइलस जैसे दूसरे टूल के बारे में जानने के लिए, उनकी कुल पोज़िशन का इस्तेमाल किया जाता है. ज़्यादा जानकारी के लिए, इनडायरेक्ट मल्टी-टच पॉइंटर जेस्चर देखें.

इनपुट डिवाइस को टचस्क्रीन, टच पैड या पॉइंटर डिवाइस के रूप में कैटगरी में बांटने के लिए, इन नियमों का इस्तेमाल किया जाता है.

  • अगर touch.deviceType प्रॉपर्टी सेट है, तो डिवाइस टाइप को बताए गए तरीके से सेट किया जाता है.
  • अगर इनपुट डिवाइस, EVIOCGPROP ioctl की मदद से INPUT_PROP_DIRECT इनपुट प्रॉपर्टी की मौजूदगी की जानकारी देता है, तो डिवाइस टाइप को टच स्क्रीन पर सेट किया जाता है. इस स्थिति में यह माना जाता है कि डायरेक्ट इनपुट टच डिवाइस, ऐसे डिसप्ले से जुड़े होते हैं जो कनेक्ट भी है.
  • अगर इनपुट डिवाइस, EVIOCGPROP ioctl के ज़रिए INPUT_PROP_POINTER इनपुट प्रॉपर्टी की मौजूदगी की जानकारी देता है, तो डिवाइस टाइप को पॉइंटर पर सेट किया जाता है.
  • अगर इनपुट डिवाइस, REL_X या REL_Y ऐक्सिस की मौजूदगी की रिपोर्ट करता है, तो डिवाइस टाइप को टच पैड पर सेट किया जाता है. इस शर्त से, उन इनपुट डिवाइसों के लिए अस्पष्टता को हल किया जाता है जिनमें माउस और टच पैड, दोनों होते हैं. इस मामले में, पॉइंटर को कंट्रोल करने के लिए, टच पैड का इस्तेमाल नहीं किया जाता, क्योंकि माउस पहले से ही इसे कंट्रोल करता है.
  • ऐसा न करने पर, डिवाइस टाइप पॉइंटर पर सेट हो जाता है. इस डिफ़ॉल्ट से यह पक्का होता है कि जिन टच पैड को किसी खास काम के लिए तय नहीं किया गया है वे पॉइंटर को कंट्रोल करते हैं.

बटन

बटन ऐसे कंट्रोल ज़रूरी नहीं हैं जिनका इस्तेमाल करके ऐप्लिकेशन, अतिरिक्त फ़ंक्शन कर सकते हैं. टच डिवाइसों पर दिखने वाले बटन, माउस बटन की तरह ही काम करते हैं. इनका इस्तेमाल मुख्य रूप से पॉइंटर टाइप के टच डिवाइसों या स्टाइलस के साथ किया जाता है.

ये बटन काम करते हैं:

  • BTN_LEFT: MotionEvent.BUTTON_PRIMARY पर मैप किया गया.
  • BTN_RIGHT: MotionEvent.BUTTON_SECONDARY पर मैप किया गया.
  • BTN_MIDDLE: MotionEvent.BUTTON_MIDDLE पर मैप किया गया.
  • BTN_BACK और BTN_SIDE: MotionEvent.BUTTON_BACK पर मैप किए गए. इस बटन को दबाने पर, किसी बटन को दबाकर रखने पर, बटन KeyEvent.KEYCODE_BACK भी लागू हो जाता है.
  • BTN_FORWARD और BTN_EXTRA: MotionEvent.BUTTON_FORWARD पर मैप किया गया. इस बटन को दबाने पर, की कोड KeyEvent.KEYCODE_FORWARD के साथ एक बटन दबाने की जानकारी भी भेजी जाती है.
  • BTN_STYLUS: MotionEvent.BUTTON_SECONDARY पर मैप किया गया.
  • BTN_STYLUS2: MotionEvent.BUTTON_TERTIARY पर मैप किया गया.

टूल और टूल टाइप

टूल, उंगली, स्टाइलस या कोई ऐसा अन्य उपकरण होता है जिसका इस्तेमाल टच डिवाइस के साथ इंटरैक्ट करने के लिए किया जाता है. कुछ टच डिवाइस, अलग-अलग तरह के टूल के बीच अंतर कर सकते हैं.

Android के अन्य हिस्सों में, जैसे कि 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 से मैप किए गए.

टूल पर कर्सर घुमाने के बजाय, उन्हें छूना

टूल, टच डिवाइस से संपर्क में हो सकते हैं या रेंज में होने के साथ-साथ उसके ऊपर हो सकते हैं. सभी टच डिवाइसों पर, टूल के टच डिवाइस के ऊपर घूमने की जानकारी नहीं मिलती. रेडियो फ़्रीक्वेंसी वाले स्टाइलस डिजिटाइज़र जैसे टूल, अक्सर यह पता लगा सकते हैं कि टूल, डिजिटाइज़र की सीमित रेंज में है या नहीं.

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) का कोऑर्डिनेट रिपोर्ट कर सकता है. अगर उंगली, ऐक्टिव एरिया से बाहर की ओर बढ़ती रहती है, तो टच स्क्रीन को कम से कम x और y से कम कॉम्पोनेंट के साथ निर्देशों की रिपोर्टिंग शुरू करनी चाहिए, जैसे कि (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 के हिसाब से कस्टमाइज़ करने की ज़रूरत नहीं है. स्टैंडर्ड Linux इनपुट प्रोटोकॉल की मदद से, Android पर कई तरह के टच सहायक डिवाइस काम कर सकते हैं. जैसे, बाहरी एचआईडी मल्टी-टच स्क्रीन, जिनमें बिना बदलाव किए गए ड्राइवर इस्तेमाल किए गए हैं.

टच डिवाइस पर की जाने वाली कार्रवाई

Android पर टच डिवाइस पर की जाने वाली कार्रवाइयों की खास जानकारी नीचे दी गई है.

  1. EventHub, evdev ड्राइवर के रॉ इवेंट की जानकारी पढ़ता है.
  2. InputReader, रॉ इवेंट का इस्तेमाल करता है और हर टूल की पोज़िशन और अन्य विशेषताओं के बारे में इंटरनल स्टेटस को अपडेट करता है. यह बटन की स्थितियों को भी ट्रैक करता है.
  3. अगर BACK या FORWARD को दबाया या छोड़ा गया था, तो InputReader, InputDispatcher को मुख्य इवेंट के बारे में सूचना देता है.
  4. InputReader से यह तय होता है कि वर्चुअल बटन दबाया गया है या नहीं. अगर ऐसा है, तो यह मुख्य इवेंट के बारे में InputDispatcher को सूचना देता है.
  5. InputReader यह तय करता है कि टच, डिसप्ले के दायरे में हुआ था या नहीं. अगर ऐसा होता है, तो यह टच इवेंट के बारे में InputDispatcher को सूचना देता है.
  6. अगर टच करने वाले टूल नहीं हैं, लेकिन कम से कम एक होवरिंग टूल है, तो InputReader, InputDispatcher को होवर इवेंट के बारे में सूचना देता है.
  7. अगर टच डिवाइस टाइप पॉइंटर है, तो InputReader, पॉइंटर जेस्चर का पता लगाता है, पॉइंटर को उसके हिसाब से मूव करता है, और पॉइंटर इवेंट के बारे में InputDispatcher को सूचना देता है.
  8. InputDispatcher, WindowManagerPolicy का इस्तेमाल यह तय करने के लिए करता है कि इवेंट को भेजा जाए या नहीं. साथ ही, यह भी तय किया जाता है कि इवेंट को डिवाइस की स्क्रीन चालू करनी है या नहीं. इसके बाद, InputDispatcher इवेंट को सही ऐप्लिकेशन पर डिलीवर करता है.

टच डिवाइस कॉन्फ़िगरेशन

टच डिवाइस के व्यवहार को डिवाइस के ऐक्सिस, बटन, इनपुट प्रॉपर्टी, इनपुट डिवाइस कॉन्फ़िगरेशन, वर्चुअल की मैप, और की लेआउट से तय किया जाता है.

कीबोर्ड कॉन्फ़िगरेशन में हिस्सा लेने वाली फ़ाइलों के बारे में ज़्यादा जानकारी के लिए, यहां दिए गए सेक्शन देखें:

प्रॉपर्टी

टच डिवाइस के व्यवहार को कॉन्फ़िगर करने और कैलिब्रेट करने के लिए, सिस्टम कई इनपुट डिवाइस कॉन्फ़िगरेशन प्रॉपर्टी पर निर्भर करता है.

इसकी एक वजह यह है कि टच डिवाइसों के डिवाइस ड्राइवर, अक्सर डिवाइस के हिसाब से यूनिट का इस्तेमाल करके, टच की विशेषताओं की जानकारी देते हैं.

उदाहरण के लिए, कई टच डिवाइस, डिवाइस के हिसाब से तय किए गए स्केल का इस्तेमाल करके, टच संपर्क क्षेत्र को मेज़र करते हैं. जैसे, टच से ट्रिगर किए गए सेंसर नोड की कुल संख्या. रॉ साइज़ की यह वैल्यू, ऐप्लिकेशन के लिए काम की नहीं होगी, क्योंकि उन्हें टच डिवाइस सेंसर नोड के फ़िज़िकल साइज़ और अन्य विशेषताओं के बारे में जानना होगा.

सिस्टम, टच डिवाइस से रिपोर्ट की गई वैल्यू को डिकोड करने, बदलने, और सामान्य बनाने के लिए, इनपुट डिवाइस कॉन्फ़िगरेशन फ़ाइलों में एन्कोड किए गए कैलिब्रेशन पैरामीटर का इस्तेमाल करता है. इससे, इन वैल्यू को एक आसान स्टैंडर्ड तरीके से दिखाया जा सकता है, ताकि ऐप्लिकेशन उन्हें समझ सकें.

दस्तावेज़ से जुड़े कन्वेंशन

दस्तावेज़ बनाने के लिए, हम कैलिब्रेशन की प्रोसेस के दौरान सिस्टम की इस्तेमाल की गई वैल्यू के बारे में बताने के लिए, इन नियमों का इस्तेमाल करते हैं.

रॉ ऐक्सिस की वैल्यू

नीचे दिए गए एक्सप्रेशन, टच डिवाइस ड्राइवर की ओर से रिपोर्ट की गई रॉ वैल्यू को EV_ABS इवेंट के तौर पर दिखाते हैं.

raw.x
ABS_X या ABS_MT_POSITION_X ऐक्सिस की वैल्यू.
raw.y
ABS_Y या ABS_MT_POSITION_Y ऐक्सिस की वैल्यू.
raw.pressure
ABS_PRESSURE या ABS_MT_PRESSURE ऐक्सिस की वैल्यू या उपलब्ध न होने पर 0.
raw.touchMajor
ABS_MT_TOUCH_MAJOR ऐक्सिस की वैल्यू या उपलब्ध न होने पर 0.
raw.touchMinor
ABS_MT_TOUCH_MINOR ऐक्सिस की वैल्यू या उपलब्ध न होने पर raw.touchMajor.
raw.toolMajor
ABS_TOOL_WIDTH या ABS_MT_WIDTH_MAJOR ऐक्सिस की वैल्यू या उपलब्ध न होने पर 0.
raw.toolMinor
ABS_MT_WIDTH_MINOR ऐक्सिस की वैल्यू या उपलब्ध न होने पर raw.toolMajor.
raw.orientation
ABS_MT_ORIENTATION ऐक्सिस की वैल्यू या उपलब्ध न होने पर 0.
raw.distance
ABS_DISTANCE या ABS_MT_DISTANCE ऐक्सिस की वैल्यू या उपलब्ध न होने पर 0.
raw.tiltX
ABS_TILT_X ऐक्सिस की वैल्यू या उपलब्ध न होने पर 0.
raw.tiltY
ABS_TILT_Y ऐक्सिस की वैल्यू या उपलब्ध न होने पर 0.

ऐक्सिस की रॉ रेंज

नीचे दिए गए एक्सप्रेशन, रॉ वैल्यू के बाउंड दिखाते हैं. इन्हें पाने के लिए, हर अक्ष के लिए EVIOCGABS ioctl को कॉल किया जाता है.

raw.*.min
रॉ अक्ष की कम से कम वैल्यू.
raw.*.max
रॉ ऐक्सिस की ज़्यादा से ज़्यादा वैल्यू.
raw.*.range
raw.*.max - raw.*.min के बराबर.
raw.*.fuzz
रॉ ऐक्सिस कितना सटीक है. उदाहरण के लिए, फ़ज़ = 1 का मतलब है कि वैल्यू, +/- 1 यूनिट के बराबर हैं.
raw.width
टच एरिया की चौड़ाई, जो raw.x.range + 1 के बराबर होती है.
raw.height
टच एरिया की ऊंचाई, जो raw.y.range + 1 के बराबर होती है.

आउटपुट की सीमाएं

नीचे दिए गए एक्सप्रेशन, आउटपुट कोऑर्डिनेट सिस्टम की विशेषताओं के बारे में बताते हैं. डिसप्ले पिक्सल जैसे ऐप्लिकेशन को रिपोर्ट की जाने वाली आउटपुट यूनिट में, टच डिवाइस के लिए इस्तेमाल की गई सरफ़ेस यूनिट की टच पोज़िशन की जानकारी का अनुवाद करने के लिए, यह सिस्टम लीनियर इंटरपोलेशन का इस्तेमाल करता है.

output.width
आउटपुट की चौड़ाई. डिसप्ले से जुड़ी टचस्क्रीन के लिए, यह डिसप्ले की चौड़ाई होती है. इसे पिक्सल में दिखाया जाता है. टच पैड (जो डिसप्ले से जुड़े नहीं हैं) के लिए, आउटपुट की चौड़ाई raw.width के बराबर होती है. इसका मतलब है कि कोई इंटरपोलेशन नहीं किया गया है.
output.height
आउटपुट की ऊंचाई. डिसप्ले से जुड़ी टच स्क्रीन के लिए, यह डिसप्ले की ऊंचाई होती है. इसे पिक्सल में दिखाया जाता है. टच पैड (जो किसी डिसप्ले से नहीं जुड़े हैं) के लिए, आउटपुट की ऊंचाई raw.height होती है. इससे पता चलता है कि कोई इंटरपोलेशन नहीं किया गया है.
output.diag
आउटपुट निर्देशांक सिस्टम के डायगनल की लंबाई, जो sqrt(output.width ^2 + output.height ^2) के बराबर होती है.

बुनियादी कॉन्फ़िगरेशन

टच इनपुट मैपर, कैलिब्रेशन वैल्यू तय करने के लिए, इनपुट डिवाइस की कॉन्फ़िगरेशन फ़ाइल में मौजूद कई कॉन्फ़िगरेशन प्रॉपर्टी का इस्तेमाल करता है. नीचे दी गई टेबल में, सामान्य मकसद के लिए कॉन्फ़िगरेशन की कुछ प्रॉपर्टी के बारे में बताया गया है. अन्य सभी प्रॉपर्टी के बारे में, यहां दिए गए सेक्शन में बताया गया है. साथ ही, उन फ़ील्ड के बारे में भी बताया गया है जिनका इस्तेमाल कैलिब्रेट करने के लिए किया जाता है.

touch.deviceType

परिभाषा: touch.deviceType = touchScreen | touchPad | pointer | default

टच डिवाइस का टाइप बताता है.

  • अगर वैल्यू touchScreen है, तो टच डिवाइस एक टच स्क्रीन है, जो डिसप्ले से जुड़ा है.

  • अगर वैल्यू touchPad है, तो टच डिवाइस एक टच पैड है, जो किसी डिसप्ले से नहीं जुड़ा है.

  • अगर वैल्यू pointer है, तो टच डिवाइस एक टच पैड है, जो किसी डिसप्ले से नहीं जुड़ा है. साथ ही, इसके मोशन का इस्तेमाल इनडायरेक्ट मल्टी-टच पॉइंटर जेस्चर के लिए किया जाता है.

  • अगर वैल्यू default है, तो सिस्टम डिवाइस टाइप का पता अपने-आप लगा लेता है. ऐसा, डिवाइस टाइप की पहचान करने वाले एल्गोरिदम के हिसाब से होता है.

डिवाइस टाइप, टच डिवाइस के व्यवहार पर कैसे असर डालता है, इस बारे में ज़्यादा जानकारी के लिए क्लासिफ़िकेशन सेक्शन देखें.

Android 3 और उससे पहले के वर्शन में, सभी टच डिवाइस को टचस्क्रीन माना गया था.

touch.orientationAware

परिभाषा: touch.orientationAware = 0 | 1

इससे पता चलता है कि टच डिवाइस को डिसप्ले के ओरिएंटेशन में होने वाले बदलावों पर प्रतिक्रिया करनी चाहिए या नहीं.

  • अगर वैल्यू 1 है, तो डिसप्ले के ओरिएंटेशन में बदलाव होने पर, टच डिवाइस से रिपोर्ट की गई टच पोज़िशन को घुमाया जाता है.

  • अगर वैल्यू 0 है, तो टच डिवाइस से रिपोर्ट की गई टच पोज़िशन, डिसप्ले के ओरिएंटेशन में होने वाले बदलावों से सुरक्षित रहती हैं.

अगर डिवाइस टचस्क्रीन है, तो डिफ़ॉल्ट वैल्यू 1 है, नहीं तो 0.

यह सिस्टम, इनर और आउटर टच स्क्रीन और डिसप्ले के बीच अंतर करता है. ओरिएंटेशन के हिसाब से काम करने वाली अंदरूनी टच स्क्रीन, अंदरूनी डिसप्ले के ओरिएंटेशन के हिसाब से घूमती है. स्क्रीन की दिशा पता करने वाली बाहरी टच स्क्रीन को बाहरी डिसप्ले के ओरिएंटेशन के आधार पर घुमाया जाता है.

ओरिएंटेशन अवेयरनेस का इस्तेमाल Nexus One जैसे डिवाइस पर टचस्क्रीन को घुमाने में सहायता के लिए किया जाता है. उदाहरण के लिए, जब डिवाइस को उसके सामान्य ओरिएंटेशन से, घड़ी की सुई के घूमने की दिशा में 90 डिग्री घुमाया जाता है, तो टच की सटीक जगहों को फिर से मैप किया जाता है. ऐसा इसलिए किया जाता है, ताकि टच स्क्रीन के सटीक कोऑर्डिनेट सिस्टम के सबसे ऊपर बाएं कोने में किए गए टच को, डिसप्ले के घुमाए गए कोऑर्डिनेट सिस्टम के सबसे ऊपर बाएं कोने में किए गए टच के तौर पर रिपोर्ट किया जा सके. ऐसा इसलिए किया जाता है, ताकि टच को उसी निर्देशांक सिस्टम के साथ रिपोर्ट किया जा सके जिसका इस्तेमाल ऐप्लिकेशन अपने विज़ुअल एलिमेंट को ड्रॉ करने के लिए करते हैं.

Honeycomb से पहले, सभी टच डिवाइसों को ओरिएंटेशन के बारे में पता होता था.

touch.gestureMode

परिभाषा: touch.gestureMode = pointer | spots | default

पॉइंटर जेस्चर के लिए प्रज़ेंटेशन मोड तय करता है. यह कॉन्फ़िगरेशन प्रॉपर्टी सिर्फ़ तब काम करती है, जब टच डिवाइस का टाइप पॉइंटर हो.

  • अगर वैल्यू pointer है, तो टच पैड के जेस्चर, माउस पॉइंटर की तरह कर्सर के ज़रिए दिखाए जाते हैं.

  • अगर वैल्यू spots है, तो टच पैड के जेस्चर को ऐंकर के ज़रिए दिखाया जाता है. ऐंकर, जेस्चर के सेंटर को दिखाता है. साथ ही, एक सर्कुलर स्पॉट का सेट भी दिखाता है, जो अलग-अलग उंगलियों की पोज़िशन दिखाता है.

INPUT_PROP_SEMI_MT इनपुट प्रॉपर्टी सेट होने पर, डिफ़ॉल्ट वैल्यू pointer होती है. इसके अलावा, 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, size फ़ील्ड

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 non-negative floating point number>

कैलिब्रेशन में इस्तेमाल किए जाने वाले स्केल फ़ैक्टर की जानकारी देता है.

डिफ़ॉल्ट वैल्यू 1.0 है.

touch.size.bias

परिभाषा: touch.size.bias = <a non-negative floating point number>

कैलिब्रेशन में इस्तेमाल की जाने वाली कॉन्स्टेंट बायस वैल्यू की जानकारी देता है.

डिफ़ॉल्ट वैल्यू 0.0 है.

touch.size.isSummed

परिभाषा: touch.size.isSummed = 0 | 1

इससे पता चलता है कि साइज़ को सभी ऐक्टिव संपर्कों के साइज़ के योग के तौर पर रिपोर्ट किया गया है या हर संपर्क के लिए अलग-अलग रिपोर्ट किया गया है.

  • अगर वैल्यू 1 है, तो इस्तेमाल से पहले, रिपोर्ट किए गए साइज़ को संपर्कों की संख्या से divide किया जाता है.

  • अगर वैल्यू 0 है, तो रिपोर्ट किए गए साइज़ का इस्तेमाल उसी तरह किया जाता है.

डिफ़ॉल्ट वैल्यू 0 है.

कुछ टच डिवाइस, खास तौर पर "सेमी-एमटी" डिवाइस, कई संपर्कों के अलग-अलग डाइमेंशन के बीच अंतर नहीं कर सकते. इसलिए, वे साइज़ का ऐसा मेज़रमेंट दिखाते हैं जो उनके कुल क्षेत्र या चौड़ाई को दिखाता है. इस प्रॉपर्टी को सिर्फ़ ऐसे डिवाइसों के लिए 1 पर सेट किया जाना चाहिए. अगर आपको नहीं पता कि GTIN सही है या नहीं, तो इस एट्रिब्यूट की वैल्यू 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 = <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-बिट फ़ील्ड होते हैं. इस प्रज़ेंटेशन का इस्तेमाल, ऐटमेल ऑब्जेक्ट आधारित प्रोटोकॉल के हिस्सों के लिए किया जाता है. डिकोड करने पर, वेक्टर से ओरिएंटेशन ऐंगल और कॉन्फ़िडेंस मैग्नीट्यूड मिलता है. कॉन्फ़िडेंस मैग्नीट्यूड का इस्तेमाल, साइज़ की जानकारी को स्केल करने के लिए किया जाता है. ऐसा तब तक किया जाता है, जब तक कि यह ज्यामितीय न हो.
  • अगर वैल्यू 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 नॉन-नेगेटिव फ़्लोटिंग पॉइंट नंबर>

कैलिब्रेशन में इस्तेमाल किए जाने वाले स्केल फ़ैक्टर की जानकारी देता है.

डिफ़ॉल्ट वैल्यू 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) का टाइप बताने के लिए, एक संबंधित कुंजी लेआउट फ़ाइल और मुख्य वर्ण मैप फ़ाइल होनी चाहिए.

वाक्य-विन्यास

वर्चुअल की मैप फ़ाइल, एक प्लेन टेक्स्ट फ़ाइल होती है. इसमें वर्चुअल बटन के लेआउट की जानकारी होती है. इस जानकारी को नई लाइन या कोलन से अलग किया जाता है.

टिप्पणी वाली लाइनें '#' से शुरू होती हैं और लाइन के आखिर तक चलती हैं.

हर वर्चुअल कुंजी के बारे में, कोलन से अलग किए गए छह कॉम्पोनेंट बताए गए हैं:

  • 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 होता है. यह टच स्क्रीन के दिखने वाले हिस्से से थोड़ा नीचे होता है.

पहली कुंजी में, 158 (KEY_BACK) का Linux स्कैन कोड, 55 का centerX, 835 का centerY, 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 का इस्तेमाल करके पॉइंटर को रद्द करता है.

सार्वजनिक एपीआई, 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. अगर इस सुविधा को हमेशा के लिए चालू करना है, तो अपनी init**rc फ़ाइल में इससे जुड़ा sysprop निर्देश जोड़ें:

    setprop persist.device_config.input_native_boot.palm_rejection_enabled 1

इसके बारे में और पढ़ें