Appareils tactiles

Android est compatible avec différents écrans et pavés tactiles, y compris les tablettes de numérisation avec stylet.

Les écrans tactiles sont des dispositifs tactiles associés à un écran, de sorte que l'utilisateur a l'impression de manipuler directement les éléments à l'écran.

Les pavés tactiles sont des dispositifs tactiles qui ne sont pas associés à un écran, comme une tablette graphique. Les pavés tactiles sont généralement utilisés pour pointer ou pour le positionnement indirect absolu ou le contrôle d'une interface utilisateur par gestes.

Les appareils tactiles peuvent être équipés de boutons dont les fonctions sont similaires à celles des boutons de souris.

Les appareils tactiles peuvent parfois être manipulés à l'aide de différents outils, tels que les doigts ou un stylet, en fonction de la technologie du capteur tactile sous-jacent.

Les appareils tactiles sont parfois utilisés pour implémenter des touches virtuelles. Par exemple, sur certains appareils Android, la zone du capteur de l'écran tactile s'étend au-delà du bord de l'écran et sert également de clavier tactile.

En raison de la grande variété d'appareils tactiles, Android s'appuie sur un grand nombre de propriétés de configuration pour décrire les caractéristiques et le comportement souhaité de chaque appareil.

Classification des appareils tactiles

Un périphérique d'entrée est classé comme périphérique multitouch si les deux conditions suivantes sont remplies :

• Le périphérique d'entrée signale la présence des axes absolus ABS_MT_POSITION_X et ABS_MT_POSITION_Y.
• Le périphérique d'entrée ne comporte aucun bouton de manette de jeu. Cette condition résout une ambiguïté avec certains gamepads qui signalent des axes avec des codes qui se chevauchent avec ceux des axes MT.

Un périphérique d'entrée est classé comme périphérique multitactile si les deux conditions suivantes sont remplies :

• Le périphérique d'entrée n'est pas classé comme périphérique multipoint. Un périphérique d'entrée est classé comme périphérique monotactile ou multitactile, mais jamais les deux.
• Le périphérique d'entrée signale la présence des axes absolus ABS_X et ABS_Y, ainsi que la présence du code de touche BTN_TOUCH.

Lorsqu'un périphérique d'entrée est classé comme périphérique tactile, la présence de touches virtuelles est déterminée en tentant de charger le fichier de mappage des touches virtuelles pour le périphérique. Si un mappage de touches virtuelles est disponible, le fichier de mise en page des touches pour l'appareil est également chargé. Pour en savoir plus sur l'emplacement et le format de ces fichiers, consultez [Fichiers de mappage de clavier virtuel](#virtual-key-map-files).

Le système charge ensuite le fichier de configuration du périphérique d'entrée pour l'écran tactile.

Tous les appareils tactiles intégrés doivent disposer de fichiers de configuration de périphérique d'entrée. Si aucun fichier de configuration de périphérique d'entrée n'est présent, le système choisit une configuration par défaut adaptée aux périphériques tactiles à usage général tels que les écrans tactiles ou les pavés tactiles HID USB ou Bluetooth externes. Ces valeurs par défaut ne sont pas conçues pour les écrans tactiles intégrés et peuvent entraîner un comportement incorrect.

Une fois la configuration du périphérique d'entrée chargée, le système le classe comme écran tactile, pavé tactile ou périphérique de pointage.

• Un appareil à écran tactile est utilisé pour manipuler directement les objets à l'écran. L'utilisateur touche directement l'écran. Le système n'a donc pas besoin d'autres affordances pour indiquer les objets manipulés.
• Un pavé tactile est utilisé pour fournir des informations de positionnement absolu à une application concernant les contacts sur une zone de capteur donnée. Cela peut être utile pour les tablettes graphiques.
• Un périphérique de pointage est utilisé pour manipuler indirectement des objets à l'écran à l'aide d'un curseur. Les doigts sont interprétés comme des gestes de pointeur multipoints. D'autres outils, tels que les stylets, sont interprétés à l'aide de positions absolues. Pour en savoir plus, consultez Gestes indirects multipoints avec le pointeur.

Les règles suivantes sont utilisées pour classer le périphérique d'entrée en tant qu'écran tactile, pavé tactile ou périphérique de pointage.

• Si la propriété touch.deviceType est définie, le type d'appareil est défini comme indiqué.
• Si le périphérique d'entrée signale la présence de la propriété d'entrée INPUT_PROP_DIRECT (via l'ioctl EVIOCGPROP), le type de périphérique est défini sur écran tactile. Cette condition suppose que les périphériques tactiles à saisie directe sont connectés à un écran également connecté.
• Si le périphérique d'entrée signale la présence de la propriété d'entrée INPUT_PROP_POINTER (via l'ioctl EVIOCGPROP), le type de périphérique est défini sur pointer.
• Si le périphérique d'entrée signale la présence des axes relatifs REL_X ou REL_Y, le type de périphérique est défini sur touch pad. Cette condition résout une ambiguïté pour les périphériques d'entrée qui se composent à la fois d'une souris et d'un pavé tactile. Dans ce cas, le pavé tactile n'est pas utilisé pour contrôler le pointeur, car la souris le contrôle déjà.
• Sinon, le type d'appareil est défini sur pointer. Cette valeur par défaut garantit que les pavés tactiles qui n'ont pas été désignés pour une autre fonction spéciale contrôlent le pointeur.

Boutons

Les boutons sont des commandes facultatives que les applications peuvent utiliser pour effectuer des fonctions supplémentaires. Les boutons sur les appareils tactiles se comportent de la même manière que les boutons de la souris et sont principalement utiles avec les appareils tactiles de type pointeur ou avec un stylet.

Les boutons suivants sont acceptés :

• BTN_LEFT : mappé sur MotionEvent.BUTTON_PRIMARY.
• BTN_RIGHT : mappé sur MotionEvent.BUTTON_SECONDARY.
• BTN_MIDDLE : mappé sur MotionEvent.BUTTON_MIDDLE.
• BTN_BACK et BTN_SIDE : mappés sur MotionEvent.BUTTON_BACK. Appuyer sur ce bouton synthétise également une pression sur une touche avec le code de touche KeyEvent.KEYCODE_BACK.
• BTN_FORWARD et BTN_EXTRA : mappés sur MotionEvent.BUTTON_FORWARD. Appuyer sur ce bouton synthétise également une pression sur la touche avec le code KeyEvent.KEYCODE_FORWARD.
• BTN_STYLUS : mappé sur MotionEvent.BUTTON_SECONDARY.
• BTN_STYLUS2 : mappé sur MotionEvent.BUTTON_TERTIARY.

Outils et types d'outils

Un outil est un doigt, un stylet ou un autre appareil utilisé pour interagir avec l'appareil tactile. Certains appareils tactiles peuvent faire la différence entre différents types d'outils.

Ailleurs dans Android, comme dans l'API MotionEvent, un outil est souvent appelé pointeur.

Les types d'outils suivants sont acceptés :

• BTN_TOOL_FINGER et MT_TOOL_FINGER : mappés sur MotionEvent.TOOL_TYPE_FINGER.
• BTN_TOOL_PEN et MT_TOOL_PEN : mappés sur MotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_RUBBER : mappé sur MotionEvent.TOOL_TYPE_ERASER.
• BTN_TOOL_BRUSH : mappé sur MotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_PENCIL : mappé sur MotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_AIRBRUSH : mappé sur MotionEvent.TOOL_TYPE_STYLUS.
• BTN_TOOL_MOUSE : mappé sur MotionEvent.TOOL_TYPE_MOUSE.
• BTN_TOOL_LENS : mappé sur MotionEvent.TOOL_TYPE_MOUSE.
• BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP et BTN_TOOL_QUADTAP : mappés sur MotionEvent.TOOL_TYPE_FINGER.

Survoler ou toucher les outils

Les outils peuvent être en contact avec l'appareil tactile ou à portée et en suspension au-dessus de celui-ci. Tous les appareils tactiles ne peuvent pas détecter la présence d'un outil au-dessus d'eux. Ceux qui le font, comme les tablettes tactiles à stylet basées sur la technologie RF, peuvent souvent détecter quand l'outil se trouve à une distance limitée de la tablette.

Le composant InputReader distingue les outils tactiles des outils de survol. De même, les outils tactiles et les outils de survol sont signalés aux applications de différentes manières.

Les outils tactiles sont signalés aux applications en tant qu'événements tactiles à l'aide de MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE, MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN et MotionEvent.ACTION_POINTER_UP.

Les outils de pointage sont signalés aux applications en tant qu'événements de mouvement génériques à l'aide de MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE et MotionEvent.ACTION_HOVER_EXIT.

Exigences concernant les pilotes d'appareils tactiles

• Les pilotes de périphériques tactiles ne doivent enregistrer que les axes et les codes de touche pour les axes et les boutons qu'ils prennent en charge. L'enregistrement d'axes ou de codes de touches non compatibles peut perturber l'algorithme de classification des appareils ou entraîner une détection incorrecte des fonctionnalités de l'appareil par le système. Par exemple, si l'appareil signale le code clé BTN_TOUCH, le système suppose que BTN_TOUCH est toujours utilisé pour indiquer si l'outil touche l'écran. Par conséquent, BTN_TOUCH ne doit pas être utilisé pour indiquer que l'outil se trouve simplement dans la plage et en mode pause.
• Les appareils monotactiles utilisent les événements d'entrée Linux suivants :
  
  • ABS_X : (OBLIGATOIRE) Indique la coordonnée X de l'outil.
  • ABS_Y : (OBLIGATOIRE) Indique la coordonnée Y de l'outil.
  • ABS_PRESSURE : (facultatif) Indique la pression physique appliquée à la pointe de l'outil ou l'intensité du signal du contact tactile.
  • ABS_TOOL_WIDTH : (facultatif) Indique la largeur ou la section transversale du contact tactile ou de l'outil lui-même.
  • ABS_DISTANCE : (facultatif) Indique la distance entre l'outil et la surface de l'appareil tactile.
  • ABS_TILT_X : (facultatif) Indique l'inclinaison de l'outil par rapport à la surface de l'appareil tactile sur l'axe X.
  • ABS_TILT_Y : (facultatif) indique l'inclinaison de l'outil par rapport à la surface de l'appareil tactile le long de l'axe Y.
  • BTN_TOUCH : (OBLIGATOIRE) Indique si l'outil touche l'appareil.
  • BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_BACK, BTN_SIDE, BTN_FORWARD, BTN_EXTRA, BTN_STYLUS, BTN_STYLUS2 : (facultatif) États du bouton "Rapports".
  • BTN_TOOL_FINGER, BTN_TOOL_PEN, BTN_TOOL_RUBBER, BTN_TOOL_BRUSH, BTN_TOOL_PENCIL, BTN_TOOL_AIRBRUSH, BTN_TOOL_MOUSE, BTN_TOOL_LENS, BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP, BTN_TOOL_QUADTAP : (facultatif) Indique le type d'outil.
• Les appareils multitouch utilisent les événements d'entrée Linux suivants :
  
  • ABS_MT_POSITION_X : (OBLIGATOIRE) Indique la coordonnée X de l'outil.
  • ABS_MT_POSITION_Y : (OBLIGATOIRE) Indique la coordonnée Y de l'outil.
  • ABS_MT_PRESSURE : (facultatif) Indique la pression physique appliquée à la pointe de l'outil ou l'intensité du signal du contact tactile.
  • ABS_MT_TOUCH_MAJOR : (facultatif) Indique la surface de section transversale du contact tactile ou la longueur de la dimension la plus longue du contact tactile.
  • ABS_MT_TOUCH_MINOR : (facultatif) Indique la longueur de la dimension la plus courte du contact tactile. Cet axe ne doit pas être utilisé si ABS_MT_TOUCH_MAJOR indique une mesure de surface.
  • ABS_MT_WIDTH_MAJOR : (facultatif) Indique la section transversale de l'outil lui-même ou la longueur de la dimension la plus longue de l'outil lui-même. N'utilisez pas cet axe sauf si vous connaissez les dimensions de l'outil lui-même.
  • ABS_MT_WIDTH_MINOR : (facultatif) Indique la longueur de la dimension la plus courte de l'outil lui-même. Cet axe ne doit pas être utilisé si ABS_MT_WIDTH_MAJOR indique une mesure de surface ou si les dimensions de l'outil lui-même sont inconnues.
  • ABS_MT_ORIENTATION : (facultatif) Indique l'orientation de l'outil.
  • ABS_MT_DISTANCE : (facultatif) Indique la distance entre l'outil et la surface de l'appareil tactile.
  • ABS_MT_TOOL_TYPE : (facultatif) Indique le type d'outil comme MT_TOOL_FINGER ou MT_TOOL_PEN.
  • ABS_MT_TRACKING_ID : (facultatif) indique l'ID de suivi de l'outil. L'ID de suivi est un entier non négatif arbitraire utilisé pour identifier et suivre chaque outil de manière indépendante lorsque plusieurs outils sont actifs. Par exemple, lorsque plusieurs doigts touchent l'appareil, chaque doigt doit se voir attribuer un ID de suivi distinct qui est utilisé tant que le doigt reste en contact. Les ID de suivi peuvent être réutilisés lorsque les outils associés sont hors de portée.
  • ABS_MT_SLOT : (facultatif) Indique l'ID de slot de l'outil lors de l'utilisation du protocole multipoint Linux B. Pour en savoir plus, consultez la documentation sur le protocole multitouch Linux.
  • BTN_TOUCH : (OBLIGATOIRE) Indique si l'outil touche l'appareil.
  • BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_BACK, BTN_SIDE, BTN_FORWARD, BTN_EXTRA, BTN_STYLUS, BTN_STYLUS2 : (facultatif) États du bouton "Rapports".
  • BTN_TOOL_FINGER, BTN_TOOL_PEN, BTN_TOOL_RUBBER, BTN_TOOL_BRUSH, BTN_TOOL_PENCIL, BTN_TOOL_AIRBRUSH, BTN_TOOL_MOUSE, BTN_TOOL_LENS, BTN_TOOL_DOUBLETAP, BTN_TOOL_TRIPLETAP, BTN_TOOL_QUADTAP : (facultatif) Indique le type d'outil.
• Si des axes sont définis pour les protocoles à un et plusieurs points de contact, seuls les axes multipoints sont utilisés et les axes à un point de contact sont ignorés.

• Les valeurs minimales et maximales des axes ABS_X, ABS_Y, ABS_MT_POSITION_X et ABS_MT_POSITION_Y définissent les limites de la zone active de l'appareil en unités de surface spécifiques à l'appareil. Dans le cas d'un écran tactile, la zone active décrit la partie de l'appareil tactile qui recouvre réellement l'écran.

  Pour un écran tactile, le système interpole automatiquement les positions tactiles signalées en unités de surface pour obtenir les positions tactiles en pixels d'affichage selon le calcul suivant :

      displayX = (x - minX) * displayWidth / (maxX - minX + 1)
      displayY = (y - minY) * displayHeight / (maxY - minY + 1)
      

  Un écran tactile peut signaler des interactions en dehors de la zone active signalée.

  Les événements tactiles initiés en dehors de la zone active ne sont pas transmis aux applications, mais peuvent être utilisés pour les touches virtuelles.

  Les applications reçoivent les événements tactiles qui sont initiés dans la zone active, ou qui entrent et sortent de la zone d'affichage. Par conséquent, si un événement tactile commence dans les limites d'une application et se déplace ensuite en dehors de la zone active, l'application peut recevoir des événements tactiles avec des coordonnées d'affichage négatives ou au-delà des limites de l'écran. Ce comportement est normal.

  Un appareil tactile ne doit jamais limiter les coordonnées tactiles aux limites de la zone active. Si un contact sort de la zone active, il doit être signalé comme étant en dehors de la zone active ou ne pas être signalé du tout.

  Par exemple, si le doigt de l'utilisateur touche le coin supérieur gauche de l'écran tactile, il peut signaler une coordonnée de (minX, minY). Si le doigt continue de se déplacer en dehors de la zone active, l'écran tactile doit commencer à signaler des coordonnées avec des composants inférieurs à minX et minY, tels que (minX - 2, minY - 3), ou il doit cesser de signaler le contact. En d'autres termes, l'écran tactile ne doit pas signaler (minX, minY) lorsque le doigt de l'utilisateur touche réellement l'extérieur de la zone active.

  Le blocage des coordonnées tactiles au bord de l'écran crée une limite matérielle artificielle autour du bord de l'écran, ce qui empêche le système de suivre de manière fluide les mouvements qui entrent ou sortent des limites de la zone d'affichage.

• Les valeurs signalées par ABS_PRESSURE ou ABS_MT_PRESSURE, si elles sont signalées, doivent être non nulles lorsque l'outil touche l'appareil et nulles dans le cas contraire pour indiquer que l'outil est en mode hover.

  L'envoi d'informations sur la pression est facultatif, mais vivement recommandé. Les applications peuvent utiliser les informations de pression pour implémenter le dessin sensible à la pression et d'autres effets.

• Les valeurs signalées par ABS_TOOL_WIDTH, ABS_MT_TOUCH_MAJOR, ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MAJOR ou ABS_MT_WIDTH_MINOR doivent être non nulles lorsque l'outil touche l'appareil et nulles dans le cas contraire, mais ce n'est pas obligatoire. Par exemple, l'appareil tactile peut mesurer la taille des contacts tactiles des doigts, mais pas celle des contacts tactiles du stylet.

  Les informations sur la taille des rapports sont facultatives, mais vivement recommandées. Les applications peuvent utiliser les informations sur la pression pour implémenter des dessins sensibles à la taille et d'autres effets.

• Les valeurs signalées par ABS_DISTANCE ou ABS_MT_DISTANCE doivent tendre vers zéro lorsque l'outil touche l'appareil. La distance peut rester non nulle même lorsque l'outil est en contact direct. Les valeurs exactes indiquées dépendent de la manière dont le matériel mesure la distance.

  L'enregistrement des informations de distance est facultatif, mais recommandé pour les appareils à stylet.

• Les valeurs signalées par ABS_TILT_X et ABS_TILT_Y doivent être nulles lorsque l'outil est perpendiculaire à l'appareil. Une inclinaison non nulle indique que l'outil est tenu incliné.

  Les angles d'inclinaison le long des axes X et Y sont supposés être spécifiés en degrés par rapport à la perpendiculaire. Le point central (parfaitement perpendiculaire) est donné par (max + min) / 2 pour chaque axe. Les valeurs inférieures au point central représentent une inclinaison vers le haut ou vers la gauche, tandis que les valeurs supérieures représentent une inclinaison vers le bas ou vers la droite.

  InputReader convertit les composantes d'inclinaison X et Y en un angle d'inclinaison perpendiculaire compris entre 0 et PI / 2 radians, et en un angle d'orientation planaire compris entre -PI et PI radians. Cette représentation permet d'obtenir une description de l'orientation compatible avec celle utilisée pour décrire les contacts du doigt.

  L'envoi d'informations sur l'inclinaison est facultatif, mais recommandé pour les stylets.

• Si le type d'outil est indiqué par ABS_MT_TOOL_TYPE, il remplace toute information sur le type d'outil indiquée par BTN_TOOL_*. Si aucune information sur le type d'outil n'est disponible, le type d'outil est défini par défaut sur MotionEvent.TOOL_TYPE_FINGER.

• Un outil est considéré comme actif si les conditions suivantes sont remplies :

  • Lorsque vous utilisez le protocole à un seul point de contact, l'outil est actif si BTN_TOUCH ou BTN_TOOL_* est défini sur 1.

    Cette condition implique que InputReader doit contenir au moins des informations sur la nature de l'outil, qu'il soit en contact ou au moins son type. Si aucune information n'est disponible, l'outil est considéré comme inactif (hors de portée).

  • Lorsque vous utilisez le protocole multitouch "A", l'outil est actif chaque fois qu'il apparaît dans le rapport de synchronisation le plus récent. Lorsque l'outil cesse d'apparaître dans les rapports de synchronisation, il n'existe plus.
  • Lorsque vous utilisez le protocole multitouch B, l'outil est actif tant qu'il dispose d'un emplacement actif. Une fois l'emplacement effacé, l'outil n'existe plus.
• Un outil est considéré comme en mode "pointage" si les conditions suivantes sont remplies :
  
  • Si l'outil est BTN_TOOL_MOUSE ou BTN_TOOL_LENS, il ne pointe pas sur l'écran, même si l'une des conditions suivantes est remplie.
  • Si l'outil est actif et que le pilote signale des informations sur la pression, et que la pression signalée est nulle, l'outil est en mode survol.
  • Si l'outil est actif et que le pilote est compatible avec le code clé BTN_TOUCH et que BTN_TOUCH a une valeur de zéro, l'outil est en mode survol.
• InputReader est compatible avec les protocoles multipoints A et B. Les nouveaux pilotes doivent utiliser le protocole B, mais les deux fonctionnent.

• À partir d'Android 4.0, il peut être nécessaire de modifier les pilotes de l'écran tactile pour qu'ils soient conformes à la spécification du protocole d'entrée Linux.

  Les modifications suivantes peuvent être requises :

  • Lorsqu'un outil devient inactif (le doigt se lève), il ne doit plus apparaître dans les rapports de synchronisation multitouch suivants. Lorsque tous les outils deviennent inactifs (tous les doigts sont "levés"), le pilote doit envoyer un paquet de rapport de synchronisation vide, tel que SYN_MT_REPORT suivi de SYN_REPORT.

    Les versions précédentes d'Android s'attendaient à ce que les événements "up" soient signalés en envoyant une valeur de pression de 0. L'ancien comportement était incompatible avec la spécification du protocole d'entrée Linux et n'est plus pris en charge.

  • Les informations sur la pression physique ou l'intensité du signal doivent être signalées à l'aide de ABS_MT_PRESSURE.

    Les versions précédentes d'Android récupéraient les informations de pression à partir de ABS_MT_TOUCH_MAJOR. L'ancien comportement était incompatible avec la spécification du protocole d'entrée Linux et n'est plus pris en charge.

  • Les informations sur la taille tactile doivent être signalées à l'aide de ABS_MT_TOUCH_MAJOR.

    Les versions précédentes d'Android récupéraient les informations sur la taille à partir de ABS_MT_TOOL_MAJOR. L'ancien comportement était incompatible avec la spécification du protocole d'entrée Linux et n'est plus pris en charge.

  Les pilotes d'appareils tactiles n'ont plus besoin de personnalisations spécifiques à Android. En s'appuyant sur le protocole d'entrée Linux standard, Android peut prendre en charge une plus grande variété de périphériques tactiles, tels que les écrans tactiles HID multipoints externes, à l'aide de pilotes non modifiés.

Utilisation d'un appareil tactile

Voici un bref récapitulatif du fonctionnement des appareils tactiles sur Android.

1. EventHub lit les événements bruts du pilote evdev.
2. InputReader utilise les événements bruts et met à jour l'état interne concernant la position et d'autres caractéristiques de chaque outil. Il suit également les états des boutons.
3. Si BACK ou FORWARD a été appuyé ou relâché, InputReader avertit InputDispatcher de l'événement clé.
4. InputReader détermine si une pression sur une touche virtuelle a eu lieu. Si c'est le cas, il envoie une notification à InputDispatcher concernant l'événement clé.
5. InputReader détermine si l'événement tactile a été initié dans les limites de l'écran. Si c'est le cas, il en informe InputDispatcher.
6. S'il n'y a pas d'outils tactiles, mais au moins un outil de survol, InputReader avertit InputDispatcher de l'événement de survol.
7. Si le type d'appareil tactile est pointer, InputReader effectue la détection des gestes du pointeur, déplace le pointeur et les points en conséquence, et informe InputDispatcher de l'événement de pointeur.
8. InputDispatcher utilise WindowManagerPolicy pour déterminer si les événements doivent être distribués et s'ils doivent réactiver l'appareil. InputDispatcher distribue ensuite les événements aux applications appropriées.

Configuration des appareils tactiles

Le comportement d'un appareil tactile est déterminé par ses axes, ses boutons, ses propriétés d'entrée, sa configuration, son mappage de touches virtuelles et sa disposition du clavier.

Pour en savoir plus sur les fichiers qui participent à la configuration du clavier, consultez les sections suivantes :

• Fichiers de configuration des périphériques d'entrée
• Fichiers de mappage de clés virtuelles

Propriétés

Le système s'appuie sur de nombreuses propriétés de configuration des périphériques d'entrée pour configurer et calibrer le comportement des écrans tactiles.

Cela s'explique en partie par le fait que les pilotes d'appareils tactiles signalent souvent les caractéristiques des contacts à l'aide d'unités spécifiques à l'appareil.

Par exemple, de nombreux appareils tactiles mesurent la zone de contact tactile à l'aide d'une échelle interne spécifique à l'appareil, comme le nombre total de nœuds de capteur déclenchés par le toucher. Cette valeur brute de taille n'aurait aucun sens pour les applications, car elles devraient connaître la taille physique et d'autres caractéristiques des nœuds de capteur de l'écran tactile.

Le système utilise les paramètres de calibration encodés dans les fichiers de configuration des périphériques d'entrée pour décoder, transformer et normaliser les valeurs signalées par l'écran tactile en une représentation standard plus simple que les applications peuvent comprendre.

Conventions de documentation

Dans cette documentation, nous utilisons les conventions suivantes pour décrire les valeurs utilisées par le système lors du processus de calibration.

Valeurs brutes des axes

Les expressions suivantes désignent les valeurs brutes signalées par le pilote de l'écran tactile en tant qu'événements EV_ABS.

raw.x

Valeur de l'axe ABS_X ou ABS_MT_POSITION_X.

raw.y

Valeur de l'axe ABS_Y ou ABS_MT_POSITION_Y.

raw.pressure

Valeur de l'axe ABS_PRESSURE ou ABS_MT_PRESSURE, ou 0 si elle n'est pas disponible.

raw.touchMajor

Valeur de l'axe ABS_MT_TOUCH_MAJOR ou 0 si elle n'est pas disponible.

raw.touchMinor

Valeur de l'axe ABS_MT_TOUCH_MINOR, ou raw.touchMajor si elle n'est pas disponible.

raw.toolMajor

Valeur de l'axe ABS_TOOL_WIDTH ou ABS_MT_WIDTH_MAJOR, ou 0 si elle n'est pas disponible.

raw.toolMinor

Valeur de l'axe ABS_MT_WIDTH_MINOR, ou raw.toolMajor si elle n'est pas disponible.

raw.orientation

Valeur de l'axe ABS_MT_ORIENTATION ou 0 si elle n'est pas disponible.

raw.distance

Valeur de l'axe ABS_DISTANCE ou ABS_MT_DISTANCE, ou 0 si elle n'est pas disponible.

raw.tiltX

Valeur de l'axe ABS_TILT_X ou 0 si elle n'est pas disponible.

raw.tiltY

Valeur de l'axe ABS_TILT_Y ou 0 si elle n'est pas disponible.

Plages d'axes brutes

Les expressions suivantes désignent les limites des valeurs brutes. Ils sont obtenus en appelant ioctl EVIOCGABS pour chaque axe.

raw.*.min

Valeur minimale incluse de l'axe brut.

raw.*.max

Valeur maximale incluse de l'axe brut.

raw.*.range

Équivaut à raw.*.max - raw.*.min.

raw.*.fuzz

Précision de l'axe brut. Par exemple, fuzz = 1 implique que les valeurs sont précises à +/- 1 unité.

raw.width

Largeur incluse de la zone tactile, équivalente à raw.x.range + 1.

raw.height

Hauteur incluse de la zone tactile, équivalente à raw.y.range + 1.

Plages de sortie

Les expressions suivantes désignent les caractéristiques du système de coordonnées de sortie. Le système utilise l'interpolation linéaire pour traduire les informations sur la position du doigt à partir des unités de surface utilisées par l'appareil tactile en unités de sortie qui sont signalées aux applications, telles que les pixels d'affichage.

output.width

Largeur de la sortie. Pour les écrans tactiles (associés à un écran), il s'agit de la largeur de l'écran en pixels. Pour les pavés tactiles (non associés à un écran), la largeur de sortie est égale à raw.width, ce qui indique qu'aucune interpolation n'est effectuée.

output.height

Hauteur de la sortie. Pour les écrans tactiles (associés à un écran), il s'agit de la hauteur de l'écran en pixels. Pour les pavés tactiles (non associés à un écran), la hauteur de sortie est égale à raw.height, ce qui indique qu'aucune interpolation n'est effectuée.

output.diag

Longueur de la diagonale du système de coordonnées de sortie, équivalente à sqrt(output.width ^2 + output.height ^2).

Configuration de base

Le mappeur d'entrée tactile utilise de nombreuses propriétés de configuration dans le fichier de configuration du périphérique d'entrée pour spécifier les valeurs de calibration. Le tableau suivant décrit certaines propriétés de configuration à usage général. Toutes les autres propriétés sont décrites dans les sections suivantes, ainsi que les champs qu'elles permettent de calibrer.

touch.deviceType

Définition : touch.deviceType = touchScreen | touchPad | pointer | default

Spécifie le type d'appareil tactile.

• Si la valeur est touchScreen, l'appareil tactile est un écran tactile associé à un écran.

• Si la valeur est touchPad, l'appareil tactile est un pavé tactile non associé à un écran.

• Si la valeur est pointer, le périphérique tactile est un pavé tactile non associé à un écran, et ses mouvements sont utilisés pour les gestes indirects multipoints.

• Si la valeur est default, le système détecte automatiquement le type d'appareil en fonction de l'algorithme de classification.

Pour en savoir plus sur l'influence du type d'appareil sur le comportement de l'appareil tactile, consultez la section Classification.

Dans Android 3 et versions antérieures, tous les appareils tactiles étaient considérés comme des écrans tactiles.

touch.orientationAware

Définition : touch.orientationAware = 0 | 1

Indique si l'appareil tactile doit réagir aux changements d'orientation de l'écran.

• Si la valeur est 1, les positions tactiles signalées par l'appareil tactile sont pivotées chaque fois que l'orientation de l'écran change.

• Si la valeur est 0, les positions tactiles signalées par l'appareil tactile sont insensibles aux changements d'orientation de l'écran.

La valeur par défaut est 1 si l'appareil est équipé d'un écran tactile, et 0 dans le cas contraire.

Le système fait la distinction entre les écrans tactiles et les écrans internes et externes. Un écran tactile interne sensible à l'orientation est pivoté en fonction de l'orientation de l'écran interne. Un écran tactile externe sensible à l'orientation est pivoté en fonction de l'orientation de l'écran externe.

La reconnaissance de l'orientation est utilisée pour la rotation des écrans tactiles sur des appareils tels que le Nexus One. Par exemple, lorsque l'appareil est pivoté de 90 degrés dans le sens des aiguilles d'une montre par rapport à son orientation naturelle, les positions absolues des contacts sont remappées de sorte qu'un contact dans l'angle supérieur gauche du système de coordonnées absolues de l'écran tactile est signalé comme un contact dans l'angle supérieur gauche du système de coordonnées pivoté de l'écran. Cela permet de signaler les événements tactiles avec le même système de coordonnées que celui utilisé par les applications pour dessiner leurs éléments visuels.

Avant Honeycomb, tous les appareils tactiles étaient censés être sensibles à l'orientation.

touch.gestureMode

Définition : touch.gestureMode = pointer | spots | default

Spécifie le mode de présentation pour les gestes du pointeur. Cette propriété de configuration n'est pertinente que lorsque l'appareil tactile est de type pointer.

• Si la valeur est pointer, les gestes sur le pavé tactile sont présentés à l'aide d'un curseur semblable à un pointeur de souris.

• Si la valeur est spots, les gestes sur le pavé tactile sont présentés par un point d'ancrage qui représente le centroïde du geste et un ensemble de points circulaires qui représentent la position de chaque doigt.

La valeur par défaut est pointer lorsque la propriété d'entrée INPUT_PROP_SEMI_MT est définie, ou spots dans le cas contraire.

Champs X et Y

Les champs X et Y fournissent des informations de position pour le centre de la zone de contact.

Calcul

Le calcul est simple : les informations de position du pilote tactile sont interpolées de manière linéaire dans le système de coordonnées de sortie.

xScale = output.width / raw.width
yScale = output.height / raw.height

If not orientation aware or screen rotation is 0 degrees:
output.x = (raw.x - raw.x.min) * xScale
output.y = (raw.y - raw.y.min) * yScale
Else If rotation is 90 degrees:
    output.x = (raw.y - raw.y.min) * yScale
    output.y = (raw.x.max - raw.x) * xScale
Else If rotation is 180 degrees:
    output.x = (raw.x.max - raw.x) * xScale
    output.y = (raw.y.max - raw.y) * yScale
Else If rotation is 270 degrees:
    output.x = (raw.y.max - raw.y) * yScale
    output.y = (raw.x - raw.x.min) * xScale
End If

Champs "touchMajor", "touchMinor", "toolMajor", "toolMinor" et "size"

Les champs touchMajor et touchMinor décrivent les dimensions approximatives de la zone de contact en unités de sortie (pixels).

Les champs toolMajor et toolMinor décrivent les dimensions approximatives de l'outil lui-même en unités de sortie (pixels).

Le champ size décrit la taille normalisée du contact par rapport au plus grand contact possible que l'écran tactile peut détecter. La taille normalisée la plus petite possible est de 0,0 (aucun contact ou contact non mesurable), et la taille normalisée la plus grande possible est de 1,0 (la zone du capteur est saturée).

Lorsque la longueur et la largeur approximatives peuvent être mesurées, le champ touchMajor spécifie la dimension la plus longue et le champ touchMinor spécifie la dimension la plus courte de la zone de contact. Lorsque seul le diamètre approximatif de la zone de contact peut être mesuré, les champs touchMajor et touchMinor sont égaux.

De même, le champ toolMajor spécifie la dimension la plus longue et le champ toolMinor spécifie la dimension la plus courte de la section transversale de l'outil.

Si la taille tactile n'est pas disponible, mais que la taille de l'outil l'est, la taille de l'outil est définie sur la taille tactile. Inversement, si la taille de l'outil n'est pas disponible, mais que la taille tactile l'est, la taille tactile est définie sur la taille de l'outil.

Les appareils tactiles mesurent ou signalent la taille du doigt et de l'outil de différentes manières. L'implémentation actuelle accepte trois types de mesures : le diamètre, la surface et le cadre de sélection géométrique en unités de surface.

Définition : touch.size.calibration = none | geometric | diameter | area | default

Spécifie le type de mesure utilisé par le pilote tactile pour indiquer la taille du doigt et de l'outil.

• Si la valeur est none, la taille est définie sur zéro.

• Si la valeur est geometric, la taille est supposée être spécifiée dans les mêmes unités de surface que la position. Elle est donc mise à l'échelle de la même manière.

• Si la valeur est diameter, la taille est supposée être proportionnelle au diamètre (largeur) du doigt ou de l'outil.

• Si la valeur est area, la taille est considérée comme proportionnelle à la zone de contact du doigt ou de l'outil.

• Si la valeur est default, le système utilise la calibration geometric si l'axe raw.touchMajor ou raw.toolMajor est disponible. Sinon, il utilise la calibration none.

touch.size.scale

Définition : touch.size.scale = <nombre à virgule flottante non négatif>

Spécifie un facteur d'échelle constant utilisé dans la calibration.

La valeur par défaut est 1.0.

touch.size.bias

Définition : touch.size.bias = <nombre à virgule flottante non négatif>

Spécifie une valeur de biais constante utilisée dans la calibration.

La valeur par défaut est 0.0.

touch.size.isSummed

Définition : touch.size.isSummed = 0 | 1

Indique si la taille est signalée comme la somme des tailles de tous les contacts actifs ou individuellement pour chaque contact.

• Si la valeur est 1, la taille indiquée est divisée par le nombre de contacts avant utilisation.

• Si la valeur est 0, la taille indiquée est utilisée telle quelle.

La valeur par défaut est 0.

Certains appareils tactiles, en particulier les appareils "Semi-MT", ne peuvent pas distinguer les dimensions individuelles de plusieurs contacts. Ils indiquent donc une mesure de taille qui représente leur surface ou leur largeur totale. Cette propriété ne doit être définie sur 1 que pour ces appareils. En cas de doute, définissez cette valeur sur 0.

Calcul

Le calcul des champs touchMajor, touchMinor, toolMajor, toolMinor et size dépend des paramètres de calibration spécifiés.

If raw.touchMajor and raw.toolMajor are available:
    touchMajor = raw.touchMajor
    touchMinor = raw.touchMinor
    toolMajor = raw.toolMajor
    toolMinor = raw.toolMinor
Else If raw.touchMajor is available:
    toolMajor = touchMajor = raw.touchMajor
    toolMinor = touchMinor = raw.touchMinor
Else If raw.toolMajor is available:
    touchMajor = toolMajor = raw.toolMajor
    touchMinor = toolMinor = raw.toolMinor
Else
    touchMajor = toolMajor = 0
    touchMinor = toolMinor = 0
    size = 0
End If

size = avg(touchMajor, touchMinor)

If touch.size.isSummed == 1:
    touchMajor = touchMajor / numberOfActiveContacts
    touchMinor = touchMinor / numberOfActiveContacts
    toolMajor = toolMajor / numberOfActiveContacts
    toolMinor = toolMinor / numberOfActiveContacts
    size = size / numberOfActiveContacts
End If

If touch.size.calibration == "none":
    touchMajor = toolMajor = 0
    touchMinor = toolMinor = 0
    size = 0
Else If touch.size.calibration == "geometric":
    outputScale = average(output.width / raw.width, output.height / raw.height)
    touchMajor = touchMajor * outputScale
    touchMinor = touchMinor * outputScale
    toolMajor = toolMajor * outputScale
    toolMinor = toolMinor * outputScale
Else If touch.size.calibration == "area":
    touchMajor = sqrt(touchMajor)
    touchMinor = touchMajor
    toolMajor = sqrt(toolMajor)
    toolMinor = toolMajor
Else If touch.size.calibration == "diameter":
    touchMinor = touchMajor
    toolMinor = toolMajor
End If

If touchMajor != 0:
    output.touchMajor = touchMajor * touch.size.scale + touch.size.bias
Else
    output.touchMajor = 0
End If

If touchMinor != 0:
    output.touchMinor = touchMinor * touch.size.scale + touch.size.bias
Else
    output.touchMinor = 0
End If

If toolMajor != 0:
    output.toolMajor = toolMajor * touch.size.scale + touch.size.bias
Else
    output.toolMajor = 0
End If

If toolMinor != 0:
    output.toolMinor = toolMinor * touch.size.scale + touch.size.bias
Else
    output.toolMinor = 0
End If

output.size = size

champ de pression

Le champ pressure décrit la pression physique approximative appliquée à l'appareil tactile sous forme de valeur normalisée comprise entre 0,0 (pas de contact) et 1,0 (pression normale).

Une pression nulle indique que l'outil est en mode survol.

touch.pressure.calibration

Définition : touch.pressure.calibration = none | physical | amplitude | default

Spécifie le type de mesure utilisé par le pilote tactile pour indiquer la pression.

• Si la valeur est none, la pression est inconnue. Elle est donc définie sur 1.0 en cas de contact et sur 0.0 en cas de survol.

• Si la valeur est physical, l'axe de pression est censé mesurer l'intensité physique réelle de la pression appliquée au pavé tactile.

• Si la valeur est amplitude, l'axe de pression est censé mesurer l'amplitude du signal, qui est liée à la taille du contact et à la pression appliquée.

• Si la valeur est default, le système utilise la calibration physical si l'axe de pression est disponible, sinon il utilise none.

touch.pressure.scale

Définition : touch.pressure.scale = <nombre à virgule flottante non négatif>

Spécifie un facteur d'échelle constant utilisé dans la calibration.

La valeur par défaut est 1.0 / raw.pressure.max.

Calcul

Le calcul du champ pressure dépend des paramètres de calibration spécifiés.

If touch.pressure.calibration == "physical" or "amplitude":
    output.pressure = raw.pressure * touch.pressure.scale
Else
    If hovering:
        output.pressure = 0
    Else
        output.pressure = 1
    End If
End If

Champs d'orientation et d'inclinaison

Le champ orientation décrit l'orientation du doigt et de l'outil sous la forme d'une mesure angulaire. Une orientation de 0 indique que l'axe principal est orienté verticalement, -PI/2 indique qu'il est orienté vers la gauche et PI/2 indique qu'il est orienté vers la droite. Lorsqu'un stylet est présent, la plage d'orientation peut être décrite dans une plage de cercle complet allant de -PI à PI.

Le champ tilt décrit l'inclinaison de l'outil sous la forme d'une mesure angulaire. Une inclinaison de 0 indique que l'outil est perpendiculaire à la surface. Une inclinaison de PI/2 indique que l'outil est à plat sur la surface.

touch.orientation.calibration

Définition : touch.orientation.calibration = none | interpolated | vector | default

Spécifie le type de mesure utilisé par le pilote tactile pour indiquer l'orientation.

• Si la valeur est none, l'orientation est inconnue et est donc définie sur 0.
• Si la valeur est interpolated, l'orientation est interpolée de manière linéaire de sorte qu'une valeur brute de raw.orientation.min correspond à -PI/2 et qu'une valeur brute de raw.orientation.max correspond à PI/2. La valeur centrale de (raw.orientation.min + raw.orientation.max) / 2 correspond à 0.
• Si la valeur est vector, l'orientation est interprétée comme un vecteur compressé composé de deux champs signés de 4 bits. Cette représentation est utilisée sur les composants Atmel Object Based Protocol. Une fois décodé, le vecteur génère un angle d'orientation et une magnitude de confiance. L'ampleur de la confiance est utilisée pour mettre à l'échelle les informations sur la taille, sauf si elle est géométrique.
• Si la valeur est default, le système utilise la calibration interpolated si l'axe d'orientation est disponible, sinon il utilise none.

Calcul

Le calcul des champs orientation et tilt dépend des paramètres de calibration spécifiés et des entrées disponibles.

If touch.tiltX and touch.tiltY are available:
    tiltXCenter = average(raw.tiltX.min, raw.tiltX.max)
    tiltYCenter = average(raw.tiltY.min, raw.tiltY.max)
    tiltXAngle = (raw.tiltX - tiltXCenter) * PI / 180
    tiltYAngle = (raw.tiltY - tiltYCenter) * PI / 180
    output.orientation = atan2(-sin(tiltXAngle), sinf(tiltYAngle))
    output.tilt = acos(cos(tiltXAngle) * cos(tiltYAngle))
Else If touch.orientation.calibration == "interpolated":
    center = average(raw.orientation.min, raw.orientation.max)
    output.orientation = PI / (raw.orientation.max - raw.orientation.min)
    output.tilt = 0
Else If touch.orientation.calibration == "vector":
    c1 = (raw.orientation & 0xF0) >> 4
    c2 = raw.orientation & 0x0F

    If c1 != 0 or c2 != 0:
        If c1 >= 8 Then c1 = c1 - 16
        If c2 >= 8 Then c2 = c2 - 16
        angle = atan2(c1, c2) / 2
        confidence = sqrt(c1*c1 + c2*c2)

        output.orientation = angle

        If touch.size.calibration == "diameter" or "area":
            scale = 1.0 + confidence / 16
            output.touchMajor *= scale
            output.touchMinor /= scale
            output.toolMajor *= scale
            output.toolMinor /= scale
        End If
    Else
        output.orientation = 0
    End If
    output.tilt = 0
Else
    output.orientation = 0
    output.tilt = 0
End If

If orientation aware:
    If screen rotation is 90 degrees:
        output.orientation = output.orientation - PI / 2
    Else If screen rotation is 270 degrees:
        output.orientation = output.orientation + PI / 2
    End If
End If

champ "Distance"

Le champ distance décrit la distance entre l'outil et la surface de l'appareil tactile. Une valeur de 0,0 indique un contact direct, et des valeurs plus élevées indiquent une distance croissante par rapport à la surface.

touch.distance.calibration

Définition : touch.distance.calibration = none | scaled | default

Spécifie le type de mesure utilisé par le pilote tactile pour indiquer la distance.

• Si la valeur est none, la distance est inconnue et est donc définie sur 0.

• Si la valeur est scaled, la distance signalée est multipliée par un facteur d'échelle constant.

• Si la valeur est default, le système utilise la calibration scaled si l'axe de distance est disponible, sinon il utilise none.

touch.distance.scale

Définition : touch.distance.scale = <nombre à virgule flottante non négatif>

Spécifie un facteur d'échelle constant utilisé dans la calibration.

La valeur par défaut est 1.0.

Calcul

Le calcul du champ distance dépend des paramètres de calibration spécifiés.

If touch.distance.calibration == "scaled":
    output.distance = raw.distance * touch.distance.scale
Else
    output.distance = 0
End If

Exemple

# Input device configuration file for a touch screen that supports pressure,
# size and orientation. The pressure and size scale factors were obtained
# by measuring the characteristics of the device itself and deriving
# useful approximations based on the resolution of the touch sensor and the
# display.
#
# Note that these parameters are specific to a particular device model.
# Different parameters need to be used for other devices.

# Basic Parameters
touch.deviceType = touchScreen
touch.orientationAware = 1

# Size
# Based on empirical measurements, we estimate the size of the contact
# using size = sqrt(area) * 28 + 0.
touch.size.calibration = area
touch.size.scale = 28
touch.size.bias = 0
touch.size.isSummed = 0

# Pressure
# Driver reports signal strength as pressure.
#
# A normal index finger touch typically registers about 80 signal strength
# units although we don't expect these values to be accurate.
touch.pressure.calibration = amplitude
touch.pressure.scale = 0.0125

# Orientation
touch.orientation.calibration = vector

Remarques sur la compatibilité

Les propriétés de configuration des appareils tactiles ont été considérablement modifiées dans Android 4.0 Ice Cream Sandwich. Tous les fichiers de configuration des périphériques d'entrée pour les appareils tactiles doivent être mis à jour pour utiliser les nouvelles propriétés de configuration.

Il peut également être nécessaire de mettre à jour les pilotes des anciens appareils tactiles.

Fichiers de mappage des touches virtuelles

Les appareils tactiles peuvent être utilisés pour implémenter des touches virtuelles.

Pour cela, il existe plusieurs façons de procéder, selon les fonctionnalités du contrôleur tactile. Certains écrans de contrôle tactiles peuvent être configurés directement pour implémenter des touches virtuelles en définissant des registres de micrologiciel. Dans d'autres cas, il est préférable d'effectuer le mappage des coordonnées tactiles vers les codes de touches dans le logiciel.

Lorsque des touches virtuelles sont implémentées dans un logiciel, le noyau doit exporter un fichier de mappage de touches virtuelles appelé virtualkeys.<devicename> en tant que propriété de la carte. Par exemple, si les pilotes de l'écran tactile indiquent que son nom est "touchyfeely", le fichier de mappage des touches virtuelles doit avoir le chemin d'accès /sys/board_properties/virtualkeys.touchyfeely.

Un fichier de mappage de touches virtuelles décrit les coordonnées et les codes de touches Linux des touches virtuelles sur l'écran tactile.

En plus du fichier de mappage de touches virtuelles, il doit exister un fichier de mise en page de clavier et un fichier de mappage de caractères de touches correspondants pour mapper les codes de touches Linux sur les codes de touches Android et pour spécifier le type de périphérique clavier (généralement SPECIAL_FUNCTION).

Syntaxe

Un fichier de mappage de touches virtuelles est un fichier en texte brut composé d'une séquence de descriptions de disposition de touches virtuelles, séparées par des sauts de ligne ou des deux-points.

Les lignes de commentaires commencent par "#" et se poursuivent jusqu'à la fin de la ligne.

Chaque clé virtuelle est décrite par six composants séparés par des deux-points :

• 0x01 : code de version. Doit toujours être 0x01.
• <Linux key code> : code de touche Linux de la touche virtuelle.
• <centerX> : coordonnée X en pixels du centre de la touche virtuelle.
• <centerY> : coordonnée Y en pixels du centre de la touche virtuelle.
• <width> : largeur de la touche virtuelle en pixels.
• <height> : hauteur de la touche virtuelle en pixels.

Toutes les coordonnées et tailles sont spécifiées en termes de système de coordonnées d'affichage.

Voici un fichier de mappage de touches virtuelles écrit sur une seule ligne.

# All on one line
0x01:158:55:835:90:55:0x01:139:172:835:125:55:0x01:102:298:835:115:55:0x01:217:412:835:95:55

Le même fichier de mappage de touches virtuelles peut également être écrit sur plusieurs lignes.

# One key per line
0x01:158:55:835:90:55
0x01:139:172:835:125:55
0x01:102:298:835:115:55
0x01:217:412:835:95:55

Dans l'exemple ci-dessus, l'écran tactile a une résolution de 480 x 800. Par conséquent, toutes les touches virtuelles ont une coordonnée <centerY> de 835, ce qui est un peu en dessous de la zone visible de l'écran tactile.

La première clé a un code de balayage Linux de 158 (KEY_BACK), un centerX de 55, un centerY de 835, une largeur de 90 et une hauteur de 55.

Exemple

Fichier de mappage des touches virtuelles : /sys/board_properties/virtualkeys.touchyfeely.

0x01:158:55:835:90:55
0x01:139:172:835:125:55
0x01:102:298:835:115:55
0x01:217:412:835:95:55

Fichier de disposition du clavier : /system/usr/keylayout/touchyfeely.kl.

key 158 BACK
key 139 MENU
key 172 HOME
key 217 SEARCH

Fichier de mappage des caractères clés : /system/usr/keychars/touchyfeely.kcm.

type SPECIAL_FUNCTION

Gestes indirects à plusieurs doigts

En mode pointeur, le système interprète les gestes suivants :

• Appuyer avec un doigt : cliquer.
• Mouvement d'un doigt : déplacez le pointeur.
• Mouvement d'un doigt et pression sur un bouton : faites glisser le pointeur.
• Mouvement à deux doigts, les deux doigts se déplaçant dans la même direction : faites glisser la zone sous le pointeur dans cette direction. Le pointeur lui-même ne bouge pas.
• Mouvement à deux doigts : les deux doigts se rapprochent ou s'écartent dans des directions différentes. Permet de faire un panoramique, de mettre à l'échelle ou de faire pivoter la zone entourant le pointeur. Le pointeur lui-même ne bouge pas.
• Mouvement à plusieurs doigts : geste de forme libre.

Refus de la paume de la main

Depuis Android 13, le système peut rejeter automatiquement les saisies avec la paume lorsque le framework intégré est activé. Les solutions personnalisées et internes sont toujours prises en charge, mais elles devront peut-être être modifiées pour renvoyer le flag TOOL_TYPE_PALM lorsqu'une paume est détectée. Le framework intégré fonctionne également avec les solutions personnalisées.

Le modèle réel examine les 90 premières millisecondes des données de geste, au niveau du pointeur actuel et des pointeurs environnants, puis évalue la distance entre les contacts et le bord de l'écran. Il détermine ensuite, pour chaque pointeur, lesquels sont des paumes. Il tient également compte de la taille de chaque contact, telle qu'indiquée par touchMajor et touchMinor. Le framework Android supprime ensuite les pointeurs marqués comme paumes du flux tactile.

Si un pointeur a déjà été envoyé aux applications, le système effectue l'une des actions suivantes :

• (S'il existe d'autres pointeurs actifs) Annule le pointeur avec ACTION_POINTER_UP et FLAG_CANCELED définis.
• (Si c'est le seul pointeur) Annule le pointeur avec ACTION_CANCEL.

Une API publique, MotionEvent.FLAG_CANCELED, indique que l'événement actuel ne doit pas déclencher d'action de l'utilisateur. Ce flag est défini pour ACTION_CANCEL et ACTION_POINTER_UP.

Si le pointeur de la paume n'a pas été envoyé aux applications, le système le supprime simplement.

Activer la désactivation de l'interaction avec la paume de la main

1. Dans votre pilote tactile, utilisez la macro input_abs_set_res pour définir les résolutions des champs suivants (les unités sont pixels par mm) :
   • ABS_MT_POSITION_X
   • ABS_MT_POSITION_Y
   • ABS_MT_TOUCH_MAJOR
   • ABS_MT_TOUCH_MINOR

   L'intégration de ABS_MT_TOUCH_MINOR est facultative. Toutefois, si votre appareil est compatible, assurez-vous que la résolution est correctement définie.

2. Pour vérifier que les champs sont correctement définis, exécutez la commande suivante :

       $ adb shell getevent -li
   

3. Pour activer la fonctionnalité lors de l'exécution, exécutez la commande suivante :

       $ adb shell device_config put input_native_boot palm_rejection_enabled 1
   

4. Redémarrez le processus system_server.

        $ adb shell stop && adb shell start
       

5. Vérifiez que adb shell dumpsys input indique qu'il y a des détecteurs de paume à l'intérieur de UnwantedInteractionBlocker. Si ce n'est pas le cas, consultez les journaux liés aux entrées pour trouver des indices sur ce qui pourrait être mal configuré.

   Consultez l'exemple suivant pour référence :

   UnwantedInteractionBlocker:
     mEnablePalmRejection: true
     isPalmRejectionEnabled (flag value): true
     mPalmRejectors:
       deviceId = 3:
         mDeviceInfo:
           max_x = 
           max_y = 
           x_res = 11.00
           y_res = 11.00
           major_radius_res = 1.00
           minor_radius_res = 1.00
           minor_radius_supported = true
           touch_major_res = 1
           touch_minor_res = 1
         mSlotState:
           mSlotsByPointerId:
   
           mPointerIdsBySlot:
   
         mSuppressedPointerIds: {}
   

6. Pour activer définitivement la fonctionnalité, ajoutez la commande sysprop correspondante dans votre fichier init**rc :

   setprop persist.device_config.input_native_boot.palm_rejection_enabled 1
   

Complément d'informations

• Protocole multipoint Linux