Contribution

Icône Android Input HAL

Le sous-système d'entrée Android se compose nominalement d'un pipeline d'événements qui traverse plusieurs couches du système.

Pipeline d'entrée

Au niveau de la couche inférieure, le périphérique d'entrée physique produit des signaux qui décrivent les changements d'état tels que les pressions sur les touches et les points de contact tactiles. Le micrologiciel de l'appareil encode et transmet ces signaux d'une manière ou d'une autre, par exemple en envoyant des rapports USB HID au système ou en produisant des interruptions sur un bus I2C.

Les signaux sont ensuite décodés par un pilote de périphérique dans le noyau Linux. Le noyau Linux fournit des pilotes pour de nombreux périphériques standard, en particulier ceux qui adhèrent au protocole HID. Cependant, un OEM doit souvent fournir des pilotes personnalisés pour les périphériques intégrés étroitement intégrés dans le système à un bas niveau, tels que les écrans tactiles.

Les pilotes de périphérique d'entrée sont responsables de la traduction des signaux spécifiques au périphérique dans un format d'événement d'entrée standard, via le protocole d'entrée Linux. Le protocole d'entrée Linux définit un ensemble standard de types d'événements et de codes dans le fichier d'en-tête du noyau linux/input.h . De cette manière, les composants en dehors du noyau n'ont pas besoin de se soucier des détails tels que les codes de balayage physiques, les utilisations HID, les messages I2C, les broches GPIO, etc.

Ensuite, le composant Android EventHub lit les événements d'entrée du noyau en ouvrant le pilote evdev associé à chaque périphérique d'entrée. Le composant Android InputReader décode ensuite les événements d'entrée en fonction de la classe d'appareil et produit un flux d'événements d'entrée Android. Dans le cadre de ce processus, les codes d'événement du protocole d'entrée Linux sont traduits en codes d'événement Android en fonction de la configuration du périphérique d'entrée, des fichiers de disposition du clavier et de diverses tables de mappage.

Enfin, InputReader envoie des événements d'entrée à InputDispatcher qui les transmet à la fenêtre appropriée.

Points de contrôle

Le pipeline d'entrée comporte plusieurs étapes qui contrôlent le comportement du périphérique d'entrée.

Configuration du pilote et du micrologiciel

Les pilotes de périphérique d'entrée configurent fréquemment le comportement du périphérique d'entrée en définissant des paramètres dans des registres ou même en téléchargeant le micrologiciel lui-même. Ceci est particulièrement le cas pour les dispositifs embarqués tels que les écrans tactiles où une grande partie du processus d'étalonnage implique le réglage de ces paramètres ou la fixation du micrologiciel pour fournir la précision et la réactivité souhaitées et supprimer le bruit.

Les options de configuration du pilote sont souvent spécifiées en tant que paramètres de module dans le package de support de la carte du noyau (BSP) afin que le même pilote puisse prendre en charge plusieurs implémentations matérielles différentes.

Cette documentation tente de décrire la configuration du pilote ou du micrologiciel, mais elle offre des conseils sur l'étalonnage du périphérique en général.

Propriétés de configuration de la carte

Le package de support de la carte noyau (BSP) peut exporter les propriétés de configuration de la carte via SysFS qui sont utilisées par le composant Android InputReader, telles que le placement de touches virtuelles sur un écran tactile.

Reportez-vous aux sections de classe de périphérique pour plus de détails sur la manière dont les différents périphériques utilisent les propriétés de configuration de la carte.

Superpositions de ressources

Quelques comportements d'entrée sont configurés au moyen de superpositions de ressources dans config.xml , comme le fonctionnement du commutateur de couvercle.

Voici quelques exemples:

  • config_lidKeyboardAccessibility : spécifie l'effet du commutateur de couvercle sur l'accès ou le config_lidKeyboardAccessibility du clavier matériel.

  • config_lidNavigationAccessibility : spécifie l'effet du commutateur du couvercle sur l'accès ou le masquage du trackpad.

  • config_longPressOnPowerBehavior : spécifie ce qui doit se passer lorsque l'utilisateur maintient le bouton d'alimentation enfoncé.

  • config_lidOpenRotation : spécifie l'effet du commutateur de couvercle sur l'orientation de l'écran.

