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

Entrée

Le sous-système d'entrée Android consiste nominalement en 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 des touches et les points de contact tactiles. Le micrologiciel de l'appareil code 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 standards, notamment ceux qui adhèrent au protocole HID. Cependant, un OEM doit souvent fournir des pilotes personnalisés pour les périphériques embarqués étroitement intégrés au système à bas niveau, tels que les écrans tactiles.

Les pilotes de périphérique d'entrée sont chargés de traduire les 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 et de codes d'événements dans le fichier d'en-tête du noyau linux/input.h . De cette façon, les composants extérieurs au noyau n'ont pas besoin de se soucier des détails tels que les codes d'analyse physique, les utilisations HID, les messages I2C, les broches GPIO, etc.

Ensuite, le composant Android EventHub lit les événements d'entrée à partir 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, le InputReader envoie les événements d'entrée au InputDispatcher qui les transmet à la fenêtre appropriée.

Points de contrôle

Il existe plusieurs étapes dans le pipeline d'entrée qui effectuent le contrôle du 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. C'est particulièrement le cas pour les appareils intégrés tels que les écrans tactiles, où une grande partie du processus d'étalonnage implique le réglage de ces paramètres ou la correction du 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 support de la carte 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 du 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 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 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 si le clavier matériel est accessible ou masqué.
config_lidNavigationAccessibility : Spécifie l'effet du commutateur du couvercle sur si le trackpad est accessible ou masqué.
config_longPressOnPowerBehavior : Spécifie ce qui doit se passer lorsque l'utilisateur maintient enfoncé le bouton d'alimentation.
config_lidOpenRotation : Spécifie l'effet du commutateur du 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 mappages de touches sont utilisés par les composants Android EventHub et InputReader pour configurer le mappage des codes d'événement Linux vers les codes d'événement 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 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 composants Android EventHub et InputReader pour configurer des caractéristiques spéciales du périphérique, telles que la manière dont les informations sur la taille tactile sont rapporté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 cartes de configuration des périphériques d'entrée.

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

Il existe souvent plusieurs identifiants 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 : elles 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, des paramètres régionaux actuels, de la configuration du système, préférences de l’utilisateur et d’autres facteurs.

Code d'analyse physique

Un code de numérisation physique est un identifiant spécifique à l'appareil associé à chaque touche, bouton ou autre commande. Étant donné que les codes d'analyse physique varient souvent d'un appareil à l'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 clés Linux.

Les codes de numérisation sont principalement intéressants pour les claviers. D'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 de périphériques pour comprendre ce qui se passe.

Utilisation CACHÉE

Une utilisation HID est un identifiant standard utilisé pour signaler l'état d'un contrôle tel qu'une touche du 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 clés Linux et autres identifiants. Les usages HID intéressent donc principalement les fabricants de périphériques.

Code clé Linux

Un code de clé Linux est un identifiant standard pour une touche ou un bouton. Les codes clés 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 noyau Linux sont chargés de traduire les codes d'analyse physique, les utilisations HID et d'autres signaux spécifiques au périphérique en codes clés 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 clé Linux associé à une clé comme son « code d'analyse ». Ceci est techniquement incorrect, mais cela permet de distinguer les codes clés Linux des codes clés Android dans l'API.

Code d'axe relatif ou absolu 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 des axes 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 noyau Linux sont chargés de traduire les utilisations HID et d'autres signaux spécifiques au périphérique en codes d'axe Linux et de fournir des informations à leur sujet dans le cadre des événements EV_REL et EV_ABS .

Code du 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 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 noyau Linux signalent les changements d'état du commutateur sous forme d'é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 clés 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 clés Linux sont mappés aux codes clés 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 clés Android sont transformées en codes de caractères à l'aide d'une carte de caractères clés 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 ensemble, le système recherche la combinaison dans la table des caractères clés et trouve la lettre majuscule « A », qui est ensuite insérée dans le widget de texte actuellement sélectionné.

Code d'axe Android

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

Méta-état 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_ .

L'état méta 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 d'état méta 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 affecte à son tour les méta-états.

État du bouton Android

L'état d'un 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 en tant que 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 leurs états est codée en dur.