Guide rapide sur les animations dans Compose

Compose dispose de nombreux mécanismes d'animation intégrés, et il peut être difficile de savoir lequel choisir. Vous trouverez ci-dessous une liste de cas d'utilisation courants des animations. Pour en savoir plus sur l'ensemble des différentes options d'API disponibles, consultez la documentation complète sur l'animation Compose.

Animer des propriétés composables courantes

Compose fournit des API pratiques qui vous permettent de résoudre de nombreux cas d'utilisation courants d'animation. Cette section explique comment animer des éléments courants d'un composable.

Animer l'apparition/la disparition

Figure 1. Animer l'apparition et la disparition d'un élément dans une colonne

Utilisez AnimatedVisibility pour masquer ou afficher un composable. Enfants à l'intérieur AnimatedVisibility peut utiliser Modifier.animateEnterExit() pour sa propre entrée ou quitter la transition.

var visible by remember {
    mutableStateOf(true)
}
// Animated visibility will eventually remove the item from the composition once the animation has finished.
AnimatedVisibility(visible) {
    // your composable here
    // ...
}
AnimationQuickGuide.kt

Les paramètres d'entrée et de sortie de AnimatedVisibility vous permettent de configurer le comportement d'un composable lorsqu'il apparaît et disparaît. Lire l'intégralité du dans la documentation.

Une autre option pour animer la visibilité d'un composable consiste à animer le alpha au fil du temps à l'aide de animateFloatAsState:

var visible by remember {
    mutableStateOf(true)
}
val animatedAlpha by animateFloatAsState(
    targetValue = if (visible) 1.0f else 0f,
    label = "alpha"
)
Box(
    modifier = Modifier
        .size(200.dp)
        .graphicsLayer {
            alpha = animatedAlpha
        }
        .clip(RoundedCornerShape(8.dp))
        .background(colorGreen)
        .align(Alignment.TopCenter)
) {
}
AnimationQuickGuide.kt

Toutefois, modifier l'alpha présente l'inconvénient que le composable reste dans la composition et continue d'occuper l'espace dans lequel il est mis en page. Ce peut amener les lecteurs d'écran et d'autres mécanismes d'accessibilité à prendre en compte l'élément à l'écran. En revanche, AnimatedVisibility finit par supprimer l'élément de la composition.

Figure 2. Animer la version alpha d'un composable

Animer la couleur de l'arrière-plan

Figure 3. Animer la couleur d'arrière-plan d'un composable

val animatedColor by animateColorAsState(
    if (animateBackgroundColor) colorGreen else colorBlue,
    label = "color"
)
Column(
    modifier = Modifier.drawBehind {
        drawRect(animatedColor)
    }
) {
    // your composable here
}
AnimationQuickGuide.kt

Cette option est plus performante que Modifier.background(). Modifier.background() est acceptable pour un paramètre de couleur ponctuel, mais lors de l'animation d'une couleur au fil du temps, cela peut entraîner plus de recompositions que nécessaire.

Pour animer indéfiniment la couleur d'arrière-plan, consultez la section Répéter une animation. .

Animer la taille d'un composable

Figure 4. Composable animé de manière fluide entre une petite et une grande taille

Compose vous permet d'animer la taille des composables de différentes manières. Utilisez animateContentSize() pour les animations entre les changements de taille des composables

Par exemple, si l'une de vos zones de texte contient du texte plusieurs lignes, vous pouvez utiliser Modifier.animateContentSize() pour obtenir un rendu plus transition:

var expanded by remember { mutableStateOf(false) }
Box(
    modifier = Modifier
        .background(colorBlue)
        .animateContentSize()
        .height(if (expanded) 400.dp else 200.dp)
        .fillMaxWidth()
        .clickable(
            interactionSource = remember { MutableInteractionSource() },
            indication = null
        ) {
            expanded = !expanded
        }

) {
}
AnimationQuickGuide.kt

Remarque :Dans ce cas, l'ordre des modificateurs est important. Veillez à le placer avant tout modificateur de taille.

Vous pouvez également utiliser AnimatedContent, avec un SizeTransform pour décrire des changements de taille.

Animer la position du composable

Figure 5 : Composable se déplaçant d'un décalage

Pour animer la position d'un composable, utilisez Modifier.offset{ } avec animateIntOffsetAsState().

var moved by remember { mutableStateOf(false) }
val pxToMove = with(LocalDensity.current) {
    100.dp.toPx().roundToInt()
}
val offset by animateIntOffsetAsState(
    targetValue = if (moved) {
        IntOffset(pxToMove, pxToMove)
    } else {
        IntOffset.Zero
    },
    label = "offset"
)

Box(
    modifier = Modifier
        .offset {
            offset
        }
        .background(colorBlue)
        .size(100.dp)
        .clickable(
            interactionSource = remember { MutableInteractionSource() },
            indication = null
        ) {
            moved = !moved
        }
)
AnimationQuickGuide.kt

Attention :Cela ne change pas où le parent perçoit le composable comme étant et n'affecte donc pas l'emplacement des frères et sœurs. Cela peut entraîner entre frères et sœurs qui se superposent ou se superposent. Le décalage n'influence que le la position des mises en page enfants de Modifier.offset{}.

Si vous voulez vous assurer que les composables ne sont pas dessinés sur ou sous d'autres lorsque vous animez la position ou la taille des composables, utilisez Modifier.layout{ }. Ce modificateur propage les modifications de taille et de position au parent, ce qui affecte ensuite les autres enfants.

Par exemple, si vous déplacez un Box dans un Column et que les autres enfants doivent se déplacer lorsque le Box se déplace, incluez les informations de décalage avec Modifier.layout{ } comme suit :

var toggled by remember {
    mutableStateOf(false)
}
val interactionSource = remember {
    MutableInteractionSource()
}
Column(
    modifier = Modifier
        .padding(16.dp)
        .fillMaxSize()
        .clickable(indication = null, interactionSource = interactionSource) {
            toggled = !toggled
        }
) {
    val offsetTarget = if (toggled) {
        IntOffset(150, 150)
    } else {
        IntOffset.Zero
    }
    val offset = animateIntOffsetAsState(
        targetValue = offsetTarget, label = "offset"
    )
    Box(
        modifier = Modifier
            .size(100.dp)
            .background(colorBlue)
    )
    Box(
        modifier = Modifier
            .layout { measurable, constraints ->
                val offsetValue = if (isLookingAhead) offsetTarget else offset.value
                val placeable = measurable.measure(constraints)
                layout(placeable.width + offsetValue.x, placeable.height + offsetValue.y) {
                    placeable.placeRelative(offsetValue)
                }
            }
            .size(100.dp)
            .background(colorGreen)
    )
    Box(
        modifier = Modifier
            .size(100.dp)
            .background(colorBlue)
    )
}
AnimationQuickGuide.kt

Figure 6 : Animer avec Modifier.layout{ }

Animer la marge intérieure d'un composable

Figure 7 : Composable avec sa marge intérieure animée

Pour animer la marge intérieure d'un composable, utilisez animateDpAsState combiné à Modifier.padding() :

var toggled by remember {
    mutableStateOf(false)
}
val animatedPadding by animateDpAsState(
    if (toggled) {
        0.dp
    } else {
        20.dp
    },
    label = "padding"
)
Box(
    modifier = Modifier
        .aspectRatio(1f)
        .fillMaxSize()
        .padding(animatedPadding)
        .background(Color(0xff53D9A1))
        .clickable(
            interactionSource = remember { MutableInteractionSource() },
            indication = null
        ) {
            toggled = !toggled
        }
)
AnimationQuickGuide.kt

Animer l'élévation d'un composable

Figure 8 Animation de l'élévation du composable lors d'un clic

Pour animer l'élévation d'un composable, utilisez animateDpAsState en combinaison avec Modifier.graphicsLayer{ } Pour les modifications d'altitude ponctuelles, utilisez Modifier.shadow(). Si vous animez l'ombre, l'option la plus performante consiste à utiliser le modificateur Modifier.graphicsLayer{ }.

val mutableInteractionSource = remember {
    MutableInteractionSource()
}
val pressed = mutableInteractionSource.collectIsPressedAsState()
val elevation = animateDpAsState(
    targetValue = if (pressed.value) {
        32.dp
    } else {
        8.dp
    },
    label = "elevation"
)
Box(
    modifier = Modifier
        .size(100.dp)
        .align(Alignment.Center)
        .graphicsLayer {
            this.shadowElevation = elevation.value.toPx()
        }
        .clickable(interactionSource = mutableInteractionSource, indication = null) {
        }
        .background(colorGreen)
) {
}
AnimationQuickGuide.kt

Vous pouvez également utiliser le composable Card et définir la propriété d'élévation sur différentes valeurs par état.

Animer l'échelle, la traduction ou la rotation du texte

Figure 9. Animation fluide du texte entre deux tailles

Lorsque vous animez l'échelle, la traduction ou la rotation du texte, définissez textMotion sur TextStyle en TextMotion.Animated. Cela garantit des transitions plus fluides entre les animations de texte. Utilisez Modifier.graphicsLayer{ } pour pour traduire, faire pivoter ou redimensionner le texte.

val infiniteTransition = rememberInfiniteTransition(label = "infinite transition")
val scale by infiniteTransition.animateFloat(
    initialValue = 1f,
    targetValue = 8f,
    animationSpec = infiniteRepeatable(tween(1000), RepeatMode.Reverse),
    label = "scale"
)
Box(modifier = Modifier.fillMaxSize()) {
    Text(
        text = "Hello",
        modifier = Modifier
            .graphicsLayer {
                scaleX = scale
                scaleY = scale
                transformOrigin = TransformOrigin.Center
            }
            .align(Alignment.Center),
        // Text composable does not take TextMotion as a parameter.
        // Provide it via style argument but make sure that we are copying from current theme
        style = LocalTextStyle.current.copy(textMotion = TextMotion.Animated)
    )
}
AnimationQuickGuide.kt

Animer la couleur du texte

Figure 10. Exemple d'animation de la couleur du texte

Pour animer la couleur du texte, utilisez le lambda color sur le composable BasicText:

val infiniteTransition = rememberInfiniteTransition(label = "infinite transition")
val animatedColor by infiniteTransition.animateColor(
    initialValue = Color(0xFF60DDAD),
    targetValue = Color(0xFF4285F4),
    animationSpec = infiniteRepeatable(tween(1000), RepeatMode.Reverse),
    label = "color"
)

BasicText(
    text = "Hello Compose",
    color = {
        animatedColor
    },
    // ...
)
AnimationQuickGuide.kt

Passer d'un type de contenu à un autre

Figure 11 Utilisation d'AnimatedContent pour animer les changements entre différents composables (ralentissement)

Utilisez AnimatedContent pour créer des animations entre différents composables, si vous si vous souhaitez simplement un fondu standard entre les composables, utilisez Crossfade.

var state by remember {
    mutableStateOf(UiState.Loading)
}
AnimatedContent(
    state,
    transitionSpec = {
        fadeIn(
            animationSpec = tween(3000)
        ) togetherWith fadeOut(animationSpec = tween(3000))
    },
    modifier = Modifier.clickable(
        interactionSource = remember { MutableInteractionSource() },
        indication = null
    ) {
        state = when (state) {
            UiState.Loading -> UiState.Loaded
            UiState.Loaded -> UiState.Error
            UiState.Error -> UiState.Loading
        }
    },
    label = "Animated Content"
) { targetState ->
    when (targetState) {
        UiState.Loading -> {
            LoadingScreen()
        }
        UiState.Loaded -> {
            LoadedScreen()
        }
        UiState.Error -> {
            ErrorScreen()
        }
    }
}
AnimationQuickGuide.kt

AnimatedContent peut être personnalisé pour afficher différents types d'entrées et et de sortie. Pour en savoir plus, consultez la documentation AnimatedContent ou lisez cet article de blog sur AnimatedContent

Animer la navigation vers différentes destinations

Figure 12 : Animer des transitions entre des composables à l'aide de navigation-compose

Pour animer les transitions entre les composables lorsque vous utilisez l'artefact navigation-compose, spécifiez enterTransition et exitTransition sur un composable. Vous pouvez également définir l'animation par défaut comme utilisé pour toutes les destinations du niveau supérieur NavHost:

val navController = rememberNavController()
NavHost(
    navController = navController, startDestination = "landing",
    enterTransition = { EnterTransition.None },
    exitTransition = { ExitTransition.None }
) {
    composable("landing") {
        ScreenLanding(
            // ...
        )
    }
    composable(
        "detail/{photoUrl}",
        arguments = listOf(navArgument("photoUrl") { type = NavType.StringType }),
        enterTransition = {
            fadeIn(
                animationSpec = tween(
                    300, easing = LinearEasing
                )
            ) + slideIntoContainer(
                animationSpec = tween(300, easing = EaseIn),
                towards = AnimatedContentTransitionScope.SlideDirection.Start
            )
        },
        exitTransition = {
            fadeOut(
                animationSpec = tween(
                    300, easing = LinearEasing
                )
            ) + slideOutOfContainer(
                animationSpec = tween(300, easing = EaseOut),
                towards = AnimatedContentTransitionScope.SlideDirection.End
            )
        }
    ) { backStackEntry ->
        ScreenDetails(
            // ...
        )
    }
}
AnimationQuickGuide.kt

Il existe de nombreux types de transitions d'entrée et de sortie qui appliquent différents effets au contenu entrant et sortant. Pour en savoir plus, consultez la documentation.

Remarque :Les transitions d'entrée et de sortie ne sont disponibles qu'avec navigation-compose. 2.7.0-alpha01.

Répéter une animation

Figure 13. Couleur d'arrière-plan animée entre deux valeurs, infinie

Utilisez rememberInfiniteTransition avec un infiniteRepeatable animationSpec pour répéter votre animation en continu. Remplacer RepeatModes par spécifier la manière dont elle doit aller et venir.

Utilisez finiteRepeatable pour répéter un nombre défini de fois.

val infiniteTransition = rememberInfiniteTransition(label = "infinite")
val color by infiniteTransition.animateColor(
    initialValue = Color.Green,
    targetValue = Color.Blue,
    animationSpec = infiniteRepeatable(
        animation = tween(1000, easing = LinearEasing),
        repeatMode = RepeatMode.Reverse
    ),
    label = "color"
)
Column(
    modifier = Modifier.drawBehind {
        drawRect(color)
    }
) {
    // your composable here
}
AnimationQuickGuide.kt

Lancer une animation au lancement d'un composable

LaunchedEffect s'exécute lorsqu'un composable entre dans la composition. Il lance une animation au lancement d'un composable. Vous pouvez l'utiliser pour piloter le changement d'état de l'animation. Utilisation de Animatable avec la méthode animateTo pour démarrer l'animation au démarrage :

val alphaAnimation = remember {
    Animatable(0f)
}
LaunchedEffect(Unit) {
    alphaAnimation.animateTo(1f)
}
Box(
    modifier = Modifier.graphicsLayer {
        alpha = alphaAnimation.value
    }
)
AnimationQuickGuide.kt

Attention :Soyez prudent lorsque vous utilisez LaunchedEffects dans des mises en page différées. Ils est relancée lorsque les éléments réintègrent la composition. Par exemple, cela peut se produire lorsque vous faites défiler la liste hors de l'écran, puis de nouveau à l'écran. Hissez plutôt votre en dehors de la mise en page différée pour éviter que l'animation ne se produise chaque défilement vers l'intérieur ou l'extérieur de la composition.

Créer des animations séquentielles

Figure 14. Schéma illustrant la progression d'une animation séquentielle, une par une.

Utilisez les API de coroutine Animatable pour effectuer des animations séquentielles ou simultanées. Appeler animateTo sur les Animatable l'un après l'autre entraîne l'attente de la fin des animations précédentes par chaque animation avant de continuer. En effet, il s'agit d'une fonction de suspension.

val alphaAnimation = remember { Animatable(0f) }
val yAnimation = remember { Animatable(0f) }

LaunchedEffect("animationKey") {
    alphaAnimation.animateTo(1f)
    yAnimation.animateTo(100f)
    yAnimation.animateTo(500f, animationSpec = tween(100))
}
AnimationQuickGuide.kt

Créer des animations simultanées

Figure 15 Schéma illustrant la progression des animations simultanées, tout en même temps.

