Jetpack Compose की मदद से, टचस्क्रीन के अलावा अन्य इनपुट इंटरैक्शन को बढ़ाना

नमस्ते!

उम्मीद है कि आपको Android Developer Summit में अच्छा लग रहा होगा. हमारी बातचीत में शामिल होने के लिए धन्यवाद.

मैं एलेक्स वैन्यो हूं. मैं Compose टीम में सॉफ़्टवेयर इंजीनियर हूं. मेरे साथ जेरेमी भी हैं. वे भी Compose टीम में सॉफ़्टवेयर इंजीनियर हैं.

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

इनपुट, मोटे तौर पर, किसी भी ऐसे तरीके को कैप्चर करता है जिससे कोई उपयोगकर्ता आपके ऐप्लिकेशन से इंटरैक्ट करता है.

मोबाइल ऐप्लिकेशन के लिए, शायद टचस्क्रीन सबसे पहले आपके दिमाग़ में आती है. हालांकि, यह इनपुट का एकमात्र तरीका नहीं है.

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

साथ ही, हमें इनपुट के नए तरीके भी देखने को मिल रहे हैं. जैसे, स्मार्ट आईवियर पर ट्रैकपैड, एक्सआर में आंख और हाथ ट्रैक करने की सुविधा, और Wear पर उंगली और कलाई के जेस्चर.

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

आपको यह ध्यान रखना होगा कि आपके ऐप्लिकेशन का इस्तेमाल, कई तरह के इनपुट टाइप के साथ किया जाएगा.

इसकी एक वजह यह है कि ऐप्लिकेशन अब कई तरह के डिवाइसों पर काम करते हैं और इन डिवाइसों को इस्तेमाल करने वाले लोगों की संख्या भी बढ़ रही है.

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

Chromebook में पहले से मौजूद ट्रैकपैड और कीबोर्ड होता है. हालांकि, इसका मतलब यह नहीं है कि इनपुट के ये टाइप सिर्फ़ Chromebook के लिए हैं.

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

इनपुट के कई तरीकों की उम्मीद करने और उन्हें सपोर्ट करने की दूसरी बड़ी वजह सुलभता है.

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

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

संक्षेप में, आपको अलग-अलग तरह के इनपुट के लिए सहायता उपलब्ध करानी चाहिए. भले ही, डिवाइस का नाप या आकार कुछ भी हो.

इसलिए, आइए देखें कि Jetpack Compose, उपयोगकर्ताओं की इन ज़रूरतों को पूरा करने में आपके ऐप्लिकेशन की मदद कैसे करता है.

आम तौर पर, Compose का सिद्धांत यह है कि इनपुट के ये अलग-अलग टाइप, स्टैंडर्ड कॉम्पोनेंट के साथ सही तरीके से काम करें. इसके लिए, आपको कुछ भी खास करने की ज़रूरत नहीं है.

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

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

इस बातचीत में, हम ऐसे दो उदाहरणों पर नज़र डालेंगे. ये दोनों ही Compose में हाल ही में जोड़े गए हैं.

संयोग से, दोनों ही ट्रैकपैड जैसे डिवाइस हैं. हालांकि, जैसा कि आपको दिखेगा, इनका इस्तेमाल बहुत अलग-अलग तरीकों से किया जाता है.

चलिए, लैपटॉप स्टाइल वाले ट्रैकपैड पर हाल ही में किए गए कुछ काम से शुरुआत करते हैं.

ट्रैकपैड, पॉइंटर पर आधारित एक इनपुट डिवाइस है.

खास तौर पर, ट्रैकपैड का इस्तेमाल करने पर आपको टू-डाइमेंशनल कोऑर्डिनेट मिलते हैं.

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

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

इस अनुवाद में, आपको प्लैटफ़ॉर्म के कई मुश्किल कन्वर्ज़न देखने को मिल सकते हैं: जैसे, कर्सर की रफ़्तार और पाम रिजेक्शन.

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

Android प्लैटफ़ॉर्म से, हमें कर्सर घुमाने की जानकारी, क्लिक के साथ-साथ सेकंडरी या टर्शियरी क्लिक की जानकारी मिलती है. यह सारी जानकारी MotionEvents में शामिल होती है.

Compose के नए वर्शन में, हमने इस व्यवहार को कैसे बेहतर बनाया है, यह समझने के लिए आइए पहले इस बारे में खास जानकारी देखें कि Compose, पॉइंटर के इन इवेंट को कैसे बेहतर तरीके से मैनेज करता है.

मैं इसे छह अलग-अलग चरणों में बांटूंगा और हम इन सभी चरणों को एक-एक करके समझेंगे.

पहले चरण में, MotionEvents को Compose में माइग्रेट किया जाता है.

