Tastaturaktionen verarbeiten
Mit Sammlungen den Überblick behalten
Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.
Compose ausprobieren
Jetpack Compose ist das empfohlene UI-Toolkit für Android. Informationen zum Umgang mit Tastaturaktionen im Tool zum Verfassen von E-Mails
Wenn der Nutzer den Fokus auf eine bearbeitbare Textansicht legt, z. B. ein EditText
-Element, und eine Hardwaretastatur angeschlossen hat, wird die gesamte Eingabe vom System verarbeitet. Wenn Sie die Tastatureingabe jedoch selbst abfangen oder direkt verarbeiten möchten, können Sie Rückrufmethoden aus der KeyEvent.Callback
-Schnittstelle implementieren, z. B. onKeyDown()
und onKeyMultiple()
.
Sowohl die Activity
- als auch die View
-Klasse implementieren die KeyEvent.Callback
-Schnittstelle. Daher überschreiben Sie in der Regel die Rückrufmethoden in der Erweiterung dieser Klassen.
Hinweis:Wenn Sie Tastaturereignisse mit der Klasse KeyEvent
und den zugehörigen APIs verarbeiten, gehen Sie davon aus, dass die Tastaturereignisse nur von einer Hardwaretastatur stammen. Verlassen Sie sich niemals darauf, dass Sie Tastenereignisse für eine beliebige Taste einer Soft-Eingabemethode (Bildschirmtastatur) erhalten.
Einzelne Schlüsselereignisse verarbeiten
Wenn Sie eine einzelne Tastenaktivierung verarbeiten möchten, implementieren Sie onKeyDown()
oder onKeyUp()
. Normalerweise verwenden Sie onKeyUp()
, wenn Sie sicherstellen möchten, dass Sie nur ein Ereignis erhalten. Wenn der Nutzer eine Taste gedrückt hält, wird onKeyDown()
mehrmals aufgerufen.
Bei dieser Implementierung reagiert das Spiel beispielsweise auf einige Tasten der Tastatur:
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);
}
}
Modifikatortasten verarbeiten
Wenn Sie auf Modifikatortastenereignisse reagieren möchten, z. B. wenn eine Taste mit der Umschalttaste oder der Strg-Taste kombiniert wird, können Sie KeyEvent
abfragen, die an die Rückrufmethode übergeben wird. Es gibt mehrere Methoden, um Informationen zu Modifikatortasten wie getModifiers()
und getMetaState()
zu erhalten.
Am einfachsten ist es jedoch, mithilfe von Methoden wie isShiftPressed()
und isCtrlPressed()
zu prüfen, ob der gewünschte Modifikatorschlüssel gedrückt wird.
Hier ist beispielsweise die onKeyUp()
-Implementierung noch einmal, mit einer zusätzlichen Verarbeitung, wenn die Umschalttaste zusammen mit einer der Tasten gedrückt wird:
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);
}
}
Weitere Informationen
Alle Inhalte und Codebeispiele auf dieser Seite unterliegen den Lizenzen wie im Abschnitt Inhaltslizenz beschrieben. Java und OpenJDK sind Marken oder eingetragene Marken von Oracle und/oder seinen Tochtergesellschaften.
Zuletzt aktualisiert: 2025-07-26 (UTC).
[[["Leicht verständlich","easyToUnderstand","thumb-up"],["Mein Problem wurde gelöst","solvedMyProblem","thumb-up"],["Sonstiges","otherUp","thumb-up"]],[["Benötigte Informationen nicht gefunden","missingTheInformationINeed","thumb-down"],["Zu umständlich/zu viele Schritte","tooComplicatedTooManySteps","thumb-down"],["Nicht mehr aktuell","outOfDate","thumb-down"],["Problem mit der Übersetzung","translationIssue","thumb-down"],["Problem mit Beispielen/Code","samplesCodeIssue","thumb-down"],["Sonstiges","otherDown","thumb-down"]],["Zuletzt aktualisiert: 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."]]