Recomposed
Gesture

Détection tactile dans Compose : gestes de tap, de glissement et de transformation

Oct 26, 2026 · 4 min read

Détection tactile dans Compose : gestes de tap, de glissement et de transformation

L'intuition

Chaque geste tactile dans Compose commence de la même façon : un bloc Modifier.pointerInput et une fonction suspendue que vous lui confiez. Ce qui change, c'est la fonction choisie, car chacune est une boucle conçue sur mesure autour du même flux brut d'événements de pointeur, adaptée à un seul type de geste.

Choisissez la mauvaise et vous finissez soit à lutter contre l'API (analyser vous-même des décalages bruts pour détecter un tap), soit à recevoir des données que vous n'avez pas demandées (des valeurs de rotation pour un geste qui n'est qu'un simple glissement).

  • detectTapGestures pour un point unique qui ne se déplace pas : tap, double-tap, appui long.
  • detectDragGestures (et ses variantes horizontale/verticale) pour un point unique qui se déplace, dans une seule direction à la fois.
  • detectTransformGestures pour deux doigts ou plus simultanément : pincer, déplacer, faire pivoter.

Tap, double-tap, appui long : detectTapGestures

Modifier.pointerInput(Unit) {
    detectTapGestures(
        onTap = { /* tap simple */ },
        onDoubleTap = { /* second tap dans la fenêtre du double-tap */ },
        onLongPress = { /* maintenu au-delà du seuil d'appui long */ },
        onPress = { /* se déclenche à chaque appui, avant que Compose sache
                       à quel geste cela va se résoudre */ }
    )
}

onPress est une lambda PressGestureScope, elle dispose donc de awaitRelease() et tryAwaitRelease(), une détection du relâchement sans bloquer les autres callbacks, utile pour un retour visuel du type appui-maintien.

Seuls les callbacks que vous passez sont câblés. Ne passer que onTap signifie que Compose ne prend jamais la peine d'attendre la fenêtre de double-tap, si bien qu'un tap isolé se résout immédiatement au lieu d'attendre de voir si un second tap suit.

Préférez cette fonction à Modifier.clickable quand vous avez besoin de quelque chose qu'elle n'expose pas : double-tap pour aimer, menu contextuel sur appui long, un changement d'échelle ou de couleur à l'état d'appui que vous contrôlez vous-même.

Ne superposez pas ceci à clickable

Ajouter detectTapGestures sur un nœud qui a déjà Modifier.clickable/combinedClickable installe deux détecteurs de gestes concurrents sur le même flux de pointeur, et vous perdez le ripple ainsi que la sémantique d'accessibilité que clickable vous offre gratuitement. Choisissez l'un ou l'autre.

Glissement à axe unique : detectDragGestures et son duo horizontal/vertical

Modifier.pointerInput(Unit) {
    detectDragGestures(
        onDragStart = { offset -> /* le doigt a dépassé le slop tactile */ },
        onDrag = { change, dragAmount -> change.consume() /* dragAmount : Offset, les deux axes */ },
        onDragEnd = { /* doigt relevé */ },
        onDragCancel = { /* geste interrompu, par ex. un autre pointeur a pris le relais */ }
    )
}

onDrag vous fournit un PointerInputChange plus un dragAmount: Offset, le delta depuis le dernier événement, pas la distance totale du glissement. C'est à vous d'appeler change.consume() ; detectDragGestures ne réclamera pas le geste pour vous.

Un glissement non consommé fuit vers le parent

Omettre change.consume() ne fait pas que rendre le geste poussif. Un scrollable/verticalScroll parent plus haut dans l'arbre n'apprend jamais que le pointeur était déjà réclamé, et défile en même temps que votre glissement.

detectHorizontalDragGestures et detectVerticalDragGestures ont la même forme, moins une dimension : onHorizontalDrag/onVerticalDrag vous fournissent un delta Float au lieu d'un Offset, et seul le de cet axe doit être franchi pour démarrer le geste. Préférez-les à la version à deux axes chaque fois que le geste est véritablement unidirectionnel (une rangée que l'on fait glisser, un curseur vertical), pour qu'un mouvement de doigt en diagonale ne remporte pas le geste sur le mauvais axe, et pour qu'une liste verticale au-dessus puisse quand même défiler normalement.

