Handgelenksgesten auf Wear OS verwenden

Handgelenksgesten können schnelle, einhändige Interaktionen mit deiner App ermöglichen, wenn der Touchscreen unpraktisch ist.

Ein Nutzer kann beispielsweise mit einer Hand durch Benachrichtigungen scrollen, während er mit der anderen eine Tasse Wasser hält. Andere Anwendungsfälle für Handgelenksgesten sind:

• In einer Jogging-App durch vertikale Bildschirme navigieren, auf denen die gegangenen Schritte, die verstrichene Zeit und das aktuelle Tempo angezeigt werden
• In einer Reise-App durch die Flug- und Gate-Informationen scrollen
• In einer Nachrichten-App durch Artikel scrollen

Um die Handgelenkgesten auf einer Smartwatch zu überprüfen, prüfe, ob sie aktiviert sind. Wähle dazu Einstellungen > Erweiterte Funktionen > Gesten > Handgelenksgesten Ein aus. Schließen Sie dann die Anleitung zu Gesten auf der Smartwatch ab, indem Sie Anleitung starten auswählen.

Hinweis:Das Schütteln des Handgelenks ist die systemweite Touch-Geste „Zurück“ oder „Rückgängig machen“ und kann von Apps nicht angepasst werden.

Handgelenksgesten können wie in dieser Anleitung beschrieben verwendet werden:

• Mit einem gewölbten Layout mit vordefinierten Gestenaktionen
• Durch die direkte Verwendung von Schlüsselereignissen, um neue Nutzeraktionen zu definieren

Jede Handgelenksgeste wird einer int-Konstante aus der Klasse KeyEvent zugeordnet, wie in der folgenden Tabelle dargestellt:

Verwenden Sie ein geschwungenes Layout, um Handgelenksgesten zu unterstützen.

Die Klasse WearableRecyclerView bietet ein gebogenes Layout für Listen und unterstützt automatisch Handgelenksgesten. Die Klasse hat vordefinierte Aktionen für das Auftreten von Handgelenksgesten, wenn die Ansicht im Fokus ist. Informationen zur Verwendung der Klasse WearableRecyclerView findest du unter Listen unter Wear OS erstellen. Weitere Informationen finden Sie auch im Abschnitt Best Practices dieses Leitfadens.

Hinweis:Die Klasse WearableRecyclerView ersetzt eine ähnliche, eingestellte Klasse in der Wearable Support Library.

Auch wenn Sie WearableRecyclerView verwenden, können Sie Konstanten aus der KeyEvent-Klasse nutzen. Die vordefinierten Aktionen können überschrieben werden, indem WearableRecyclerView abgeleitet und der onKeyDown()-Callback noch einmal implementiert wird. Das Verhalten kann mit setEnableGestureNavigation(false) vollständig deaktiviert werden. Weitere Informationen findest du unter Tastaturaktionen verarbeiten.

Schlüsselereignisse direkt verwenden

Du kannst wichtige Ereignisse außerhalb einer WearableRecyclerView verwenden, um neue Aktionen als Reaktion auf Gestenereignisse auszulösen. Wichtig ist, dass diese Gestenereignisse erkannt werden, wenn sich ein Gerät im Aktivmodus befindet, und sie auf die gleiche Weise wie alle Schlüsselereignisse ausgelöst.

Eine Klasse, die sich auf die Nutzerinteraktion bezieht, z. B. ein View oder ein Activity, und die KeyEvent.Callback implementiert, kann wichtige Ereignisse im Zusammenhang mit Handgelenksgesten überwachen, ebenso wie sie für jedes andere Schlüsselereignis aufgelistet werden kann. Das Android-Framework ruft das View oder Activity auf, das den Fokus auf die Schlüsselereignisse hat. Für Touch-Gesten wird der Callback der onKeyDown()-Methode aufgerufen, wenn Touch-Gesten auftreten.

Eine Anwendung kann beispielsweise vordefinierte Aktionen in einem View oder Activity überschreiben, das KeyEvent.Callback so implementiert:

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 Practices

• Auf den Seiten KeyEvent und KeyEvent.Callback findest du Informationen zur Übermittlung wichtiger Ereignisse an View und Activity.
• Achte auf eine einheitliche Richtung: Verwende „Handgelenk nach außen schwenken“ für das nächste und „Handgelenk nach oben schwenken“ für vorherige.
• Halte parallel zu einer Touch-Geste.
• Geben Sie visuelles Feedback.
• Verwenden Sie keinen Schlüsselcode, um Funktionen zu implementieren, die für den Rest des Systems nicht intuitiv sind. Du solltest KEYCODE_NAVIGATE_NEXT beispielsweise nicht verwenden, um eine Aktion abzubrechen oder mit einem Wischen in der linken und rechten Achse zu navigieren.
• Fangen Sie Schlüsselereignisse nicht für Elemente ab, die nicht Teil der Benutzeroberfläche sind, z. B. Ansichten, die nicht auf dem Bildschirm zu sehen sind oder teilweise verdeckt sind. Das funktioniert genauso wie bei allen Schlüsselereignissen.
• Interpretieren Sie wiederholte Gesten mit Gesten nicht in eine eigene, neuartige Geste. Dies kann zu einem Konflikt mit der Systemgeste „Schütteln des Handgelenks“ führen.

• Damit eine Ansicht empfangene Gestentastenereignisse erhält, muss sie fokussiert sein. Weitere Informationen finden Sie unter View.setFocusable().

  Da Gesten als Schlüsselereignisse behandelt werden, lösen sie einen Wechsel aus dem Touch-Modus aus, der zu unerwarteten Aktionen führen kann. Da Nutzer unter Umständen abwechselnd Berührungen und Touch-Gesten verwenden, kann die View::setFocusableInTouchmode()-Methode erforderlich sein. In einigen Fällen kann auch die Verwendung von setDescendantFocusability(FOCUS_BEFORE_DESCENDANTS) erforderlich sein, damit die gewünschte Ansicht fokussiert wird, wenn sich der Fokus nach einem Wechsel zum oder vom Touchmodus ändert.

• Verwende requestFocus() und clearFocus() mit Bedacht:
  • Achten Sie beim Aufrufen von requestFocus() darauf, dass die Ansicht im Fokus ist. Wenn die Ansicht außerhalb des sichtbaren Bildschirmbereichs liegt oder von einer anderen Ansicht verdeckt wird, können Überraschungen auftreten, wenn Gesten Callbacks auslösen.
  • Die Methode clearFocus() initiiert eine fokussierte Suche, um eine andere geeignete Ansicht zu finden. Abhängig von der Ansichtshierarchie erfordert diese Suche möglicherweise eine nicht triviale Berechnung. Es kann auch sein, dass der Fokus auch einer Ansicht zugewiesen wird, von der Sie nicht erwarten, dass sie im Fokus stehen.

• Schlüsselereignisse werden zuerst an die Ansicht gesendet, wobei der Fokus in der Ansichtshierarchie liegt. Wenn das Ereignis in der fokussierten Ansicht nicht verarbeitet wird, also false zurückgegeben wird, wird das Ereignis nicht an die übergeordnete Ansicht gesendet, selbst wenn es Fokus erhalten kann und ein KeyListener hat. Stattdessen wird das Ereignis an die aktuelle Aktivität mit der Ansichtshierarchie mit Fokus übergeben.

  Daher kann es notwendig sein, alle Ereignisse auf einer höheren Ebene abzufangen und dann die relevanten Codes weiterzugeben. Alternativ können Sie eine Unterklasse der Aktivität erstellen und die Methode dispatchKeyEvent(KeyEvent event) überschreiben, um Schlüssel bei Bedarf abzufangen oder sie zu verarbeiten, wenn sie nicht auf niedrigeren Ebenen verarbeitet werden.