Utilizzare i gesti del polso su Wear

I gesti del polso possono consentire interazioni rapide con una sola mano con la tua app quando un touchscreen non è pratico.

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

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

Per rivedere i gesti del polso su un orologio dispositivo, verifica che i gesti siano attivata selezionando Impostazioni > Funzionalità avanzate > Gesti > Gesti del polso Attivato. Quindi completa la Il tutorial sui gesti sull'orologio selezionando Avvia tutorial.

Nota: scuotere il polso rappresenta il gesto Indietro a livello di sistema o di annullamento. e non è disponibile per la personalizzazione delle app.

I gesti del polso possono essere utilizzati nei seguenti modi, descritti in questa guida:

• Con un layout curvo, che ha azioni di gesti predefinite
• Utilizzando direttamente gli eventi chiave per definire nuove azioni utente

Ogni gesto del polso è mappato a una costante int dalla KeyEvent come illustrato nella tabella seguente:

Usa un layout curvo per supportare i gesti del polso

La classe WearableRecyclerView fornisce una curva per gli elenchi e supporta automaticamente gesti del polso. La classe ha azioni predefinite per le occorrenze di gesti del polso quando la visualizzazione è a fuoco. Per informazioni sull'utilizzo la WearableRecyclerView classe, vedi Creare elenchi su Wear OS. Inoltre, vedi le Best practice di questa guida.

Nota: il corso WearableRecyclerView sostituisce una classe simile, deprecato nella libreria di supporto Wearable.

Anche se usi un WearableRecyclerView, potrebbe essere utile usare costanti da KeyEvent . Le azioni predefinite possono essere sostituite creando sottoclassi del tipo WearableRecyclerView e reimplementando il Chiamata onKeyDown(). Il comportamento può essere completamente disattivato mediante setEnableGestureNavigation(false). Per ulteriori informazioni, vedi Consente di gestire le azioni da tastiera.

Utilizza direttamente gli eventi chiave

Puoi utilizzare gli eventi chiave al di fuori di un WearableRecyclerView per attivare nuove azioni in risposta al gesto eventi. Soprattutto, questi eventi di gesti vengono riconosciuti quando un dispositivo è in attiva e vengono pubblicati come tutti gli eventi chiave.

Una classe relativa all'interazione dell'utente, ad esempio View o un Activity, che implementa KeyEvent.Callback può ascoltare eventi chiave correlati a gesti del polso come per qualsiasi altro evento chiave. Framework Android chiama View o Activity che ha concentrati sugli eventi chiave. Per i gesti, onKeyDown() viene chiamato quando si verificano dei gesti.

Ad esempio, un'app può eseguire l'override delle azioni predefinite in un 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

• Leggi KeyEvent e KeyEvent.Callback pagine per la pubblicazione degli eventi chiave View e Activity.
• Mantieni un approccio direzionale coerente: usa "ruota il polso verso l'esterno" della e poi "ruota il polso verso l'interno" per i precedenti.
• Usa un tocco parallelo per un gesto.
• Fornisci un feedback visivo.
• Non utilizzare un codice chiave per implementare funzionalità che potrebbero controintuitivo al resto del sistema. Ad esempio, non utilizzare KEYCODE_NAVIGATE_NEXT per annullare un'azione o navigare nel asse sinistro-destro con rulli.
• Non intercettare gli eventi chiave sugli elementi che non fanno parte del dell'interfaccia utente, ad esempio le visualizzazioni fuori schermo o parzialmente in questione. Questo vale per qualsiasi evento chiave.
• Non reinterpretare i gesti di rotazione ripetuti in un tuo nuovo gesto. Il dispositivo potrebbe essere in conflitto con lo "scuotimento del polso" del sistema gesto.

• Affinché una vista possa ricevere gli eventi chiave dei gesti, deve avere focus; vedi View.setFocusable().

  Poiché i gesti vengono considerati come eventi chiave, attivano una transizione dalla "modalità touch" che potrebbero generare risposte impreviste cose nuove. Dato che gli utenti possono alternare le funzionalità touch e gesti, potrebbe essere necessario il metodo View::setFocusableInTouchmode(). In alcuni casi, potrebbe essere necessario usare anche setDescendantFocusability(FOCUS_BEFORE_DESCENDANTS) così che, quando lo stato attivo cambia dopo una modifica alla o dalla modalità tocco, il con la vista desiderata.

• Utilizza requestFocus() e clearFocus() attentamente:
  .
  • Quando chiami il numero requestFocus(), assicurati che sia appropriato per il per mettere a fuoco. Se la visualizzazione è fuori schermo o coperta da un'altra visualizzazione, possono verificarsi sorprese quando i gesti attivano richiamate.
  • Il metodo clearFocus() avvia una ricerca di impostazione dello stato attivo per trovarne un altro vista adatta. A seconda della gerarchia delle visualizzazioni, questa ricerca potrebbe non banali. Potrebbe anche assegnare lo stato attivo a una vista che non ti aspetti di mettere in evidenza.

• Gli eventi chiave vengono pubblicati per primi nella vista con lo stato attivo nella vista nella gerarchia. Se la vista con lo stato attivo non gestisce l'evento, cioè restituisce false: l'evento non viene pubblicato nella vista principale, nemmeno se può ricevere lo stato attivo e ha un valore KeyListener. Piuttosto, l'evento viene pubblicato nell'attività corrente. che mostra la gerarchia di visualizzazione con lo stato attivo.

  Pertanto, potrebbe essere necessario rilevare tutti gli eventi al livello superiore e poi trasmettere i codici pertinenti. In alternativa, puoi creare sottoclassi dell'attività e sostituire la Metodo dispatchKeyEvent(KeyEvent event) per intercettare le chiavi quando necessario o quando non vengono gestiti strati inferiori.