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).
detectTapGesturespour 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.detectTransformGesturespour 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
| Fonction | Pointeurs | Callbacks | Forme du delta |
|---|---|---|---|
detectTapGestures | 1, immobile | onTap, onDoubleTap, onLongPress, onPress | aucune, position seulement |
detectDragGestures | 1, se déplace | onDragStart, onDrag, onDragEnd, onDragCancel | Offset par événement |
detectHorizontalDragGestures / detectVerticalDragGestures | 1, se déplace sur un axe | même forme, onHorizontalDrag/onVerticalDrag | Float par événement |
detectTransformGestures | 2+ | un callback onGesture | centroid, 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.



