Compatibilité des entrées

Sur les appareils ChromeOS, de nombreux utilisateurs interagissent avec les applications à l'aide d'un clavier, d'une souris, d'un pavé tactile, d'un stylet ou d'une manette de jeu. Bien que ces périphériques d'entrée soient également utilisés sur les téléphones Android, ils sont moins courants et sont souvent négligés par les développeurs.

Les développeurs qui souhaitent que leur application fonctionne correctement avec les saisies sur ChromeOS et d'autres appareils Android à grand écran doivent envisager les optimisations suivantes :

  • Ajoutez et testez les fonctionnalités de base du clavier, comme la navigation à l'aide des touches fléchées et de tabulation, la touche Entrée pour confirmer la saisie de texte et la barre d'espace pour lire et mettre en pause le contenu dans les applications multimédias.
  • Ajoutez des raccourcis clavier standards, le cas échéant (par exemple, ctrl+z pour annuler et ctrl+s pour enregistrer).
  • Testez les interactions de base de la souris telles que le clic droit pour afficher le menu contextuel, les modifications d'icône au passage de la souris, et l'utilisation de la molette ou du pavé tactile pour faire défiler les événements sur des vues personnalisées.
  • Testez les périphériques d'entrée spécifiques aux applications, comme le stylet pour dessiner des applications, des manettes de jeu et des télécommandes MIDI pour les applications musicales.
  • Envisagez de proposer des modes d'entrée avancés qui permettraient à l'application de se démarquer dans les environnements de bureau (par exemple, le pavé tactile comme fondu enchaîné pour les applications de DJ, la capture de souris pour les jeux et un large éventail de raccourcis clavier pour les utilisateurs expérimentés).

Clavier

La manière dont votre application réagit à la saisie au clavier contribue à une expérience de qualité sur ordinateur. Il existe trois types de saisie au clavier : navigation, touches et raccourcis.

La navigation au clavier est rarement implémentée dans les applications centrées sur l'écran tactile, mais les utilisateurs s'y attendent lorsqu'ils utilisent une application avec un clavier. Elle peut également être essentielle pour les utilisateurs ayant des besoins d'accessibilité spécifiques sur les téléphones et les ordinateurs.

Pour de nombreuses applications, la navigation via les touches fléchées et la touche de tabulation suffit. Elle est en grande partie gérée automatiquement par le framework Android. Par exemple, une vue Button est sélectionnable par défaut, et la navigation au clavier devrait généralement fonctionner sans code supplémentaire. Afin d'activer la navigation au clavier pour les vues qui ne sont pas sélectionnables par défaut, les développeurs doivent les marquer comme telles. Pour ce faire, vous pouvez procéder de manière programmatique ou en XML, comme suit. Pour en savoir plus, consultez la documentation sur la gestion de la sélection. 

yourView.isFocusable = true

Vous pouvez également définir l'attribut focusable dans le fichier de mise en page : 

android:focusable="true"

Une fois la sélection activée, le framework Android crée un mappage de navigation de toutes les vues sélectionnables en fonction de leur position. Cela fonctionne généralement normalement. Aucun effort supplémentaire n'est donc nécessaire. Lorsque le mappage par défaut n'est pas adapté aux besoins d'une application, vous pouvez le remplacer comme suit : 

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

Il est recommandé d'essayer d'accéder à toutes les fonctionnalités de votre application, avant sa compilation, à l'aide du clavier uniquement. Il doit être possible d'accéder aux actions les plus courantes sans utiliser la souris ni l'écran tactile.

Remarque : N'oubliez pas que le clavier peut être essentiel aux utilisateurs ayant des besoins d'accessibilité spécifiques.

Touches de clavier

Pour la saisie de texte qui serait gérée par un clavier virtuel à l'écran (IME) comme EditText, les applications devraient se comporter comme prévu sur ChromeOS sans nécessiter d'efforts supplémentaires de la part du développeur. Pour les touches que le framework ne peut pas anticiper, les applications devront gérer ce comportement elles-mêmes. Cela est particulièrement vrai pour les applications avec des vues personnalisées.

Il peut s'agir d'applications de chat qui utilisent la touche Entrée pour envoyer un message, d'applications multimédias qui lancent et arrêtent la lecture avec la barre d'espace, ou de jeux qui contrôlent le mouvement avec les touches w, a, s et d.

