Appareil tactile

Android prend en charge une variété d'écrans et de tablettes tactiles, y compris les tablettes numériques à stylet.

Les écrans tactiles sont des appareils tactiles associés à un affichage de telle sorte que l'utilisateur a l'impression de manipuler directement des éléments à l'écran.

Les tablettes tactiles sont des appareils tactiles qui ne sont pas associés à un écran, comme une tablette numérisée. Les pavés tactiles sont généralement utilisés pour le pointage ou pour le positionnement indirect absolu ou le contrôle gestuel d'une interface utilisateur.

Les appareils tactiles peuvent avoir des boutons dont les fonctions sont similaires à celles des boutons de la souris.

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

Les appareils tactiles sont parfois utilisés pour implémenter des clés 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 remplit une double fonction en tant que partie intégrante d'un 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 multi-touch 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 n'a aucun bouton de manette de jeu. Cette condition résout une ambiguïté avec certaines manettes de jeu qui signalent des axes avec des codes qui chevauchent ceux des axes MT.

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

  • Le périphérique d'entrée n'est pas classé comme périphérique multi-touch. Un périphérique d'entrée est soit classé comme périphérique à une seule touche, soit comme périphérique multi-touch, jamais les deux.
  • Le dispositif d'entrée signale la présence des axes absolus ABS_X et ABS_Y , ainsi que la présence du code clé 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 de touches virtuelles pour le périphérique. Si une carte de touches virtuelle est disponible, le fichier de disposition des touches du périphérique est également chargé. Reportez-vous à [Fichiers de mappage de touches virtuelles](#virtual-key-map-files) pour plus d'informations sur l'emplacement et le format de ces fichiers.

Ensuite, le système charge le fichier de configuration du périphérique d'entrée pour le périphérique tactile.

Tous les appareils tactiles intégrés doivent avoir des fichiers de configuration de périphérique d'entrée. Si aucun fichier de configuration du périphérique d'entrée n'est présent, le système choisit une configuration par défaut appropriée pour les périphériques tactiles à usage général tels que les écrans tactiles ou les tablettes tactiles externes USB ou Bluetooth HID. 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 classe le périphérique d'entrée comme un écran tactile , un pavé tactile ou un pointeur .

  • Un appareil à écran tactile est utilisé pour la manipulation directe d’objets sur l’écran. L'utilisateur touche directement l'écran, le système n'a donc pas besoin de moyens supplémentaires pour indiquer les objets manipulés.
  • Un dispositif à pavé tactile est utilisé pour fournir des informations de positionnement absolues à une application concernant les touches sur une zone de capteur donnée. Cela peut être utile pour les tablettes numériques.
  • Un dispositif de pointeur est utilisé pour la manipulation indirecte d'objets sur l'écran à l'aide d'un curseur. Les doigts sont interprétés comme des gestes de pointeur multi-touch. D'autres outils, tels que les stylets, sont interprétés à l'aide de positions absolues. Voir Gestes du pointeur multi-touch indirects pour plus d’informations.

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

  • Si la propriété touch.deviceType est définie, le type de périphérique 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 ), alors le type de périphérique est défini sur touch screen . Cette condition suppose que les périphériques tactiles à entrée 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 ), alors 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 , alors 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 constitués à 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 de périphérique est défini sur pointeur . Cette valeur par défaut garantit que les pavés tactiles qui n'ont pas été désignés à d'autres fins spéciales contrôlent le pointeur.

Boutons

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

Les boutons suivants sont pris en charge :

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

Outils et types d'outils

Un outil est un doigt, un stylet ou un autre appareil utilisé pour interagir avec le périphérique tactile. Certains appareils tactiles peuvent distinguer 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 pris en charge :

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

Outils de survol ou de toucher

Les outils peuvent être soit en contact avec l'appareil tactile, soit à portée et planer au-dessus de celui-ci. Tous les appareils tactiles ne peuvent pas détecter la présence d'un outil survolant l'appareil tactile. Ceux qui le font, comme les numériseurs à stylet RF, peuvent souvent détecter lorsque l'outil se trouve dans une portée limitée du numériseur.

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

Configuration requise pour le pilote de périphérique tactile

  • Les pilotes d'appareils tactiles doivent enregistrer uniquement les axes et les codes clés des axes et des boutons qu'ils prennent en charge. L'enregistrement d'axes ou de codes clés non pris en charge peut perturber l'algorithme de classification des appareils ou amener le système à détecter de manière incorrecte les capacités de l'appareil. 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 est simplement à portée et en vol stationnaire.
  • Les appareils à simple pression utilisent les événements d'entrée Linux suivants :
    • ABS_X : (REQUIS) Rapporte la coordonnée X de l'outil.
    • ABS_Y : (REQUIS) Indique la coordonnée Y de l'outil.
    • ABS_PRESSURE : (facultatif) Rapporte la pression physique appliquée à la pointe de l'outil ou la force du signal du contact tactile.
    • ABS_TOOL_WIDTH : (facultatif) Indique la surface transversale ou la largeur du contact tactile ou de l'outil lui-même.
    • ABS_DISTANCE : (facultatif) Rapporte la distance de l'outil à la surface de l'appareil tactile.
    • ABS_TILT_X : (facultatif) Signale l'inclinaison de l'outil par rapport à la surface du périphérique tactile le long de l'axe X.
    • ABS_TILT_Y : (facultatif) Signale l'inclinaison de l'outil par rapport à la surface du périphérique tactile le long de l'axe Y.
    • BTN_TOUCH : (REQUIS) 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) Rapports sur les états du bouton .
    • 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 multi-touch utilisent les événements d'entrée Linux suivants :
    • ABS_MT_POSITION_X : (REQUIS) Rapporte la coordonnée X de l'outil.
    • ABS_MT_POSITION_Y : (REQUIS) Rapporte la coordonnée Y de l'outil.
    • ABS_MT_PRESSURE : (facultatif) Rapporte la pression physique appliquée à la pointe de l'outil ou la force du signal du contact tactile.
    • ABS_MT_TOUCH_MAJOR : (facultatif) Indique la surface transversale du contact tactile ou la longueur de la dimension la plus longue du contact tactile.
    • ABS_MT_TOUCH_MINOR : (facultatif) Rapporte la longueur de la dimension la plus courte du contact tactile. Cet axe ne doit pas être utilisé si ABS_MT_TOUCH_MAJOR signale une mesure de surface.
    • ABS_MT_WIDTH_MAJOR : (facultatif) Indique la surface de 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 à moins de connaître 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 rapporte une mesure de surface ou si les dimensions de l'outil lui-même sont inconnues.
    • ABS_MT_ORIENTATION : (facultatif) Rapporte l'orientation de l'outil.
    • ABS_MT_DISTANCE : (facultatif) Rapporte la distance de l'outil à 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) Signale l'ID de suivi de l'outil. L'ID de suivi est un entier arbitraire non négatif utilisé pour identifier et suivre chaque outil indépendamment lorsque plusieurs outils sont actifs. Par exemple, lorsque plusieurs doigts touchent l'appareil, chaque doigt doit se voir attribuer un identifiant de suivi distinct qui est utilisé tant que le doigt reste en contact. Les identifiants de suivi peuvent être réutilisés lorsque leurs outils associés sont hors de portée.
    • ABS_MT_SLOT : (facultatif) Indique l'ID d'emplacement de l'outil, lors de l'utilisation du protocole Linux multi-touch 'B'. Reportez-vous à la documentation du protocole Linux multi-touch pour plus de détails.
    • BTN_TOUCH : (REQUIS) 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) Rapports sur les états du bouton .
    • 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 pour les protocoles mono-touch et multi-touch sont définis, alors seuls les axes multi-touch sont utilisés et les axes mono-touch sont ignorés.
  • Les valeurs minimale et maximale 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 du périphérique 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 contacts en dehors de la zone active signalée.

    Les touches initiées en dehors de la zone active ne sont pas transmises aux applications mais peuvent être utilisées pour les touches virtuelles.

    Les touches initiées à l'intérieur de la zone active, ou qui entrent et sortent de la zone d'affichage, sont transmises aux applications. Par conséquent, si un contact commence dans les limites d’une application puis se déplace 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’affichage. Il s’agit d’un comportement attendu.

    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 doit 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 s'éloigner de la zone active, l'écran tactile doit soit commencer à signaler les coordonnées avec des composants inférieurs à minX et minY, tels que (minX - 2, minY - 3), soit cesser complètement de signaler le toucher. En d'autres termes, l'écran tactile ne doit pas signaler (minX, minY) lorsque le doigt de l'utilisateur touche réellement en dehors de la zone active.

    Le fait de fixer les coordonnées tactiles au bord de l'écran crée une limite artificielle dure autour du bord de l'écran qui empêche le système de suivre en douceur 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 différentes de zéro lorsque l'outil touche l'appareil et de zéro sinon pour indiquer que l'outil est en survol.

    La communication des informations sur la pression est facultative mais fortement recommandée. Les applications peuvent utiliser les informations de pression pour implémenter un 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 différentes de zéro lorsque l'outil touche l'appareil et de zéro dans le cas contraire, mais ce n'est pas obligatoire. Par exemple, l'appareil tactile peut être capable de mesurer la taille des contacts tactiles du doigt, mais pas des contacts tactiles du stylet.

    Les informations sur la taille des rapports sont facultatives mais fortement recommandées. Les applications peuvent utiliser les informations de 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 se rapprocher de 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.

    La communication des informations sur la distance est facultative mais recommandée pour les appareils à stylet.

  • Les valeurs rapporté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, les valeurs supérieures au point central représentent une inclinaison vers le bas ou vers la droite.

    InputReader convertit les composants d'inclinaison X et Y en un angle d'inclinaison perpendiculaire allant de 0 à PI / 2 radians et un angle d'orientation planaire allant de -PI à PI radians. Cette représentation aboutit à une description de l'orientation compatible avec ce qui est utilisé pour décrire les touchers des doigts.

    La communication des informations d’inclinaison est facultative mais recommandée pour les appareils à stylet.

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

  • Un outil est déterminé comme étant actif en fonction des conditions suivantes :

    • Lors de l'utilisation du protocole single-touch, l'outil est actif si BTN_TOUCH ou BTN_TOOL_* vaut 1.

      Cette condition implique InputReader doit disposer d'au moins quelques informations sur la nature de l'outil, soit s'il est tactile, soit au moins son type d'outil. Si aucune information n'est disponible, alors l'outil est considéré comme inactif (hors de portée).

    • Lors de l'utilisation du protocole multi-touch « 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 cesse d'exister.
    • Lors de l'utilisation du protocole multi-touch « B », l'outil est actif tant qu'il dispose d'un emplacement actif. Lorsque l'emplacement est vidé, l'outil cesse d'exister.
  • Un outil est déterminé comme étant en survol en fonction des conditions suivantes :
    • Si l'outil est BTN_TOOL_MOUSE ou BTN_TOOL_LENS , alors l'outil ne survole pas, même si l'une des conditions suivantes est vraie.
    • Si l'outil est actif et que le conducteur rapporte des informations sur la pression et que la pression signalée est nulle, alors l'outil est en survol.
    • Si l'outil est actif et que le pilote prend en charge le code clé BTN_TOUCH et que BTN_TOUCH a une valeur de zéro, alors l'outil est en survol.
  • InputReader prend en charge les protocoles multi-touch « A » et « B ». Les nouveaux pilotes doivent utiliser le protocole « B », mais l'un ou l'autre fonctionne.
  • À partir d'Android 4.0, les pilotes d'écran tactile devront peut-être être modifiés pour se conformer à la spécification du protocole d'entrée Linux.

    Les modifications suivantes peuvent être nécessaires :

    • Lorsqu'un outil devient inactif (le doigt monte vers le haut), il devrait cesser d'apparaître dans les rapports de synchronisation multi-touch suivants. Lorsque tous les outils deviennent inactifs (tous les doigts montent vers le haut), 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 la force 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 de 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 de périphériques 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 multi-touch HID externes, à l'aide de pilotes non modifiés.

