Zgodność urządzeń wejściowych na dużych ekranach

Na urządzeniach z dużym ekranem użytkownicy częściej używają klawiatury mysz, trackpad, rysik lub pad do gier. Aby umożliwić aplikacji akceptowanie danych wejściowych z: urządzeń zewnętrznych, wykonaj te czynności:

  • Przetestuj podstawową obsługę klawiatury, np. nawigację za pomocą klawisza Tab i klawiszy strzałek, Potwierdzanie wpisywania tekstu klawisza i odtwarzanie/wstrzymywanie spacji w aplikacjach do multimediów
  • Dodaj standardowe skróty klawiszowe tam, gdzie to możliwe. na przykład Ctrl + Z aby cofnąć, lub naciśnij Ctrl + S, aby zapisać zmiany.
  • Testuj podstawowe interakcje z myszą, by zobaczyć kontekst, tak jak kliknij prawym przyciskiem myszy. menu, zmiany ikon po najechaniu kursorem oraz zdarzenia przewijania kółkiem myszy lub trackpada włączone widoki niestandardowe
  • Przetestuj urządzenia wejściowe specyficzne dla aplikacji, takie jak rysik do rysowania, gra, kontrolery do gier i kontrolery MIDI do aplikacji muzycznych
  • Zastanów się nad zaawansowaną obsługą wprowadzania, która może sprawić, że aplikacja będzie się wyróżniać środowiska komputerowe; na przykład touchpada jako cross-fadera w aplikacjach dla DJ-ów, przechwytywania myszą w grach oraz rozbudowanych skrótów klawiszowych użytkownicy skoncentrowani na klawiaturze

Klawiatura

To, w jaki sposób aplikacja reaguje na wprowadzanie tekstu z klawiatury, przyczynia się do zapewnienia dobrej jakości dużego ekranu z myślą o użytkownikach. Są trzy rodzaje wprowadzania za pomocą klawiatury: nawigacja, naciśnięcia klawiszy i skrótów.

Nawigacja za pomocą klawiatury jest rzadko wdrażana w aplikacjach dotykowych, ale użytkownicy tego oczekuje, gdy używają aplikacji i trzymają ręce na klawiaturze. Może są też niezbędne dla osób z ułatwieniami dostępu na telefonach, tabletach, na urządzeniach składanych i komputerach.

W wielu aplikacjach wystarczy do tego prosty klawisz strzałki i nawigacja po kartach. obsługiwane głównie automatycznie przez platformę Androida. Na przykład widok Pole Button jest domyślnie możliwe do zaznaczenia, a nawigacja za pomocą klawiatury powinna działać bez dodatkowego kodu. Aby włączyć nawigację za pomocą klawiatury w widokach, które są domyślnie nie można zaznaczyć, deweloperzy powinni je oznaczyć jako możliwe do zaznaczenia, można zrobić programowo lub w formacie XML, jak pokazano poniżej. Zobacz Skupienie .

Kotlin

yourView.isFocusable = true

Java

yourView.setFocusable(true);

Możesz też ustawić atrybut focusable w pliku układu:

android:focusable="true"

Po włączeniu zaznaczenia platforma Androida tworzy mapowanie nawigacyjne dla wszystkich widoków, które można zaznaczyć, na podstawie ich pozycji. Zwykle działa to zgodnie z oczekiwaniami i nie są potrzebne żadne dodatkowe działania. Gdy domyślne mapowanie jest niepoprawne dla może być zastąpiony w następujący sposób:

Kotlin

// Arrow keys
yourView.nextFocusLeftId = R.id.view_to_left
yourView.nextFocusRightId = R.id.view_to_right
yourView.nextFocusTopId = R.id.view_above
yourView.nextFocusBottomId = R.id.view_below

// Tab key
yourView.nextFocusForwardId = R.id.next_view

Java

// Arrow keys
yourView.setNextFocusLeftId(R.id.view_to_left);
yourView.setNextFocusRightId(R.id.view_to_left);
yourView.setNextFocusTopId(R.id.view_to_left);
yourView.setNextFocusBottomId(R.id.view_to_left);

// Tab key
yourView.setNextFocusForwardId(R.id.next_view);

Warto spróbować uzyskać dostęp do wszystkich funkcji aplikacji przed każdym wydaniem tylko za pomocą klawiatury. Dostęp do czynności wykonywane bez użycia myszy lub dotyku.

Pamiętaj, że obsługa klawiatury może być niezbędna dla użytkowników z ułatwieniami dostępu do Twoich potrzeb.

Naciśnięcia klawiszy

Na potrzeby wprowadzania tekstu obsługiwanego przez ekranową klawiaturę wirtualną (IME), np. EditText, aplikacje powinno działać prawidłowo na urządzeniach z dużym ekranem, bez dodatkowej pracy z deweloperem. W przypadku naciśnięć klawiszy, których struktura nie jest w stanie przewidzieć, muszą sami sobie radzić z tymi zachowaniami. Dotyczy to zwłaszcza aplikacji, w których widoków niestandardowych.

Są to na przykład aplikacje do obsługi czatu, które wysyłają wiadomości za pomocą klawisza Enter, aplikacje, które uruchamiają i zatrzymują odtwarzanie klawiszem spacji, oraz gry z użyciem klawiszy w, a, s i d.

Większość aplikacji zastępuje onKeyUp() wywołanie zwrotne i dodaj oczekiwane zachowanie dla każdego otrzymanego kodu klucza, jak pokazano na ilustracji poniżej:

Kotlin

override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
    return when (keyCode) {
        KeyEvent.KEYCODE_ENTER -> {
            sendChatMessage()
            true
        }
        KeyEvent.KEYCODE_SPACE -> {
            playOrPauseMedia()
            true
        }
        else -> super.onKeyUp(keyCode, event)
    }
}

Java

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_ENTER) {
        sendMessage();
        return true;
    } else if (KeyEvent.KEYCODE_SPACE){
        playOrPauseMedia();
        return true;
    } else {
        return super.onKeyUp(keyCode, event);
    }
}

Zdarzenie onKeyUp występuje po zwolnieniu klucza. Użycie tego wywołania zwrotnego uniemożliwia aplikacje muszą przetworzyć wiele zdarzeń onKeyDown po przytrzymaniu klawisza lub wolno go zwalniać. Gry i aplikacje, które chcą poznać kluczowe momenty lub gdy użytkownik przytrzymuje klawisze na klawiaturze, może wyszukać onKeyDown() i obsługiwać powtarzające się zdarzenia onKeyDown.

Więcej informacji o obsłudze klawiatury znajdziesz w artykule Obsługa działań klawiatury

Skróty

Przy korzystaniu ze sprzętu należy używać popularnych skrótów klawiszowych Ctrl, Alt i Shift. klawiatury. W przeciwnym razie ich działanie może być irytujące. Zaawansowani użytkownicy doceniają też skróty, używanych zadań w poszczególnych aplikacjach. Skróty ułatwiają korzystanie z aplikacji i rozróżnienie ich w aplikacjach, które nie mają skrótów.

Typowe skróty to Ctrl + S (zapisanie), Ctrl + Z (cofnięcie) i Ctrl + Shift + Z (Ponów). Przykłady bardziej zaawansowanych skrótów znajdziesz w sekcji lista Klawisze skrótów VLC Media Player

Skróty można zaimplementować za pomocą dispatchKeyShortcutEvent() Przechwytuje wszystkie kombinacje klawiszy meta (Alt, Ctrl i Shift) dla danego argumentu (kod). Aby wyszukać konkretny metaklucz, użyj polecenia KeyEvent.isCtrlPressed(), KeyEvent.isShiftPressed(), KeyEvent.isAltPressed() lub KeyEvent.hasModifiers().

oddzielenie kodu skrótu od innej obsługi naciśnięć klawiszy (np. onKeyUp()); i onKeyDown()) mogą ułatwić obsługę kodu i włączają domyślne akceptowania metakluczy bez konieczności ręcznego wdrażania każdego przypadku. Zezwolenie na wszystkie kombinacje metatagów może być również wygodniejsze dla przyzwyczajonych do różnych układów klawiatury i systemów operacyjnych.

Kotlin

override fun dispatchKeyShortcutEvent(event: KeyEvent): Boolean {
  return when (event.keyCode) {
    KeyEvent.KEYCODE_O -> {
      openFile() // Ctrl+O, Shift+O, Alt+O
      true
    }
    KeyEvent.KEYCODE_Z-> {
      if (event.isCtrlPressed) {
        if (event.isShiftPressed) {
          redoLastAction() // Ctrl+Shift+Z pressed
          true
        } else {
          undoLastAction() // Ctrl+Z pressed
          true
        }
      }
    }
    else -> {
      return super.dispatchKeyShortcutEvent(event)
    }
  }
}

Java

@Override
public boolean dispatchKeyShortcutEvent(KeyEvent event) {
  if (event.getKeyCode() == KeyEvent.KEYCODE_O) {
      openFile(); // Ctrl+O, Shift+O, Alt+O
      return true;
  } else if(event.getKeyCode() == KeyEvent.KEYCODE_Z) {
      if (event.isCtrlPressed()) {
          if (event.isShiftPressed()) {
              redoLastAction();
              return true;
          }
          else {
              undoLastAction();
              return true;
          }
      }
  }
  return super.dispatchKeyShortcutEvent(event);
}

Możesz też zaimplementować skróty w onKeyUp(), sprawdzając KeyEvent.isCtrlPressed(), KeyEvent.isShiftPressed(), lub KeyEvent.isAltPressed() w taki sam sposób jak powyżej. Może to być łatwiejsze, jeśli to raczej modyfikacja działania aplikacji niż skrót. Na przykład gdy W oznacza „idź do przodu”. a Shift + W oznacza „bieg do przodu”.

Kotlin

override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
  return when(keyCode) {
    KeyEvent.KEYCODE_W-> {
      if (event.isShiftPressed) {
        if (event.isCtrlPressed) {
          flyForward() // Ctrl+Shift+W pressed
          true
        } else {
          runForward() // Shift+W pressed
          true
        }
      } else {
        walkForward() // W pressed
        true
      }
    }
    else -> super.onKeyUp(keyCode, event)
  }
}

Java

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_W) {
        if (event.isShiftPressed()) {
            if (event.isCtrlPressed()) {
                flyForward(); // Ctrl+Shift+W pressed
                return true;
            } else {
                runForward(); // Shift+W pressed
                return true;
            }
        } else {
            walkForward();
            return true;
        }
    }
    return super.onKeyUp(keyCode, event);
}

Rysik

Wiele urządzeń z dużym ekranem ma rysik, a aplikacje na Androida obsługują go wprowadzanie tekstu na ekranie dotykowym. Niektóre urządzenia mogą też mieć rysunek USB lub Bluetooth taki jak Wacom Intuos. Aplikacje na Androida mogą odbierać wejście Bluetooth, ale nie obsługują wejścia USB.

Zdarzenie rysika jest zgłaszane jako zdarzenie ekranu dotykowego przez View.onTouchEvent() lub View.onGenericMotionEvent(), i zawiera MotionEvent.getSource() typu SOURCE_STYLUS.

MotionEvent będzie też zawierać dodatkowe dane:

Punkty historyczne

Android grupuje zdarzenia wejściowe i dostarcza je raz na klatkę. Rysik może zgłaszać zdarzenia ze znacznie większą częstotliwością niż wyświetlacz. Podczas tworzenia aplikacji do rysowania, ważne jest, aby sprawdzić zdarzenia, które mogą wcześniejsze za pomocą interfejsów API getHistorical:

  • MotionEvent.getHistoricalX()
  • MotionEvent.getHistoricalY()
  • MotionEvent.getHistoricalPressure()
  • MotionEvent.getHistoricalAxisValue()

Odrzucenie palm

Gdy użytkownik rysuje, pisze lub korzysta z aplikacji za pomocą rysika, dotkną ekranu dłonią. Zdarzenie dotknięcia (ustawione na ACTION_DOWN lub ACTION_POINTER_DOWN) mogą zostać zgłoszone do aplikacji, zanim system rozpozna i zignoruje przypadkowe dotknięcie dłoni.

Android anuluje zdarzenia dotyku dłoni, wysyłając MotionEvent Jeśli aplikacja otrzymuje ACTION_CANCEL, anuluj gest. Jeśli aplikacja otrzymuje ACTION_POINTER_UP, sprawdź, czy Ustawiono FLAG_CANCELED. Jeśli więc anuluj gest.

Nie sprawdzaj tylko FLAG_CANCELED. Dla wygody użytkowników Androida 13 system ustawia FLAG_CANCELED dla zdarzeń ACTION_CANCEL, ale dla poprzednich wersji nie.

Android 12

Na Androidzie 12 (poziom interfejsu API 32) i starszych wersjach można wykrywać odrzucenie dłoni. tylko w przypadku zdarzeń dotknięcia jednym wskaźnikiem. Jeśli jedynym wskaźnikiem jest dotknięcie dłoni, system anuluje zdarzenie, ustawiając właściwość ACTION_CANCEL dla obiektu zdarzenia ruchu. Jeśli inne wskaźniki nie działają, system ustawia ACTION_POINTER_UP, czyli niewystarczające do wykrycia odrzucenia dłoni.

Android 13

Na Androidzie 13 (poziom interfejsu API 33) i nowszych, jeśli jedynym wskaźnikiem jest dotyk dłoni, system anuluje wydarzenie, ustawiając wartości ACTION_CANCEL i FLAG_CANCELED na do obiektu zdarzenia ruchu. Jeśli inne wskaźniki nie działają, system ustawia ACTION_POINTER_UP i FLAG_CANCELED.

Gdy aplikacja otrzyma zdarzenie ruchu z pomocą ACTION_POINTER_UP, sprawdź FLAG_CANCELED, aby określić, czy zdarzenie wskazuje odrzucenie dłoni (lub anulowanie innego wydarzenia).

Notatki

ChromeOS ma specjalną intencję, która umożliwia wyświetlanie zarejestrowanych aplikacji do robienia notatek użytkowników. Aby zarejestrować aplikację jako aplikację do robienia notatek, dodaj ten kod do Plik manifestu Androida:

<intent-filter>
    <action android:name="org.chromium.arc.intent.action.CREATE_NOTE" />
    <category android:name="android.intent.category.DEFAULT" />
</intent-filter>

Gdy aplikacja jest zarejestrowana, użytkownik może wybrać ją jako domyślną aplikację do robienia notatek. . Po wysłaniu prośby o dodanie nowej notatki aplikacja powinna utworzyć pustą notatkę do wprowadzania tekstu za pomocą rysika. Gdy użytkownik chce dodać adnotację do obrazu (np. zrzut ekranu lub pobrany obraz), aplikacja uruchamia się z atrybutem ClipData zawierającym co najmniej jeden element z identyfikatorami URI content://. Aplikacja powinna utworzyć notatkę: używa pierwszego załączonego obrazu jako obrazu tła i włącza tryb, w którym użytkownik może rysować po ekranie za pomocą rysika.

Testuj intencje robienia notatek bez rysika

Aby sprawdzić, czy aplikacja prawidłowo reaguje na zamiary robienia notatek bez aktywnej aplikacji rysikiem, skorzystaj z następującej metody, aby wyświetlić opcje robienia notatek ChromeOS:

  1. Włączanie trybu programisty i umożliwianie zapisu na urządzeniu
  2. Naciśnij Ctrl + Alt + F2, aby otworzyć terminal
  3. Uruchom polecenie sudo vi /etc/chrome_dev.conf
  4. Naciśnij i, aby edytować i dodać --ash-enable-palette do nowego wiersza na końcu pliku
  5. Zapisz, naciskając Esc, a następnie wpisując :, w, q, a następnie naciskając Enter
  6. Naciśnij Ctrl + Alt + F1, aby wrócić do zwykłego interfejsu ChromeOS
  7. Wyloguj się i zaloguj ponownie

Na półce powinno znajdować się menu rysika:

  • Kliknij przycisk rysika na półce i wybierz Nowa notatka. Powinno się otworzyć pustą notatkę z rysunkiem.
  • Zrób zrzut ekranu. Na półce kliknij przycisk stylów > Zrzut całego ekranu lub pobierz obraz. Powinna być dostępna opcja „Dodaj adnotację do obrazu”. w powiadomienia. Powinno to uruchomić aplikację z obrazem gotowym do z adnotacjami.

Obsługa myszy i touchpada

Większość aplikacji zwykle obsługuje tylko 3 duże ekrany, zdarzenia: kliknięcie prawym przyciskiem myszy, najechanie kursorem i przeciągnij i upuść.

Kliknij prawym przyciskiem myszy

wszelkie działania, które powodują wyświetlenie menu kontekstowego przez aplikację, takie jak kliknięcie przycisku przytrzymaj powinien również reagować na zdarzenia kliknięcia prawym przyciskiem myszy. Obsługa kliknięcia prawym przyciskiem myszy zdarzeń, aplikacje powinny rejestrować View.OnContextClickListener Szczegółowe informacje o tworzeniu menu kontekstowego znajdziesz w artykule Tworzenie menu kontekstowych

Kotlin

yourView.setOnContextClickListener {
  showContextMenu()
  true
}

Java

yourView.setOnContextClickListener(v -> {
    showContextMenu();
    return true;
});

Najechanie

Deweloperzy mogą sprawić, że układy aplikacji będą dopracowane i łatwiejsze w obsłudze dzięki do obsługi zdarzeń najechania. Dotyczy to zwłaszcza widoków niestandardowych. Dwie najbardziej przydatne typowe przykłady:

  • Wskazywanie użytkownikom, czy element ma interaktywne działanie, np. którą można kliknąć lub edytować, zmieniając ikonę wskaźnika myszy
  • dodawanie wizualnej opinii do elementów na dużej liście lub na siatce, gdy wskaźnik jest w pozycji najeżdżanie na nie kursorem

Kotlin

// Change the icon to a "hand" pointer on hover,
// Highlight the view by changing the background.
yourView.setOnHoverListener { view, _ ->
  addVisualHighlighting(true)
  view.pointerIcon =
    PointerIcon.getSystemIcon(view.context,
    PointerIcon.TYPE_HAND)
  false // listener did not consume the event.
}

Java

yourView.setOnHoverListener((view, event) -> {
    addVisualHighlighting(true);
    view.setPointerIcon(PointerIcon
            .getSystemIcon(view.getContext(), PointerIcon.TYPE_HAND));
    return true;
});

Przeciągnij i upuść

W środowisku obejmującym wiele okien użytkownicy chcą móc przeciągać i upuszczać elementy między aplikacjami. Dotyczy to komputerów, tabletów, telefonów na urządzeniach składanych w trybie podzielonego ekranu.

Programiści powinni zastanowić się, czy użytkownicy mogą przeciągać elementy na . Oto kilka typowych przykładów: edytorzy zdjęć mogą spodziewać się fotografie, odtwarzacze dźwięku powinny odbierać pliki audio, a także rysunki programy powinny otrzymywać zdjęcia.

Aby dodać obsługę przeciągania i upuszczania, postępuj zgodnie z instrukcjami Przeciągnij i upuść dokumentację i zapoznaj się z nią w tym miejscu Post na blogu na temat ChromeOS.

Specjalne uwagi dotyczące ChromeOS

  • Pamiętaj, aby poprosić o uprawnienia w aplikacji requestDragAndDropPermissions, aby uzyskać dostęp elementy przeciągnięte spoza aplikacji
  • Aby można było przeciągnąć element, musi on mieć flagę View.DRAG_FLAG_GLOBAL do innych aplikacji

Zaawansowana obsługa wskaźników

Aplikacje, które zaawansowane obsługują wprowadzanie danych za pomocą myszy i touchpada, powinny spełniać Dokumentacja Androida dotycząca View.onGenericMotionEvent() i użyj MotionEvent.getSource() rozróżniać SOURCE_MOUSE i SOURCE_TOUCHSCREEN.

Sprawdź MotionEvent, aby wdrożyć wymagane działanie:

  • Ruch generuje ACTION_HOVER_MOVE zdarzeń.
  • Przyciski generują zdarzenia ACTION_BUTTON_PRESS i ACTION_BUTTON_RELEASE. Możesz też sprawdzić bieżący stan wszystkich przycisków myszy/trackpada za pomocą getButtonState()
  • Przewijanie kółkiem myszy generuje zdarzenia ACTION_SCROLL.

Kontrolery do gier

Niektóre urządzenia z Androidem o dużym ekranie obsługują do 4 kontrolerów do gier. Do obsługi kontrolerów do gier na Androida deweloperzy powinni używać standardowych interfejsów API kontrolera gier na Androida. (zobacz Obsługa kontrolerów do gier).

Przyciski są mapowane na wspólne wartości w ramach wspólnego mapowania. Niestety, Nie wszyscy producenci kontrolerów do gier stosują te same konwencje mapowania. Możesz zapewnić znacznie lepsze wrażenia, jeśli zezwolisz użytkownikom na wybieranie innych na popularnych mapach kontrolerów. Zobacz Przetwarzanie naciśnięć przycisków na padzie do gier .

Tryb translacji danych wejściowych

W ChromeOS domyślnie włączony jest tryb translacji danych wejściowych. Większość aplikacji na Androida Dzięki temu tryb umożliwia prawidłowe działanie aplikacji w środowisku stacjonarnym. Oto kilka przykładów obejmuje automatyczne włączanie przewijania 2 palcami po touchpadzie, myszy przewijanie kółkiem i mapowanie nieprzetworzonych współrzędnych wyświetlania na współrzędne okna. Deweloperzy aplikacji nie muszą stosować żadnych z tych funkcji. się dowiedzieć.

Jeśli aplikacja stosuje niestandardowe dane wejściowe, np. definiowała parametr niestandardowy ściągnięcie palców 2 palcami na touchpadzie lub te tłumaczenia zdarzeń wejściowych spodziewanych przez aplikację, możesz wyłączyć tłumaczenie danych wejściowych przez dodanie tego tagu do pliku manifestu Androida:

<uses-feature
    android:name="android.hardware.type.pc"
    android:required="false" />

Dodatkowe materiały

. .