Die Intuition
Jede Touch-Geste in Compose beginnt auf dieselbe Weise: ein
Modifier.pointerInput-Block und eine Suspend-Funktion, die man ihm übergibt.
Was sich ändert, ist die Funktion selbst, denn jede ist eine eigens dafür gebaute
Schleife über denselben rohen Pointer-Event-Stream, zugeschnitten auf eine
bestimmte Art von Geste.
Wählt man die falsche aus, kämpft man entweder gegen die API an (rohe Offsets selbst parsen, um einen Tap zu erkennen) oder bekommt Daten geliefert, die man gar nicht angefordert hat (Rotationswerte für eine Geste, die nur ein Drag ist).
detectTapGesturesfür einen einzelnen Punkt, der sich nicht bewegt: Tap, Doppel-Tap, Long-Press.detectDragGestures(und seine horizontalen/vertikalen Geschwister) für einen einzelnen Punkt, der sich bewegt, jeweils in eine Richtung.detectTransformGesturesfür zwei oder mehr Finger gleichzeitig: Pinch, Pan, Rotation.
Tap, Doppel-Tap, Long-Press: detectTapGestures
Modifier.pointerInput(Unit) {
detectTapGestures(
onTap = { /* einzelner Tap */ },
onDoubleTap = { /* zweiter Tap innerhalb des Doppel-Tap-Zeitfensters */ },
onLongPress = { /* über den Long-Press-Schwellenwert hinaus gehalten */ },
onPress = { /* feuert bei jedem Press-Down, bevor Compose weiß,
zu welcher Geste sich das auflösen wird */ }
)
}onPress ist ein PressGestureScope-Lambda, es erhält also awaitRelease()
und tryAwaitRelease(), eine Release-Erkennung, ohne die anderen Callbacks zu
blockieren, nützlich für Press-and-Hold-artiges Feedback.
Nur die Callbacks, die man übergibt, werden auch verdrahtet. Übergibt man nur
onTap, wartet Compose die Doppel-Tap-Zeitspanne gar nicht erst ab, sodass ein
einzelner Tap sofort aufgelöst wird, statt abzuwarten, ob ein zweiter Tap folgt.
Greife hierzu statt zu Modifier.clickable, wenn man etwas braucht, das es
nicht bietet: Doppel-Tap-zum-Liken, ein Long-Press-Kontextmenü, eine
Press-State-Skalierung oder Farbänderung, die man selbst steuert.
Nicht auf clickable aufsetzen
Fügt man detectTapGestures einem Node hinzu, der bereits
Modifier.clickable/combinedClickable besitzt, installiert man zwei
konkurrierende Gestendetektoren auf demselben Pointer-Stream, und man verliert
den Ripple sowie die Accessibility-Semantik, die clickable kostenlos liefert.
Entscheide dich für eins davon.
Drag auf einer Achse: detectDragGestures und sein horizontales/vertikales Pendant
Modifier.pointerInput(Unit) {
detectDragGestures(
onDragStart = { offset -> /* Finger hat sich über den Touch-Slop hinaus bewegt */ },
onDrag = { change, dragAmount -> change.consume() /* dragAmount: Offset, beide Achsen */ },
onDragEnd = { /* Finger angehoben */ },
onDragCancel = { /* Geste unterbrochen, z. B. weil ein anderer Pointer übernommen hat */ }
)
}onDrag liefert ein PointerInputChange plus ein dragAmount: Offset, das
Delta seit dem letzten Event, nicht die gesamte Drag-Distanz. change.consume()
muss man selbst aufrufen; detectDragGestures beansprucht die Geste nicht von
sich aus.
Ein nicht konsumiertes Drag sickert zum Parent durch
Lässt man change.consume() aus, fühlt sich die Geste nicht nur träge an. Ein
scrollable/verticalScroll weiter oben im Baum erfährt nie, dass der Pointer
bereits beansprucht wurde, und scrollt gleichzeitig mit dem eigenen Drag.
detectHorizontalDragGestures und detectVerticalDragGestures haben dieselbe
Form, minus einer Dimension: onHorizontalDrag/onVerticalDrag liefern ein
Float-Delta statt eines Offset, und nur die
dieser einen Achse muss überschritten werden, um die Geste zu starten. Greife
hierzu statt zur zweiachsigen Variante, wann immer die Geste wirklich nur in
eine Richtung geht (eine Swipe-Zeile, ein vertikaler Slider), damit eine
diagonale Fingerbewegung die Geste nicht auf der falschen Achse gewinnt und
eine darüberliegende vertikale Liste weiterhin normal scrollen kann.
Pinch, Pan, Rotation: detectTransformGestures
Modifier.pointerInput(Unit) {
detectTransformGestures(
panZoomLock = false
) { centroid, pan, zoom, rotation ->
/* centroid: Offset, Mittelpunkt zwischen den aktiven Pointern
pan: Offset, Verschiebung seit dem letzten Event
zoom: Float, Skalierungsfaktor seit dem letzten Event (1f = unverändert)
rotation: Float, Grad seit dem letzten Event */
}
}
ist der Grund, warum detectTransformGestures einen einzigen Callback statt
vier entgegennimmt: Pan, Zoom und Rotation sind keine separaten Gesten, sondern
drei Zahlen, die Compose bei jedem Frame aus demselben Multi-Pointer-Event
ableitet, es gibt also nichts aufzulösen, so wie zwischen einem Tap und einem
Long-Press.
panZoomLock = true tut das Gegenteil dessen, was der Name nahelegt: Es
sperrt die Rotation aus, nicht Pan oder Zoom. Welche Schwelle die Geste
zuerst überschreitet, entscheidet für den Rest der Geste über ihre Form,
überschreiten Pan/Zoom zuerst, bleibt die Rotation ab dann bei 0f. Nützlich
für einen Pinch-to-Zoom-Bildbetrachter oder eine Karte, bei denen man Pan und
Zoom will, aber nicht möchte, dass zwei kneifende Finger auch als
versehentliche Rotation gelesen werden. Ein Zuschneide-Tool, das alle drei in
einer Geste kombiniert, ist der Fall, in dem man es bei false belässt.
zoom und rotation sind Deltas, keine Summen
zoom und rotation sind die Änderung seit dem letzten Event, nicht die
laufende Gesamtsumme der Geste. Multipliziere in den eigenen Akkumulator
hinein (scale *= zoom), weise nicht zu (scale = zoom), sonst setzt sich
die Transformation bei jedem Frame zurück, statt sich zu akkumulieren.
Die Wahl zwischen ihnen
| Funktion | Pointer | Callbacks | Delta-Form |
|---|---|---|---|
detectTapGestures | 1, bleibt an Ort und Stelle | onTap, onDoubleTap, onLongPress, onPress | keine, nur Position |
detectDragGestures | 1, bewegt sich | onDragStart, onDrag, onDragEnd, onDragCancel | Offset pro Event |
detectHorizontalDragGestures / detectVerticalDragGestures | 1, bewegt sich auf einer Achse | gleiche Form, onHorizontalDrag/onVerticalDrag | Float pro Event |
detectTransformGestures | 2+ | ein onGesture-Callback | centroid, pan: Offset; zoom, rotation: Float |
Detektoren kombinieren, und das Primitive darunter
Ein einzelner Modifier.pointerInput-Block kann nur einen detect*Gestures-Aufruf
ausführen, denn jeder davon ist eine Endlosschleife (aufgebaut auf
awaitEachGesture), die nie zurückkehrt, solange der Block lebt. Schreibt man
detectTapGestures(...) gefolgt von detectDragGestures(...) im selben Block,
laufen sie nicht gegeneinander um die Wette, der zweite Aufruf ist schlicht
unerreichbarer Code. Braucht man einen Tap und ein Drag auf demselben Node,
muss man jedem einen eigenen pointerInput-Modifier geben, Compose führt beide
parallel aus, jeder beobachtet unabhängig denselben rohen Stream.
Welcher Pointer für den zweiten Detektor verfügbar bleibt, hängt vom Touch-Slop
ab und davon, welches PointerInputChange zuerst konsumiert wird, Mechanik,
die dieser Blog an anderer Stelle für sich behandelt.
Jede dieser Funktionen ist eine Schleife, formuliert in Begriffen von
awaitPointerEventScope/awaitEachGesture, dem tiefer liegenden Primitiv, das
PointerInputScope eigentlich exponiert. Man greift nur dann direkt darauf
zurück, wenn keine der vier obigen Funktionen passt, etwa eine
benutzerdefinierte mehrstufige Geste, die mitten im Stream wechseln muss,
worauf sie lauscht.
pointerInput auf das keyen, was das Lambda tatsächlich liest
Alle vier werden über Modifier.pointerInput(key) installiert. Keyt man auf
Unit, während das Lambda über Zustand schließt, der sich ändert, wird der
Block nie neu installiert und liest weiterhin den Zustand, der bei der ersten
Komposition galt. Keye auf den Zustand, den der Callback liest, oder lies
diesen Zustand stattdessen über rememberUpdatedState.



