Appareils tactiles

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

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

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

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

Les appareils tactiles peuvent parfois être manipulés à l'aide de divers outils comme 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 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 à la fois de clavier tactile.

En raison de la grande variété d'appareils tactiles, Android s'appuie sur un grand nombre des 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 considéré comme un périphérique multipoint si les deux les conditions suivantes sont remplies:

  • L'appareil 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 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 considéré comme un périphérique à touche unique si les deux les conditions suivantes sont réunies:

  • L'appareil d'entrée n'est pas classé comme appareil multipoint. Un périphérique d'entrée est classé en tant qu’appareil à toucher unique ou en tant qu’appareil multipoint, jamais les deux.
  • Le périphérique d'entrée signale la présence des valeurs absolues ABS_X et ABS_Y les axes et la présence du code de touche BTN_TOUCH.

Lorsqu'un périphérique d'entrée est classé comme appareil tactile, la présence de touches virtuelles est déterminée en essayant de charger le fichier de mappage des touches virtuelles pour l'appareil. Si un mappage de clés virtuelles est disponible, la disposition des touches pour l'appareil est également chargé. Consultez la section [Fichiers de mappage de touches virtuelles](#virtual-key-map-files) pour en savoir plus 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 l'appareil 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 d'appareil 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 paramètres par défaut ne sont pas conçus pour les écrans tactiles intégrés et peut entraîner un comportement incorrect.

Une fois la configuration de l'appareil d'entrée chargée, le système le classe comme écran tactile, souris ou pointeur.

  • Un appareil à écran tactile permet de manipuler directement des objets sur le l'écran. L'utilisateur touche directement l'écran, donc le système ne ont besoin de toutes les affordances supplémentaires pour indiquer les objets manipulées.
  • Un pavé tactile est utilisé pour fournir des informations de position absolue. à une application concernant les gestes 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 des objets sur le à l'écran à l'aide d'un curseur. Les doigts sont interprétés comme des gestes de pointeur multipoint. D'autres outils, tels que les stylets, sont interprétés à l'aide de positions absolues. Pour en savoir plus, consultez la section Gestes indirects avec le pointeur multipoint.

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

  • 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 INPUT_PROP_DIRECT d'entrée (via l'ioctl EVIOCGPROP), le type d'appareil est défini sur écran tactile. Cette condition suppose que la saisie directe périphériques sont connectés à un écran qui est également connecté.
  • Si le périphérique d'entrée signale la présence de INPUT_PROP_POINTER propriété d'entrée (via l'ioctl EVIOCGPROP), puis le type d'appareil défini sur pointer.
  • Si le périphérique d'entrée signale la présence de REL_X ou REL_Y axes relatifs, le type d'appareil est défini sur pavé tactile. Cette condition résout une ambiguïté pour les périphériques d'entrée constitués à la fois d'une souris et 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 pointeur. Cette valeur par défaut garantit des pavés tactiles qui n'ont pas d'autres fonctions contrôler le pointeur.

Boutons

Les boutons sont des commandes facultatives que les applications peuvent utiliser pour effectuer des fonctions supplémentaires. Les boutons des appareils tactiles se comportent de la même manière que ceux de la souris et sont principalement utilisés avec les appareils tactiles de type pointeur avec le 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 avec MotionEvent.BUTTON_BACK. Appuyer sur ce bouton synthétise également l'appui 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 aussi une pression sur une touche avec le code de touche 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 distinction 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 à MotionEvent.TOOL_TYPE_FINGER.

Passer la souris sur les outils ou appuyer sur ceux-ci

Les outils peuvent être soit en contact avec l'appareil tactile, soit à portée et en pointant l'appareil au-dessus d'elle. Tous les appareils tactiles ne détectent pas la présence d'un outil au-dessus de l'appareil tactile. Ceux qui le font, comme les numériseurs à stylet basés sur la technologie RF, peuvent souvent détecter quand l'outil se trouve dans une plage 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 avec 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.

Exigences concernant les pilotes d'appareils tactiles

  • Les pilotes d'appareils 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 touche non compatibles peut perturber l'algorithme de classification de l'appareil 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 de touche BTN_TOUCH, le système suppose que BTN_TOUCH est toujours utilisé pour indiquer si l'outil est touchant l'écran. Par conséquent, BTN_TOUCH ne doit pas être utilisé pour indiquer que l'outil se trouve simplement dans la plage et qu'il est en survol.
  • Les appareils à écran tactile unique 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 à l'extrémité de l'outil ou l'intensité du signal du contact tactile.
    • ABS_TOOL_WIDTH (facultatif): indique la superficie transversale ou la largeur des le 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 à partir de la surface de l'appareil tactile le long de 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) État 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 multipoint 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 la pointe de l'outil ou l'intensité du signal du contact tactile.
    • ABS_MT_TOUCH_MAJOR (facultatif): indique l'aire 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. Cette axe ne doit pas être utilisée si ABS_MT_TOUCH_MAJOR indique une mesure de surface.
    • ABS_MT_WIDTH_MAJOR (facultatif): indique l'aire transversale du l'outil lui-même ou la longueur de la dimension la plus longue de l'outil lui-même. N'utilisez pas cette 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. Cette axe ne doit pas être utilisée 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 le de l'appareil tactile.
    • ABS_MT_TOOL_TYPE : (facultatif) indique le type d'outil sous la forme 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 nombre entier arbitraire non négatif permettant d'identifier et suivre chaque outil indépendamment lorsque plusieurs outils sont actifs. Par exemple, lorsque plusieurs doigts touchent l'appareil, un ID de suivi distinct doit être attribué à chaque doigt et utilisé tant qu'il reste en contact. Les ID de suivi peuvent être réutilisés lorsque les outils associés ne sont plus à portée.
    • ABS_MT_SLOT (facultatif): indique l'ID d'emplacement de l'outil si vous utilisez la propriété Protocole multipoint Linux B Pour en savoir plus, consultez la documentation sur le protocole multipoint Linux.
    • BTN_TOUCH: (OBLIGATOIRE) indique si l'outil est en contact avec le appareil.
    • BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_BACK BTN_SIDE, BTN_FORWARD BTN_EXTRA, BTN_STYLUS, BTN_STYLUS2: (facultatif) État 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 à la fois pour le protocole à point unique et le protocole multipoint, seuls les axes multipoint sont utilisés et les axes à point unique 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 de l'appareil tactile qui recouvre réellement l'écran.

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

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

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

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

    Les pressions déclenchées dans la zone active ou qui entrent et sortent de la zone d'affichage sont transmises aux applications. Par conséquent, si un appui 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'écran. Ce comportement est normal.

    Un appareil tactile ne doit jamais limiter les coordonnées tactiles aux limites de la zone active. Si une pression quitte la zone active, elle doit être signalée comme située en dehors de la zone active, sans quoi elle ne doit pas être signalée du tout.

    Par exemple, si l'utilisateur touche l'angle supérieur gauche l'écran tactile, il peut indiquer une coordonnée de (minX, minY). Si l'utilisateur continue de déplacer son doigt en dehors de la zone active, l'écran tactile doit commencer à signaler des coordonnées avec des composants inférieurs à minX et minY, par exemple (minX - 2, minY - 3), ou cesser complètement de signaler le toucher. En d'autres termes, l'écran tactile ne doit pas envoyer de valeurs (minX, minY) lorsque le doigt de l'utilisateur est réellement en dehors de la zone active.

    Le forçage des coordonnées tactiles sur le bord de l'écran crée une limite 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és, doivent être différents de zéro lorsque l'outil est en contact avec l'appareil. et zéro dans le cas contraire pour indiquer que l'outil est survolé.

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

  • Les valeurs indiquées par ABS_TOOL_WIDTH, ABS_MT_TOUCH_MAJOR, ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MAJOR ou ABS_MT_WIDTH_MINOR doit être différent de zéro lorsque l'outil entre en contact avec l'appareil et zéro dans le cas contraire, mais ce n'est pas obligatoire. Par exemple, l'appareil tactile peut être en mesure de mesurer la taille des contacts tactiles avec les doigts, mais pas ceux avec le stylet.

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

  • Les valeurs indiquées par ABS_DISTANCE ou ABS_MT_DISTANCE doivent s'approcher 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 sur la manière dont le matériel mesure la distance.

    Le signalement des informations de distance est facultatif, mais recommandé pour les appareils à stylet.

  • Les valeurs indiquées par ABS_TILT_X et ABS_TILT_Y doivent être égales à zéro. lorsque l'outil est perpendiculaire à l'appareil. Une inclinaison non nulle indique l'outil doit être 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. On donne au point central (parfaitement perpendiculaire) par (max + min) / 2 pour chaque axe. Valeurs inférieures au point central représente une inclinaison vers le haut ou vers la gauche, 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 angle d'inclinaison compris entre 0 et PI / 2 radians, et un angle d'orientation planaire compris entre -PI et PI radians. Cette représentation se traduit par description de l'orientation compatible avec ce qui est utilisé pour décrire vos doigts.

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

  • Si le type d'outil est signalé par ABS_MT_TOOL_TYPE, il remplace toutes les informations sur le type d'outil signalées par BTN_TOOL_*. Si aucune information n'est disponible, le type d'outil est défini par défaut sur MotionEvent.TOOL_TYPE_FINGER

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

    • Lorsque vous utilisez le protocole à contact unique, l'outil est actif si BTN_TOUCH, ou BTN_TOOL_* est égal à 1.

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

    • Lorsque vous utilisez le protocole multipoint "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 synchronisation des rapports, elle n'existe plus.
    • Avec le protocole multipoint B, l'outil reste actif tant que elle dispose d'un emplacement actif. Lorsque l'emplacement est effacé, l'outil n'existe plus.
  • Les conditions suivantes déterminent qu'un outil pointe sur l'écran:
    • Si l'outil est BTN_TOOL_MOUSE ou BTN_TOOL_LENS, alors il n'est pas survolé, même si l'une des conditions suivantes est remplie.
    • Si l'outil est actif et que le pilote indique des informations de pression, et que la pression indiquée est nulle, l'outil est en suspension.
    • Si l'outil est actif et que le pilote est compatible avec le code de touche BTN_TOUCH et que BTN_TOUCH a une valeur de zéro, l'outil est en survol.
  • InputReader est compatible à la fois avec le protocole multipoint "A" et "B". Les nouveaux pilotes doivent utiliser le protocole B, mais les deux fonctionnent.

  • À partir d'Android 4.0, les pilotes d'écran tactile peuvent nécessiter d'être modifiés pour se conformer à la spécification du protocole d'entrée Linux.

    Les modifications suivantes peuvent être requises:

    • Lorsqu'un outil devient inactif (le doigt « monte »), il devrait cesser d'apparaître dans les rapports de synchronisation multipoint suivants. Lorsque tous les outils deviennent inactifs (tous les doigts sont "en l'air"), 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 attendaient 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 indiquées via ABS_MT_PRESSURE

      Les versions précédentes d'Android ont récupéré des informations sur la pression de ABS_MT_TOUCH_MAJOR. L'ancien comportement n'était pas compatible avec Spécification du protocole d'entrée Linux et n'est plus compatible.

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

      Les versions précédentes d'Android ont récupéré les informations de taille à partir de ABS_MT_TOOL_MAJOR L'ancien comportement n'était pas compatible avec Spécification du protocole d'entrée Linux et n'est plus compatible.

    Les pilotes d'appareils tactiles n'ont plus besoin de personnalisations spécifiques à Android. En s'appuyant sur le protocole d'entrée standard de Linux, Android est compatible avec une plus grande variété de périphériques tactiles, tels que le multipoint HID externe à l'aide de pilotes non modifiés.

Fonctionnement de l'appareil tactile

Voici un bref récapitulatif 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 les états des boutons.
  3. Si vous avez appuyé ou relâché sur RETOUR ou AVANT, InputReader informe InputDispatcher de l'événement clé.
  4. InputReader détermine si une pression sur une touche virtuelle a eu lieu. Si tel est le cas, il informe InputDispatcher de l'événement clé.
  5. InputReader détermine si la pression a été initiée dans le les limites de l'écran. Si tel est le cas, il informe InputDispatcher de l'événement tactile.
  6. Si aucun outil ne touche l'écran, mais qu'au moins un outil est en survol, InputReader informe InputDispatcher de l'événement de survol.
  7. Si le type d'appareil tactile est pointeur, InputReader effectue la détection des gestes du pointeur, déplace le pointeur et les repères 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 déclenchés et s’ils doivent activer l’appareil. InputDispatcher transmet ensuite les événements aux applications appropriées.

Configuration de l'appareil tactile

Le comportement de l'appareil tactile est déterminé par ses axes, ses boutons, ses propriétés d'entrée, sa configuration de l'appareil d'entrée, son mappage de touches virtuelles et sa mise en page de touches.

Reportez-vous aux sections suivantes pour en savoir plus sur les fichiers participer à la configuration du clavier:

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

Cela s'explique notamment par le fait que les pilotes d'appareils pour les appareils tactiles signalent souvent les caractéristiques des pressions à 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 à chaque appareil, comme le nombre total les nœuds de capteurs déclenchés par un toucher. Cette valeur de taille brute ne sont pas significatives pour les applications, car elles auraient besoin de connaître la taille physique et d'autres caractéristiques des nœuds du capteur de l'appareil tactile.

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

Conventions de documentation

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

Valeurs brutes de l'axe

Les expressions suivantes désignent les valeurs brutes rapportées par l'appui pilote d'appareil 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
La valeur de l'axe ABS_PRESSURE ou ABS_MT_PRESSURE, ou 0 si non disponibles.
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
La valeur de l'axe ABS_DISTANCE ou ABS_MT_DISTANCE, ou 0 si non disponibles.
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 non disponible.

Plages brutes de l'axe

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

raw.*.min
Valeur minimale inclusive de l'axe brut.
raw.*.max
Valeur maximale inclusive de l'axe brut.
raw.*.range
Équivaut à raw.*.max - raw.*.min.
raw.*.fuzz
Précision de l'axe brut. Ex. : La valeur fuzz = 1 implique que les valeurs sont précises à +/- 1 unité.
raw.width
Largeur inclusive de la zone tactile, équivalente à raw.x.range + 1.
raw.height
Hauteur inclusive de la zone tactile, qui équivaut à raw.y.range + 1.

Plages de sortie

Les expressions suivantes indiquent les caractéristiques du système de coordonnées de sortie. Le système utilise l'interpolation linéaire pour traduire les informations de position tactile les unités de surface utilisées par l'appareil tactile dans les unités de sortie signalées à des applications, comme les pixels d'affichage.

output.width
Largeur de la sortie. Pour les écrans tactiles (associés à un écran), cette est la largeur d'affichage 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), cette est la hauteur d'affichage 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 en diagonale du système de coordonnées de sortie, qui équivaut à 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 de l'appareil d'entrée pour spécifier les valeurs de calibrage. 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 utilisés pour le calibrage.

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é avec un écran.

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

  • Si la valeur est pointer, cela signifie que l'appareil tactile est un pavé tactile non associé. avec un écran, et ses mouvements sont utilisés pour gestes indirects du pointeur multipoint.

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

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

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 un écran tactile, 0 dans le cas contraire.

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

La détection de l'orientation est utilisée pour prendre en charge la rotation des écrans tactiles sur les appareils comme 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 gestes sont remappées de sorte qu'un geste dans l'angle supérieur gauche du système de coordonnées absolu de l'écran tactile soit signalé comme un geste dans l'angle supérieur gauche du système de coordonnées pivoté de l'écran. Cela permet que les pressions 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 à l'aide d'un curseur comme le pointeur de la souris.

  • Si la valeur est spots, les gestes du pavé tactile sont présentés par une ancre qui représente le centroïde du geste et un ensemble de taches 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. est défini, 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 issues du pilote tactile sont interpolée de manière linéaire au 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 de l'écran tactile par rapport à le plus grand appui possible que l'appareil tactile peut détecter. Le plus petit la taille normalisée possible est de 0, 0 (aucun contact ou non mesurable), et la valeur la plus élevée la 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 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 d'outil n'est pas disponible mais que la taille de l'écran tactile est disponible, elle est définie sur la même taille que l'outil.

Les appareils tactiles mesurent ou indiquent la taille des écrans tactiles et la taille de l'outil de différentes manières. L'implémentation actuelle accepte trois types de mesures : le diamètre, la surface et la boîte 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 indiquer la taille de l'écran tactile 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 le même les unités de la surface au lieu de 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 à le diamètre (largeur) de l'appui ou de l'outil.

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

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

Touch.size.scale

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

Spécifie un facteur de scaling constant utilisé lors de l'étalonnage.

La valeur par défaut est 1.0.

touche.taille.biais

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

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

La valeur par défaut est 0.0.

touche.taille.isSummed

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

Indique si la taille est indiquée comme la somme des tailles de toutes contacts actifs ou est signalé 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 éléments suivants : touchMajor, touchMinor, toolMajor, toolMinor, et size dépendent des paramètres de calibrage 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 la forme d'une valeur normalisée comprise entre 0,0 (pas de pression) et 1,0 (pression normale).

Une pression nulle indique que l'outil est survolé.

calibration.pressure.toucher

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

Indique 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 définie sur 1,0 lorsque tactile et 0.0 lorsque vous passez la souris dessus.

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

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

  • Si la valeur est default, le système utilise l'étalonnage physical si le axe de pression disponible. Sinon, utilise none.

touch.pressure.scale

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

Spécifie un facteur de scaling constant utilisé lors de 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 de l'appui et de l'outil sous la forme d'un la mesure angulaire. Une orientation 0 indique que l'axe principal est orienté verticalement, -PI/2 indique que l'axe principal est orienté vers la gauche, PI/2 indique que l'axe principal 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 à partir de -PI ou PI.

Le champ tilt décrit l'inclinaison de l'outil en tant que 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 lecteur tactile pour indiquer l'orientation.

  • Si la valeur est none, l'orientation est inconnue et est définie sur 0.
  • Si la valeur est interpolated, l'orientation est interpolée linéairement de sorte qu'une valeur brute de raw.orientation.min soit mappée sur -PI/2 et qu'une valeur brute de raw.orientation.max soit mappée sur PI/2. La valeur du centre de (raw.orientation.min + raw.orientation.max) / 2 correspond à 0.
  • Si la valeur est vector, l'orientation est interprétée comme un vecteur empaqueté composé de deux champs signés de 4 bits. Cette représentation est utilisée sur le protocole basé sur les objets Atmel de l'infrastructure. Lorsqu'il est décodé, le vecteur génère un angle d'orientation et un niveau de confiance grandeur. L'ampleur de la confiance est utilisée pour mettre à l'échelle les informations de taille, sauf si elles sont géométriques.
  • Si la valeur est default, le système utilise l'étalonnage interpolated si l'axe d'orientation est disponible. Sinon, utilise none.

Calcul

Le calcul des champs orientation et tilt dépend du les paramètres d'étalonnage spécifiés et 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 l'appareil tactile. sur la surface de l'écran. Une valeur de 0,0 indique un contact direct, tandis qu'une valeur supérieure indique un contact direct. qui augmente la distance 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. Elle est donc définie sur 0.

  • Si la valeur est scaled, la distance indiquée est multipliée par un facteur de mise à l'é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 de scaling constant utilisé lors de l'étalonnage.

La valeur par défaut est 1.0.

Calcul

Le calcul du champ distance dépend de l'étalonnage spécifié paramètres.

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 changé de manière significative dans Android 4.0 Ice Cream Sandwich. Tous les fichiers de configuration de périphérique d'entrée pour l'écran tactile les appareils doivent être mis à jour pour utiliser les nouvelles propriétés de configuration.

Vous devrez peut-être aussi utiliser les pilotes des appareils tactiles plus anciens mis à jour.

Fichiers de mappage de touches virtuelles

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

Pour ce faire, plusieurs options s'offrent à vous, en fonction des fonctionnalités du contrôleur tactile. Certains contrôleurs tactiles peuvent être configurés directement pour implémenter des touches programmables en définissant des registres de micrologiciel. Dans d'autres cas, il est préférable d'effectuer la mise en correspondance des coordonnées tactiles avec les codes de touche dans le logiciel.

Lorsque des touches virtuelles sont implémentées dans le logiciel, le noyau doit exporter un fichier de mappage de touches virtuelles appelé virtualkeys.<devicename> en tant que propriété de carte. Par exemple, si les pilotes de l'appareil à écran tactile indiquent son nom comme "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 touche Linux des touches virtuelles de l'écran tactile.

En plus du fichier de mappage de clés virtuelles, il doit y avoir une disposition de clé correspondante et un fichier de mappage de caractères de clé pour mapper les codes clés Linux aux codes de touche Android et pour spécifier le type de périphérique de clavier (généralement SPECIAL_FUNCTION).

Syntaxe

Un fichier de mappage de touches virtuelles est un fichier au format texte brut composé d'une séquence de descriptions de mise en page de touches virtuelles, séparées par des lignes ou des deux-points.

Les lignes de commentaire commencent par le signe "#" et continuer 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 clé virtuelle.
  • <centerY> : coordonnées 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 fonction du système de coordonnées de l'écran.

Voici un fichier de mappage de clés virtuelle é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 clés 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. En conséquence, tous les clés virtuelles ont un <centerY> la coordonnée 835, qui est légèrement inférieure la zone visible de l'écran tactile.

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

Exemple

Fichier de mappage de clés 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 des touches: /system/usr/keylayout/touchyfeely.kl.

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

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

type SPECIAL_FUNCTION

Gestes indirects du pointeur multipoint

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

  • Appuyer avec un seul doigt: cliquer.
  • Geste à un doigt : déplacez le curseur.
  • Mouvements avec un seul doigt et appuis sur un bouton: faites glisser le pointeur.
  • Déplacez deux doigts dans la même direction que les deux doigts: faites glisser la zone située sous le pointeur dans cette direction. Le pointeur lui-même ne bouge pas.
  • Mouvement de deux doigts se rapprochant ou s'éloignant dans des directions différentes : panoramique/mise à l'échelle/rotation de la zone entourant le pointeur. Le pointeur lui-même ne se déplace pas.
  • Mouvement à plusieurs doigts: geste à forme libre.

Refus de la paume de la main

À partir d'Android 13, le système peut rejeter automatiquement les entrées de la paume de la main. lorsque le framework intégré est activé. Les solutions internes personnalisées sont toujours prises en charge, mais elles peuvent devoir être modifiées pour renvoyer l'indicateur TOOL_TYPE_PALM lorsqu'une paume de la main est détectée. Le framework intégré fonctionne également avec des solutions personnalisées.

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

Si un pointeur a déjà été envoyé aux applications, le système:

  • (S'il existe d'autres pointeurs actifs) Annule le pointeur avec ACTION_POINTER_UP et FLAG_CANCELED définis.
  • (S'il s'agit du seul pointeur) Annule le pointeur avec ACTION_CANCEL.

Une API publique, MotionEvent.FLAG_CANCELED, indique que la version actuelle ne doit pas déclencher d'action de l'utilisateur. Cette option est définie pour ACTION_CANCEL et ACTION_POINTER_UP.

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

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 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. Toutefois, si votre appareil 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é pendant 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 la présence de rejets de paume de la main à l'intérieur UnwantedInteractionBlocker Si ce n'est pas le cas, vérifiez les journaux d'entrée 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 init**rc :

    setprop persist.device_config.input_native_boot.palm_rejection_enabled 1

Complément d'informations