इसलिए, Compose असल में एक व्यू है: एक बहुत ही जटिल व्यू जो बहुत कुछ करता है. हालांकि, यह सिर्फ़ एक व्यू है. इसका मतलब है कि इसे पॉइंटर इनपुट के लिए, पूरे Android सिस्टम में काम करना होगा.

Compose में, इसका मतलब है कि Compose, सामान्य गतिविधि के अंदर सामान्य विंडो में मौजूद होता है. इसलिए, इसे MotionEvents मिलते हैं: Android प्लैटफ़ॉर्म के MotionEvents.

इसके बाद, Compose को उन्हें मैनेज करना होगा और वह सब करना होगा जो आपको Compose में पॉइंटर इनपुट के लिए करना है.

यहां पहला चरण, उन MotionEvents को Compose में इंटरनल, प्लैटफ़ॉर्म-एग्नोस्टिक रिप्रज़ेंटेशन में बदलना है. इसे हम PointerInputEvent कहते हैं.

यह एक इंटरनल टाइप है. इसलिए, आपको यह सीधे तौर पर नहीं दिखेगा.

अगर आपको यहां होने वाली सभी गतिविधियों की जानकारी देखनी है, तो MotionEventAdapter पर जाएं. हालांकि, हम यहां उन जानकारी को छोड़ रहे हैं.

इसलिए, अब हमारे पास Compose में MotionEvent का एक ऐसा वर्शन है जो किसी भी प्लैटफ़ॉर्म पर काम कर सकता है.

इसके बाद, यह पता चलता है कि इनपुट आम तौर पर समय के साथ होता है.

आपको एक के बाद एक कई इनपुट इवेंट मिलते हैं. इसलिए, समय के साथ क्या हो रहा है, इस बारे में जानना वाकई मददगार होता है.

हाथ के जेस्चर, वेलोसिटी ट्रैकिंग, और स्लोप डिटेक्शन जैसी चीज़ों के लिए, यह समझना ज़रूरी है कि हर समय क्या हो रहा है.

इसलिए, इस प्रोसेसिंग पाइपलाइन का अगला चरण, समय की इस जानकारी को जोड़ना है. साथ ही, यह लगातार होने वाले पॉइंटर इवेंट के आधार पर कुछ प्रीप्रोसेसिंग करेगा.

कोड में, इसे मौजूदा PointerInputEvent को लेने, उसे पिछले इवेंट के साथ जोड़ने, और फिर समय के हिसाब से InternalPointerEvent बनाने के तौर पर देखा जा सकता है.

जैसा कि नाम से पता चलता है, यह एक और इंटरनल टाइप है. हालांकि, इसे पॉइंटर इनपुट में होने वाले बदलावों के लिए, अलग-अलग पॉइंटर आईडी के मैप के तौर पर देखा जा सकता है. PointerInputChanges एक पब्लिक टाइप है.

यह हमारा पहला वीडियो है.

अलग-अलग पॉइंटर आईडी के बारे में सोचते समय, आपको यह ध्यान रखना चाहिए कि अब हमें समय को ट्रैक करने के बारे में पता है. इसलिए, हम यह भी ट्रैक कर सकते हैं कि पॉइंटर आईडी कब आते हैं और कब जाते हैं.

सिर्फ़ एक नहीं है.

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

अगर आपको इस बारे में ज़्यादा जानकारी चाहिए, तो PointerInputChangeEventProducer को देखें. यह इन सभी कामों को करता है. हालांकि, हम इस बारे में बात नहीं करेंगे.

हमें और भी बहुत कुछ करना है.

इसलिए, अब हमारे पास इनपुट का Compose वर्शन है. इसमें समय की जानकारी भी है.

अगला चरण यह तय करना है कि उस इवेंट का क्या करना है.

हम इसे कहां भेजें?

इससे हिट पाथ की टेस्टिंग की जाती है.

मान लीजिए कि हमारे पास एक MotionEvent है और यह ComposeView पूरी विंडो या पूरी स्क्रीन को भर रहा है.

हमें यह पता लगाना होगा कि इसे कहां भेजना है.

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

इन लेआउट नोड में निर्देशांक, सीमाएं, और आकार होते हैं. इसलिए, हमें यह पता लगाना होगा कि इनमें से किस नोड पर क्लिक किया गया है.

हालांकि, यह भी सबसे सामान्य नज़रिया नहीं है.

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

हम ऐसा अक्सर करते हैं.

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

इसलिए, इस मामले में नेस्टिंग हैरारकी के हिसाब से तीन लेवल हैं.

इसलिए, हमारे पास हिट पाथ है. हालांकि, यह काफ़ी नहीं है.

