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
ObjectAnimatorest attaché à uneView. 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 simplemutableStateOf, 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.
| Fonction | Anime | Remarques |
|---|---|---|
animateFloatAsState | Float | le cas de base ; la plupart des autres ne sont que ceci avec un type enveloppé autour |
animateDpAsState | Dp | identique à Float, simplement enveloppé dans une unité |
animateIntAsState | Int | arrondit à un nombre entier à chaque frame |
animateIntOffsetAsState | IntOffset | x/y en pixels entiers, par exemple Modifier.offset { } |
animateIntSizeAsState | IntSize | largeur/hauteur en pixels entiers |
animateOffsetAsState | Offset | x/y en float, par exemple une position glissée |
animateSizeAsState | Size | largeur/hauteur en float |
animateRectAsState | Rect | les quatre bords, animés ensemble |
animateColorAsState | Color | vit dans un artefact animation séparé du reste, car Color entraîne le module graphics dont animation-core évite autrement de dépendre |
animateValueAsState | tout T | la 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.
animateFloatAsStatepilotant unescaleou unealphaà partir deinteractionSource.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.
animateDpAsStatesur laheightd'une carte (ou unModifier.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.
animateColorAsStatesur lebackgroundd'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.
Animatablepiloté directement dansModifier.pointerInput:snapToà chaque delta de glissement pour un suivi exact 1:1 sous le doigt, puis soitanimateTo(0f)pour revenir en place, soitanimateDecaypour 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.
animateFloatAsStatesur 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é.
Animatableattendu avecanimateToà 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,AnimatedOpacityet le reste de la familleImplicitlyAnimatedWidgetfonctionnent commeanimate*AsState, vous changez une propriété cible et le widget se reconstruit vers elle de lui-même.AnimationControllerassocié à unTweenest 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 easesur un élément signifie que vous n'appelez jamais rien pour « démarrer » une animation. Vous changez simplement lawidth(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 queanimateDpAsStateréagissant à une nouvelletargetValue. - SwiftUI :
.animation(_:value:)est la moitié implicite, celle en forme d'animate*AsState, reliez-la à une propriété@Stateet 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.dpC'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.