La plupart des applications ignorent l'événement onKeyUp et ajoutent le comportement attendu pour chaque code clavier reçu, comme suit. 

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

L'utilisation de onKeyUp empêche les applications de recevoir plusieurs événements si une touche est maintenue enfoncée ou relâchée lentement. Les jeux et les applications sur lesquels les utilisateurs doivent appuyer sur des touches du clavier peuvent rechercher l'événement onKeyDown.

En fonction des besoins d'une application, le remplacement d'onKeyUp pour l'ensemble de l'activité fournit généralement le comportement nécessaire. Si vous le souhaitez, vous pouvez ajouter un onKeyListener à une vue spécifique. Par exemple, une application peut écouter la touche Entrée dans un EditText spécifique uniquement, et non dans l'activité, afin de mettre en œuvre la fonctionnalité d'envoi uniquement lorsque l'utilisateur saisit du texte dans une zone de chat.

Lorsque vous ajoutez la prise en charge du clavier, suivez la documentation sur la gestion du clavier d'Android.

Raccourcis

Les raccourcis courants basés sur ctrl, alt et shift sont attendus dans les environnements de bureau. Si une application ne les implémente pas, l'expérience peut être frustrante et décevante pour les utilisateurs. Les utilisateurs avancés apprécient également les raccourcis pour les tâches fréquentes spécifiques aux applications. Les raccourcis contribuent à la facilité d'utilisation d'une application et la différencient de celles qui n'en ont pas.

Les raccourcis les plus courants sont Enregistrer (ctrl+s), Annuler (ctrl+z) et Répéter (ctrl+shift+z). Pour obtenir un exemple de raccourcis plus avancés, consultez la liste des touches de raccourci VLC Media Player.

Les raccourcis peuvent être implémentés à l'aide de dispatchKeyShortcutEvent. Toutes les combinaisons de méta-touches (alt, ctrl et shift) sont alors interceptées pour un code clavier donné. Pour rechercher une méta-touche spécifique, utilisez KeyEvent.isCtrlPressed(), KeyEvent.isShiftPressed(), KeyEvent.isAltPressed() ou KeyEvent.hasModifiers().

La séparation du code de raccourci des autres méthodes de saisie au clavier (onKeyUp ou onKeyDown, par exemple) facilite la maintenance du code et permet l'acceptation par défaut des méta-touches sans avoir à implémenter manuellement les vérifications des méta-touches dans tous les cas. L'autorisation de toutes les combinaisons de méta-touches est parfois également plus pratique pour les utilisateurs habitués à différentes configurations de clavier et systèmes d'exploitation. 

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

Vous pouvez également implémenter des raccourcis dans onKeyUp en recherchant KeyEvent.isCtrlPressed(), KeyEvent.isShiftPressed() ou KeyEvent.isAltPressed() de la même manière. Cette approche est parfois plus facile à gérer si le méta-comportement correspond davantage à une modification d'un comportement d'application qu'à un raccourci. (par exemple, lorsque "w" signifie "avancer en marchant" et "Maj+w" signifie "avancer en courant"). 

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
      }
    }
    else -> super.onKeyUp(keyCode, event)
  }
}

Compatibilité avec la souris et le pavé tactile

ChromeOS gère automatiquement la plupart des événements de souris et de pavé tactile pour qu'ils agissent comme des événements tactiles sur un téléphone Android. Cela inclut le défilement à deux doigts sur le pavé tactile ou avec la molette de la souris. La plupart des applications ne doivent généralement gérer que trois événements axés sur les ordinateurs : effectuer un clic droit, pointer le curseur et glisser-déposer.

Effectuer un clic droit

Toutes les actions qui entraînent l'affichage d'un menu contextuel par une application, comme l'appui prolongé sur un élément de la liste, doivent également réagir aux événements de clic droit. Pour gérer les événements de clic droit, les applications doivent enregistrer un View.OnContextClickListener. Pour découvrir comment créer un menu contextuel, consultez la documentation sur les menus contextuels d'Android. 

yourView.setOnContextClickListener { view ->
  showContextMenu()
  true
}

Remarque : Toutes les vues inscrites pour un menu contextuel avec Activity.registerForContextMenu() doivent automatiquement fonctionner à la fois avec les appuis longs et le clic droit sans avoir à enregistrer un écouteur de clics contextuel.

Survol

