बड़ी स्क्रीन पर इनपुट की सुविधा काम करती है

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

• कीबोर्ड के बुनियादी इस्तेमाल की जांच करें. जैसे, पहले जैसा करने के लिए Ctrl+Z, कॉपी करने के लिए Ctrl+C, और सेव करने के लिए Ctrl+S. डिफ़ॉल्ट कीबोर्ड शॉर्टकट की सूची देखने के लिए, कीबोर्ड की कार्रवाइयों को मैनेज करना लेख पढ़ें.
• कीबोर्ड के बेहतर वर्शन की जांच करें. उदाहरण के लिए, Tab बटन और ऐरो बटन की मदद से कीबोर्ड पर नेविगेट करना, Enter बटन से टेक्स्ट डालने की पुष्टि करना, और मीडिया ऐप्लिकेशन में Spacebar का इस्तेमाल करके चलाना और रोकना.
• माउस के बुनियादी इंटरैक्शन की जांच करें. इसमें, कॉन्टेक्स्ट मेन्यू के लिए राइट क्लिक, कर्सर घुमाने पर आइकॉन में होने वाले बदलाव, और कस्टम कॉम्पोनेंट पर माउस व्हील या ट्रैकपैड स्क्रोल इवेंट शामिल हैं.
• ऐप्लिकेशन के हिसाब से इनपुट डिवाइसों की जांच करें. जैसे, स्टाइलस, गेम कंट्रोलर, और संगीत ऐप्लिकेशन के एमआईडीआई कंट्रोलर.
• ऐसे इनपुट सिस्टम का इस्तेमाल करें जो बेहतर अनुभव दे सकें. इससे, डेस्कटॉप पर ऐप्लिकेशन का इस्तेमाल करना आसान हो जाता है. उदाहरण के लिए, डीजे ऐप्लिकेशन के लिए क्रॉस-फ़ेडर के तौर पर टचपैड, गेम के लिए माउस कैप्चर, और कीबोर्ड का इस्तेमाल करने वाले उपयोगकर्ताओं के लिए कीबोर्ड शॉर्टकट.

कीबोर्ड

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

नेविगेशन

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

कई ऐप्लिकेशन के लिए, ऐरो बटन और Tab बटन का नेविगेशन, Android फ़्रेमवर्क अपने-आप मैनेज करता है. उदाहरण के लिए, कुछ कॉम्पोज़ेबल डिफ़ॉल्ट रूप से फ़ोकस किए जा सकते हैं. जैसे, Button या clickable मॉडिफ़ायर वाला कॉम्पोज़ेबल. आम तौर पर, कीबोर्ड नेविगेशन किसी अतिरिक्त कोड के बिना काम करना चाहिए. डिफ़ॉल्ट रूप से फ़ोकस न किए जा सकने वाले कस्टम कॉम्पोज़ेबल के लिए, कीबोर्ड नेविगेशन की सुविधा चालू करने के लिए, focusable मॉडिफ़ायर जोड़ें:

var color by remember { mutableStateOf(Green) }
Box(
    Modifier
        .background(color)
        .onFocusChanged { color = if (it.isFocused) Blue else Green }
        .focusable()
) {
    Text("Focusable 1")
}
FocusSnippets.kt

ज़्यादा जानकारी के लिए, कॉम्पोज़ेबल को फ़ोकस करने लायक बनाना लेख पढ़ें.

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

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

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

Row {
    Column(Modifier.focusGroup()) {
        Button({}) { Text("Row1 Col1") }
        Button({}) { Text("Row2 Col1") }
        Button({}) { Text("Row3 Col1") }
    }
    Column(Modifier.focusGroup()) {
        Button({}) { Text("Row1 Col2") }
        Button({}) { Text("Row2 Col2") }
        Button({}) { Text("Row3 Col2") }
    }
}

ज़्यादा जानकारी के लिए, फ़ोकस ग्रुप के साथ बेहतर नेविगेशन उपलब्ध कराना लेख पढ़ें.

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

याद रखें कि सुलभता से जुड़ी ज़रूरतों वाले उपयोगकर्ताओं के लिए, कीबोर्ड की सुविधा ज़रूरी हो सकती है.

कीस्ट्रोक

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

कुछ उदाहरणों में, चैट ऐप्लिकेशन शामिल हैं, जो मैसेज भेजने के लिए Enter बटन का इस्तेमाल करते हैं. इसके अलावा, मीडिया ऐप्लिकेशन Spacebar का इस्तेमाल करके, वीडियो चलाना और बंद करना शुरू करते हैं. साथ ही, गेम w, a, s, और d बटन का इस्तेमाल करके, गेम में आगे-पीछे की गति को कंट्रोल करते हैं.

onKeyEvent मॉडिफ़ायर की मदद से, अलग-अलग कीस्ट्रोक को मैनेज किया जा सकता है. यह मॉडिफ़ायर, एक लेम्ब्डा स्वीकार करता है. इस लेम्ब्डा को तब कॉल किया जाता है, जब बदले गए कॉम्पोनेंट को कोई मुख्य इवेंट मिलता है. KeyEvent#type प्रॉपर्टी की मदद से, यह तय किया जा सकता है कि इवेंट, बटन दबाने (KeyDown) या बटन छोड़ने (KeyUp) से जुड़ा है या नहीं:

Box(
    modifier = Modifier.focusable().onKeyEvent {
        if(
            it.type == KeyEventType.KeyUp &&
            it.key == Key.S
        ) {
            doSomething()
            true
        } else {
            false
        }
    }
)  {
    Text("Press S key")
}

इसके अलावा, onKeyUp() कॉलबैक को बदला जा सकता है और हर मिले की-कोड के लिए, उम्मीद के मुताबिक व्यवहार जोड़ा जा सकता है:

override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
    return when (keyCode) {
        KeyEvent.KEYCODE_ENTER -> {
            sendChatMessage()
            true
        }
        KeyEvent.KEYCODE_SPACE -> {
            playOrPauseMedia()
            true
        }
        else -> super.onKeyUp(keyCode, event)
    }
}

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

ज़्यादा जानकारी के लिए, कीबोर्ड से की जाने वाली कार्रवाइयों को मैनेज करना लेख पढ़ें.

शॉर्टकट

हार्डवेयर कीबोर्ड का इस्तेमाल करते समय, सामान्य कीबोर्ड शॉर्टकट काम करते हैं. इनमें Ctrl, Alt, Shift, और Meta बटन शामिल हैं. अगर कोई ऐप्लिकेशन शॉर्टकट लागू नहीं करता है, तो उपयोगकर्ताओं को इसका अनुभव पसंद नहीं आएगा. ऐडवांस उपयोगकर्ता, ऐप्लिकेशन के अक्सर इस्तेमाल किए जाने वाले टास्क के लिए शॉर्टकट की भी सराहना करते हैं. शॉर्टकट की मदद से, किसी ऐप्लिकेशन को आसानी से इस्तेमाल किया जा सकता है. साथ ही, यह उन ऐप्लिकेशन से अलग दिखता है जिनमें शॉर्टकट नहीं होते.

कुछ सामान्य शॉर्टकट में Ctrl+S (सेव करें), Ctrl+Z (पहले जैसा करें), और Ctrl+Shift+Z (फिर से करें) शामिल हैं. डिफ़ॉल्ट शॉर्टकट की सूची के लिए, कीबोर्ड से की जाने वाली कार्रवाइयां मैनेज करना लेख पढ़ें.

KeyEvent ऑब्जेक्ट में ये एट्रिब्यूट होते हैं, जिनसे पता चलता है कि बटन दबाए गए हैं या नहीं:

• isAltPressed
• isCtrlPressed
• isMetaPressed
• isShiftPressed

उदाहरण के लिए:

Box(
    Modifier.onKeyEvent {
        if (it.isAltPressed && it.key == Key.A) {
            println("Alt + A is pressed")
            true
        } else {
            false
        }
    }
    .focusable()
)

ज़्यादा जानकारी के लिए, ये देखें:

• कार्रवाई बदलने वाली कुंजियां
• कीबोर्ड शॉर्टकट सहायक

स्टाइलस

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

स्टाइलस MotionEvent ऑब्जेक्ट ऐक्सेस करने के लिए, ड्रॉइंग की जगह पर pointerInteropFilter बदलाव करने वाला टूल जोड़ें. ViewModel क्लास को ऐसे तरीके के साथ लागू करें जो गति से जुड़े इवेंट को प्रोसेस करता हो. साथ ही, pointerInteropFilter मॉडिफ़ायर के onTouchEvent लैम्ब्डा के तौर पर तरीका पास करें:

@Composable
@OptIn(ExperimentalComposeUiApi::class)
fun DrawArea(modifier: Modifier = Modifier) {
   Canvas(modifier = modifier
       .clipToBounds()
       .pointerInteropFilter {
           viewModel.processMotionEvent(it)
       }

   ) {
       // Drawing code here.
   }
}

MotionEvent ऑब्जेक्ट में इवेंट के बारे में जानकारी होती है:

• MotionEvent#getToolType(), डिसप्ले से संपर्क करने वाले टूल के आधार पर TOOL_TYPE_FINGER, TOOL_TYPE_STYLUS या TOOL_TYPE_ERASER दिखाता है
• MotionEvent#getPressure(), स्टाइलस पेन पर डाले गए दबाव की जानकारी देता है (अगर यह सुविधा काम करती है)
• MotionEvent#getAxisValue() के साथ MotionEvent.AXIS_TILT और MotionEvent.AXIS_ORIENTATION, स्टाइलस के फ़िज़िकल झुकाव और ओरिएंटेशन की जानकारी देते हैं (अगर यह सुविधा काम करती है)

पुराने पॉइंट

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

• MotionEvent#getHistoricalX()
• MotionEvent#getHistoricalY()
• MotionEvent#getHistoricalPressure()
• MotionEvent#getHistoricalAxisValue()

हथेली के निशान की पहचान न हो पाना

जब उपयोगकर्ता स्टाइलस का इस्तेमाल करके, आपके ऐप्लिकेशन पर ड्रॉ करते हैं, लिखते हैं या उससे इंटरैक्ट करते हैं, तो कभी-कभी वे अपनी हथेली से स्क्रीन को छूते हैं. टच इवेंट (ACTION_DOWN या ACTION_POINTER_DOWN पर सेट करें) की सूचना, सिस्टम के अनचाहे तरीके से हथेली के छूने की पहचान करने और उसे अनदेखा करने से पहले, आपके ऐप्लिकेशन को दी जा सकती है.

Android, MotionEvent भेजकर, हथेली से छूने से जुड़े इवेंट रद्द करता है. अगर आपके ऐप्लिकेशन को ACTION_CANCEL मिलता है, तो जेस्चर को रद्द करें. अगर आपके ऐप्लिकेशन को ACTION_POINTER_UP मिलता है, तो देखें कि FLAG_CANCELED सेट है या नहीं. अगर ऐसा है, तो जेस्चर को रद्द करें.

सिर्फ़ FLAG_CANCELED के लिए जांच न करें. Android 13 (एपीआई लेवल 33) और उसके बाद के वर्शन पर, सिस्टम ACTION_CANCEL इवेंट के लिए FLAG_CANCELED सेट करता है. हालांकि, सिस्टम Android के पुराने वर्शन पर फ़्लैग सेट नहीं करता.

Android 12

Android 12 (एपीआई लेवल 32) और उससे पहले के वर्शन पर, सिर्फ़ एक पॉइंटर वाले टच इवेंट के लिए, पाम रिजेक्शन का पता लगाया जा सकता है. अगर सिर्फ़ हथेली का स्पर्श पॉइंटर है, तो सिस्टम, मोशन इवेंट ऑब्जेक्ट पर ACTION_CANCEL सेट करके इवेंट रद्द कर देता है. अगर अन्य पॉइंटर बंद हैं, तो सिस्टम ACTION_POINTER_UP सेट करता है. हालांकि, यह वैल्यू, पाम रिजेक्शन का पता लगाने के लिए ज़रूरी नहीं है.

Android 13

Android 13 (एपीआई लेवल 33) और उसके बाद के वर्शन पर, अगर सिर्फ़ हथेली का स्पर्श पॉइंटर है, तो सिस्टम, मोशन इवेंट ऑब्जेक्ट पर ACTION_CANCEL और FLAG_CANCELED सेट करके इवेंट रद्द कर देता है. अगर अन्य पॉइंटर बंद हैं, तो सिस्टम ACTION_POINTER_UP और FLAG_CANCELED सेट करता है.

जब भी आपके ऐप्लिकेशन को ACTION_POINTER_UP वाला कोई मोशन इवेंट मिलता है, तो FLAG_CANCELED देखें. इससे यह पता चलता है कि इवेंट में, हथेली के इशारे को अस्वीकार करने (या किसी दूसरे इवेंट को रद्द करने) की जानकारी है या नहीं.

नोट लेने के लिए ऐप्लिकेशन

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

<intent-filter>
    <action android:name="org.chromium.arc.intent.action.CREATE_NOTE" />
    <category android:name="android.intent.category.DEFAULT" />
</intent-filter>

जब कोई ऐप्लिकेशन सिस्टम में रजिस्टर हो जाता है, तो उपयोगकर्ता उसे डिफ़ॉल्ट तौर पर नोट लेने वाले ऐप्लिकेशन के तौर पर चुन सकता है. जब किसी नए नोट का अनुरोध किया जाता है, तो ऐप्लिकेशन को स्टाइलस इनपुट के लिए एक खाली नोट बनाना चाहिए. जब उपयोगकर्ता किसी इमेज (जैसे, स्क्रीनशॉट या डाउनलोड की गई इमेज) पर एनोटेट करना चाहता है, तो ऐप्लिकेशन ClipData के साथ लॉन्च होता है. इसमें content:// यूआरआई वाले एक या उससे ज़्यादा आइटम होते हैं. ऐप्लिकेशन को एक नोट बनाना चाहिए, जिसमें अटैच की गई पहली इमेज को बैकग्राउंड इमेज के तौर पर इस्तेमाल किया जाए. साथ ही, ऐसा मोड चालू करना चाहिए जिसमें उपयोगकर्ता, स्क्रीन पर स्टाइलस से ड्रॉ कर सके.

स्टाइलस के बिना नोट लेने के इंटेंट की जांच करना

[TBD remove section.]

यह जांचने के लिए कि कोई ऐप्लिकेशन, स्टाइलस के बिना नोट लेने के इंटेंट पर सही तरीके से जवाब देता है या नहीं, ChromeOS पर नोट लेने के विकल्प दिखाने के लिए यह तरीका अपनाएं:

1. डेवलपर मोड पर स्विच करना और डिवाइस पर डेटा सेव करने की अनुमति देना
2. टर्मिनल खोलने के लिए, Ctrl+Alt+F2 दबाएं
3. sudo vi /etc/chrome_dev.conf कमांड चलाएं
4. फ़ाइल के आखिर में नई लाइन में बदलाव करने और --ash-enable-palette जोड़ने के लिए, i दबाएं
5. Esc दबाकर सेव करें. इसके बाद, :, w, q टाइप करें और Enter दबाएं
6. ChromeOS के सामान्य यूज़र इंटरफ़ेस (यूआई) पर वापस जाने के लिए, Ctrl+Alt+F1 दबाएं
7. लॉग आउट करके, फिर से लॉग इन करें