Reportez-vous à la documentation dans frameworks/base/core/res/res/values/config.xml pour plus de détails sur chaque option de configuration.

Cartes clés

Les cartes de touches sont utilisées par les EventHub Android EventHub et InputReader pour configurer le mappage des codes d'événements Linux aux codes d'événements Android pour les touches, les boutons du joystick et les axes du joystick. Le mappage peut dépendre du périphérique ou de la langue.

Reportez-vous aux sections sur les classes d'appareils pour plus de détails sur la manière dont les différents appareils utilisent les mappages de touches.

Fichiers de configuration du périphérique d'entrée

Les fichiers de configuration du périphérique d'entrée sont utilisés par les EventHub Android EventHub et InputReader pour configurer les caractéristiques spéciales du périphérique, telles que la façon dont les informations de taille tactile sont signalées.

Reportez-vous aux sections sur les classes de périphériques pour plus de détails sur la manière dont les différents périphériques utilisent les mappages de configuration des périphériques d'entrée.

Comprendre les utilisations HID et les codes d'événements

Il existe souvent plusieurs identificateurs différents utilisés pour désigner une touche donnée sur un clavier, un bouton sur un contrôleur de jeu, un axe de joystick ou une autre commande. Les relations entre ces identifiants ne sont pas toujours les mêmes: ils dépendent d'un ensemble de tables de mappage, dont certaines sont fixes, et d'autres qui varient en fonction des caractéristiques du périphérique, du pilote de périphérique, de la locale actuelle, de la configuration du système, préférences de l'utilisateur et autres facteurs.

Code de scan physique

Un code de scan physique est un identifiant spécifique à l'appareil associé à chaque touche, bouton ou autre commande. Étant donné que les codes de balayage physiques varient souvent d'un périphérique à un autre, le micrologiciel ou le pilote de périphérique est chargé de les mapper aux identifiants standard tels que les utilisations HID ou les codes de clé Linux.

Les codes de scan sont principalement intéressants pour les claviers. D'autres périphériques communiquent généralement à un bas niveau à l'aide de broches GPIO, de messages I2C ou d'autres moyens. Par conséquent, les couches supérieures de la pile logicielle s'appuient sur les pilotes de périphérique pour donner un sens à ce qui se passe.

Utilisation HID

Une utilisation HID est un identifiant standard utilisé pour signaler l'état d'un contrôle tel qu'une touche de clavier, un axe de joystick, un bouton de souris ou un point de contact tactile. La plupart des périphériques d'entrée USB et Bluetooth sont conformes à la spécification HID, ce qui permet au système de s'interfacer avec eux de manière uniforme.

L'Android Framework s'appuie sur les pilotes HID du noyau Linux pour traduire les codes d'utilisation HID en codes de clé Linux et autres identifiants. Par conséquent, les utilisations HID intéressent principalement les fabricants de périphériques.

Code de clé Linux

Un code de clé Linux est un identifiant standard pour une clé ou un bouton. Les codes de clé Linux sont définis dans le fichier d'en-tête linux/input.h aide de constantes commençant par le préfixe KEY_ ou BTN_ . Les pilotes d'entrée du noyau Linux sont responsables de la traduction des codes de balayage physiques, des utilisations HID et d'autres signaux spécifiques au périphérique en codes de clé Linux et de la fourniture d'informations à leur sujet dans le cadre d'événements EV_KEY .

L'API Android fait parfois référence au code de clé Linux associé à une clé comme son «code d'analyse». Ceci est techniquement incorrect mais cela permet de distinguer les codes de clé Linux des codes de clé Android dans l'API.

Code d'axe relatif ou absolu Linux