Pour rendre leurs mises en page d'application plus fluides et plus faciles à utiliser, les développeurs peuvent gérer les événements de pointage. Cela est particulièrement vrai pour les vues personnalisées. Voici les deux exemples les plus courants :

  • Modifier l'icône du pointeur de la souris pour indiquer aux utilisateurs si un élément a un comportement interactif, par exemple s'il est cliquable ou modifiable
  • Ajouter un retour visuel aux éléments d'une longue liste ou grille lorsque le pointeur passe dessus 
// 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(applicationContext,
    PointerIcon.TYPE_HAND)
  false // listener did not consume the event.
}

Glisser-déposer

Dans un environnement multifenêtre, les utilisateurs s'attendent à pouvoir glisser-déposer des éléments entre les applications. Cela est le cas pour les appareils ChromeOS, les tablettes, les téléphones et les pliables en mode écran partagé.

Les développeurs doivent déterminer si les utilisateurs sont susceptibles de faire glisser des éléments dans leur application. Voici quelques exemples courants de cas d'utilisation : les éditeurs de photos qui reçoivent des photos, les lecteurs audio qui reçoivent des fichiers audio et les programmes de dessin qui reçoivent des photos.

Pour permettre de glisser-déposer des éléments, consultez la documentation Android sur la fonctionnalité Glisser-déposer, et consultez cet article du blog ChromeOS.

Remarques concernant ChromeOS

  • Pour gérer les fichiers de l'application Fichiers de ChromeOS, recherchez le type MIME application/x-arc-uri-list.
  • N'oubliez pas de demander l'autorisation à l'aide de requestDragAndDropPermissions pour accéder aux éléments que l'utilisateur fait glisser depuis l'extérieur de l'application.
  • Un élément doit être associé à l'indicateur View.DRAG_FLAG_GLOBAL pour pouvoir être glissé vers d'autres applications.

Compatibilité avec la sélection multiple

Si votre application contient des listes ou des grilles, demandez-vous si vos utilisateurs pourraient bénéficier de la sélection multiple. Une expérience de sélection multiple de haute qualité avec une souris et un pavé tactile inclut souvent des fonctionnalités telles que la sélection par bande. L'implémentation de cette fonctionnalité peut être difficile, mais vous pouvez utiliser la bibliothèque Recyclerview Selection.

Exemple de sélection multiple de bandes avec une souris et un pointeur.

Compatibilité avancée avec les pointeurs

Les applications qui gèrent les commandes avancées de la souris et du pavé tactile doivent respecter la documentation Android concernant View.onGenericMotionEvent() et utiliser MotionEvent.getSource() pour faire la distinction entre SOURCE_MOUSE et SOURCE_TOUCHSCREEN.

Examinez MotionEvent pour mettre en œuvre le comportement requis :

  • Le mouvement génère des événements ACTION_HOVER_MOVE.
  • Les boutons génèrent des événements ACTION_BUTTON_PRESS et ACTION_BUTTON_RELEASE. Vous pouvez également vérifier l'état actuel de tous les boutons de la souris ou du pavé tactile avec getButtonState().
  • Le défilement de la molette de la souris génère des événements ACTION_SCROLL.

Stylet

De nombreux Chromebooks sont équipés d'un stylet, que les applications Android gèrent comme la saisie tactile. Certains appareils peuvent également disposer d'une tablette graphique USB ou Bluetooth, comme Wacom Intuos. Les applications Android peuvent recevoir une entrée Bluetooth, mais ne fonctionnent pas avec les entrées USB.

Un événement de stylet est signalé comme événement tactile à l'aide de View.onTouchEvent() ou View.onGenericMotionEvent(), et contient un MotionEvent.getSource() de type SOURCE_STYLUS. MotionEvent contient également des données supplémentaires :

Points historiques

Android regroupe les événements d'entrée et les distribue une fois par frame. Un stylet peut signaler des événements avec une fréquence beaucoup plus élevée que l'écran. Lors de la création d'applications de dessin, il est important de rechercher les événements récents à l'aide des API getHistorical :

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

Refus de la paume de la main

ChromeOS tente de reconnaître quand la paume d'un utilisateur repose sur l'écran tactile. Toutefois, ce n'est pas toujours possible. Il peut arriver qu'un événement tactile soit signalé à l'application avant que l'OS ne le reconnaisse comme une pression de la paume de la main. Dans ce cas, les événements tactiles seront annulés par la création d'un événement ACTION_CANCEL.

