Cómo controlar las acciones del teclado

Cuando el usuario enfoca una vista de texto editable, como una EditText y el usuario tiene un teclado de hardware conectado, es controlada por el sistema. Sin embargo, si quieres interceptar o controlar directamente la entrada del teclado tú mismo, puedes hacerlo implementando métodos de devolución de llamada de KeyEvent.Callback interfaz, como onKeyDown() y onKeyMultiple().

Tanto el Activity y las clases View implementan el KeyEvent.Callback, por lo que generalmente anulan los métodos de devolución de llamada en tu extensión de estas clases, ya que lo que sea apropiado.

Nota: Al controlar eventos del teclado con el botón Clase KeyEvent y APIs relacionadas, esperamos que los eventos del teclado provengan solo de un teclado de hardware. No confíes nunca en la recepción de claves eventos para cualquier tecla en un método de entrada de software (un teclado en pantalla).

Cómo controlar eventos de una sola tecla

Para controlar cómo se presiona una tecla, implementa onKeyDown() o onKeyUp(), según corresponda. Por lo general, usas onKeyUp() si quieres asegurarte de recibir solo un evento. Si el usuario mantiene presionada una tecla, Luego, se llama varias veces a onKeyDown().

Por ejemplo, en esta implementación, se responde a algunas teclas del teclado para controlar un juego:

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);
    }
}

Cómo controlar teclas modificadoras

Para responder a eventos de teclas modificadoras, como cuando una tecla se combina con Mayúsculas o Control, puedes consultar KeyEvent que se pasa al método de devolución de llamada. Varios métodos proporcionan información sobre las teclas modificadoras, getModifiers() y getMetaState(). Sin embargo, la solución más sencilla es comprobar la tecla modificadora exacta que te interesa se presiona con métodos como isShiftPressed() y isCtrlPressed().

Por ejemplo, esta es la implementación de onKeyUp(). de nuevo, con control adicional cuando la tecla Mayúsculas se mantiene presionada con una de las teclas:

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);
    }
}

Recursos adicionales