Cette page a été traduite par l'API Cloud Translation.

Entrée

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 la plus basse, 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 HID USB 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 standards, en particulier ceux qui respectent le protocole HID. Toutefois, un OEM doit souvent fournir des pilotes personnalisés pour les appareils embarqués étroitement intégrés au système à bas niveau, tels que les écrans tactiles.

Les pilotes de périphériques d'entrée sont chargés de traduire les signaux spécifiques à l'appareil en 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 et de codes d'événements dans le fichier d'en-tête du kernel 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 numérisation physiques, les utilisations HID, les messages I2C, les broches GPIO, etc.

Ensuite, le composant EventHub Android 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 de l'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 de l'appareil d'entrée, des fichiers de mise en page du clavier et des diverses tables de mappage.

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

Points de contrôle

Plusieurs étapes du pipeline d'entrée permettent de contrôler le comportement du périphérique d'entrée.

Configuration du pilote et du micrologiciel

Les pilotes d'appareils d'entrée configurent souvent le comportement de l'appareil d'entrée en définissant des paramètres dans des registres, voire en mettant en ligne le micrologiciel lui-même. C'est particulièrement le cas pour les appareils intégrés tels que les écrans tactiles, où une grande partie du processus de calibrage consiste à ajuster ces paramètres ou à corriger le micrologiciel pour fournir la précision et la réactivité souhaitées, et pour 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 prise en charge 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 fournit des conseils sur le calibrage de l'appareil en général.

Propriétés de configuration du tableau

Le package de prise en charge de la carte du kernel (BSP) peut exporter des propriétés de configuration de la carte via SysFS qui sont utilisées par le composant InputReader d'Android, comme l'emplacement des touches virtuelles sur un écran tactile.

Reportez-vous aux sections sur les classes d'appareils pour en savoir plus sur la façon dont les différents appareils utilisent les propriétés de configuration de la carte.

Superpositions de ressources

Quelques comportements d'entrée sont configurés via des superpositions de ressources dans config.xml, comme le fonctionnement du bouton de verrouillage du capot.

Voici quelques exemples :

config_lidKeyboardAccessibility: indique l'effet du bouton de rabat sur l'accessibilité ou le masquage du clavier physique.
config_lidNavigationAccessibility: spécifie l'effet du bouton de verrouillage de l'écran sur l'accessibilité ou le masquage du pavé tactile.
config_longPressOnPowerBehavior: spécifie ce qui doit se passer lorsque l'utilisateur appuie de manière prolongée sur le bouton Marche/Arrêt.
config_lidOpenRotation: spécifie l'effet du bouton du rabat sur l'orientation de l'écran.

Pour en savoir plus sur chaque option de configuration, consultez la documentation de frameworks/base/core/res/res/values/config.xml.

Mappages des touches

Les mappages de touches sont utilisés par les composants EventHub et InputReader d'Android pour configurer la mise en correspondance des codes d'événement Linux avec les codes d'événement Android pour les touches, les boutons du joystick et les axes du joystick. La mise en correspondance peut dépendre de l'appareil ou de la langue.

Reportez-vous aux sections sur les classes d'appareils pour en savoir plus sur la façon dont les différents appareils utilisent les mappages de touches.

Fichiers de configuration des périphériques d'entrée

Les fichiers de configuration des appareils d'entrée sont utilisés par les composants EventHub et InputReader d'Android pour configurer des caractéristiques spéciales de l'appareil, telles que la manière dont les informations sur la taille de l'écran tactile sont signalées.

Reportez-vous aux sections sur la classe d'appareils pour en savoir plus sur la façon dont les différents appareils utilisent les cartes de configuration des appareils d'entrée.

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

Plusieurs identifiants différents sont souvent utilisés pour faire référence à une touche donnée sur un clavier, un bouton sur une manette de jeu, un axe de joystick ou une autre commande. Les relations entre ces identifiants ne sont pas toujours les mêmes: elles dépendent d'un ensemble de tables de mappage, certaines étant fixes et d'autres variant en fonction des caractéristiques de l'appareil, du pilote de l'appareil, des paramètres régionaux actuels, de la configuration du système, des préférences utilisateur et d'autres facteurs.

