Processar ações do teclado

Quando o usuário focaliza uma visualização de texto editável, como um elemento EditText, e tem um teclado de hardware conectado, todas as entradas são processadas pelo sistema. No entanto, se você quiser interceptar ou processar diretamente a entrada do teclado, implemente métodos de callback na interface KeyEvent.Callback, como onKeyDown() e onKeyMultiple().

As classes Activity e View implementam a interface KeyEvent.Callback. Portanto, você geralmente modifica os métodos de callback na extensão dessas classes, conforme adequado.

Observação:ao processar eventos de teclado com a classe KeyEvent e APIs relacionadas, espera-se que os eventos de teclado sejam provenientes apenas de um teclado de hardware. Nunca confie no recebimento de eventos de tecla para qualquer tecla em um método de entrada simples (um teclado na tela).

Processar eventos de tecla única

Para gerenciar um pressionamento de tecla individual, implemente onKeyDown() ou onKeyUp(), conforme apropriado. Normalmente, use onKeyUp() para garantir que você receberá apenas um evento. Se o usuário tocar em uma tecla e a mantiver pressionada, onKeyDown() será chamado várias vezes.

Por exemplo, esta implementação responde a algumas teclas do teclado para controlar um jogo:

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

Processar teclas modificadoras

Para responder a eventos de tecla modificadora, por exemplo, quando uma tecla é combinada com Shift ou Control, consulte o KeyEvent transmitido para o método de callback. Vários métodos fornecem informações sobre as teclas modificadoras, como getModifiers() e getMetaState(). No entanto, a solução mais simples é verificar se a tecla modificadora exata que você quer usar está sendo pressionada com métodos como isShiftPressed() e isCtrlPressed().

Por exemplo, confira a implementação onKeyUp() novamente, com processamento extra para quando a tecla Shift é mantida pressionada com uma das 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);
    }
}

Outros recursos