Gerenciar ações do teclado

Quando o usuário focaliza uma visualização de texto editável, como um elemento EditText, e tem um teclado físico conectado, todas as entradas são processadas pelo sistema. No entanto, se você quer interceptar ou processar diretamente a entrada do teclado por conta própria, é preciso implementar métodos de callback da interface KeyEvent.Callback, como onKeyDown() e onKeyMultiple().

As classes Activity e View implementam a interface KeyEvent.Callback. Assim, você geralmente deve modificar os métodos de callback na extensão dessas classes, conforme apropriado.

Observação: ao processar eventos de teclado com a classe KeyEvent e as APIs relacionadas, você deve esperar que esses eventos de teclado sejam originados apenas de um teclado físico. Nunca espere receber eventos de nenhuma tecla em um método de entrada simples (teclado na tela).

Processar eventos de tecla únicos

Para processar um pressionamento de tecla individual, implemente onKeyDown() ou onKeyUp(), conforme adequado. Normalmente, é preciso usar onKeyUp() se você quer ter certeza de que receberá apenas um evento. Se o usuário tocar no botão e o mantiver pressionado, 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", você pode consultar o KeyEvent que é passado para o método de callback. Vários métodos disponibilizam informações sobre teclas modificadoras, como getModifiers() e getMetaState(). No entanto, a solução mais simples é verificar se a tecla modificadora exata do seu interesse está sendo pressionada com métodos como isShiftPressed() e isCtrlPressed().

Por exemplo, veja a implementação onKeyDown() novamente, com um 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);
        }
    }