याद है, मैंने कहा था कि हमारे पास कई पॉइंटर इनपुट इवेंट हैं और कई पॉइंटर डाउन हो सकते हैं?

इसके लिए, हमारे पास पूरा हिट पाथ ट्री होना चाहिए.

एक से ज़्यादा पॉइंटर होने पर, सिर्फ़ एक हिट पाथ नहीं होता.

इसलिए, अगला चरण इस हिट पाथ ट्री को बनाना और अपडेट करना है.

इसलिए, यहां इस बारे में ज़्यादा जानकारी दी गई है कि क्या हो रहा है.

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

जब कोई पॉइंटर नीचे जाता है, तो हम उस हिट पाथ को ट्रैक करते हैं. यह ट्री का पूरा पाथ होता है. इसके बाद, हमें उस पॉइंटर के लिए एक हिट पाथ मिलता है.

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

यह कुछ नोड के साथ इंटरसेक्ट कर सकता है, जैसे कि दूसरा नोड. हालांकि, यह अन्य नोड के साथ भी इंटरैक्ट कर सकता है.

दाईं ओर, हिट पाथ ट्री है, जिसे हम अब मैनेज कर रहे हैं.

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

ठीक है।

इसलिए, अब हमारे पास एक हिट पाथ ट्री है, जिसे हम इन इनपुट इवेंट के लिए मैनेज कर रहे हैं. इसका मतलब है कि हम अगले चरण पर हैं.

अब हमें पता है कि इन पॉइंटर इनपुट इवेंट को कहां भेजना है और कौनसे नोड किस इवेंट में दिलचस्पी रखते हैं.

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

यह बहुत अच्छा है कि आपके नोड को अपने लोकल कोऑर्डिनेट स्पेस में इनपुट इवेंट मिलते हैं. इसलिए, आपको खुद से कोऑर्डिनेट मैथ करने की ज़रूरत नहीं है.

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

आखिर में, छठे चरण में इवेंट को असल में भेजा जाता है.

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

हम ऐसा तीन अलग-अलग पास में करते हैं.

हमारे पास एक शुरुआती पास, एक मुख्य पास, और एक फ़ाइनल पास होता है.

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

इसलिए, पहला पास, यानी कि शुरुआती पास, पैरंट से चाइल्ड तक जाता है.

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

इससे, शुरुआत में बच्चे को इवेंट का ऐक्सेस मिल जाता है. हालांकि, इसके बाद उसे कोई और इवेंट नहीं मिलता.

दूसरा पास, मुख्य पास होता है.

यह इकलौता ऐसा ऐरो है जो डिसेंडेंट से ऐंसेस्टर की ओर जाता है.

जैसा कि नाम से पता चलता है, यह गेम में चीज़ें करने के लिए मुख्य पास है.

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

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

यहां बच्चा अपने माता-पिता को बता सकता है कि उन्होंने इवेंट का कुछ हिस्सा देख लिया है.

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

तो, ये तीन पास और छह फ़ेज़ हैं.

ये पॉइंटर इनपुट सिस्टम के ऊपर मौजूद हर चीज़ का आधार हैं.

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

इन सभी बातों के साथ, अब हम इस बारे में थोड़ी बात कर सकते हैं कि हमने Compose में ट्रैकपैड के काम करने के तरीके को कैसे बेहतर बनाया है.

इसलिए, Compose 1.12 से पहले, ट्रैकपैड इनपुट इवेंट को टच के पॉइंटर टाइप के तौर पर रिपोर्ट किया जाता था. ऐसा इसलिए, क्योंकि कर्सर को कंट्रोल करने के लिए, ट्रैकपैड के साथ उंगली से इंटरैक्ट किया जाता है.

हालांकि, उपयोगकर्ता को उम्मीद होती है कि यह इनपुट टाइप, फ़िज़िकल माउस की तरह ही काम करेगा.

इसलिए, हमने पॉइंटर टाइप को PointerType.Touch से बदलकर PointerType.Mouse कर दिया.

इस बदलाव के बाद, उपयोगकर्ताओं को माउस और ट्रैकपैड का बेहतर अनुभव मिलेगा. यह अनुभव, इस जानकारी को देखने वाले किसी भी कॉम्पोनेंट के लिए एक जैसा होगा.

इसका एक उदाहरण टूलटिप का व्यवहार है: हो सकता है कि आपको टूलटिप के लिए, ट्रैकपैड और माउस का व्यवहार एक जैसा रखना हो.

ट्रैकपैड में किया गया दूसरा बड़ा बदलाव, उंगलियों से किए जाने वाले हाथ के जेस्चर से जुड़ा है.

पहले, Compose को Android प्लैटफ़ॉर्म के नकली उंगलियों वाले कॉन्सेप्ट से गुज़रना पड़ता था. यह कॉन्सेप्ट स्मार्ट था, लेकिन थोड़ा डरावना भी था.

आइए, जानते हैं कि इसका क्या मतलब है.

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

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

इसलिए, ट्रैकपैड पर दो उंगलियों को ऊपर की ओर ले जाने पर, टचस्क्रीन पर एक नकली उंगली ऊपर की ओर जाती है. इससे स्क्रीन नीचे की ओर स्क्रोल होती है.

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

इसके लिए, नकली उंगली की दिशा को बदल दिया जाता है.

इसलिए, अब ट्रैकपैड पर दो उंगलियों को ऊपर की ओर ले जाने पर, टचस्क्रीन पर एक नकली उंगली नीचे की ओर जाती है. इससे स्क्रीन ऊपर की ओर स्क्रोल होती है. यह पहले के मुकाबले बिलकुल उलट है.

स्केलिंग भी कुछ इसी तरह से काम करती है.

जब ट्रैकपैड पर दो उंगलियों का इस्तेमाल करके साइज़ बदला जाता है, तो Android दो नकली टचस्क्रीन उंगलियां जनरेट करता है. ये उंगलियां, जेस्चर के हिसाब से नीचे की ओर जाती हैं और फिर एक-दूसरे के करीब या दूर जाती हैं. इससे ज़ूम इन या ज़ूम आउट करने के लिए, मनचाहा जेस्चर मिलता है.

इसलिए, Compose 1.12 में पैनिंग और Compose 1.13 में स्केलिंग के लिए, अब हम उन नकली उंगलियों को इंटरसेप्ट करते हैं.

हम उन्हें उसी तरह नहीं भेजते जिस तरह प्लैटफ़ॉर्म हमें देता है. हम उन्हें नए पॉइंटर इवेंट टाइप में फिर से समझते हैं: पैनिंग के लिए PanStart, PanMove, और PanEnd. साथ ही, स्केलिंग के लिए ScaleStart, ScaleChange, और ScaleEnd.

हम ऐसा Android से Compose इवेंट कन्वर्ज़न फ़ेज़ में करते हैं, जिसके बारे में मैंने पहले बताया था.

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

आइए, जानते हैं कि यह क्यों ज़रूरी है.

हम ऐसा क्यों करते हैं?

मान लें कि यहां मौजूद यह बॉक्स एक अच्छी इमेज है, जिसे हमें बड़ा करना है.

ट्रैकपैड पर दो उंगलियों का इस्तेमाल करके स्केल करने पर, ऐसा हो सकता है कि दो नकली उंगलियों में से एक, एलिमेंट को मिस कर दे.

इसका हिट पाथ, इमेज को इंटरसेक्ट नहीं करेगा और यह सीमाओं के बाहर से शुरू होगा.

इसलिए, स्केल करने के बजाय, हो सकता है कि इमेज स्क्रोल हो जाए.

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

उपयोगकर्ता को यह नहीं चाहिए था.

वे अपने कारोबार को बढ़ाना चाहते थे.

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

कर्सर चाहे कहीं भी हो या जिस एलिमेंट को स्केल करना है उसके किनारे के कितना भी करीब हो, अब वह सही तरीके से स्केल होगा.

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

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

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

साथ ही, हमने टेस्टिंग एपीआई भी जोड़े हैं. इनकी मदद से, यह भी देखा जा सकता है कि आपका ऐप्लिकेशन, इन सभी अलग-अलग तरह के इनपुट को सही तरीके से हैंडल कर रहा है या नहीं.

इसलिए, performTrackpadInput काफ़ी हद तक माउस और टच के लिए, मौजूदा टेस्टिंग एपीआई जैसा दिखता है.

onNodeWithContentDescription("Photo")
    .performTrackpadInput {
        click(center)

        pan(Offset(0f, 100f))

        scale(0.9f)
    }

इन सभी का इस्तेमाल करके, यह पुष्टि की जा सकती है कि आपका ऐप्लिकेशन सही तरीके से काम कर रहा है. इससे कोई फ़र्क़ नहीं पड़ता कि उपयोगकर्ता आपके डिवाइस पर कौनसा इनपुट डिवाइस इस्तेमाल कर रहा है.

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

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

धन्यवाद.

ठीक है।

नमस्ते, मैं जेरेमी वॉकर हूं.

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

खास तौर पर, इनडायरेक्ट इनपुट टाइप के साथ ऐसा होता है. यह इनपुट टाइप, डिवाइस के साइज़, डाइमेंशन या कॉन्फ़िगरेशन के आधार पर नए इनपुट की वजह से आया है: इंटेलिजेंट आईवियर.

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

ये एलेक्स के बताए गए कान से थोड़े अलग हैं. ये सिर के दोनों तरफ़ होते हैं, वर्टिकल होते हैं, बहुत चौड़े होते हैं, और बहुत छोटे होते हैं.

इसलिए, जब हम यह सोच रहे थे कि Compose में यह कैसे काम करेगा, तो हमने पाया कि अगर आपके सामने एक छोटा सा बटन है और आपको उसे छूने के लिए कर्सर को मूव करना पड़े, तो यह एक अच्छा अनुभव नहीं होगा, है न?

तो, हम इसे कैसे सपोर्ट करेंगे?

स्मार्ट ग्लास का यूज़र इंटरफ़ेस कुछ ऐसा दिखता है.

इसे खास तौर पर इस तरह से डिज़ाइन किया गया है कि यह आपके फ़ील्ड ऑफ़ व्यू (कैमरे से दिख रहा व्यू) पर कॉन्टेंट को आसानी से दिखा सके.

हालांकि, यह बहुत आसान है. हम इसे आसान रखने की कोशिश करते हैं.

यहां दिए गए उदाहरण में, आपको एक सूची दिख रही होगी.

इसमें बीच में मौजूद किसी एलिमेंट पर फ़ोकस किया गया है.

हम असल में क्या करना चाहते हैं?

हमें इसे चुनना है या शायद पिछले या अगले विकल्प पर जाना है.

यह ज़रूरी नहीं है कि हम स्क्रीन पर मौजूद जगह की जानकारी का इस्तेमाल करें.

यह थोड़ा मुश्किल है, लेकिन यहां आपको तीन विकल्प दिख रहे हैं: कॉल को खत्म करना, अनम्यूट करना या वीडियो बंद करना.

हालांकि, आपको उसे चुनना होगा या किसी दूसरे विकल्प पर जाकर उसे चुनना होगा.

इसलिए, हमें लगता है कि हमें स्क्रीन पर किसी जगह को सीधे तौर पर मैप करने की ज़रूरत नहीं है. इस मामले में, आपकी आंखों को मैप करने की ज़रूरत नहीं है.

तो, हाँ, यह असल में ऐसा दिखता है.

उदाहरण के लिए, यहां देखा जा सकता है कि मैं सिर्फ़ एलिमेंट के बीच स्विच कर रहा हूं. यह Glasses के यूज़र इंटरफ़ेस (यूआई) पर है और यह हमारी ज़रूरत के हिसाब से सही है.

इसके बाद, उस पर टैप करें.

इसलिए, हमने Android को देखा और सोचा कि ऐसी कौनसी चीज़ें मौजूद हैं जिनका इस्तेमाल करके, हम इस सुविधा को उपलब्ध करा सकते हैं.

अगर आप लोगों को कभी ऐसा लगा हो कि ओह, माफ़ करें.

यहां पर, वीडियो को आगे बढ़ाया जा रहा है.

मुझे वापस जाने दो.

आपने कर दिखाया।

ठीक है।

इसलिए, अगर आपने कभी इनमें से किसी डिवाइस का इस्तेमाल किया है और उसे किसी Android डिवाइस से लिंक किया है, तो आपको पता होगा कि यूज़र इंटरफ़ेस (यूआई) एलिमेंट को एक से दूसरे डिवाइस पर आसानी से ले जाया जा सकता है.

उदाहरण के लिए, रिमोट से Google TV पर फ़िल्मों की पूरी ग्रिड देखी जा सकती है. इसके बाद, ऐरो बटन दबाकर अपनी पसंद की फ़िल्म पर जाएं और उसे चुनने के लिए, 'ठीक है' बटन दबाएं.

अगर आपके पास गेम मेन्यू है और आपके पास यह कंट्रोलर है, तो डी-पैड या जॉयस्टिक का इस्तेमाल करके, किसी यूज़र इंटरफ़ेस (यूआई) एलिमेंट पर जाएं. जैसे, किसी मेन्यू में जाएं और उसे चुनें.

कीबोर्ड के साथ भी ऐसा ही है.

इसलिए, यह Compose में हमारी ज़रूरत के मुताबिक है.

यहां कुछ चीज़ें दी गई हैं, ताकि आपको अंदाज़ा हो सके कि यह कैसा दिखता है.

अगर हम थोड़ा और पीछे जाएं, तो एक ऐसा टचपैड टाइप था जिसे टीवी के साथ जोड़ा गया था. इसमें नेविगेशन टच नाम की सुविधा का इस्तेमाल किया जाता था.

और वहां विचार यह है कि यह पूरी तरह से नहीं है x और y निर्देशांक पूरी तरह से नहीं हैं स्क्रीन से बिल्कुल भी नहीं छुआ.

