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

Saisir

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 le plus bas, 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 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 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 embarqués qui sont étroitement intégrés au 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 façon, les composants extérieurs au 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 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, l' InputReader envoie les événements d'entrée à l'InputDispatcher qui les transmet à la fenêtre appropriée.

Points de contrôle

Il existe plusieurs étapes dans le pipeline d'entrée 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. C'est particulièrement le cas pour les appareils embarqués tels que les écrans tactiles où une grande partie du processus d'étalonnage consiste à régler 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 offre des conseils sur l'étalonnage de l'appareil en général.

Propriétés de configuration de la carte

Le package de prise en charge 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 , telles que le fonctionnement du commutateur de couvercle.

Voici quelques exemples:

config_lidKeyboardAccessibility : spécifie l'effet du commutateur de couvercle sur l'accessibilité ou le masquage du clavier matériel.
config_lidNavigationAccessibility : spécifie l'effet du commutateur de couvercle sur l'accessibilité 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 mappages de touches sont utilisés par les composants Android EventHub et InputReader pour configurer le mappage des codes d'événement Linux aux codes d'événement Android pour les touches, les boutons du joystick et les axes du joystick. Le mappage peut dépendre de l'appareil 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 composants Android EventHub et InputReader pour configurer des caractéristiques spéciales du périphérique telles que la façon 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 une manette de jeu, un axe de manette 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 de l'appareil, du pilote de l'appareil, de la locale actuelle, de la configuration du système, préférences de l'utilisateur et d'autres facteurs.

Code de numérisation physique

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

Les codes de balayage sont principalement intéressants pour les claviers. D'autres appareils communiquent généralement à 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'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 clé Linux et autres identifiants. Par conséquent, les usages HID intéressent 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 de clé 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 responsables de la traduction des codes d'analyse physiques, des utilisations HID et d'autres signaux spécifiques à l'appareil en codes de clé Linux et de la fourniture d'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é en tant que "code de numérisation". Ceci est techniquement incorrect, mais cela aide à 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, 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 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 de commutation 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 des commutateurs en tant 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 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 aux codes de touche Android. Différentes dispositions de touches peuvent être utilisées selon le modèle de clavier, la langue, le pays, la disposition ou les 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 pressées ensemble, le système recherche la combinaison dans la carte des 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 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 d'appareil, de la langue, du pays, de la disposition ou de fonctions spéciales.

État méta d'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 les 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 manière 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 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 de bouton approprié.

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