Recomposed
Animation

animate*AsState vs Animatable : l'animation n'est qu'une valeur interpolée

Oct 10, 2026 · 7 min read

animate*AsState vs Animatable : l'animation n'est qu'une valeur interpolée

L'intuition

Quand on vient du Android basé sur les Views, ou de la plupart des toolkits UI impératifs, « animer quelque chose » ressemble à une action que l'on effectue. On prend un objet, un ObjectAnimator, un UIViewPropertyAnimator, on lui donne une durée et une cible, puis on appelle .start(). L'animation est une chose qui s'exécute sur une vue, séparément du reste de votre code, et vous devez penser à l'annuler vous-même avec .cancel() si une nouvelle animation se déclenche avant que l'ancienne ne se termine.

animate*AsState et Animatable ressemblent, vus de l'extérieur, au même genre d'API : une durée, une courbe d'accélération, une valeur cible. Le modèle mental sous-jacent est pourtant différent :

  • Il n'y a pas d'objet d'animation attaché à un composable comme un ObjectAnimator est attaché à une View. Ce qui existe, c'est une valeur, et la lecture actuelle de cette valeur à une frame donnée n'est que « l'endroit où en est actuellement l' » sur son chemin vers la dernière cible.
  • Vous n'appelez jamais vous-même .start() ni .cancel() dans le cas courant. Vous changez la cible, en modifiant un simple mutableStateOf, et l'animation remarque que la cible a bougé et se reciblele elle-même.
  • Si la cible change à nouveau en plein vol (l'utilisateur tape deux fois rapidement), rien n'a besoin d'être arrêté puis redémarré. La valeur se courbe simplement vers la nouvelle cible depuis l'endroit où elle se trouve actuellement.

Exemple concret : une valeur qui saute vs une valeur animée

// saut : expanded bascule instantanément, size bascule avec lui, aucune animation du tout
var expanded by remember { mutableStateOf(false) }
val size = if (expanded) 200.dp else 100.dp
 
Box(Modifier.size(size).background(Color.Blue))
// animé : même booléen, même expression cible, mais size est maintenant une lecture
// d'une valeur interpolée au lieu de la cible brute
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))

La seule chose qui a changé, c'est l'endroit où size est lu. expanded bascule toujours instantanément dans les deux versions, il n'existe pas de « booléen animé ». animateDpAsState se contente de s'intercaler entre cette cible et le size que vous lisez, en adoucissant ce que vous voyez à l'écran à chaque frame, sans jamais toucher à expanded.

Autres cas : Animatable est le même mécanisme, mais à la main

animate*AsState est le wrapper de confort. Animatable est la même idée avec le wrapper retiré, pour que vous puissiez voir ce qu'elle fait réellement :

var target by remember { mutableStateOf(0f) }
val offset = remember { Animatable(0f) }
 
LaunchedEffect(target) {
    // se recible automatiquement : si offset est déjà en plein vol vers une
    // ancienne cible, ceci annule cette exécution et continue depuis l'endroit
    // où offset se trouve actuellement, vers la nouvelle cible
    offset.animateTo(target, animationSpec = spring())
}
 
Row {
    Button(onClick = { target = 0f }) { Text("0f") }
    Button(onClick = { target = 120f }) { Text("120f") }
}

Cela fait, à la main, exactement ce que fait cette ligne unique pour vous :

val offset by animateFloatAsState(targetValue = target, animationSpec = spring())

Appuyez sur les deux boutons ci-dessous comme sur ceux de ce code, y compris des appuis rapides en plein vol. La courbe est la même spring() par défaut de Compose, (Spring.StiffnessMedium, Spring.DampingRatioNoBouncy), et non une courbe d'accélération générique qui en tiendrait lieu :

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