इनका इस्तेमाल सिर्फ़ जेस्चर की पहचान करने के लिए किया जाता है.

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

बाईं ओर स्वाइप करने पर, बाईं, ऊपर, और नीचे की ओर जाया जा सकता है.

इसलिए, इससे हमें ज़्यादातर वही जानकारी मिलती है जो हमें चाहिए.

खींचने और छोड़ने, स्वाइप करने वगैरह की जानकारी पाने के लिए, सिर्फ़ x और y का इस्तेमाल किया जाता है. जैसे, रफ़्तार को ट्रैक करने के लिए. इससे हमें Compose का इस्तेमाल शुरू करने के लिए, ज़्यादातर ज़रूरी जानकारी मिल जाती है.

यह बिलकुल सटीक नहीं है, क्योंकि यह टीवी से मैप किया गया है. इसलिए, हमें यह पक्का करना होगा कि हम टीवी के रास्ते पर न जाएं और बाद में टीवी को खराब न करें. इसलिए, हमें यह पक्का करना होगा कि हम उन्हें अलग-अलग करें. हालांकि, इस बारे में हम थोड़ी देर में बात करेंगे.

हालांकि, इससे हमें शुरुआत करने में मदद मिलती है.

इससे हम इस तरह के टच नेविगेशन का इस्तेमाल कर सकते हैं.

ठीक है.

एपीआई का डिज़ाइन कैसा दिखेगा?

Compose में, सबसे सामान्य या सबसे ज़्यादा इस्तेमाल किया जाने वाला इनपुट, टच है. है न?

इसलिए, हमें इस पर काफ़ी काम करना है.

इसलिए, हमें यह समझना पड़ा कि यह उससे कैसे जुड़ा है.

आपको याद दिला दें कि PointerEvent ऐसा दिखता है.

यहां देखा जा सकता है कि आपके पास एक टाइप है, जो ऊपर की ओर जाने वाला डाउन टाइप है. इसके बाद, आपके पास यह PointerInputChange है, जो सिर्फ़ एक सूची है. इसे उंगलियों के तौर पर समझा जा सकता है.

अगर आपने तीन उंगलियां नीचे की हैं, तो सूची में तीन चीज़ें होंगी.

इसलिए, हम चाहते थे कि यह कुछ ऐसा दिखे.

यह कोई यूज़र इंटरफ़ेस (यूआई) मॉड्यूल नहीं है. यह मॉड्यूल, इनपुट से जुड़े काम करने के लिए ज़्यादातर डेवलपर के इस्तेमाल किए जाने वाले मॉड्यूल से काफ़ी छोटा है.

ये फ़ाउंडेशन लेयर के ऊपर एक लेयर की तरह होंगे.

यहीं पर हमारे सभी जेस्चर डिटेक्टर मौजूद हैं.

डेवलपर के तौर पर, आपको इन सभी चीज़ों की परवाह नहीं होती. जैसे, मिनट इनपुट.

आपको बस यह जानना होता है कि क्या कोई ड्रैग हुआ, क्या कोई क्लिक हुआ, क्या कोई स्वाइप हुआ. इसके बाद, उसके आधार पर अपनी कार्रवाई की जाती है.

इसलिए, हमारे पास कई कोड हैं जो आपके लिए यह काम करते हैं. ये कोड, बैकग्राउंड में काम करने वाली इन सुविधाओं की मदद से काम करते हैं.

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

इसलिए, हमने एक नया टाइप बनाया जो काफ़ी हद तक पहले जैसा ही दिखता है.

इसे इनडायरेक्ट कहा जाता है.

इसका मतलब है कि स्क्रीन को सीधे तौर पर नहीं छुआ जाता.

इसलिए, यह आपको बताता है कि यह सुविधा आने वाली है. इसे टच पॉइंट के नज़रिए से न देखें.

ध्यान दें कि हम यहां सिर्फ़ जेस्चर को हैंडल कर रहे हैं और यूज़र इंटरफ़ेस (यूआई) एलिमेंट के बीच नेविगेट कर रहे हैं.

टाइप एक जैसा है.

इसमें उंगलियों की सूची होती है.

इस मामले में, यह IndirectPointerInputChange है.

हमने ऐसा किया और यह तरीका बहुत कारगर साबित हुआ.

इसके बाद, हमें एक और आइटम मिला, जिसका नाम प्राइमरी डायरेक्शनल मोशन ऐक्सिस है.

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

तो, यह कैसे हुआ?

इसके अलावा, आपके सिर के साइड में यह टचपैड है. यह चौड़ा और छोटा है.

इसलिए, इस समय हमें यह आइडिया आया कि ठीक है, हमारे पास टच नेविगेशन है.