Code de scan physique

Un code de numérisation physique est un identifiant propre à l'appareil, associé à chaque touche, bouton ou autre commande. Étant donné que les codes de numérisation physiques varient souvent d'un appareil à l'autre, le micrologiciel ou le pilote de l'appareil est chargé de les mapper sur des identifiants standards tels que les utilisations HID ou les codes de touche Linux.

Les codes de balayage sont principalement utiles pour les claviers. Les autres appareils communiquent généralement à un niveau bas à 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 d'appareil pour comprendre ce qui se passe.

Utilisation des périphériques HID

Une utilisation HID est un identifiant standard qui permet de signaler l'état d'une commande telle 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.

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

Code de touche Linux

Un code de touche Linux est un identifiant standard d'une touche ou d'un bouton. Les codes de touche Linux sont définis dans le fichier d'en-tête linux/input.h à l'aide de constantes commençant par le préfixe KEY_ ou BTN_. Les pilotes d'entrée du kernel Linux sont chargés de traduire les codes de numérisation physiques, les utilisations HID et d'autres signaux spécifiques à l'appareil en codes de touche Linux, et de fournir des informations à leur sujet dans le cadre des événements EV_KEY.

L'API Android fait parfois référence au code de touche Linux associé à une touche en tant que "code de numérisation". Ce n'est pas techniquement correct, mais cela permet de distinguer les codes de touche Linux des codes de touche Android dans l'API.

Code d'axe relatif ou absolu sous Linux

Un code d'axe relatif ou absolu Linux est un identifiant standard permettant de signaler des mouvements relatifs ou des positions absolues le long d'un axe, tels que 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 à l'aide de constantes commençant par le préfixe REL_ ou ABS_. Les pilotes d'entrée du kernel Linux sont chargés de traduire les utilisations HID et d'autres signaux spécifiques à l'appareil en codes d'axe Linux, et de fournir des informations à leur sujet dans le cadre des événements EV_REL et EV_ABS.

Code de commutateur Linux

Un code de contacteur Linux est un identifiant standard permettant de signaler l'état d'un contacteur sur un appareil, tel qu'un contacteur de capot. Les codes de commutateur Linux sont définis dans le fichier d'en-tête linux/input.h à l'aide de constantes commençant par le préfixe SW_. Les pilotes d'entrée du kernel Linux signalent les changements d'état du commutateur en tant qu'é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 de clé Android

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

La disposition des touches spécifie comment les codes de touche Linux sont mappés sur les codes de touche 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 touche Android sont transformées en codes de caractère à l'aide d'un mappage de caractères de touche spécifique à l'appareil et aux paramètres régionaux. Par exemple, lorsque les touches identifiées comme KEYCODE_SHIFT et KEYCODE_A sont toutes deux enfoncées, le système recherche la combinaison dans le mappage des caractères de la touche et trouve la lettre majuscule "A", qui est ensuite insérée dans le widget de texte actuellement sélectionné.

Code Android Axis

Un code d'axe Android est un identifiant standard défini dans l'API Android pour indiquer un axe d'appareil particulier. Les codes d'axe Android sont définis par la classe android.view.MotionEvent en tant que constantes commençant par le préfixe AXIS_.

La mise en page des touches spécifie comment les codes d'axe Linux sont mappés sur les 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 mise en page ou des fonctions spéciales.

État méta Android

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

L'état méta actuel est déterminé par le composant Android InputReader, qui surveille le moment où les touches de modification telles que KEYCODE_SHIFT_LEFT sont enfoncées / relachées, et définit / réinitialise l'indicateur d'état méta approprié.

La relation entre les touches de modification et les méta-états est codée en dur, mais la mise en page des touches peut modifier la façon dont les touches de modification elles-mêmes sont mappées, ce qui affecte à son tour 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 les boutons (sur une souris ou un stylet) enfoncés. Les états des boutons Android sont définis par la classe android.view.MotionEvent en tant que constantes commençant par le préfixe BUTTON_.

L'état actuel du bouton est déterminé par le composant InputReader d'Android, qui surveille le moment où les boutons (sur une souris ou un stylet) sont enfoncés / relâches 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.