Fonctionnement de l'appareil tactile

Ce qui suit est un bref résumé du fonctionnement de l'appareil tactile sur Android.

  1. EventHub lit les événements bruts du pilote evdev .
  2. InputReader consomme les événements bruts et met à jour l'état interne concernant la position et d'autres caractéristiques de chaque outil. Il suit également l'état des boutons.
  3. Si BACK ou FORWARD a été enfoncé ou relâché, InputReader informe InputDispatcher de l'événement clé.
  4. InputReader détermine si une pression sur une touche virtuelle s'est produite. Si tel est le cas, il informe InputDispatcher de l'événement clé.
  5. InputReader détermine si le toucher a été initié dans les limites de l'écran. Si tel est le cas, il informe InputDispatcher de l'événement tactile.
  6. S'il n'y a pas d'outils tactiles mais qu'il y a au moins un outil de survol, InputReader informe InputDispatcher de l'événement de survol.
  7. Si le type de périphérique tactile est pointer , InputReader effectue la détection des gestes du pointeur, déplace le pointeur et le repère 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éveiller le périphérique. Ensuite, InputDispatcher transmet les événements aux applications appropriées.

Configuration de l'appareil tactile

Le comportement du périphérique tactile est déterminé par les axes, les boutons, les propriétés d'entrée, la configuration du périphérique d'entrée, la configuration des touches virtuelles et la disposition des touches de l'appareil.

Reportez-vous aux sections suivantes pour plus de détails sur les fichiers qui participent à la configuration du clavier :

Propriétés

Le système s'appuie sur de nombreuses propriétés de configuration du périphérique d'entrée pour configurer et calibrer le comportement du périphérique tactile.

L'une des raisons à cela est que les pilotes de périphériques tactiles signalent souvent les caractéristiques des touches à l'aide d'unités spécifiques au périphérique.

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

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

Conventions documentaires

À des fins de documentation, nous utilisons les conventions suivantes pour décrire les valeurs utilisées par le système pendant le processus d'étalonnage.

Valeurs brutes des axes

Les expressions suivantes désignent les valeurs brutes signalées par le pilote du périphérique tactile en tant qu'événements EV_ABS .

raw.x
La valeur de l'axe ABS_X ou ABS_MT_POSITION_X .
raw.y
La valeur de l'axe ABS_Y ou ABS_MT_POSITION_Y .
raw.pressure
La valeur de l'axe ABS_PRESSURE ou ABS_MT_PRESSURE , ou 0 si non disponible.
raw.touchMajor
La valeur de l'axe ABS_MT_TOUCH_MAJOR , ou 0 si non disponible.
raw.touchMinor
La valeur de l'axe ABS_MT_TOUCH_MINOR , ou raw.touchMajor si non disponible.
raw.toolMajor
La valeur de l'axe ABS_TOOL_WIDTH ou ABS_MT_WIDTH_MAJOR , ou 0 si non disponible.
raw.toolMinor
La valeur de l'axe ABS_MT_WIDTH_MINOR , ou raw.toolMajor s'il n'est pas disponible.
raw.orientation
La valeur de l'axe ABS_MT_ORIENTATION , ou 0 si non disponible.
raw.distance
La valeur de l'axe ABS_DISTANCE ou ABS_MT_DISTANCE , ou 0 si non disponible.
raw.tiltX
La valeur de l'axe ABS_TILT_X , ou 0 si non disponible.
raw.tiltY
La valeur de l'axe ABS_TILT_Y , ou 0 si non disponible.

Plages d'axes brutes

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

raw.*.min
La valeur minimale inclusive de l'axe brut.
raw.*.max
La valeur maximale inclusive de l’axe brut.
raw.*.range
Équivalent à raw.*.max - raw.*.min .
raw.*.fuzz
La précision de l'axe brut. par exemple. fuzz = 1 implique que les valeurs sont précises à +/- 1 unité.
raw.width
La largeur inclusive de la zone tactile, équivalente à raw.x.range + 1 .
raw.height
La hauteur inclusive 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 en sortie. Le système utilise l'interpolation linéaire pour traduire les informations de position tactile des unités de surface utilisées par le périphérique tactile en unités de sortie qui sont signalées aux applications telles que les pixels d'affichage.

output.width
La largeur de sortie. Pour les écrans tactiles (associés à un afficheur), il s'agit de la largeur d'affichage en pixels. Pour les tablettes tactiles (non associées à un écran), la largeur de sortie est égale à raw.width , indiquant qu'aucune interpolation n'est effectuée.
output.height
La hauteur de sortie. Pour les écrans tactiles (associés à un afficheur), il s'agit de la hauteur d'affichage en pixels. Pour les tablettes tactiles (non associées à un écran), la hauteur de sortie est égale à raw.height , indiquant qu'aucune interpolation n'est effectuée.
output.diag
La longueur 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 d'étalonnage. 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 avec les champs qu'elles sont utilisées pour calibrer.

touch.deviceType

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

Spécifie le type de périphérique tactile.

  • Si la valeur est touchScreen , le périphérique tactile est un écran tactile associé à un écran.

  • Si la valeur est touchPad , le périphérique 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 du pointeur multi-touch .

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

Reportez-vous à la section Classification pour plus de détails sur la manière dont le type d'appareil influence le comportement de l'appareil tactile.

Sous 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

Spécifie si le périphérique tactile doit réagir aux changements d'orientation de l'affichage.

  • Si la valeur est 1 , les positions tactiles signalées par le périphérique tactile pivotent chaque fois que l'orientation de l'affichage change.

  • Si la valeur est 0 , les positions tactiles signalées par le périphérique tactile sont insensibles aux changements d'orientation de l'affichage.

La valeur par défaut est 1 si l'appareil est un écran tactile, 0 sinon.

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

La connaissance de l'orientation est utilisée pour prendre en charge la rotation des écrans tactiles sur des appareils comme le Nexus One. Par exemple, lorsque l'appareil pivote de 90 degrés dans le sens des aiguilles d'une montre par rapport à son orientation naturelle, les positions absolues des touches sont remappées de telle sorte qu'une touche dans le coin supérieur gauche du système de coordonnées absolues de l'écran tactile est signalée comme une touche dans le coin supérieur gauche. coin du système de coordonnées pivoté de l'écran. Ceci est fait pour que les touches soient signalées 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 supposés prendre en compte 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 pointeur .

  • Si la valeur est pointer , les gestes du pavé tactile sont présentés au moyen d'un curseur similaire au pointeur d'une souris.

  • Si la valeur est spots , les gestes du pavé tactile sont présentés par une ancre qui représente le centre de gravité du geste et un ensemble de points circulaires qui représentent la position des doigts individuels.

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 provenant du pilote tactile sont interpolées linéairement 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

touchMajor, touchMinor, toolMajor, toolMinor, champs de taille

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 toucher par rapport au contact le plus grand possible que l'appareil tactile peut détecter. La plus petite taille normalisée possible est de 0,0 (pas de contact ou non mesurable) et la plus grande taille normalisée 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 zone transversale de l'outil.

Si la taille tactile n'est pas disponible mais que la taille de l'outil est disponible, alors la taille de l'outil est définie de manière égale à la taille tactile. À l’inverse, si la taille de l’outil n’est pas disponible mais que la taille du toucher est disponible, alors la taille du toucher est définie de manière égale à la taille de l’outil.

Les appareils tactiles mesurent ou signalent la taille du toucher et la taille de l'outil de différentes manières. L'implémentation actuelle prend en charge trois types différents de mesures : le diamètre, la surface et le cadre de délimitation 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 signaler la taille du toucher et la taille 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 toucher ou de l'outil.

  • Si la valeur est area , la taille est supposée être proportionnelle à la zone du toucher ou de l'outil.

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

touch.size.scale

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

Spécifie un facteur d’échelle constant utilisé dans l’étalonnage.

La valeur par défaut est 1.0 .

touch.size.bias

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

Spécifie une valeur de biais constante utilisée dans l'étalonnage.

La valeur par défaut est 0.0 .

touch.size.isSummed

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

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

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

  • Si la valeur est 0 , la taille signalé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 et indiquent donc une mesure de taille qui représente leur surface ou largeur totale. Cette propriété ne doit être définie que sur 1 pour de tels 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 d'étalonnage 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 au périphérique tactile sous la forme d'une valeur normalisée comprise entre 0,0 (pas de contact) et 1,0 (pleine force).

Une pression nulle indique que l'outil est en vol stationnaire.

étalonnage.de.pression.toucher

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

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

  • Si la valeur est none , la pression est inconnue, elle est donc réglée sur 1,0 au toucher et 0,0 en survol.

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

  • Si la valeur est amplitude , l'axe de pression est supposé 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 l'étalonnage physical si l'axe de pression est disponible, sinon il n'en utilise none .

touch.pression.échelle

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

Spécifie un facteur d’échelle constant utilisé dans l’étalonnage.

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

Calcul

Le calcul du champ pressure dépend des paramètres d'étalonnage 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 toucher et de l'outil comme une mesure angulaire. Une orientation de 0 indique que l'axe majeur est orienté verticalement, -PI/2 indique que l'axe majeur est orienté vers la gauche, PI/2 indique que l'axe principal est orienté vers la droite. Lorsqu'un outil de stylet est présent, la plage d'orientation peut être décrite dans une plage de cercle complet de -PI ou PI .

Le champ tilt décrit l'inclinaison de l'outil comme 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 signaler l'orientation.

  • Si la valeur none , l'orientation est inconnue, elle est donc définie sur 0.
  • Si la valeur est interpolated , l'orientation est interpolée linéairement de telle sorte qu'une valeur brute de raw.orientation.min mapes à -PI/2 et une valeur brute de raw.orientation.max maps à PI/2 . La valeur centrale de (raw.orientation.min + raw.orientation.max) / 2 cartes à 0 .
  • Si la valeur est vector , l'orientation est interprétée comme un vecteur emballé constituant deux champs 4 bits signés. Cette représentation est utilisée sur des pièces de protocole basées sur les objets Atmel. Lorsqu'il est décodé, le vecteur crée un angle d'orientation et une magnitude de confiance. L'amplitude de confiance est utilisée pour mettre à l'échelle les informations de taille, sauf si elle est géométrique.
  • Si la valeur est default , le système utilise l'étalonnage interpolated si l'axe d'orientation disponible, sinon n'en utilise none .

Calcul

Le calcul des champs orientation et tilt dépend des paramètres d'étalonnage spécifiés et de l'entrée disponible.

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 de distance

Le champ distance décrit la distance entre l'outil et la surface du dispositif tactile. Une valeur de 0,0 indique un contact direct et des valeurs plus grandes indiquent une distance croissante de 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 signaler la distance.

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

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

  • Si la valeur est default , le système utilise l'étalonnage scaled si l'axe de distance disponible, sinon n'en utilise none .

Touch.Distance.Scale

Définition: touch.distance.scale = <Numéro de point flottant non négatif>

Spécifie un facteur d'échelle constant utilisé dans l'étalonnage.

La valeur par défaut est 1.0 .

Calcul

Le calcul du champ distance dépend des paramètres d'étalonnage 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 périphériques Touch ont considérablement changé dans Android Ice Cream Sandwich 4.0. Tous les fichiers de configuration des périphériques d'entrée pour les périphériques tactiles doivent être mis à jour pour utiliser les nouvelles propriétés de configuration.

Les anciens pilotes de périphérique Touch pourraient également devoir être mis à jour.

Fichiers de cartes clés virtuels

Les appareils tactiles sont souvent utilisés pour implémenter des clés virtuelles.

Il existe plusieurs façons de le faire, selon les capacités du contrôleur tactile. Certains contrôleurs tactiles peuvent être directement configurés pour implémenter les touches souples en définissant les registres du micrologiciel. D'autres fois, il est souhaitable d'effectuer le mappage des coordonnées tactiles aux codes clés du logiciel.

Lorsque les clés virtuelles sont implémentées dans le logiciel, le noyau doit exporter un fichier de carte de clé virtuelle appelée virtualkeys.<devicename> en tant que propriété de la carte. Par exemple, si les pilotes de périphérique à écran tactile signalent son nom comme "touchyfeely", le fichier de carte de clé virtuelle doit avoir le chemin /sys/board_properties/virtualkeys.touchyfeely .

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

En plus du fichier de carte de clé virtuelle, il doit y avoir un fichier de disposition de clé et un fichier de caractéristiques de caractéristiques de clé correspondant pour mapper les codes de clé Linux sur les codes de clé Android et pour spécifier le type de périphérique clavier (généralement SPECIAL_FUNCTION ).

Syntaxe

Un fichier de carte de clé virtuelle est un fichier texte brut composé d'une séquence de descriptions de mise en page virtuelle de la clé soit séparée par Newlines ou par Colons.

Les lignes de commentaires commencent par «#» et continuent jusqu'à la fin de la ligne.

Chaque clé virtuelle est décrite par 6 composants délimités par le côlon:

  • 0x01 : un code de version. Doit toujours être 0x01 .
  • <Code de clé Linux>: le code de clé Linux de la touche virtuelle.
  • <Neentrex>: La coordonnée X pixel du centre de la clé virtuelle.
  • <Centery>: La coordonnée des pixels Y du centre de la clé virtuelle.
  • <largeur>: la largeur de la clé virtuelle dans les pixels.
  • <hauteur>: la hauteur de la clé virtuelle dans les 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 carte de clé virtuelle tous écrits 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 carte de clé virtuelle 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 480x800. En conséquence, toutes les clés virtuelles ont une coordonnée <enter> de 835, ce qui est un peu en dessous de la zone visible de l'écran tactile.

La première touche a un code de numérisation Linux de 158 ( KEY_BACK ), CenterX de 55 , centrer de 835 , largeur de 90 et hauteur de 55 .

Exemple

Fichier de carte de clé virtuelle: /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 mise en page de clé: /system/usr/keylayout/touchyfeely.kl .

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

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

type SPECIAL_FUNCTION

Gestes de pointeur multi-touch indirects

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

  • Appuyez sur un seul doigt: cliquez.
  • Mouvement unique: déplacez le pointeur.
  • Appuyez sur le bouton MOTION PLUS SOINGE: Faites glisser le pointeur.
  • Deux doigts de doigt 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.
  • Deux doigts de doigt les deux doigts se déplaçant l'un vers l'autre ou l'un de l'autre dans des directions différentes: Pan / échelle / tournez la zone entourant le pointeur. Le pointeur lui-même ne bouge pas.
  • Motion des doigts multiples: geste de forme libre.

Rejet de palme

À partir d'Android 13, le système peut rejeter automatiquement les entrées de Palms lorsque le cadre intégré est activé. Les solutions internes et personnalisées sont toujours prises en charge, bien qu'elles puissent devoir être modifiées pour retourner l'indicateur TOOL_TYPE_PALM lorsqu'un palmier est détecté. Le cadre intégré fonctionne également en conjonction avec des solutions personnalisées.

Le modèle réel examine les 90 premiers ms de données de gestes, sur le pointeur actuel, et aux pointeurs environnants, puis considère à quelle distance du bord d'affichage des touches. Il détermine alors, sur une base par pointeur, laquelle des pointeurs est des palmiers. Il prend également en compte la taille de chaque contact, comme indiqué par touchMajor et touchMinor . Le framework Android supprime ensuite les pointeurs qui sont marqués comme des paumes du flux tactile.

Si un pointeur était déjà envoyé aux applications, alors le système soit:

  • (S'il y a d'autres pointeurs actifs) annule le pointeur avec ACTION_POINTER_UP et FLAG_CANCELED Set.
  • (S'il s'agit du 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 l'action utilisateur. Cet drapeau est défini pour ACTION_CANCEL et ACTION_POINTER_UP .

Si le pointeur de palmier n'a pas été envoyé aux applications, le système laisse simplement tomber le pointeur.

Activer le rejet de la paume

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

    La prise en charge de ABS_MT_TOUCH_MINOR est facultative. Cependant, si votre appareil le prend en charge, assurez-vous que la résolution est correctement définie.

  2. Pour confirmer que les champs sont définis correctement, exécutez:
        $ adb shell getevent -li
    
  3. Pour activer la fonctionnalité pendant l'exécution, exécutez:
        $ 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. Confirmez que adb shell dumpsys input montre qu'il y a des rejecteurs de palme à l'intérieur UnwantedInteractionBlocker . Si ce n'est pas le cas, vérifiez les journaux liés à l'entrée pour trouver des indices sur ce qui pourrait être mal configuré.

    Voir 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
    

Lectures complémentaires