इसलिए, बाईं और दाईं ओर स्वाइप किया जा सकता है.

यह तरीका बहुत अच्छा है.

लेकिन, अगर आप सोचें कि ट्रैकपैड अब कैसे मौजूद हैं, तो?

बाईं या दाईं ओर जाने पर, आपको यूज़र इंटरफ़ेस (यूआई) कॉन्टेंट के साथ ट्रैकपैड पर बाईं या दाईं ओर जाना होगा.

ऊपर या नीचे जाने पर, सूची में ऊपर या नीचे की ओर स्क्रोल किया जाएगा.

इसलिए, अगर चश्मे के साथ ऐसा करने की कोशिश की जाए, तो यह बहुत बुरा नहीं है, है न?

लेकिन अगर ऐसा किया जाता है, तो यह अच्छा अनुभव नहीं होता.

हमें पता चला कि सबसे नैचुरल मूवमेंट, टैप करना है. हालांकि, चश्मे के साइड में स्वाइप करना भी एक नैचुरल मूवमेंट है.

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

इसके बारे में इस तरह से सोचा जा सकता है कि अगर आपके सामने कोई सूची है, तो यहां स्वाइप करने पर, सूची में आगे या पीछे जाया जा सकता है.

इसलिए, हम दो डाइमेंशन वाला इनपुट ले रहे हैं और इसे एक डाइमेंशन वाले तरीके से समझने की कोशिश कर रहे हैं.

यहीं से प्राइमरी मोशन ऐक्सिस का आइडिया आया. इसमें हॉरिज़ॉन्टल और वर्टिकल, दोनों तरह से स्क्रोल किया जा सकता है.

इसलिए, डिवाइस पर ही यह तय किया जा सकता है.

आप कह सकते हैं कि यह कोई सामान्य ट्रैकपैड नहीं है.

मैं चाहता हूं कि मुख्य दिशा हॉरिज़ॉन्टल हो. यही मुख्य ऐक्सिस है, जिसके साथ मुझे आगे बढ़ना है.

इसलिए, यह आइडिया वहीं से आया.

ठीक है।

इसलिए, हमें इस बात की खुशी है.

Compose, सब कुछ मैनेज कर रहा है.

साथ ही, आपके पास वर्टिकल वीडियो का यह शानदार फ़ॉर्मैट है.

इस बारे में सोचा जा सकता है.

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

हमारे पास ऊपर, नीचे, बाएं, दाएं का विकल्प नहीं है.

हमारे पास सिर्फ़ आगे और पीछे जाने का विकल्प है.

इसके बाद, हम उसे मैप कर सकते हैं. इसके लिए, आपको अगले और पिछले फ़ोकस के बारे में पता होना चाहिए.

अब हम अगले और पिछले पर जाते हैं.

यह वर्टिकल वीडियो के लिए बहुत अच्छा है.

यह और भी बेहतर है.

यह हॉरिज़ॉन्टल मोड में भी काम करता है, है न?

क्योंकि आपके पास फ़ोकस किए गए आइटम का एक ग्रुप होता है.

आपको बस अगली या पिछली स्लाइड पर जाना होगा. यह दोनों के साथ काम करता है.

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

इसलिए, अब हमें इस कॉन्सेप्ट को प्लैटफ़ॉर्म पर वापस लाना पड़ा और यह कहना पड़ा कि ठीक है, हमें इसे प्लैटफ़ॉर्म पर तय करना होगा, ताकि हम इसे स्टैंडर्ड बना सकें और ये डिवाइस खुद ही इसे तय कर सकें. इसके बाद, Compose इसे पूरी तरह से सपोर्ट कर सकता है.

इसलिए, एक ऐसा मामला है जहां हमने Compose में काम किया और Compose में आगे बढ़े और पीछे की ओर काम किया. साथ ही, इसे अपने साथ लेकर आए.

हमने ठीक ऐसा ही किया.

हमने यह नया एपीआई इसलिए बनाया है, ताकि आप या आपका डिवाइस यह तय कर सके कि किस तरह के विज्ञापन दिखाने हैं.

InputDevice.ViewBehavior
.getPrimaryDirectionalMotionAxis()

आपको याद होगा कि मैंने पहले टच इनपुट या टच नेविगेशन के बारे में बात की थी. मैंने बताया था कि यह सुविधा मुख्य रूप से टीवी के लिए है.

हम उन लागू किए गए तरीकों को नहीं बदलना चाहते थे.

इसलिए, हमने एक और फ़ील्ड जोड़ा है, ताकि इस नए तरह के ग्लास इनपुट की जानकारी दी जा सके.

ठीक है।

आखिर में, आपके लिए इसका क्या मतलब है?