Un code d'axe relatif ou absolu Linux est un identifiant standard pour signaler les mouvements relatifs ou les positions absolues le long d'un axe, comme les mouvements relatifs d'une souris le long de son axe X ou la position absolue d'un joystick le long de son axe X. Le code d'axe Linux est défini dans le fichier d'en-tête linux/input.h aide de constantes commençant par le préfixe REL_ ou ABS_ . Les pilotes d'entrée du noyau Linux sont responsables de la traduction des utilisations HID et d'autres signaux spécifiques au périphérique en codes d'axe Linux et de la fourniture d'informations à leur sujet dans le cadre des événements EV_REL et EV_ABS .

Code de commutateur Linux

Un code de commutateur Linux est un identifiant standard permettant de signaler l'état d'un commutateur sur un périphérique, tel qu'un commutateur de couvercle. Les codes de commutation Linux sont définis dans le fichier d'en-tête linux/input.h aide de constantes commençant par le préfixe SW_ . Les pilotes d'entrée du noyau Linux signalent les changements d'état des commutateurs sous EV_SW événements EV_SW .

Les applications Android ne reçoivent généralement pas d'événements des commutateurs, mais le système peut les utiliser en interne pour contrôler diverses fonctions spécifiques à l'appareil.

Code clé Android

Un code de clé Android est un identifiant standard défini dans l'API Android pour indiquer une clé particulière telle que «HOME». Les codes de clé Android sont définis par la classe android.view.KeyEvent comme des constantes commençant par le préfixe KEYCODE_ .

La disposition des touches spécifie comment les codes de clé Linux sont mappés aux codes de clé Android. Différentes dispositions de touches peuvent être utilisées en fonction du modèle de clavier, de la langue, du pays, de la disposition ou des fonctions spéciales.

Les combinaisons de codes de touches Android sont transformées en codes de caractères à l'aide d'une carte de caractères de touches spécifiques à l'appareil et aux paramètres régionaux. Par exemple, lorsque les touches identifiées comme KEYCODE_SHIFT et KEYCODE_A sont toutes deux pressées ensemble, le système recherche la combinaison dans la table de caractères clés et trouve la lettre majuscule «A», qui est ensuite insérée dans le widget de texte actuellement ciblé.

Code d'axe Android

Un code d'axe Android est un identifiant standard défini dans l'API Android pour indiquer un axe de périphérique particulier. Les codes d'axe Android sont définis par la classe android.view.MotionEvent comme des constantes commençant par le préfixe AXIS_ .

La disposition des touches spécifie comment les codes d'axe Linux sont mappés aux codes d'axe Android. Différentes dispositions de touches peuvent être utilisées en fonction du modèle de l'appareil, de la langue, du pays, de la disposition ou des fonctions spéciales.

État Meta Android

Un méta-état Android est un identifiant standard défini dans l'API Android pour indiquer quelles touches de modification sont enfoncées. Les méta-états Android sont définis par la classe android.view.KeyEvent comme des constantes commençant par le préfixe META_ .

Le méta-état actuel est déterminé par le composant Android InputReader qui surveille lorsque des touches de modification telles que KEYCODE_SHIFT_LEFT sont enfoncées / relâchées et définit / réinitialise l'indicateur de méta-état approprié.

La relation entre les touches de modification et les méta états est codée en dur, mais la disposition des touches peut modifier la façon dont les touches de modification elles-mêmes sont mappées, ce qui à son tour affecte les méta états.

État du bouton Android

Un état de bouton Android est un identifiant standard défini dans l'API Android pour indiquer quels boutons (sur une souris ou un stylet) sont enfoncés. Les états des boutons Android sont définis par la classe android.view.MotionEvent comme des constantes commençant par le préfixe BUTTON_ .

L'état actuel du bouton est déterminé par le composant Android InputReader qui surveille lorsque les boutons (sur une souris ou un stylet) sont enfoncés / relâchés et définit / réinitialise l'indicateur d'état du bouton approprié.

La relation entre les boutons et les états des boutons est codée en dur.

Lectures complémentaires

  1. Codes d'événement d'entrée Linux
  2. Protocole multipoint Linux
  3. Pilotes d'entrée Linux
  4. Retour de force Linux
  5. Informations HID, y compris les tableaux d'utilisation HID