Używanie gestów nadgarstka na Wear

Gesty nadgarstka umożliwiają szybkie, niewygodne korzystanie z aplikacji jedną ręką.

Na przykład użytkownik może przewijać powiadomienia jedną ręką, trzymając drugą szklankę wody. Inne zastosowania gestów nadgarstka to:

• w aplikacji do biegania przechodzenie po pionowych ekranach wyświetlających zrobione kroki, czas, który upłynął, i bieżące tempo;
• przewijanie informacji o locie i bramce w aplikacji podróżniczej;
• przewijanie artykułów w aplikacji z wiadomościami;

Aby przeglądać gesty nadgarstka na zegarku, sprawdź, czy są one włączone. W tym celu wybierz Ustawienia > Funkcje zaawansowane > Gesty > Gesty nadgarstka są włączone. Następnie przejdź samouczek gestów na zegarku, wybierając Uruchom samouczek.

Uwaga: potrząsanie nadgarstkiem działa w całym systemie za pomocą gestów cofania i cofania. Nie można tego zmienić w przypadku aplikacji.

Gesty nadgarstka mogą być używane na następujące sposoby zgodnie z opisem w tym przewodniku:

• W układzie zakrzywionym ze wstępnie zdefiniowanymi działaniami umożliwiającymi wykonywanie gestów.
• Przez zastosowanie bezpośrednich zdarzeń kluczowych do definiowania nowych działań użytkownika

Każdy gest nadgarstka jest zmapowany na stałą int z klasy KeyEvent, jak pokazano w tej tabeli:

Użyj zakrzywionego układu do obsługi gestów nadgarstka.

Klasa WearableRecyclerView zapewnia zakrzywiony układ list i automatycznie obsługuje gesty nadgarstka. Ta klasa ma wstępnie zdefiniowane działania związane z wystąpieniami gestów nadgarstka, gdy widok jest zaznaczony. Informacje o używaniu klasy WearableRecyclerView znajdziesz w artykule Tworzenie list na Wear OS. Zapoznaj się też z sekcją tego przewodnika dotyczącą sprawdzonych metod.

Uwaga: klasa WearableRecyclerView zastępuje podobną, wycofaną klasę w bibliotece pomocy urządzenia do noszenia.

Nawet jeśli korzystasz z typu WearableRecyclerView, możesz używać stałych z klasy KeyEvent. Wstępnie zdefiniowane działania można zastąpić, tworząc podklasę WearableRecyclerView i ponownie implementując wywołanie zwrotne onKeyDown(). Działanie to można całkowicie wyłączyć za pomocą polecenia setEnableGestureNavigation(false). Więcej informacji znajdziesz w sekcji Obsługa działań klawiatury.

Użyj kluczowych zdarzeń bezpośrednio

Kluczowych zdarzeń możesz używać poza obiektem WearableRecyclerView, aby wywoływać nowe działania w odpowiedzi na zdarzenia związane z gestami. Co ważne, te zdarzenia gestów są rozpoznawane, gdy urządzenie jest w trybie aktywnym, i są wywoływane w taki sam sposób jak wszystkie kluczowe zdarzenia.

Klasa związana z interakcją użytkownika, na przykład View lub Activity, która implementuje KeyEvent.Callback, może nasłuchiwać kluczowych zdarzeń związanych z gestami nadgarstka tak samo jak w przypadku każdego innego kluczowego zdarzenia. Platforma Androida wywołuje View lub Activity, które koncentrują się na kluczowych zdarzeniach. W przypadku gestów wywołanie zwrotne metody onKeyDown() jest wywoływane po wystąpieniu gestów.

Aplikacja może na przykład zastąpić wstępnie zdefiniowane działania w dyrektywie View lub Activity z implementacją KeyEvent.Callback w ten sposób:

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

Sprawdzone metody

• Sprawdź strony KeyEvent i KeyEvent.Callback pod kątem przesyłania kluczowych zdarzeń do View i Activity.
• Zachowaj stabilną alokację kierunkową: „obróć nadgarstek od przodu” w przypadku następnego i „obróć nadgarstek do przodu” w przypadku poprzedniego.
• Używaj równoległego dotykania ekranu, aby wykonać gest.
• Prześlij wizualną opinię.
• Nie używaj kodu klucza do wdrażania funkcji, które byłyby sprzeczne z intuicją resztą systemu. Nie używaj na przykład polecenia KEYCODE_NAVIGATE_NEXT do anulowania działania ani poruszania się po osi od lewej do prawej za pomocą ruchów.
• Nie przechwytuj kluczowych zdarzeń w elementach, które nie są częścią interfejsu, np. w wyświetleniach spoza ekranu lub częściowo zakrytych. Działa to tak samo jak w przypadku każdego kluczowego zdarzenia.
• Nie interpretuj ponownie powtarzanych gestów do postaci na własny, nowatorski gest. Może to być w konflikcie z gestem systemowym „potrząsania nadgarstkiem”.

• Aby widok otrzymywał najważniejsze zdarzenia gestów, musi być zaznaczony – patrz View.setFocusable().

  Gesty są traktowane jak kluczowe zdarzenia, więc wywołują wyjście z „trybu dotykowego”, które może wywołać nieoczekiwane rzeczy. Użytkownicy mogą przełączać się między dotykami i gestami, dlatego może być wymagana metoda View::setFocusableInTouchmode(). W niektórych przypadkach może być konieczne użycie właściwości setDescendantFocusability(FOCUS_BEFORE_DESCENDANTS), aby po przejściu na tryb dotykowy lub z niego zaznaczenie znalazło się we właściwym widoku.

• Ostrożnie używaj znaczników requestFocus() i clearFocus():
  • Gdy wywołujesz funkcję requestFocus(), upewnij się, że widok jest odpowiedni dla tego widoku. Jeśli widok znajduje się poza ekranem lub jest przysłonięty innym widokiem, gdy gesty wywołują wywołania zwrotne, mogą wystąpić niespodzianki.
  • Metoda clearFocus() inicjuje fokus w celu znalezienia innego odpowiedniego widoku. W zależności od hierarchii widoków to wyszukiwanie może wymagać nieprostych obliczeń. Może też spowodować przypisanie zaznaczenia do widoku, którego nie oczekujesz.

• Kluczowe zdarzenia są dostarczane jako pierwsze do widoku z aktywną hierarchią widoków. Jeśli aktywny widok nie obsługuje zdarzenia – czyli zwraca wartość false – nie jest ono wyświetlane w widoku nadrzędnym, nawet jeśli może być aktywne i ma element KeyListener. Zdarzenie jest wyświetlane w bieżącym działaniu, w którym jest zaznaczona hierarchia widoków.

  W związku z tym może być konieczne wychwycenie wszystkich zdarzeń na wyższym poziomie, a następnie przekazanie odpowiednich kodów. Możesz też utworzyć podklasyfikację aktywności i zastąpić metodę dispatchKeyEvent(KeyEvent event), która w razie potrzeby przechwytuje klucze, lub obsługiwać je, gdy nie są obsługiwane na niższych warstwach.