यह जेस्चर डिटेक्टर का एक बेहतर वर्शन है.

// Glimmer Library
Box(
    modifier =
        Modifier.fillMaxSize()
            .onIndirectPointerGesture(
                enabled = true,
                onSwipeForward = { /* onSwipeForward */ },
                onSwipeBackward = { /* onSwipeBackward */ },
                onClick = { /* onClick */ },
            )
            .focusTarget()
) {
    // App()

अगर Foundation का इस्तेमाल किया जा रहा है, तो यह जेस्चर डिटेक्टर के साथ काम करेगा.

हमने आपके लिए यह काम कर दिया है. इसलिए, आपको कुछ करने की ज़रूरत नहीं है.

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

ठीक है।

इसलिए, हमने एपीआई के काम करने के तरीके के बारे में बताया है. साथ ही, प्लैटफ़ॉर्म और Compose में इसके काम करने के तरीके के बारे में भी बताया है.

टेस्टिंग के बारे में क्या?

इसलिए, जब आपको टच की जांच करनी हो, तो टच ऐसा दिखता है.

@Test
clickTest {

rule.onNodeWithTag(defaultTag)
.performTouchInput
{ click(center) }

}

आपको बस performTouchInput कहना होगा और फिर जेस्चर देना होगा.

इसके लिए, कई तरह के जेस्चर होते हैं. हम जेस्चर को काम करने लायक बनाने के लिए, सभी छोटे-छोटे इवेंट बनाते हैं.

यह बड़े लेवल पर कैसे काम करता है?

आपके पास Compose यूज़र इंटरफ़ेस (यूआई) मॉड्यूल और यूज़र इंटरफ़ेस (यूआई) टेस्टिंग मॉड्यूल है. ये दोनों MotionEvents का इस्तेमाल करके, कम से कम इनपुट के हिसाब से कम्यूनिकेट करते हैं.

यूज़र इंटरफ़ेस (यूआई) टेस्टिंग मॉड्यूल, सूची बनाने के तरीके का भी इस्तेमाल करता है. यह तरीका MotionEvent पर आधारित होता है.

मैं आपको यह क्यों बता रहा हूं?

क्योंकि प्रोग्राम के हिसाब से ऐसा MotionEvent नहीं बनाया जा सकता जो इनडायरेक्ट इनपुट इवेंट जैसा हो. यह मेरे लिए बहुत अच्छी बात थी, क्योंकि इसका मतलब था कि मुझे मॉड्यूल और सूची बनाने वाले सिस्टम के बीच होने वाले सभी कम्यूनिकेशन को फिर से लिखना था.

लेकिन मैंने ऐसा किया.

आपके लिए इसके क्या मायने हैं?

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

आपको बस नाम में 'इनडायरेक्ट' जोड़ना होगा.

@Test
clickTest {

rule.onNodeWithTag(defaultTag)
// .performTouchInput
.performIndirectPointerInput (
IndirectPointerEventPrimaryDirectionalMotionAxis.X,
inputDeviceSize,
)
{ click(center) }
}

अब, मैंने कुछ अतिरिक्त पैरामीटर पास किए हैं.

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

इसके बाद, इनपुट साइज़ ज़ाहिर तौर पर टचपैड का साइज़ होगा.

हालांकि, इससे ज़्यादा फ़र्क़ नहीं पड़ता.

इसलिए, अगर सोर्स कोड को देखें, तो आपको दिखेगा कि मैंने सिर्फ़ एक एक्सटेंशन फ़ंक्शन लिखा है और यह कुछ ऐसा दिखता है.

@Test
clickTest {

rule.onNodeWithTag(defaultTag)
// .performTouchInput
.performIndirectPointerInput
{ click(center) }

}

ठीक है।

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

हालांकि, हम ये काम कर रहे हैं. मैं आंखों और हाथों को ट्रैक करने के लिए भी ये कसरतें कर रहा हूं. इसलिए, आने वाले समय में और भी बहुत कुछ देखने को मिलेगा.

इसलिए, मैं चाहता हूं कि आप मेरे हिस्से से क्या याद रखें?

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

इसलिए, अगर इन Foundation जेस्चर डिटेक्टर का इस्तेमाल किया जा रहा है, तो यह सुविधा अपने-आप काम करती है.

यह सबसे ज़रूरी है.

दूसरा, Compose मुख्य यूज़र इंटरफ़ेस (यूआई) टूलकिट है. हम प्लैटफ़ॉर्म और टूलकिट, दोनों में नए इनपुट टाइप को एक्सप्लोर और सपोर्ट करना जारी रखेंगे. जैसा कि मैंने यहां किया है.

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

धन्यवाद, हमें उम्मीद है कि इससे आपको मदद मिली होगी.