Cet événement indique à l'application que certaines touches ne sont pas valides et qu'elle doit annuler toutes les interactions provoquées par ces touches. Par exemple, une application de dessin peut dessiner temporairement de nouvelles lignes dès qu'elles sont reçues pour offrir la latence la plus faible, mais ne les enregistrer définitivement sur le canevas qu'une fois la série tactile terminée proprement. Si des événements tactiles sont annulés entre-temps, les lignes temporaires peuvent être effacées.

Remarque : Dans les applications de dessin et d'écriture, vous pouvez réduire les événements indésirables de pression via la paume de la main ou les doigts en fournissant un paramètre d'interface utilisateur qui désactive le dessin au doigt et n'utilise que les événements de stylet pour dessiner dans ce mode.

Applications de prise de notes

ChromeOS utilise un intent spécial qui présente aux utilisateurs les applications de prise de notes enregistrées. Pour enregistrer une application en tant qu'application de prise de notes, ajoutez le code suivant au fichier manifeste Android : 

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

Lorsqu'une application est enregistrée, l'utilisateur peut la sélectionner comme application de prise de notes par défaut. Lorsqu'une nouvelle note est demandée, l'application doit créer une note vide prête à être saisie par le stylet. Lorsque l'utilisateur souhaite annoter une image (par exemple, une capture d'écran ou une image téléchargée), l'application se lance avec ClipData et contient un ou plusieurs éléments avec des URI content://. L'application doit créer une note qui utilise la première image jointe comme image d'arrière-plan et passer dans un mode permettant à l'utilisateur de dessiner à l'écran avec un stylet.

Tester les intents de prise de notes sans stylet

Pour vérifier si une application répond correctement aux intents de prise de notes sans stylet actif, utilisez la méthode suivante afin d'afficher les options de prise de notes :

  1. Activez le mode développeur et rendez l'appareil accessible en écriture.
  2. Appuyez sur ctrl+alt+f2 pour ouvrir un terminal.
  3. Exécutez la commande sudo vi /etc/chrome_dev.conf.
  4. Appuyez sur i pour effectuer des modifications, puis ajoutez --ash-enable-palette à une nouvelle ligne à la fin du fichier
  5. Pour enregistrer, appuyez sur Esc, puis saisissez :, w, q et appuyez sur Enter.
  6. Appuyez sur ctrl+alt+f1 pour revenir à l'interface utilisateur ChromeOS standard.

Un menu de stylet devrait maintenant s'afficher sur l'étagère :

  • Appuyez sur le bouton du stylet situé sur l'étagère, puis sélectionnez Nouvelle note. Une note de dessin vide devrait s'afficher.
  • Prenez une capture d'écran. À partir de l'étagère, sélectionnez Bouton du stylet > Capturer l'écran ou téléchargez une image. L'option "Annoter l'image" devrait s'afficher dans la notification. Celle-ci devrait lancer l'application avec l'image prête à être annotée.

Manettes de jeu

Les Chromebooks sont compatibles avec un maximum de quatre manettes de jeu. Les développeurs doivent utiliser les API de manette de jeu Android standards pour les gérer.

Les boutons sont mis en correspondance avec des valeurs communes suivant un mappage commun. Malheureusement, tous les fabricants de manettes de jeu ne suivent pas les mêmes conventions de mappage. Vous offrirez une bien meilleure expérience si vous autorisez les utilisateurs à sélectionner différents mappages de manettes populaires.

Mode de conversion d'entrée

ChromeOS offre un mode de conversion d'entrée par défaut. Pour la plupart des applications Android, ce mode permet aux applications de fonctionner comme prévu dans un environnement de bureau. Par exemple, il permet l'activation automatique du défilement à deux doigts sur le pavé tactile, le défilement de la molette de la souris et le mappage des coordonnées brutes de l'écran avec les coordonnées de la fenêtre. En règle générale, les développeurs d'applications n'ont pas besoin d'implémenter ces comportements eux-mêmes.

Si une application met en œuvre un comportement de saisie personnalisé, par exemple si vous définissez une action personnalisée de pincement avec deux doigts sur le pavé tactile, ou si ces conversions d'entrée ne fournissent pas les événements d'entrée attendus par l'application, vous pouvez désactiver la conversion d'entrée en ajoutant la balise suivante au fichier manifeste Android : 

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