Die Intuition
Wer von View-basiertem Android kommt, oder von den meisten imperativen
UI-Toolkits, empfindet „etwas animieren" als eine Aktion, die man ausführt.
Man nimmt sich ein Objekt, einen ObjectAnimator, einen
UIViewPropertyAnimator, gibt ihm eine Dauer und ein Ziel und ruft
.start() auf. Die Animation ist ein Ding, das auf einer View läuft,
getrennt vom Rest des Codes, und man muss selbst daran denken, sie mit
.cancel() zu stoppen, falls eine neue startet, bevor die alte fertig ist.
animate*AsState und Animatable
wirken von außen wie dieselbe Art von API: eine Dauer, eine Easing-Kurve,
ein Zielwert. Das zugrunde liegende mentale Modell ist jedoch ein anderes:
- Es gibt kein Animationsobjekt, das an einem Composable hängt, so wie ein
ObjectAnimatoran einerViewhängt. Was existiert, ist ein Wert, und der aktuelle Stand dieses Werts in einem beliebigen Frame ist einfach „wo die gerade steht" auf dem Weg zum aktuellsten Ziel. - Man ruft im üblichen Fall niemals selbst
.start()oder.cancel()auf. Man ändert das Ziel, indem man einen einfachenmutableStateOfändert, und die Animation merkt, dass sich das Ziel verschoben hat, und richtet sich selbst neu aus. - Ändert sich das Ziel erneut mitten im Flug (der Nutzer tippt zweimal schnell), muss nichts gestoppt und neu gestartet werden. Der Wert biegt einfach von dort, wo er gerade steht, zum neuen Ziel ab.
Konkretes Beispiel: ein Wert, der springt, vs. ein Wert, der animiert wird
// jump: expanded flips instantly, size flips with it, no animation at all
var expanded by remember { mutableStateOf(false) }
val size = if (expanded) 200.dp else 100.dp
Box(Modifier.size(size).background(Color.Blue))// animated: same boolean, same target expression, but size is now a read
// of an interpolated value instead of the raw target
var expanded by remember { mutableStateOf(false) }
val size by animateDpAsState(targetValue = if (expanded) 200.dp else 100.dp)
Box(Modifier.size(size).background(Color.Blue))Das Einzige, was sich geändert hat, ist, woher size gelesen wird.
expanded springt in beiden Versionen weiterhin sofort um, so etwas wie
einen „animierten Boolean" gibt es nicht. animateDpAsState sitzt
einfach zwischen diesem Ziel und dem size, das gelesen wird, und glättet
das, was pro Frame auf dem Bildschirm zu sehen ist, ganz ohne expanded
selbst zu berühren.
Weitere Fälle: Animatable ist derselbe Mechanismus, von Hand
animate*AsState ist der bequeme Wrapper. Animatable ist dieselbe Idee
mit abgeschältem Wrapper, sodass man sieht, was dabei tatsächlich passiert:
var target by remember { mutableStateOf(0f) }
val offset = remember { Animatable(0f) }
LaunchedEffect(target) {
// retargets automatically: if offset is already mid-flight toward an
// older target, this cancels that run and continues from wherever
// offset currently sits, toward the new target
offset.animateTo(target, animationSpec = spring())
}
Row {
Button(onClick = { target = 0f }) { Text("0f") }
Button(onClick = { target = 120f }) { Text("120f") }
}Das tut, von Hand, genau das, was dieser Einzeiler für einen übernimmt:
val offset by animateFloatAsState(targetValue = target, animationSpec = spring())Tippe die beiden Buttons unten so, wie die im Code, auch schnell und
mitten im Flug. Die Kurve ist dieselbe
spring(), auf die Compose standardmäßig setzt (Spring.StiffnessMedium,
Spring.DampingRatioNoBouncy), keine generische Easing-Kurve als Ersatz
dafür:
offset.value = 0.0f — animating toward target 0
tap the other button mid-flight: the curve bends toward the new target instead of resetting to zero
Intern merkt sich animateFloatAsState ein Animatable und startet einen
,
der auf das Ziel geschlüsselt ist und dessen Body genau derselbe
animateTo-Aufruf ist. Der Grund, direkt zu Animatable zu greifen statt
zum *AsState-Wrapper, ist Kontrolle: animateTo ist eine
Suspend-Funktion, man kann sie also awaiten und Code ausführen, nachdem
die Animation tatsächlich zur Ruhe gekommen ist; snapTo springt ohne
jede Interpolation zu einem Wert, nützlich, um Zustand zurückzusetzen ohne
sichtbare Animation; und animateDecay lässt einen Fling unter seinem
eigenen Schwung weiterlaufen, statt einem festen Ziel nachzujagen.
Das Grundprinzip
Das ist wertbasierte Animation. Die „Animation" ist nichts weiter als
ein Animatable-Wert plus eine laufende
,
die Frame für Frame immer neue interpolierte Werte hineinschreibt, auf das
zuletzt übergebene Ziel zu, entlang der Kurve, die von einem
beschrieben wird.
animate*AsState ist eine verwaltete Instanz genau davon: ein gemerktes
Animatable plus ein LaunchedEffect, das animateTo(target) aufruft,
jedes Mal wenn sich das Ziel ändert. Es gibt kein separates „Player"-Objekt,
das außerhalb des Werts selbst sitzt, der Wert ist die Animation.
Die gesamte animate*AsState-Familie
Jede typisierte animate*AsState-Funktion ist genau derselbe Animatable
LaunchedEffect-Wrapper aus dem letzten Abschnitt, nur vorausgefüllt mit einemTwoWayConverterfür einen bestimmten Typ, dem Teil, der weiß, wie man diesen Typ in einen Vektor von Floats verwandelt und zurück, damit ein Spring oder Tween überhaupt etwas zum Interpolieren hat.
| Funktion | Animiert | Hinweise |
|---|---|---|
animateFloatAsState | Float | der Grundfall; die meisten anderen sind das mit einem Typ darum gewickelt |
animateDpAsState | Dp | wie Float, nur mit Einheit umhüllt |
animateIntAsState | Int | rundet jeden Frame auf eine ganze Zahl |
animateIntOffsetAsState | IntOffset | x/y in ganzen Pixeln, z. B. Modifier.offset { } |
animateIntSizeAsState | IntSize | Breite/Höhe in ganzen Pixeln |
animateOffsetAsState | Offset | x/y als Float, z. B. eine gezogene Position |
animateSizeAsState | Size | Breite/Höhe als Float |
animateRectAsState | Rect | alle vier Kanten, gemeinsam animiert |
animateColorAsState | Color | liegt in einem eigenen animation-Artefakt, getrennt vom Rest, da Color das Grafikmodul mitzieht, von dem animation-core sonst keine Abhängigkeit hat |
animateValueAsState | beliebiges T | die generische Form hinter allem oben; übergib deinen eigenen TwoWayConverter<T, V>, und sie animiert einen Typ, den keine der benannten Funktionen abdeckt |
Es gibt kein animateBooleanAsState, und das ist kein Versehen: Ein
Boolean hat nichts, zwischen dem interpoliert werden könnte, er ist
einer von zwei Werten ohne irgendetwas dazwischen. „Zwischen" true und
false zu animieren bedeutet immer eigentlich, einen anderen Typ zu
animieren, der die beiden Zustände repräsentiert, einen Float-Alphawert,
eine Color, eine Dp-Größe, wobei der Boolean nur entscheidet, auf
welches Ziel dieser Wert zusteuern soll.
Wo man das tatsächlich einsetzen würde
- Press-Feedback.
animateFloatAsState, dasscaleoderalphaanhand voninteractionSource.collectIsPressedAsState()steuert, sodass ein Button sich im Moment des Drückens sichtbar zusammenzieht oder abdunkelt und beim Loslassen wieder zurückfedert. - Expand/Collapse.
animateDpAsStateauf derheighteiner Karte (oder einemModifier.size), umgeschaltet von demselben Boolean, der auch den Inhalt wechselt, sodass sich der Container in der Größe anpasst, statt zwischen zwei Höhen hin- und herzuspringen. - Auswahl-Hervorhebung.
animateColorAsStateauf dembackgroundeines Listenelements, umgeschaltet von einem Selected-Flag, sodass ein Wechsel der Auswahl die Hervorhebungsfarbe überblendet, statt sie ein- und auszublitzen. - Drag-to-Dismiss.
Animatable, direkt inModifier.pointerInputgesteuert:snapTobei jedem Drag-Delta für exaktes 1:1-Tracking unter dem Finger, dann entwederanimateTo(0f), um zurückzuschnappen, oderanimateDecay, um es vom Bildschirm fliegen zu lassen, je danach, ob der Drag beim Loslassen eine Dismiss-Schwelle überschritten hat. - Fortschritt, der nicht in diskreten Sprüngen tickt.
animateFloatAsStateauf dem Bruchteil einer Fortschrittsanzeige, wobei der zugrunde liegende State nur in der Granularität aktualisiert wird, in der die eigentliche Arbeit berichtet, sodass die Leiste selbst für die Geschmeidigkeit sorgt, statt dass die Datenquelle das leisten muss. - Code erst ausführen, wenn die Bewegung tatsächlich fertig ist.
Animatable, mitanimateToin einer Coroutine erwartet, sodass der Dismiss-Callback einer Snackbar, oder das erneute Aktivieren eines Buttons, genau dann feuert, wenn das Herausgleiten sichtbar abgeschlossen ist, nicht in dem Moment, in dem sich der Zielzustand umgedreht hat.
Anderswo: dasselbe Grundprinzip, anderes Framework
- Flutter: Genau dieselbe Aufteilung existiert, nur unter anderen
Namen.
AnimatedContainer,AnimatedOpacityund der Rest derImplicitlyAnimatedWidget-Familie funktionieren wieanimate*AsState, man ändert eine Zieleigenschaft, und das Widget baut sich von selbst darauf zu neu auf.AnimationControllerzusammen mit einemTweenist das Äquivalent zuAnimatable: dieselbe zugrunde liegende Interpolation, mit direkter Kontrolle über Start, Stopp und das Lesen des Werts mitten im Flug. - CSS-Transitions:
transition: width 0.3s easeauf einem Element bedeutet, dass man nie etwas aufruft, um eine Animation zu „starten". Man ändert einfach diewidth(etwa durch Umschalten einer Klasse), und der Browser interpoliert vom alten berechneten Wert zum neuen, dasselbe Retargeting-Verhalten wie beianimateDpAsState, das auf einen neuentargetValuereagiert. - SwiftUI:
.animation(_:value:)ist die implizite,animate*AsState- förmige Hälfte, man verdrahtet sie mit einer@State-Eigenschaft, und jede Änderung dieser Eigenschaft animiert automatisch.withAnimation { }um eine explizite State-Mutation gewickelt ist dieAnimatable-förmige Hälfte: Man animiert immer noch einen Wert, löst und begrenzt ihn aber selbst, statt einen Modifier auf Änderungen achten zu lassen.
Wo das tatsächlich zu Fehlern führt
Den LaunchedEffect auf das Falsche schlüsseln
// wrong: Unit never changes, so this effect runs once on first
// composition and never again. offset.animateTo runs exactly once,
// toward whatever target happened to be at that moment.
LaunchedEffect(Unit) {
offset.animateTo(target)
}// right: keyed on target, so the effect relaunches, and retargets,
// every time target actually changes
LaunchedEffect(target) {
offset.animateTo(target)
}Jede spätere Änderung von target wird in der ersten Version stillschweigend
ignoriert, weil nichts den Block erneut auslöst. Animatable weiß nicht,
dass sich der Wert geändert hat; nur ein auf diesen Wert geschlüsselter
LaunchedEffect weiß das.
Das remember um das Animatable vergessen
// wrong: a brand-new Animatable(0f), reset to 0f, on every recomposition
val offset = Animatable(0f)// right: the same instance survives recomposition, so it can actually
// finish animating instead of restarting from 0f each time
val offset = remember { Animatable(0f) }Ohne remember schafft es der Wert nie, tatsächlich bis zu seinem Ziel zu
animieren. Er wird ständig von Grund auf neu erstellt und startet erneut,
was wie Jitter aussieht oder wie ein Wert, der nahe seinem Startpunkt
feststeckt.
Einen animierten Read mit einem rohen Read desselben Ziels mischen
// mismatch: color crossfades, but size jumps instantly, even though
// both are supposedly animating off the same `selected` boolean
val color by animateColorAsState(if (selected) Color.Blue else Color.Gray)
val size = if (selected) 56.dp else 48.dpDas ist derselbe Bug wie im allerersten Beispiel dieses Beitrags, nur
versehentlich wieder eingeführt, sobald ein Composable mehr als eine
Eigenschaft hat, die von demselben Ziel abhängt. Das zu beheben ist derselbe
Schritt wie in jenem Beispiel: size ebenfalls durch animateDpAsState
laufen lassen.
Das mentale Modell, das man tatsächlich nutzen sollte
Man sagt Compose nicht, eine Animation abzuspielen; man übergibt ihm
einen neuen Zielwert, und das Animatable darunter interpoliert
weiterhin auf das zuletzt übergebene Ziel zu.