En interne, animateFloatAsState mémorise un Animatable et lance un paramétré par la cible, dont le corps est ce même appel animateTo. La raison de recourir directement à Animatable plutôt qu'au wrapper *AsState est le contrôle : animateTo est une fonction suspendue, donc vous pouvez l'await et exécuter du code une fois l'animation réellement stabilisée ; snapTo saute à une valeur sans aucune interpolation, utile pour réinitialiser un état sans animation visible ; et animateDecay permet à un lancer de continuer sous son propre élan au lieu de poursuivre une cible fixe.

Le fondamental

C'est l'animation basée sur la valeur. L'« animation » n'est qu'une valeur Animatable plus une en cours d'exécution qui continue d'écrire de nouvelles valeurs interpolées dedans, frame après frame, vers la dernière cible qui lui a été donnée, en suivant la courbe décrite par un . animate*AsState est une instance gérée de cela exactement : un Animatable mémorisé plus un LaunchedEffect qui appelle animateTo(target) chaque fois que la cible change. Il n'existe pas d'objet « lecteur » séparé situé à l'extérieur de la valeur elle-même, la valeur est l'animation.

Toute la famille animate*AsState

Chaque fonction animate*AsState typée est exactement le même wrapper Animatable + LaunchedEffect de la section précédente, simplement pré-remplie avec un TwoWayConverter pour un type spécifique, la pièce qui sait transformer ce type en un vecteur de floats et inversement, pour qu'un ressort ou un tween ait quelque chose à interpoler.

FonctionAnimeRemarques
animateFloatAsStateFloatle cas de base ; la plupart des autres ne sont que ceci avec un type enveloppé autour
animateDpAsStateDpidentique à Float, simplement enveloppé dans une unité
animateIntAsStateIntarrondit à un nombre entier à chaque frame
animateIntOffsetAsStateIntOffsetx/y en pixels entiers, par exemple Modifier.offset { }
animateIntSizeAsStateIntSizelargeur/hauteur en pixels entiers
animateOffsetAsStateOffsetx/y en float, par exemple une position glissée
animateSizeAsStateSizelargeur/hauteur en float
animateRectAsStateRectles quatre bords, animés ensemble
animateColorAsStateColorvit dans un artefact animation séparé du reste, car Color entraîne le module graphics dont animation-core évite autrement de dépendre
animateValueAsStatetout Tla forme générique sous-jacente à tout ce qui précède ; donnez-lui votre propre TwoWayConverter<T, V> et elle animera un type qu'aucune des fonctions nommées ne couvre

Il n'existe pas d'animateBooleanAsState, et ce n'est pas un oubli : un Boolean n'a rien à interpoler entre deux valeurs, c'est une valeur parmi deux sans rien au milieu. Animer « entre » true et false signifie toujours en réalité animer un autre type qui représente les deux états, un alpha Float, une Color, une taille Dp, le booléen ne décidant que vers quelle cible cette valeur doit se diriger.

Où vous auriez réellement recours à ces API

  • Retour visuel à l'appui. animateFloatAsState pilotant une scale ou une alpha à partir de interactionSource.collectIsPressedAsState(), pour qu'un bouton se compresse ou s'assombrisse visiblement dès qu'il est pressé, puis revienne en ressort au relâchement.
  • Expand/collapse. animateDpAsState sur la height d'une carte (ou un Modifier.size), basculé par le même booléen qui change le contenu, pour que le conteneur se redimensionne au lieu de sauter brutalement entre deux hauteurs.
  • Surlignage de sélection. animateColorAsState sur le background d'un élément de liste, basculé par un indicateur de sélection, pour que changer de sélection fasse un fondu de la couleur de surlignage au lieu de la faire clignoter.
  • Glisser pour rejeter. Animatable piloté directement dans Modifier.pointerInput : snapTo à chaque delta de glissement pour un suivi exact 1:1 sous le doigt, puis soit animateTo(0f) pour revenir en place, soit animateDecay pour le laisser s'envoler hors de l'écran, selon que le glissement a franchi un seuil de rejet au relâchement.
  • Progression qui n'avance pas par sauts discrets. animateFloatAsState sur la fraction d'une barre de progression, l'état sous-jacent n'étant mis à jour qu'à la granularité à laquelle le travail réel le rapporte, pour que ce soit la barre elle-même qui apporte la fluidité, et non la source de données qui doive le faire.
  • Exécuter du code seulement une fois le mouvement réellement terminé. Animatable attendu avec animateTo à l'intérieur d'une coroutine, pour que le callback de disparition d'un snackbar, ou la réactivation d'un bouton, se déclenche quand le glissement de sortie s'est visiblement terminé, et non à l'instant où l'état cible a basculé.

Ailleurs : même fondamental, framework différent

  • Flutter : exactement la même séparation existe, simplement sous d'autres noms. AnimatedContainer, AnimatedOpacity et le reste de la famille ImplicitlyAnimatedWidget fonctionnent comme animate*AsState, vous changez une propriété cible et le widget se reconstruit vers elle de lui-même. AnimationController associé à un Tween est l'équivalent d'Animatable : la même interpolation sous-jacente, avec un contrôle direct sur le démarrage, l'arrêt et la lecture de la valeur en plein vol.
  • Transitions CSS : transition: width 0.3s ease sur un élément signifie que vous n'appelez jamais rien pour « démarrer » une animation. Vous changez simplement la width (en basculant une classe, par exemple), et le navigateur interpole depuis l'ancienne valeur calculée vers la nouvelle, le même comportement de reciblage que animateDpAsState réagissant à une nouvelle targetValue.
  • SwiftUI : .animation(_:value:) est la moitié implicite, celle en forme d'animate*AsState, reliez-la à une propriété @State et chaque changement de cette propriété s'anime automatiquement. withAnimation { } enveloppant une mutation d'état explicite est la moitié en forme d'Animatable : vous animez toujours une valeur, mais en la déclenchant et en la délimitant vous-même au lieu de laisser un modifier surveiller les changements.

Où cela piège réellement les gens

Paramétrer le LaunchedEffect sur la mauvaise chose

// faux : Unit ne change jamais, donc cet effet s'exécute une fois à la
// première composition et jamais plus. offset.animateTo s'exécute exactement
// une fois, vers la cible qui se trouvait là à ce moment-là.
LaunchedEffect(Unit) {
    offset.animateTo(target)
}
// correct : paramétré sur target, donc l'effet se relance, et se recible,
// chaque fois que target change réellement
LaunchedEffect(target) {
    offset.animateTo(target)
}

Chaque changement ultérieur de target est silencieusement ignoré dans la première version, car rien ne redéclenche le bloc. Animatable ne sait pas que votre valeur a changé ; seul un LaunchedEffect paramétré sur cette valeur le sait.

Oublier remember autour de l'Animatable

// faux : un tout nouvel Animatable(0f), réinitialisé à 0f, à chaque recomposition
val offset = Animatable(0f)
// correct : la même instance survit à la recomposition, donc elle peut
// réellement terminer son animation au lieu de redémarrer à chaque fois depuis 0f
val offset = remember { Animatable(0f) }

Sans remember, la valeur ne termine jamais réellement son animation vers sa cible. Elle est sans cesse recréée depuis zéro puis redémarre, ce qui ressemble à du tremblement ou à une valeur coincée près de son point de départ.

Mélanger une lecture animée avec une lecture brute de la même cible

// incohérence : color fait un fondu, mais size saute instantanément, même si
// les deux sont censés s'animer à partir du même booléen `selected`
val color by animateColorAsState(if (selected) Color.Blue else Color.Gray)
val size = if (selected) 56.dp else 48.dp

C'est le même bug que dans le tout premier exemple de cet article, simplement réintroduit par accident une fois qu'un composable a plus d'une propriété pilotée à partir de la même cible. Le corriger passe par le même geste que cet exemple : faire aussi passer size par animateDpAsState.

Modèle mental à réellement utiliser

Vous ne dites pas à Compose de jouer une animation ; vous lui remettez une nouvelle valeur cible, et l'Animatable sous-jacent continue de s'interpoler vers la dernière cible que vous lui avez remise.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail