Recomposed
Animation

animate*AsState vs Animatable: Animation ist nur ein interpolierter Wert

Oct 10, 2026 · 7 min read

animate*AsState vs Animatable: Animation ist nur ein interpolierter Wert

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 ObjectAnimator an einer View hä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 einfachen mutableStateOf ä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 einem TwoWayConverter fü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.
FunktionAnimiertHinweise
animateFloatAsStateFloatder Grundfall; die meisten anderen sind das mit einem Typ darum gewickelt
animateDpAsStateDpwie Float, nur mit Einheit umhüllt
animateIntAsStateIntrundet jeden Frame auf eine ganze Zahl
animateIntOffsetAsStateIntOffsetx/y in ganzen Pixeln, z. B. Modifier.offset { }
animateIntSizeAsStateIntSizeBreite/Höhe in ganzen Pixeln
animateOffsetAsStateOffsetx/y als Float, z. B. eine gezogene Position
animateSizeAsStateSizeBreite/Höhe als Float
animateRectAsStateRectalle vier Kanten, gemeinsam animiert
animateColorAsStateColorliegt in einem eigenen animation-Artefakt, getrennt vom Rest, da Color das Grafikmodul mitzieht, von dem animation-core sonst keine Abhängigkeit hat
animateValueAsStatebeliebiges Tdie 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, das scale oder alpha anhand von interactionSource.collectIsPressedAsState() steuert, sodass ein Button sich im Moment des Drückens sichtbar zusammenzieht oder abdunkelt und beim Loslassen wieder zurückfedert.
  • Expand/Collapse. animateDpAsState auf der height einer Karte (oder einem Modifier.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. animateColorAsState auf dem background eines Listenelements, umgeschaltet von einem Selected-Flag, sodass ein Wechsel der Auswahl die Hervorhebungsfarbe überblendet, statt sie ein- und auszublitzen.
  • Drag-to-Dismiss. Animatable, direkt in Modifier.pointerInput gesteuert: snapTo bei jedem Drag-Delta für exaktes 1:1-Tracking unter dem Finger, dann entweder animateTo(0f), um zurückzuschnappen, oder animateDecay, 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. animateFloatAsState auf 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, mit animateTo in 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, AnimatedOpacity und der Rest der ImplicitlyAnimatedWidget-Familie funktionieren wie animate*AsState, man ändert eine Zieleigenschaft, und das Widget baut sich von selbst darauf zu neu auf. AnimationController zusammen mit einem Tween ist das Äquivalent zu Animatable: dieselbe zugrunde liegende Interpolation, mit direkter Kontrolle über Start, Stopp und das Lesen des Werts mitten im Flug.
  • CSS-Transitions: transition: width 0.3s ease auf einem Element bedeutet, dass man nie etwas aufruft, um eine Animation zu „starten". Man ändert einfach die width (etwa durch Umschalten einer Klasse), und der Browser interpoliert vom alten berechneten Wert zum neuen, dasselbe Retargeting-Verhalten wie bei animateDpAsState, das auf einen neuen targetValue reagiert.
  • 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 die Animatable-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.dp

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

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach