Processar ações do teclado

Quando o usuário focaliza uma visualização de texto editável, como uma EditText e o usuário tiver um teclado físico conectado, todos é processada pelo sistema. Porém, se você quiser interceptar ou manipular diretamente a entrada do teclado, é possível fazer isso implementando métodos de callback do KeyEvent.Callback interface, como onKeyDown() e onKeyMultiple().

Tanto o Activity e View implementam a interface KeyEvent.Callback. Portanto, geralmente substituir os métodos de callback na extensão dessas classes, conforme apropriados.

Observação:ao processar eventos de teclado com o a classe KeyEvent e as APIs relacionadas, espera que os eventos de teclado venham apenas de um teclado físico. Nunca dependa do recebimento de chaves eventos para qualquer tecla em um método de entrada de software (um teclado na tela).

Processar eventos de tecla única

Para lidar com um pressionamento de tecla individual, implemente onKeyDown() ou onKeyUp(), conforme apropriado. Normalmente, você usa onKeyUp() se quiser garantir o recebimento de apenas um evento. Se o usuário tocar e segurar uma tecla, então onKeyDown() é 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 teclas modificadoras, por exemplo, quando uma tecla é combinada com Shift ou Controle, é possível consultar KeyEvent que é passado para o método de retorno de chamada. 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 que importa é ser pressionada com métodos como isShiftPressed() e isCtrlPressed().

Por exemplo, esta é a implementação de onKeyUp() novamente, com processamento extra para quando a tecla Shift é 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