Processar ações do teclado

Experimente trabalhar com o Compose
O Jetpack Compose é o kit de ferramentas de UI recomendado para Android. Aprenda a processar ações de teclado no Compose.
Gerenciar ações do teclado no Compose →

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ê quiser interceptar ou processar diretamente a entrada do teclado, é preciso implementar métodos de callback na interface KeyEvent.Callback, como onKeyDown() e onKeyMultiple().

Tanto a classe Activity quanto a View implementam a interface KeyEvent.Callback. Portanto, geralmente é necessário 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 APIs relacionadas, espere que os eventos de teclado venham apenas de um teclado físico. Nunca espere receber eventos de nenhuma tecla em um método de entrada flexível (teclado na tela).

Processar eventos de tecla única

Para processar o pressionamento de uma tecla individual, implemente onKeyDown() ou onKeyUp(), conforme apropriado. Normalmente, você usa onKeyUp() se quiser garantir que vai receber apenas um evento. Se o usuário pressionar e manter uma tecla 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, como quando uma tecla é combinada com Shift ou Control, você pode consultar o KeyEvent que é transmitido para o método de callback. Vários métodos fornecem informações sobre teclas modificadoras, como getModifiers() e getMetaState(). No entanto, a solução mais simples é verificar se a tecla modificadora exata está sendo pressionada com métodos como isShiftPressed() e isCtrlPressed().

Por exemplo, esta é a implementação de onKeyUp() novamente, com um tratamento 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