Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

कीबोर्ड से जुड़ी कार्रवाइयां मैनेज करना

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

डिफ़ॉल्ट कीबोर्ड शॉर्टकट

ये कीबोर्ड शॉर्टकट पहले से उपलब्ध होते हैं.

कीबोर्ड शॉर्टकट	कार्रवाई	शॉर्टकट के साथ काम करने वाले कंपोज़ेबल
`Shift`+`Ctrl`+`लेफ़्ट ऐरो`/`राइट ऐरो`	शब्द की शुरुआत/आखिर तक का टेक्स्ट चुनना	`BasicTextField`, `TextField`
`Shift`+`Ctrl`+`अप ऐरो`/`डाउन ऐरो`	पैराग्राफ़ की शुरुआत/आखिर तक का टेक्स्ट चुनना	`BasicTextField`, `TextField`
`Shift`+`Alt`+`अप ऐरो`/`डाउन ऐरो` या `Shift`+`मेटा`+`लेफ़्ट ऐरो`/`राइट ऐरो`	टेक्स्ट की शुरुआत/आखिर तक का टेक्स्ट चुनना	`BasicTextField`, `TextField`
`Shift`+`लेफ़्ट ऐरो`/`राइट ऐरो`	वर्ण चुनें	`BasicTextField`, `TextField`
`Ctrl`+`A`	सभी चुनें	`BasicTextField`, `TextField`
`Ctrl`+`C`/`Ctrl`+`X`/`Ctrl`+`V`	कॉपी/कट/पेस्ट करना	`BasicTextField`, `TextField`
`Ctrl`+`Z`/`Ctrl`+`Shift`+`Z`	पहले जैसा करें/फिर से करें	`BasicTextField`, `TextField`
`PageDown`/`PageUp`	स्क्रोल करें	`LazyColumn`, `verticalScroll` मॉडिफ़ायर, `scrollable` मॉडिफ़ायर

महत्वपूर्ण इवेंट

Compose में, onKeyEvent मॉडिफ़ायर की मदद से, किसी एक कीस्ट्रोक को मैनेज किया जा सकता है. यह मॉडिफ़ायर, एक लैम्डा स्वीकार करता है. इस लैम्डा को तब कॉल किया जाता है, जब बदले गए कॉम्पोनेंट को कोई मुख्य इवेंट मिलता है. मुख्य इवेंट को KeyEvent ऑब्जेक्ट के तौर पर बताया गया है. onKeyEvent मॉडिफ़ायर को पास किए गए लैम्ब्डा में मौजूद ऑब्जेक्ट को देखकर, हर मुख्य इवेंट की जानकारी पाई जा सकती है.

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

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

यहां दिए गए स्निपेट से पता चलता है कि जब उपयोगकर्ता Box कॉम्पोनेंट पर S बटन को छोड़ता है, तो doSomething() फ़ंक्शन को कैसे कॉल किया जाता है:

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

संशोधक कुंजियां

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

अपने ऐप्लिकेशन के मुख्य इवेंट के बारे में साफ़ तौर पर बताएं. नीचे दिया गया स्निपेट, doSomething() फ़ंक्शन को सिर्फ़ तब कॉल करता है, जब उपयोगकर्ता सिर्फ़ S बटन को छोड़ता है. अगर उपयोगकर्ता, कार्रवाई बदलने वाली किसी कुंजी को दबाता है, जैसे कि Shift कुंजी, तो ऐप्लिकेशन फ़ंक्शन को कॉल नहीं करता.

Box(
    modifier = Modifier
        .focusable()
        .onKeyEvent {
            if (
                it.type == KeyEventType.KeyUp &&
                it.key == Key.S &&
                !it.isAltPressed &&
                !it.isCtrlPressed &&
                !it.isMetaPressed &&
                !it.isShiftPressed
            ) {
                doSomething()
                true
            } else {
                false
            }
        }
) {
    Text("Press S key with a modifier key")
}commands.kt

Spacebar और Enter कुंजी के क्लिक इवेंट

Spacebar और Enter बटन से भी क्लिक इवेंट ट्रिगर होते हैं. उदाहरण के लिए, उपयोगकर्ता Spacebar या Enter बटन का इस्तेमाल करके, मीडिया प्लेबैक को टॉगल (चलाएं या रोकें) कर सकते हैं. इसके लिए, क्लिक इवेंट को इस तरह मैनेज करना होगा:

MediaPlayer(modifier = Modifier.clickable { togglePausePlay() })commands.kt

clickable मॉडिफ़ायर, मुख्य इवेंट को इंटरसेप्ट करता है. साथ ही, Spacebar या Enter बटन दबाने पर, onClick() कॉलबैक को कॉल करता है. इसलिए, स्निपेट में Spacebar या Enter बटन दबाकर, togglePausePlay() फ़ंक्शन को कॉल किया जाता है.

ऐसे मुख्य इवेंट जिनका इस्तेमाल नहीं किया गया

इस्तेमाल न किए गए मुख्य इवेंट, उस कॉम्पोनेंट से भेजे जाते हैं जहां इवेंट हुआ था. इसके बाद, वे इवेंट को शामिल करने वाले बाहरी कॉम्पोनेंट तक जाते हैं. नीचे दिए गए उदाहरण में, S बटन को रिलीज़ करने पर, InnerComponent मुख्य इवेंट का इस्तेमाल करता है. इसलिए, S बटन को रिलीज़ करने पर ट्रिगर होने वाले मुख्य इवेंट, OuterComponent को नहीं मिलते. इसलिए, actionB() फ़ंक्शन को कभी कॉल नहीं किया जाता.

InnerComponent पर मौजूद अन्य मुख्य इवेंट, जैसे कि D बटन को रिलीज़ करना, OuterComponent से मैनेज किए जा सकते हैं. actionC() फ़ंक्शन को कॉल किया जाता है, क्योंकि D बटन को रिलीज़ करने के लिए मुख्य इवेंट को OuterComponent पर भेजा जाता है.

OuterComponent(
    modifier = Modifier.onKeyEvent {
        when {
            it.type == KeyEventType.KeyUp && it.key == Key.S -> {
                actionB() // This function is never called.
                true
            }

            it.type == KeyEventType.KeyUp && it.key == Key.D -> {
                actionC()
                true
            }

            else -> false
        }
    }
) {
    InnerComponent(
        modifier = Modifier.onKeyEvent {
            if (it.type == KeyEventType.KeyUp && it.key == Key.S) {
                actionA()
                true
            } else {
                false
            }
        }
    )
}commands.kt

`onKeyPreviewEvent` मॉडिफ़ायर

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

val focusManager = LocalFocusManager.current
var textFieldValue by remember { mutableStateOf(TextFieldValue()) }

TextField(
    textFieldValue,
    onValueChange = {
        textFieldValue = it
    },
    modifier = Modifier.onPreviewKeyEvent {
        if (it.type == KeyEventType.KeyUp && it.key == Key.Tab) {
            focusManager.moveFocus(FocusDirection.Next)
            true
        } else {
            false
        }
    }
)commands.kt

डिफ़ॉल्ट रूप से, TextField कॉम्पोनेंट, उपयोगकर्ताओं के Tab कुंजी दबाने पर हर बार एक टैब वर्ण जोड़ता है. भले ही, onKeyEvent मॉडिफ़ायर के साथ मुख्य इवेंट को हैंडल किया गया हो. किसी भी टैब वर्ण को जोड़े बिना कीबोर्ड फ़ोकस को मूव करने के लिए, मुख्य इवेंट से जुड़ी कार्रवाइयों को ट्रिगर करने से पहले, मुख्य इवेंट को हैंडल करें. जैसा कि स्निपेट में दिखाया गया है. onKeyPreviewEvent() लैम्ब्डा, true को रिटर्न करके मुख्य इवेंट को इंटरसेप्ट करता है.

पैरंट कॉम्पोनेंट, अपने चाइल्ड कॉम्पोनेंट पर होने वाले मुख्य इवेंट को इंटरसेप्ट कर सकता है. नीचे दिए गए स्निपेट में, जब उपयोगकर्ता S बटन दबाते हैं, तो actionForPreview() फ़ंक्शन को कॉल करने के बजाय, previewSKey() फ़ंक्शन को कॉल किया जाता है.

Column(
    modifier = Modifier.onPreviewKeyEvent {
        if (it.key == Key.S) {
            previewSKey()
            true
        } else {
            false
        }
    }
) {
    Box(
        modifier = Modifier
            .focusable()
            .onPreviewKeyEvent {
                actionForPreview(it)
                false
            }
            .onKeyEvent {
                actionForKeyEvent(it)
                true
            }
    ) {
        Text("Press any key")
    }
}commands.kt

उपयोगकर्ताओं के Tab कुंजी दबाने पर भी, Box कॉम्पोनेंट के लिए onPreviewKeyEvent() लैम्डा ट्रिगर नहीं होता है. सबसे पहले, पैरंट कॉम्पोनेंट पर onPreviewKeyEvent() लैंबडा को कॉल किया जाता है. इसके बाद, चाइल्ड कॉम्पोनेंट में onPreviewKeyEvent() को कॉल किया जाता है. इस सुविधा का इस्तेमाल करके, पूरी स्क्रीन पर कीबोर्ड शॉर्टकट लागू किए जा सकते हैं.

अन्य संसाधन

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

आगे बढ़ें

कीबोर्ड शॉर्टकट सहायक