Utilizzare i gesti del polso su Wear

I gesti del polso consentono interazioni rapide con la tua app con una sola mano quando un touchscreen è scomodo.

Ad esempio, un utente può scorrere le notifiche con una mano mentre tiene in mano una tazza d'acqua con l'altra. Altri casi d'uso per i gesti del polso includono:

• In un'app per il jogging, navigazione tra schermate verticali che mostrano passi effettuati, tempo trascorso e ritmo attuale
• In un'app di viaggi, scorrere le informazioni su volo e gate
• In un'app di notizie, scorrere gli articoli

Per controllare i gesti del polso su un smartwatch, conferma che i gesti siano attivati selezionando Impostazioni > Funzionalità avanzate > Gesti > Gesti polso attivi. Quindi, completa il tutorial sui gesti sullo smartwatch selezionando Avvia tutorial.

Nota: lo scuotimento del polso equivale al gesto indietro o di annullamento a livello di sistema e non è disponibile per la personalizzazione delle app.

I gesti del polso possono essere utilizzati nei seguenti modi, come descritto nella presente guida:

• Con un layout curvo, provvisto di azioni gestuali predefinite
• Utilizzando direttamente gli eventi chiave per definire nuove azioni utente

Ogni gesto del polso è mappato a una costante int della classe KeyEvent, come mostrato nella seguente tabella:

Utilizza un layout curvo per supportare i gesti del polso

Il corso WearableRecyclerView fornisce un layout curvo per gli elenchi e supporta automaticamente i gesti del polso. La classe contiene azioni predefinite per le occorrenze dei gesti del polso quando la visualizzazione è attiva. Per informazioni sull'utilizzo della classe WearableRecyclerView, consulta la sezione Creare elenchi su Wear OS. Consulta anche la sezione Best practice di questa guida.

Nota: la classe WearableRecyclerView sostituisce una classe simile e ritirata nella libreria di assistenza indossabile.

Anche se utilizzi un WearableRecyclerView, potresti voler utilizzare le costanti della classe KeyEvent. Le azioni predefinite possono essere sostituite sottoclassando WearableRecyclerView e implementando nuovamente il callback onKeyDown(). Il comportamento può essere disattivato completamente utilizzando setEnableGestureNavigation(false). Per maggiori informazioni, consulta la sezione Gestire le azioni da tastiera.

Usa direttamente gli eventi chiave

Puoi utilizzare gli eventi chiave esterni a WearableRecyclerView per attivare nuove azioni in risposta agli eventi dei gesti. È importante sottolineare che questi eventi dei gesti vengono riconosciuti quando un dispositivo è in modalità attiva e vengono inviati allo stesso modo di tutti gli eventi chiave.

Una classe correlata all'interazione dell'utente, ad esempio View o Activity, che implementa KeyEvent.Callback può ascoltare gli eventi chiave relativi ai gesti del polso così come può essere elencato per qualsiasi altro evento chiave. Il framework Android chiama l'elemento View o Activity incentrato sugli eventi chiave. Per i gesti, il callback del metodo onKeyDown() viene chiamato quando si verificano gesti.

Ad esempio, un'app può eseguire l'override delle azioni predefinite in un elemento View o Activity che implementa KeyEvent.Callback nel seguente modo:

class GesturesActivity : Activity() {

    /* KeyEvent.Callback */
    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
        return when (keyCode) {
            KeyEvent.KEYCODE_NAVIGATE_NEXT ->
                // Do something that advances a user View to the next item in an ordered list.
                moveToNextItem()
            KeyEvent.KEYCODE_NAVIGATE_PREVIOUS ->
                // Do something that advances a user View to the previous item in an ordered list.
                moveToPreviousItem()
            else -> {
                // If you did not handle it, let it be handled by the next possible element as determined
                // by the Activity.
                super.onKeyDown(keyCode, event)
            }
        }
    }

    /** Shows the next item in the custom list.  */
    private fun moveToNextItem(): Boolean {
        ...
        // Return true if handled successfully, otherwise return false.
        return false
    }

    /** Shows the previous item in the custom list.  */
    private fun moveToPreviousItem(): Boolean {
        ...
        // Return true if handled successfully, otherwise return false.
        return false
    }
}

public final class GesturesActivity extends Activity {

 @Override /* KeyEvent.Callback */
 public boolean onKeyDown(int keyCode, KeyEvent event) {
  switch (keyCode) {
   case KeyEvent.KEYCODE_NAVIGATE_NEXT:
    // Do something that advances a user View to the next item in an ordered list.
    return moveToNextItem();
   case KeyEvent.KEYCODE_NAVIGATE_PREVIOUS:
    // Do something that advances a user View to the previous item in an ordered list.
    return moveToPreviousItem();
  }
  // If you did not handle it, let it be handled by the next possible element as determined by the Activity.
  return super.onKeyDown(keyCode, event);
 }

 /** Shows the next item in the custom list. */
 private boolean moveToNextItem() {
  boolean handled = false;
  ...
  // Return true if handled successfully, otherwise return false.
  return handled;
 }

 /** Shows the previous item in the custom list. */
 private boolean moveToPreviousItem() {
  boolean handled = false;
  ...
  // Return true if handled successfully, otherwise return false.
  return handled;
 }
}

Best practice

• Controlla le pagine KeyEvent e KeyEvent.Callback per la pubblicazione degli eventi chiave nei tuoi View e Activity.
• Mantieni un'invito direzionale coerente: usa "ruota il polso verso l'esterno" per il passaggio successivo e "ruota il polso verso l'interno" per il precedente.
• Usa la funzione di tocco parallelo per un gesto.
• Fornire un feedback visivo.
• Non utilizzare un codice chiave per implementare funzionalità che sarebbero controintuitive per il resto del sistema. Ad esempio, non usare KEYCODE_NAVIGATE_NEXT per annullare un'azione o per spostarti sull'asse sinistro-destra con i gesti di scorrimento.
• Non intercettare gli eventi chiave su elementi che non fanno parte dell'interfaccia utente, ad esempio le viste fuori schermo o parzialmente coperte. È la stessa degli eventi chiave.
• Non reinterpretare i gesti rapidi ripetuti con i gesti di scorrimento. Questo potrebbe essere in conflitto con il gesto di "scuotimento del polso" del sistema.

• Affinché una vista riceva gli eventi dei tasti dei gesti, deve essere attiva. Vedi View.setFocusable().

  Poiché i gesti sono considerati eventi chiave, attivano una transizione dalla "modalità tocco" che potrebbe causare operazioni inaspettate. Poiché gli utenti potrebbero alternare l'uso del tocco e dei gesti, potrebbe essere necessario il metodo View::setFocusableInTouchmode(). In alcuni casi, potrebbe essere necessario utilizzare setDescendantFocusability(FOCUS_BEFORE_DESCENDANTS) in modo che quando lo stato attivo cambia dopo un passaggio da o verso la modalità tocco, la visualizzazione desiderata viene messa a fuoco.

• Utilizza requestFocus() e clearFocus() con attenzione:
  • Quando chiami requestFocus(), assicurati che sia appropriato per la visualizzazione. Se la visualizzazione è fuori schermo o è coperta da un'altra visualizzazione, possono verificarsi sorprese quando i gesti attivano i callback.
  • Il metodo clearFocus() avvia una ricerca dell'elemento attivo per trovare un'altra vista adatta. A seconda della gerarchia delle visualizzazioni, questa ricerca potrebbe richiedere un calcolo non banale. Potrebbe anche essere necessario assegnare lo stato attivo a una visualizzazione che non ti aspetti sia selezionata.

• Gli eventi chiave vengono pubblicati per primi nella visualizzazione, con lo stato attivo nella gerarchia delle visualizzazioni. Se la vista attiva non gestisce l'evento (in altre parole, restituisce false), l'evento non viene pubblicato nella vista principale, anche se può ricevere lo stato attivo e ha un elemento KeyListener. Piuttosto, l'evento viene pubblicato all'attività corrente tenendo in evidenza la gerarchia delle visualizzazioni.

  Pertanto, potrebbe essere necessario individuare tutti gli eventi a un livello superiore e poi trasferire i codici pertinenti. In alternativa, puoi sottoclassare l'attività e sostituire il metodo dispatchKeyEvent(KeyEvent event) per intercettare le chiavi quando necessario o gestirle quando non vengono gestite ai livelli inferiori.