Gestire le azioni della tastiera

Quando l'utente attiva una visualizzazione di testo modificabile, come EditText e l'utente ha una tastiera hardware collegata, è gestito dal sistema. Tuttavia, se vuoi intercettare o gestire direttamente l'immissione da tastiera, puoi farlo implementando metodi di callback da KeyEvent.Callback dell'interfaccia utente, ad esempio onKeyDown() e onKeyMultiple().

Sia Activity e View di classi implementano KeyEvent.Callback, quindi puoi generalmente sostituiscono i metodi di callback nell'estensione di queste classi, appropriato.

Nota: quando gestisci gli eventi della tastiera con il classe KeyEvent e API correlate, gli eventi tastiera provengono solo da una tastiera hardware. Non fare mai affidamento sulla ricezione delle chiavi eventi per qualsiasi tasto di un metodo di immissione software (una tastiera sullo schermo).

Gestire gli eventi chiave singoli

Per gestire la pressione di un singolo tasto, implementa onKeyDown() o onKeyUp(), in base alle necessità. Di solito, utilizzi onKeyUp() se vuoi assicurarti di ricevere un solo evento. Se l'utente tiene premuto un tasto, allora onKeyDown() viene chiamato più volte.

Ad esempio, questa implementazione risponde ad alcuni tasti della tastiera per controllare un gioco:

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

Gestisci i tasti di modifica

Per rispondere agli eventi dei tasti di modifica, ad esempio quando un tasto viene combinato con Maiusc. o Controllo, puoi esegui una query su KeyEvent che viene passato al metodo di callback. Diversi metodi forniscono informazioni sui tasti di modifica, come getModifiers() e getMetaState(). Tuttavia, la soluzione più semplice consiste nel verificare l'esatto tasto di modifica che ti interessa viene premuto con metodi come isShiftPressed() e isCtrlPressed().

Ad esempio, ecco l'implementazione di onKeyUp() di nuovo, con una gestione aggiuntiva quando il tasto Maiusc viene tenuto premuto con uno dei tasti:

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

Risorse aggiuntive