अब शेल्फ़ पर स्टाइलस मेन्यू दिखेगा:

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

माउस और टचपैड के साथ काम करना

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

राइट क्लिक करना

सूची के किसी आइटम को दबाकर रखने जैसी किसी भी कार्रवाई से, ऐप्लिकेशन में संदर्भ मेन्यू दिखता है. इसलिए, दायां क्लिक करने पर भी ऐसा होना चाहिए.

राइट क्लिक इवेंट को मैनेज करने के लिए, ऐप्लिकेशन को View.OnContextClickListener रजिस्टर करना चाहिए:

Box(modifier = Modifier.fillMaxSize()) {
    AndroidView(
        modifier = Modifier.fillMaxSize(),
        factory = { context ->
            val rootView = FrameLayout(context)
            val onContextClickListener =
                View.OnContextClickListener { view ->
                    showContextMenu()
                    true
                }
            rootView.setOnContextClickListener(onContextClickListener)
            rootView
        },
    )
}

कॉन्टेक्स्ट मेन्यू बनाने के बारे में जानने के लिए, कॉन्टेक्स्ट मेन्यू बनाना लेख पढ़ें.

कर्सर घुमाएं

कर्सर घुमाने पर होने वाले इवेंट को मैनेज करके, अपने ऐप्लिकेशन के लेआउट को बेहतर और इस्तेमाल में आसान बनाया जा सकता है. यह खास तौर पर, पसंद के मुताबिक बनाए गएघटकों के लिए सही है:

इसके दो सबसे सामान्य उदाहरण ये हैं:

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

खींचें और छोड़ें

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

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

खींचें और छोड़ें सुविधा जोड़ने के लिए, खींचें और छोड़ें लेख पढ़ें. साथ ही, ChromeOS पर Android — खींचें और छोड़ें सुविधा लागू करना ब्लॉग पोस्ट भी पढ़ें.

ChromeOS के लिए खास बातें

• ऐप्लिकेशन के बाहर से खींचे और छोड़े गए आइटम ऐक्सेस करने के लिए, requestDragAndDropPermissions() से अनुमति का अनुरोध करना न भूलें

• किसी आइटम को खींचकर दूसरे ऐप्लिकेशन में छोड़ने के लिए, उस पर View.DRAG_FLAG_GLOBAL फ़्लैग होना चाहिए

  ड्रैग इवेंट शुरू करना देखें

ऐडवांस पॉइंटर सपोर्ट

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

@Composable
private fun LogPointerEvents(filter: PointerEventType? = null) {
    var log by remember { mutableStateOf("") }
    Column {
        Text(log)
        Box(
            Modifier
                .size(100.dp)
                .background(Color.Red)
                .pointerInput(filter) {
                    awaitPointerEventScope {
                        while (true) {
                            val event = awaitPointerEvent()
                            // handle pointer event
                            if (filter == null || event.type == filter) {
                                log = "${event.type}, ${event.changes.first().position}"
                            }
                        }
                    }
                }
        )
    }
}
UnderstandGesturesSnippets.kt

इनके बारे में जानने के लिए, PointerEvent ऑब्जेक्ट की जांच करें:

• PointerType: PointerEvent#changes से माउस, स्टाइलस, टच वगैरह
• PointerEventType: पॉइंटर की कार्रवाइयां, जैसे कि दबाना, मूव करना, स्क्रोल करना, और छोड़ना

गेम कंट्रोलर

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

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

इनपुट का अनुवाद मोड

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

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

<uses-feature
    android:name="android.hardware.type.pc"
    android:required="false" />

अन्य संसाधन

• ChromeOS पर इनपुट की सुविधाएं