कीबोर्ड से जुड़ी कार्रवाइयां मैनेज करना
संग्रह की मदद से व्यवस्थित रहें
अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.
'लिखें' सुविधा आज़माएं
Android के लिए, Jetpack Compose को यूज़र इंटरफ़ेस (यूआई) टूलकिट के तौर पर सुझाया जाता है. Compose में कीबोर्ड से की जाने वाली कार्रवाइयों को मैनेज करने का तरीका जानें.
जब उपयोगकर्ता, बदलाव किए जा सकने वाले टेक्स्ट व्यू पर फ़ोकस करता है, जैसे कि EditText
एलिमेंट और उपयोगकर्ता के पास हार्डवेयर कीबोर्ड जुड़ा होता है, तो सभी इनपुट को सिस्टम मैनेज करता है. हालांकि, अगर आपको कीबोर्ड इनपुट को खुद इंटरसेप्ट करना है या सीधे मैनेज करना है, तो KeyEvent.Callback
इंटरफ़ेस से कॉलबैक के तरीकों को लागू करें. जैसे, onKeyDown()
और onKeyMultiple()
.
Activity
और View
, दोनों क्लास KeyEvent.Callback
इंटरफ़ेस को लागू करती हैं. इसलिए, आम तौर पर इन क्लास के एक्सटेंशन में, कॉलबैक के तरीकों को ज़रूरत के हिसाब से बदला जाता है.
ध्यान दें: KeyEvent
क्लास और उससे जुड़े एपीआई की मदद से कीबोर्ड इवेंट मैनेज करते समय, यह उम्मीद करें कि कीबोर्ड इवेंट सिर्फ़ हार्डवेयर कीबोर्ड से आ रहे हैं. सॉफ़्ट इनपुट के तरीके (ऑन-स्क्रीन कीबोर्ड) पर किसी भी बटन के लिए, बटन दबाने पर होने वाली इवेंट पाने पर कभी भरोसा न करें.
एक बटन से होने वाले इवेंट मैनेज करना
किसी एक बटन को दबाने पर होने वाली कार्रवाई को मैनेज करने के लिए, ज़रूरत के हिसाब से onKeyDown()
या onKeyUp()
लागू करें. आम तौर पर, onKeyUp()
का इस्तेमाल तब किया जाता है, जब आपको यह पक्का करना हो कि आपको सिर्फ़ एक इवेंट मिले. अगर उपयोगकर्ता किसी बटन को दबाकर रखता है, तो onKeyDown()
को कई बार कॉल किया जाता है.
उदाहरण के लिए, यह लागू करने पर, गेम को कंट्रोल करने के लिए कीबोर्ड के कुछ बटन काम करते हैं:
Kotlin
override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
return when (keyCode) {
KeyEvent.KEYCODE_D -> {
moveShip(MOVE_LEFT)
true
}
KeyEvent.KEYCODE_F -> {
moveShip(MOVE_RIGHT)
true
}
KeyEvent.KEYCODE_J -> {
fireMachineGun()
true
}
KeyEvent.KEYCODE_K -> {
fireMissile()
true
}
else -> super.onKeyUp(keyCode, event)
}
}
Java
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_D:
moveShip(MOVE_LEFT);
return true;
case KeyEvent.KEYCODE_F:
moveShip(MOVE_RIGHT);
return true;
case KeyEvent.KEYCODE_J:
fireMachineGun();
return true;
case KeyEvent.KEYCODE_K:
fireMissile();
return true;
default:
return super.onKeyUp(keyCode, event);
}
}
कार्रवाई बदलने वाली कुंजियों को हैंडल करना
कार्रवाई बदलने वाले बटन के इवेंट का जवाब देने के लिए, KeyEvent
के बारे में क्वेरी की जा सकती है. KeyEvent
, कॉलबैक तरीके में पास किया जाता है. जैसे, जब किसी बटन को Shift या Control के साथ दबाया जाता है. कई तरीकों से, getModifiers()
और getMetaState()
जैसी कार्रवाई बदलने वाली कुंजियों के बारे में जानकारी मिलती है.
हालांकि, सबसे आसान तरीका यह देखना है कि isShiftPressed()
और isCtrlPressed()
जैसे तरीकों से, वह बदलाव करने वाला बटन दबाया जा रहा है जिसकी आपको ज़रूरत है.
उदाहरण के लिए, यहां onKeyUp()
को लागू करने का तरीका फिर से बताया गया है. इसमें, किसी एक बटन के साथ Shift बटन को दबाकर रखने पर, अतिरिक्त हैंडल करने की सुविधा भी शामिल है:
Kotlin
override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
return when (keyCode) {
...
KeyEvent.KEYCODE_J -> {
if (event.isShiftPressed) {
fireLaser()
} else {
fireMachineGun()
}
true
}
KeyEvent.KEYCODE_K -> {
if (event.isShiftPressed) {
fireSeekingMissle()
} else {
fireMissile()
}
true
}
else -> super.onKeyUp(keyCode, event)
}
}
Java
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch (keyCode) {
...
case KeyEvent.KEYCODE_J:
if (event.isShiftPressed()) {
fireLaser();
} else {
fireMachineGun();
}
return true;
case KeyEvent.KEYCODE_K:
if (event.isShiftPressed()) {
fireSeekingMissle();
} else {
fireMissile();
}
return true;
default:
return super.onKeyUp(keyCode, event);
}
}
अन्य संसाधन
-
कीबोर्ड शॉर्टकट सहायक: सिस्टम की स्क्रीन, जिसकी मदद से उपयोगकर्ता आपके ऐप्लिकेशन में उपलब्ध कीबोर्ड शॉर्टकट खोज सकते हैं.
इस पेज पर मौजूद कॉन्टेंट और कोड सैंपल कॉन्टेंट के लाइसेंस में बताए गए लाइसेंस के हिसाब से हैं. Java और OpenJDK, Oracle और/या इससे जुड़ी हुई कंपनियों के ट्रेडमार्क या रजिस्टर किए हुए ट्रेडमार्क हैं.
आखिरी बार 2025-07-26 (UTC) को अपडेट किया गया.
[[["समझने में आसान है","easyToUnderstand","thumb-up"],["मेरी समस्या हल हो गई","solvedMyProblem","thumb-up"],["अन्य","otherUp","thumb-up"]],[["वह जानकारी मौजूद नहीं है जो मुझे चाहिए","missingTheInformationINeed","thumb-down"],["बहुत मुश्किल है / बहुत सारे चरण हैं","tooComplicatedTooManySteps","thumb-down"],["पुराना","outOfDate","thumb-down"],["अनुवाद से जुड़ी समस्या","translationIssue","thumb-down"],["सैंपल / कोड से जुड़ी समस्या","samplesCodeIssue","thumb-down"],["अन्य","otherDown","thumb-down"]],["आखिरी बार 2025-07-26 (UTC) को अपडेट किया गया."],[],[],null,["# Handle keyboard actions\n\nTry the Compose way \nJetpack Compose is the recommended UI toolkit for Android. Learn how to handle keyboard actions in Compose. \n[Handle keyboard actions in Compose →](/develop/ui/compose/touch-input/keyboard-input/commands#key_events) \n\nWhen the user gives focus to an editable text view, such as an\n[EditText](/reference/android/widget/EditText)\nelement, and the user has a hardware keyboard attached, all\ninput is handled by the system. However, if you want to intercept\nor directly handle the keyboard input yourself, you can do so by implementing callback methods\nfrom the [KeyEvent.Callback](/reference/android/view/KeyEvent.Callback)\ninterface, such as [onKeyDown()](/reference/android/view/KeyEvent.Callback#onKeyDown(int, android.view.KeyEvent))\nand [onKeyMultiple()](/reference/android/view/KeyEvent.Callback#onKeyMultiple(int, int, android.view.KeyEvent)).\n\nBoth the [Activity](/reference/android/app/Activity)\nand [View](/reference/android/view/View) classes implement the\n`KeyEvent.Callback` interface, so you\ngenerally override the callback methods in your extension of these classes, as\nappropriate.\n\n**Note:** When handling keyboard events with the\n[KeyEvent](/reference/android/view/KeyEvent) class and related APIs,\nexpect that the keyboard events are coming only from a hardware keyboard. Never rely on receiving key\nevents for any key on a soft input method (an on-screen keyboard).\n\nHandle single key events\n------------------------\n\nTo handle an individual key press, implement\n[onKeyDown()](/reference/android/app/Activity#onKeyDown(int, android.view.KeyEvent))\nor [onKeyUp()](/reference/android/app/Activity#onKeyUp(int, android.view.KeyEvent)),\nas appropriate. Usually, you use\n`onKeyUp()`\nif you want to ensure that you receive only one event. If the user presses and holds a key,\nthen `onKeyDown()` is called multiple times.\n\nFor example, this implementation responds to some keyboard keys to control a game: \n\n### Kotlin\n\n```kotlin\noverride fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {\n return when (keyCode) {\n KeyEvent.KEYCODE_D -\u003e {\n moveShip(MOVE_LEFT)\n true\n }\n KeyEvent.KEYCODE_F -\u003e {\n moveShip(MOVE_RIGHT)\n true\n }\n KeyEvent.KEYCODE_J -\u003e {\n fireMachineGun()\n true\n }\n KeyEvent.KEYCODE_K -\u003e {\n fireMissile()\n true\n }\n else -\u003e super.onKeyUp(keyCode, event)\n }\n}\n```\n\n### Java\n\n```java\n@Override\npublic boolean onKeyUp(int keyCode, KeyEvent event) {\n switch (keyCode) {\n case KeyEvent.KEYCODE_D:\n moveShip(MOVE_LEFT);\n return true;\n case KeyEvent.KEYCODE_F:\n moveShip(MOVE_RIGHT);\n return true;\n case KeyEvent.KEYCODE_J:\n fireMachineGun();\n return true;\n case KeyEvent.KEYCODE_K:\n fireMissile();\n return true;\n default:\n return super.onKeyUp(keyCode, event);\n }\n}\n```\n\nHandle modifier keys\n--------------------\n\nTo respond to modifier key events, such as when a key is combined with \u003ckbd\u003eShift\u003c/kbd\u003e\nor \u003ckbd\u003eControl\u003c/kbd\u003e, you can\nquery the `KeyEvent`\nthat is passed to the callback method. Several methods\nprovide information about modifier keys, such as\n[getModifiers()](/reference/android/view/KeyEvent#getModifiers())\nand [getMetaState()](/reference/android/view/KeyEvent#getMetaState()).\nHowever, the simplest solution is to check whether\nthe exact modifier key you care about is being pressed with methods such as\n[isShiftPressed()](/reference/android/view/KeyEvent#isShiftPressed())\nand [isCtrlPressed()](/reference/android/view/KeyEvent#isCtrlPressed()).\n\nFor example, here's the `onKeyUp()` implementation\nagain, with extra handling for when the \u003ckbd\u003eShift\u003c/kbd\u003e key is held down with one of the keys: \n\n### Kotlin\n\n```kotlin\noverride fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {\n return when (keyCode) {\n ...\n KeyEvent.KEYCODE_J -\u003e {\n if (event.isShiftPressed) {\n fireLaser()\n } else {\n fireMachineGun()\n }\n true\n }\n KeyEvent.KEYCODE_K -\u003e {\n if (event.isShiftPressed) {\n fireSeekingMissle()\n } else {\n fireMissile()\n }\n true\n }\n else -\u003e super.onKeyUp(keyCode, event)\n }\n}\n```\n\n### Java\n\n```java\n@Override\npublic boolean onKeyUp(int keyCode, KeyEvent event) {\n switch (keyCode) {\n ...\n case KeyEvent.KEYCODE_J:\n if (event.isShiftPressed()) {\n fireLaser();\n } else {\n fireMachineGun();\n }\n return true;\n case KeyEvent.KEYCODE_K:\n if (event.isShiftPressed()) {\n fireSeekingMissle();\n } else {\n fireMissile();\n }\n return true;\n default:\n return super.onKeyUp(keyCode, event);\n }\n}\n```\n\nAdditional resources\n--------------------\n\n- [Keyboard Shortcuts Helper](/develop/ui/compose/touch-input/keyboard-input/keyboard-shortcuts-helper): System screen that enables users to search the keyboard shortcuts your app offers."]]