Utilisez les API de coroutine (Animatable#animateTo() ou animate) ou L'API Transition pour réaliser des animations simultanées. Si vous utilisez plusieurs fonctions de lancement dans un contexte de coroutine, les animations sont lancées en même temps :

val alphaAnimation = remember { Animatable(0f) }
val yAnimation = remember { Animatable(0f) }

LaunchedEffect("animationKey") {
    launch {
        alphaAnimation.animateTo(1f)
    }
    launch {
        yAnimation.animateTo(100f)
    }
}
AnimationQuickGuide.kt

Vous pouvez utiliser l'API updateTransition pour utiliser le même état pour piloter de nombreuses animations de propriétés différentes en même temps. L'exemple ci-dessous anime deux propriétés contrôlées par un changement d'état, rect et borderWidth:

var currentState by remember { mutableStateOf(BoxState.Collapsed) }
val transition = updateTransition(currentState, label = "transition")

val rect by transition.animateRect(label = "rect") { state ->
    when (state) {
        BoxState.Collapsed -> Rect(0f, 0f, 100f, 100f)
        BoxState.Expanded -> Rect(100f, 100f, 300f, 300f)
    }
}
val borderWidth by transition.animateDp(label = "borderWidth") { state ->
    when (state) {
        BoxState.Collapsed -> 1.dp
        BoxState.Expanded -> 0.dp
    }
}
AnimationQuickGuide.kt

Optimiser les performances des animations

Les animations dans Compose peuvent entraîner des problèmes de performances. Cela est dû à la nature d'une animation : déplacer ou modifier rapidement des pixels à l'écran, image par image, pour créer l'illusion de mouvement.

Examinez les différentes phases de Compose: la composition, la mise en page et le dessin. Si votre animation modifie la phase de mise en page. Tous les composables concernés doivent donc de la remise en page et de la redessiner. Si votre animation se produit pendant la phase de dessin, elle est par défaut plus performante que si vous exécutiez l'animation pendant la phase de mise en page, car elle a moins de travail à effectuer dans l'ensemble.

Pour que votre application effectue le moins d'actions possible lors de l'animation, choisissez la version lambda d'un Modifier dans la mesure du possible. Cette action ignore la recomposition et effectue l'animation en dehors de la phase de composition. Sinon, utilisez Modifier.graphicsLayer{ }, car ce modificateur s'exécute toujours dans le dessin à chaque phase. Pour en savoir plus, consultez la section Différer les lectures dans la documentation sur les performances.

Modifier la chronologie de l'animation

Par défaut, Compose utilise des animations de rétroaction pour la plupart des animations. Les ressorts, ou animations basées sur la physique, sont plus naturels. Ils peuvent également être interrompus elles prennent en compte la vitesse actuelle de l'objet, plutôt qu'une durée fixe. Si vous souhaitez remplacer la valeur par défaut, toutes les API d'animation présentées ci-dessus peuvent définir un animationSpec pour personnaliser l'exécution d'une animation, que vous souhaitiez qu'elle s'exécute sur une durée donnée ou qu'elle soit plus rebondissante.

Vous trouverez ci-dessous un récapitulatif des différentes options animationSpec :

• spring : animation basée sur la physique, par défaut pour toutes les animations. Vous pouvez modifier la rigidité ou le dampingRatio pour obtenir un aspect différent de l'animation.
• tween (abréviation de entre) : animation basée sur la durée, anime entre deux valeurs à l'aide d'une fonction Easing.
• keyframes: spécification permettant de spécifier des valeurs à certains points clés d'une de l'animation.
• repeatable : spécification basée sur la durée qui s'exécute un certain nombre de fois, spécifié par RepeatMode.
• infiniteRepeatable: spécification basée sur la durée qui s'exécute indéfiniment.
• snap : s'ancre instantanément à la valeur de fin sans animation.

Figure 16. Aucune spécification n'a été définie, contrairement aux spécifications Custom Spring

Pour en savoir plus sur les animationSpecs, consultez la documentation complète.

Ressources supplémentaires

Pour voir d'autres exemples d'animations amusantes dans Compose, consultez les ressources suivantes:

• 5 animations rapides dans Compose
• Faire avancer une méduse dans Compose
• Personnaliser AnimatedContent dans Compose
• Présentation des fonctions de lissage de vitesse dans Compose