Pincer, déplacer, faire pivoter : detectTransformGestures

Modifier.pointerInput(Unit) {
    detectTransformGestures(
        panZoomLock = false
    ) { centroid, pan, zoom, rotation ->
        /* centroid : Offset, point médian entre les pointeurs actifs
           pan : Offset, translation depuis le dernier événement
           zoom : Float, facteur d'échelle depuis le dernier événement (1f = inchangé)
           rotation : Float, degrés depuis le dernier événement */
    }
}

Le explique pourquoi detectTransformGestures prend un seul callback au lieu de quatre : déplacement, zoom et rotation ne sont pas des gestes séparés, ce sont trois nombres que Compose dérive du même événement multi-pointeur à chaque frame, il n'y a donc rien à résoudre comme c'est le cas entre un tap et un appui long.

panZoomLock = true fait l'inverse de ce que son nom suggère : il verrouille la rotation, pas le déplacement ni le zoom. Le premier seuil que le geste franchit décide de sa forme pour le reste du geste ; déplacement/zoom en premier signifie que la rotation reste à 0f à partir de là. Utile pour une visionneuse d'images ou une carte en pincer-pour-zoomer, où vous voulez le déplacement et le zoom mais pas que deux doigts en train de pincer soient aussi lus comme une rotation accidentelle. Un outil de recadrage qui combine les trois dans un seul geste est le cas où il faut le laisser à false.

zoom et rotation sont des deltas, pas des totaux

zoom et rotation sont le changement depuis le dernier événement, pas le total cumulé du geste. Multipliez dans votre propre accumulateur (scale *= zoom), n'assignez pas (scale = zoom), sinon votre transformation se réinitialise à chaque frame au lieu de s'accumuler.

Choisir entre elles

FonctionPointeursCallbacksForme du delta
detectTapGestures1, immobileonTap, onDoubleTap, onLongPress, onPressaucune, position seulement
detectDragGestures1, se déplaceonDragStart, onDrag, onDragEnd, onDragCancelOffset par événement
detectHorizontalDragGestures / detectVerticalDragGestures1, se déplace sur un axemême forme, onHorizontalDrag/onVerticalDragFloat par événement
detectTransformGestures2+un callback onGesturecentroid, pan : Offset; zoom, rotation : Float

Combiner des détecteurs, et le primitif sous-jacent

Un seul bloc Modifier.pointerInput ne peut exécuter qu'un seul appel detect*Gestures, car chacun est une boucle infinie (construite sur awaitEachGesture) qui ne retourne jamais tant que le bloc est actif. Écrire detectTapGestures(...) suivi de detectDragGestures(...) dans le même bloc ne les fait pas s'exécuter en parallèle, le second appel est simplement du code inatteignable. Avoir besoin d'un tap et d'un glissement sur le même nœud signifie donner à chacun son propre modificateur pointerInput, Compose les exécute alors en parallèle, chacun surveillant indépendamment le même flux brut.

Quel pointeur reste disponible pour le second détecteur dépend du slop tactile et de quel PointerInputChange est consommé en premier, des mécaniques que ce blog traite séparément.

Chacune de ces fonctions est une boucle écrite en termes de awaitPointerEventScope/awaitEachGesture, le primitif de plus bas niveau que PointerInputScope expose réellement. Vous ne descendez directement à ce niveau que lorsqu'aucune des quatre fonctions ci-dessus ne convient, un geste personnalisé multi-étapes, par exemple, qui doit changer ce qu'il écoute en cours de flux.

Calez la clé de pointerInput sur ce que la lambda lit réellement

Les quatre sont installées via Modifier.pointerInput(key). La caler sur Unit alors que la lambda capture un état qui change fait que le bloc ne se réinstalle jamais, et il continue donc de lire la valeur que cet état avait à la première composition. Calez-la plutôt sur l'état lu par le callback, ou lisez cet état via rememberUpdatedState.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail