Eingabekompatibilität auf großen Bildschirmen

Auf Geräten mit großen Bildschirmen interagieren Nutzende häufig über die Tastatur mit Apps. Maus, Touchpad, Eingabestift oder Gamepad. So aktivieren Sie, dass Ihre App Eingaben akzeptiert von externen Geräten, gehen Sie so vor:

• Testen Sie die grundlegende Tastaturunterstützung, z. B. bei der Tastaturnavigation mit Tabulatortaste oder Pfeiltasten. Bestätigung der Tastentexteingabe und Wiedergabe/Pause der Leertaste in Medien-Apps
• Fügen Sie nach Bedarf Standard-Tastenkombinationen hinzu. z. B. Strg + Z zum Rückgängigmachen und Strg + S zum Speichern
• Grundlegende Mausinteraktionen in Form eines Rechtsklicks für Kontext testen Menü, Symboländerungen beim Bewegen des Mauszeigers und Scroll-Ereignisse des Mausrads oder Touchpads auf Benutzerdefinierte Ansichten
• App-spezifische Eingabegeräte testen, z. B. Eingabestifte zum Zeichnen von Apps oder Spielen Controller für Spiele und MIDI-Controller für Musik-Apps
• Erwägen Sie die erweiterte Eingabeunterstützung, um die App in Desktop-Umgebungen zum Beispiel ein Touchpad als Cross-Fader für DJ-Apps, Mauserfassung für Spiele und umfangreiche Tastenkombinationen für tastaturorientierte Nutzer

Tastatur

Die Art und Weise, wie deine App auf Tastatureingaben reagiert, trägt zu einem guten großen Bildschirm bei. Nutzererfahrung. Es gibt drei Arten von Tastatureingaben: Navigation, Tastenkombinationen und Tastenkombinationen.

Navigation

Die Tastaturnavigation wird selten in berührungsorientierten Apps implementiert, aber Nutzer wenn sie eine App verwenden und die Hände auf eine Tastatur legen. Es kann auch für Nutzende mit Bedienungshilfen auf Smartphones, Tablets, faltbare Smartphones und Desktop-Geräte.

Bei vielen Apps reicht die einfache Navigation mit den Pfeiltasten und der Tabulatortaste aus. werden meist automatisch vom Android-Framework verarbeitet. Die Ansicht einer Button ist standardmäßig fokussierbar, die Tastaturnavigation sollte im Allgemeinen funktionieren ganz ohne zusätzlichen Code. Um die Tastaturnavigation für Ansichten zu aktivieren, nicht fokussierbar sind, sollten Entwickler sie als fokussierbar markieren, wie unten gezeigt programmatisch oder in XML erfolgen kann. Weitere Informationen finden Sie unter Fokusbearbeitung .

yourView.isFocusable = true

yourView.setFocusable(true);

Alternativ können Sie das Attribut focusable in Ihrer Layoutdatei festlegen:

android:focusable="true"

Sobald der Fokus aktiviert ist, erstellt das Android-Framework eine Navigationszuordnung für alle fokussierbaren Ansichten basierend auf ihrer Position. Das funktioniert in der Regel wie erwartet und Sie müssen nichts weiter tun. Wenn die Standardzuordnung für einen App-Anforderungen erfüllt, kann er wie folgt überschrieben werden:

// 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

// 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);

Versuchen Sie, auf alle Funktionen Ihrer App zuzugreifen, vor jedem Loslassen nur mit der Tastatur. Der Zugriff auf die die häufigsten Aktionen ohne Maus- oder Berührungseingabe.

Denken Sie daran, dass die Tastaturunterstützung für Nutzende mit Bedienungshilfen Anforderungen.

Tastenanschläge

Zur Texteingabe, die über eine Bildschirmtastatur gesteuert wird (IME) wie EditText, Apps sich auf Geräten mit großen Bildschirmen wie erwartet verhalten, ohne dass für den Entwickler. Bei Tastaturanschlägen, die vom Framework nicht vorhersehbar sind, das Verhalten selbst bewältigen müssen. Dies gilt insbesondere für Apps mit benutzerdefinierte Ansichten verwenden.

Beispiele sind Chat-Apps, die über die Eingabetaste Nachrichten, Medien Apps, die die Wiedergabe mit der Leertaste starten und beenden, sowie Spiele, die die Wiedergabe steuern Bewegung mit den Tasten w, a, s und d.

Die meisten Apps überschreiben die onKeyUp() und fügen Sie für jeden empfangenen Schlüsselcode das erwartete Verhalten hinzu, unten:

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

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

Ein onKeyUp-Ereignis tritt auf, wenn ein Schlüssel freigegeben wird. Die Verwendung dieses Callbacks verhindert, dass Apps müssen nicht mehrere onKeyDown-Ereignisse verarbeiten, wenn eine Taste gedrückt gehalten wird. oder langsam losgelassen werden. Spiele und Apps, die sofort wissen möchten, wann oder die davon ausgehen, dass Nutzer Tasten gedrückt halten müssen, onKeyDown() und die wiederholten onKeyDown-Ereignisse selbst verarbeiten.

Weitere Informationen zur Unterstützung der Tastatur finden Sie unter Tastaturaktionen ausführen

Verknüpfungen

Die gängigen Tastenkürzel Strg, Alt und Umschalttaste werden auf Hardware-Geräten erwartet Tastatur. Werden sie nicht in einer App implementiert, fühlt es sich möglicherweise an, für Nutzende frustrierend ist. Fortgeschrittene Nutzer bevorzugen auch häufig Tastenkürzel App-spezifische Aufgaben ausgeführt haben. Verknüpfungen erleichtern die Verwendung und Unterscheidung einer App von Apps, die keine Verknüpfungen haben.

Gängige Tastenkürzel sind Strg + S (Speichern), Strg + Z (Rückgängig machen) und Strg + Umschalttaste + Z (Wiederholen). Ein Beispiel für erweiterte Tastenkombinationen finden Sie unter die Liste der Tastenkombinationen für den VLC Media Player:

Verknüpfungen können mithilfe von dispatchKeyShortcutEvent() Diese Funktion fängt alle Meta-Tastenkombinationen (Alt, Strg und Umschalttaste) für eine bestimmte Keycode ein. Um nach einem bestimmten Metaschlüssel zu suchen, verwenden Sie KeyEvent.isCtrlPressed(), KeyEvent.isShiftPressed() KeyEvent.isAltPressed() oder KeyEvent.hasModifiers()

Trennen des Verknüpfungscodes von anderen Tastenanschlägen (z. B. onKeyUp()) und onKeyDown()) können die Code-Wartung vereinfachen und die Standard- Akzeptanz von Metaschlüsseln, ohne dass Meta-Schlüsselprüfungen manuell in für jeden Fall. Das Zulassen aller Meta-Tasten-Kombinationen kann auch praktischer sein für Nutzende, die mit verschiedenen Tastaturlayouts und Betriebssystemen vertraut sind.

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

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

Du kannst Tastenkombinationen auch in onKeyUp() implementieren. Suche dazu nach KeyEvent.isCtrlPressed(), KeyEvent.isShiftPressed() oder KeyEvent.isAltPressed() wie oben beschrieben. Dies kann einfacher zu verwalten sein, geht es eher um eine Veränderung des Anwendungsverhaltens als um eine Verknüpfung. Beispiel: W bedeutet „vorwärts gehen“. Umschalttaste + W bedeutet „Vorwärts laufen“.

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

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

Eingabestift

Auf vielen Geräten mit großem Bildschirm ist ein Eingabestift installiert, was bei Android-Apps Touchscreen-Eingabe. Einige Geräte haben möglicherweise auch eine USB- oder Bluetooth-Zeichnung. Tabelle, wie die Wacom Intuos Android-Apps können Bluetooth-Eingaben empfangen, funktionieren jedoch nicht mit der USB-Eingabe.

Ein Eingabestift-Ereignis wird als Touchscreen-Ereignis gemeldet über View.onTouchEvent() oder View.onGenericMotionEvent() und enthält ein MotionEvent.getSource() vom Typ SOURCE_STYLUS

MotionEvent enthält auch zusätzliche Daten:

• MotionEvent.getToolType() gibt TOOL_TYPE_FINGER, TOOL_TYPE_STYLUS, oder TOOL_TYPE_ERASER je nachdem, welches Werkzeug die Oberfläche berührt hat,
• MotionEvent.getPressure() meldet den physischen Druck, der auf den Eingabestift ausgeübt wird (falls unterstützt)
• MotionEvent.getAxisValue() mit MotionEvent.AXIS_TILT und MotionEvent.AXIS_ORIENTATION Damit lässt sich die physische Neigung und Ausrichtung des Eingabestifts erkennen (falls unterstützt)

Historische Punkte

Android führt Eingabeereignisse zu Batches und stellt sie einmal pro Frame bereit. Einen Eingabestift Ereignisse mit viel höherer Häufigkeit als auf dem Display melden. Beim Erstellen Zeichen-Apps zu sehen, ist es wichtig, nach Ereignissen zu suchen, mithilfe der getHistorical APIs:

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

Ablehnung der Handfläche

Wenn Nutzer mit einem Eingabestift zeichnen, schreiben oder mit Ihrer App interagieren, den Bildschirm mit der Handfläche berühren. Das Touch-Ereignis (festgelegt auf ACTION_DOWN oder ACTION_POINTER_DOWN) kann an Ihre App gemeldet werden, bevor das System die unbeabsichtigt berührt.

Android bricht Palm Touch-Ereignisse ab, indem ein MotionEvent Wenn Ihre App ACTION_CANCEL, abbrechen Touch-Geste. Wenn Ihre App ACTION_POINTER_UP, prüfen, ob FLAG_CANCELED ist festgelegt. Wenn brechen Sie die Bewegung ab.

Nicht nur nach FLAG_CANCELED suchen. Ab Android 13 wurde der Einfachheit halber Das System legt FLAG_CANCELED für ACTION_CANCEL-Ereignisse fest, aber vorherige Versionen tun Sie das nicht.

Android 12

Unter Android 12 (API-Level 32) und niedriger ist die Erkennung von Handflächenablehnung möglich nur für Single-Pointer-Touch-Events. Wenn Sie nur die Handfläche berühren, wird die Schaltfläche das System das Ereignis abbricht, indem es ACTION_CANCEL für das Bewegungsereignisobjekt festlegt. Sind andere Zeiger ausgefallen, legt das System ACTION_POINTER_UP fest, also nicht ausreichend, um die Abwesenheit der Handfläche zu erkennen.

Android 13

Unter Android 13 (API-Level 33) und höher: bricht das System den Termin ab, indem ACTION_CANCEL und FLAG_CANCELED auf das Bewegungsereignisobjekt. Sind andere Zeiger ausgefallen, legt das System ACTION_POINTER_UP und FLAG_CANCELED.

Immer wenn deine App ein Bewegungsereignis mit ACTION_POINTER_UP empfängt, solltest du auf FLAG_CANCELED, um festzustellen, ob das Ereignis auf eine Palmablehnung hinweist (oder andere Termine abgesagt werden.

Notizen-Apps

ChromeOS hat einen besonderen Zweck, der registrierte Notizen-Apps für Nutzer zugänglich macht. Nutzenden. Um eine App als Notizen-App zu registrieren, fügen Sie Folgendes zur Android-Manifest:

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

Wenn eine App registriert ist, kann der Nutzer sie als Standard für Notizen festlegen Wenn eine neue Notiz angefordert wird, sollte die App eine leere Notiz erstellen. für die Eingabe per Eingabestift. Wenn der Nutzer einem Bild (z. B. einem Screenshot oder heruntergeladenes Bild) startet die App mit ClipData, die das Ein oder mehrere Elemente mit content://-URIs. Die App sollte einen Hinweis erstellen, verwendet das erste angehängte Bild als Hintergrundbild und wechselt in einen Modus, in dem die Nutzende mit einem Eingabestift auf dem Bildschirm zeichnen können.

Notizen-Intents ohne Eingabestift testen

Um zu testen, ob eine App korrekt auf Notizen-Intents reagiert, ohne dass eine aktive Eingabestift verwenden, können Sie mit der folgenden Methode ChromeOS:

1. In den Entwicklermodus wechseln und das Gerät beschreibbar machen
2. Drücken Sie Strg + Alt + F2, um ein Terminal zu öffnen
3. Führen Sie den Befehl sudo vi /etc/chrome_dev.conf aus.
4. Drücken Sie i, um den Text zu bearbeiten und --ash-enable-palette in eine neue Zeile einzufügen der Datei
5. Drücken Sie zum Speichern die Esc-Taste, geben Sie dann :, w, q ein und drücken Sie die Eingabetaste.
6. Drücken Sie Strg + Alt + F1, um zur regulären ChromeOS-Benutzeroberfläche zurückzukehren
7. Abmelden und wieder anmelden

In der Ablage sollte jetzt ein Eingabestiftmenü angezeigt werden:

• Tippe in der Ablage auf die Eingabestift-Schaltfläche und wähle Neue Notiz aus. Dies sollte geöffnet werden. eine leere Zeichnungsnotiz.
• Machen Sie einen Screenshot. Wählen Sie in der Ablage die Schaltfläche Eingabestift > Bildschirm aufnehmen oder laden Sie ein Bild herunter. Es sollte die Option „Bild annotieren“ angezeigt werden. in der Benachrichtigung. Nun sollte die App mit dem Bild gestartet werden. gekennzeichnet sind.

Unterstützung für Maus und Touchpad

Die meisten Apps benötigen in der Regel nur drei große Bildschirme Ereignisse: Rechtsklick, Hover und Drag-and-drop verwenden.

Rechtsklick

Alle Aktionen, die dazu führen, dass eine App ein Kontextmenü anzeigt, z. B. Tippen & halte einen auch auf Rechtsklick-Ereignisse reagieren. Zur Verarbeitung des Rechtsklicks müssen Apps einen View.OnContextClickListener Weitere Informationen zum Erstellen eines Kontextmenüs finden Sie unter Kontextmenüs erstellen

yourView.setOnContextClickListener {
  showContextMenu()
  true
}

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

Mauszeiger hierher bewegen

Entwickler können ihre App-Layouts ausgefeilt und benutzerfreundlich gestalten, indem sie die Verarbeitung von Hover-Ereignissen. Dies gilt insbesondere für benutzerdefinierte Ansichten. Die beiden wichtigsten Gängige Beispiele dafür sind:

• Sie zeigen Nutzern an, ob ein Element interaktives Verhalten aufweist, z. B. anklickbar oder bearbeitbar ist, indem Sie das
• Visuelles Feedback zu Elementen in einer großen Liste oder einem Raster hinzufügen, wenn der Zeiger wenn Sie mit der Maus

// 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.
}

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

Drag-and-Drop

Im Mehrfenstermodus erwarten Nutzer, dass sie Elemente per Drag-and-drop hinzufügen können. zwischen Apps wechseln. Dies gilt sowohl für Desktop-Geräte als auch für Tablets, Mobiltelefone und faltbare Smartphones im Split-Screen-Modus.

Entwickler sollten überlegen, ob Nutzende Elemente Hier einige Beispiele: Fotoeditoren sollten müssen Audio-Player Audiodateien und Zeichnungen empfangen. Sendungen sollten Fotos empfangen können.

Um Drag-and-drop zu unterstützen, folgen Sie der Android-App Dokumentation per Drag-and-drop verschieben und ansehen in dieser ChromeOS-Blogpost.

Besondere Hinweise für ChromeOS

• Denken Sie daran, für den Zugriff die Berechtigung über requestDragAndDropPermissions anzufordern Elemente, die von außerhalb der App hineingezogen werden
• Elemente können nur verschoben werden, wenn sie das Flag View.DRAG_FLAG_GLOBAL haben auf andere Anwendungen

Erweiterte Zeigerunterstützung

Apps, die eine erweiterte Steuerung der Maus- und Touchpad-Eingabe ermöglichen, sollten die Android-Dokumentation für View.onGenericMotionEvent() und verwenden Sie MotionEvent.getSource() um zwischen SOURCE_MOUSE und SOURCE_TOUCHSCREEN

Sehen Sie sich die MotionEvent an, um das erforderliche Verhalten zu implementieren:

• Beim Verschieben werden ACTION_HOVER_MOVE-Ereignisse generiert.
• Schaltflächen generieren ACTION_BUTTON_PRESS- und ACTION_BUTTON_RELEASE-Ereignisse. Sie können den aktuellen Status aller Maus- bzw. Touchpad-Tasten auch mit getButtonState()
• Beim Scrollen mit dem Mausrad werden ACTION_SCROLL-Ereignisse generiert.

Controller

Einige Android-Geräte mit großem Bildschirm unterstützen bis zu vier Controller. Entwickler sollten die standardmäßigen Android-Gamecontroller-APIs verwenden, Weitere Informationen zur Unterstützung von Controllern

Schaltflächen werden gemeinsamen Werten zugeordnet, die einer gemeinsamen Zuordnung folgen. Leider nicht alle Hersteller von Gamecontrollern dieselben Mapping-Konventionen. Die Nutzererfahrung ist viel besser, wenn Sie Nutzern die Möglichkeit bieten, beliebte Controller-Mappings. Weitere Informationen finden Sie unter Gamepad-Tastendrücke verarbeiten .

Eingabeübersetzungsmodus

ChromeOS aktiviert standardmäßig einen Eingabeübersetzungsmodus. Für die meisten Android-Apps dass Apps in einer Desktopumgebung wie erwartet funktionieren. Einige Beispiele automatisches Scrollen mit zwei Fingern auf dem Touchpad, Scrollen durch das Mausrad und Zuordnung von Rohkoordinaten zur Anzeige zu Fensterkoordinaten. Im Allgemeinen müssen App-Entwickler keines dieser Verhaltensweisen implementieren. selbst.

Wenn eine App ein benutzerdefiniertes Eingabeverhalten implementiert, z. B. durch Festlegen eines Auseinander- und Zusammenziehen auf dem Touchpad mit zwei Fingern oder diese Eingabeübersetzungen Eingabeereignisse, die von der App erwartet werden, können Sie die Eingabeübersetzung indem Sie dem Android-Manifest das folgende Tag hinzufügen:

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

Weitere Informationen

• Eingabekompatibilität