Property Animation : qu'est-ce que c'est, ObjectAnimator et ValueAnimator

Qu'est-ce que Property Animation ?

Property Animation est un framework dans Android SDK (package android.animation) qui anime toutes les propriétés de n'importe quel objet (View, Drawable, classe personnalisée) pendant une durée spécifiée. Contrairement à View Animation, qui fonctionne uniquement avec View et ne modifie que la représentation visuelle (transformation matricielle), Property Animation modifie les champs réels de l'objet. Cela signifie qu'après une animation translationX, l'objet se trouve réellement à la nouvelle position et les clics sont traités au nouvel emplacement.

L'architecture de Property Animation repose sur trois classes clés : ValueAnimator — le générateur de valeurs de base, ObjectAnimator — une sous-classe pour se lier à une propriété d'objet, AnimatorSet — un orchestrateur pour l'animation de groupe. Les trois prennent en charge Interpolator (courbe de vitesse) et TypeEvaluator (règle d'interpolation entre les valeurs).

Selon Android Performance Patterns (Google, 2025), Property Animation fonctionne jusqu'à 60 FPS avec un Interpolator correctement configuré et sans calculs lourds dans onAnimationUpdate(). Pour les animations complexes (3D, physique), RenderThread (RenderNode Animations) est recommandé dans Android 12+. Property Animation reste le choix principal pour animer les propriétés View — translationX, rotationY, scaleX, alpha et autres.

ObjectAnimator : animation des propriétés d'un objet

ObjectAnimator est la classe la plus populaire de Property Animation. Elle étend ValueAnimator et appelle automatiquement le setter de la propriété spécifiée de l'objet avec des valeurs animées. Pour qu'ObjectAnimator fonctionne, l'objet doit avoir un setter public pour la propriété à animer (par exemple, setTranslationX(float) pour la propriété « translationX »).

import android.animation.ObjectAnimator
import android.view.View

// ObjectAnimator for translationX
val animator = ObjectAnimator.ofFloat(
    myView,
    "translationX",
    0f,
    300f
).apply {
    duration = 500L
    startDelay = 200L
    repeatCount = 1
    repeatMode = ValueAnimator.REVERSE
    interpolator = FastOutSlowInInterpolator()
    start()
}

Propriétés View prises en charge : translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. ObjectAnimator.ofFloat() est utilisé pour les propriétés float, ofInt() pour int, ofObject() pour les types personnalisés (couleur, point). Pour l'animation de couleur, utilisez ofObject() avec ArgbEvaluator ou HsvEvaluator.

// ObjectAnimator avec TypeEvaluator personnalisé (couleur)
import android.animation.ObjectAnimator
import android.animation.ArgbEvaluator
import android.graphics.Color

val colorAnim = ObjectAnimator.ofObject(
    myView,
    "backgroundColor",
    ArgbEvaluator(),
    Color.BLUE,
    Color.RED
).apply {
    duration = 1000L
    repeatCount = ValueAnimator.INFINITE
    repeatMode = ValueAnimator.REVERSE
    start()
}

// Animer plusieurs propriétés simultanément
val scaleXAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.5f)
val scaleYAnim = ObjectAnimator.ofFloat(myView, "scaleY", 1f, 1.5f)
val alphaAnim = ObjectAnimator.ofFloat(myView, "alpha", 1f, 0.5f)

AnimatorListener — une interface pour suivre les événements d'animation : onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Utilisez AnimatorListenerAdapter pour ne redéfinir que les méthodes nécessaires. À partir d'Android 12, Animator.AnimationCallback avec prise en charge des coroutines via suspendAnimationFrame a été ajouté.

ValueAnimator : génération de valeurs animées

ValueAnimator est la classe de base de Property Animation qui génère des valeurs animées du début à la fin sur une période donnée. Contrairement à ObjectAnimator, ValueAnimator n'est pas lié à un objet — il calcule simplement des valeurs intermédiaires et notifie via un écouteur. Le développeur décide quoi faire avec les valeurs obtenues : définir une propriété View, modifier un paramètre Drawable, mettre à jour le dessin personnalisé dans onDraw().

import android.animation.ValueAnimator
import android.view.animation.LinearInterpolator

"> ValueAnimator : animation de la progression du chargement
val valueAnimator = ValueAnimator.ofFloat(0f, 100f).apply {
    duration = 2000L
    interpolator = LinearInterpolator()
    repeatCount = ValueAnimator.INFINITE

    addUpdateListener { animator ->
        val progress = animator.animatedValue as Float
        progressBar.progress = progress.toInt()
        progressText.text = "${progress.toInt()}%"
    }

    addListener(object : AnimatorListenerAdapter() {
        override fun onAnimationRepeat(animation: Animator) {
            Log.d("Anim", "Progress animation restarted")
        }
    })
    start()
}

ValueAnimator.ofInt() — utilisé pour les propriétés entières (largeur, hauteur, nombre d'étapes). ValueAnimator.ofObject() — pour les types personnalisés avec TypeEvaluator. ValueAnimator.ofPropertyValuesHolder() — pour l'animation parallèle de plusieurs propriétés avec un seul minuteur, économisant des ressources par rapport à des Animators séparés pour chaque propriété.

// ValueAnimator.ofObject avec PointEvaluator
import android.animation.ValueAnimator
import android.graphics.PointF
import android.animation.PointFEvaluator

val pointAnim = ValueAnimator.ofObject(
    PointFEvaluator(),
    PointF(0f, 0f),
    PointF(300f, 500f)
).apply {
    duration = 1000L
    addUpdateListener { animator ->
        val point = animator.animatedValue as PointF
        movingView.x = point.x
        movingView.y = point.y
    }
    start()
}

Performances de ValueAnimator : à 60 FPS, onAnimationUpdate est appelé toutes les ~16,7 ms. Évitez à l'intérieur de l'écouteur : les allocations d'objets (créez PointF/RectF une fois), l'appel de findViewById(), les calculs lourds (E/S fichier, réseau). Pour animer 20+ éléments simultanément, utilisez PropertyValuesHolder dans un seul Animator au lieu de 20 Animators séparés. Pour une animation avec changement de taille, utilisez View.setLayoutParams() uniquement à la fin de l'animation (via AnimatorListenerAdapter.onAnimationEnd).

AnimatorSet : composition d'animations

AnimatorSet est un orchestrateur qui permet d'exécuter plusieurs instances d'Animator (ObjectAnimator, ValueAnimator) dans un ordre spécifique : séquentiellement (playSequentially), en parallèle (playTogether), avec des délais (after, before, with). AnimatorSet prend en charge l'imbrication — un AnimatorSet peut contenir d'autres AnimatorSets pour des scénarios complexes.

import android.animation.AnimatorSet
import android.animation.ObjectAnimator

// AnimatorSet : animation séquentielle et parallèle
val fadeIn = ObjectAnimator.ofFloat(myView, "alpha", 0f, 1f)
val slideUp = ObjectAnimator.ofFloat(myView, "translationY", 100f, 0f)
val bounce = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.1f, 1f)

val animatorSet = AnimatorSet().apply {
    // En parallèle : fadeIn + slideUp
    play(fadeIn).with(slideUp)
    "> Après : bounce avec un délai de 200ms
    play(bounce).after(200L)

    duration = 400L
    interpolator = FastOutSlowInInterpolator()
    addListener(object : AnimatorListenerAdapter() {
        override fun onAnimationEnd(animation: Animator) {
            Log.d("Anim", "Set completed")
        }
    })
    start()
}

AnimatorSet.Builder fournit une API fluide pour construire des chaînes : with() — en parallèle, before() — avant, after() — après. AnimatorSet prend en charge cancel() pour arrêter toutes les animations de l'ensemble. Pour les scénarios complexes (25+ animateurs), utilisez PropertyValuesHolder — il est plus performant car il utilise un seul minuteur partagé au lieu d'un séparé pour chaque Animator.

Interpolator et TypeEvaluator : contrôle de la vitesse et du type

Interpolator définit la courbe de vitesse de l'animation de 0 à 1. Android fournit des Interpolators intégrés : LinearInterpolator (uniforme), AccelerateDecelerateInterpolator (lent-rapide-lent), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (avec dépassement), BounceInterpolator (avec rebond), AnticipateOvershootInterpolator (avec recul avant le début et dépassement de la cible). Un Interpolator personnalisé est implémenté via TimeInterpolator.

import android.animation.ObjectAnimator
import android.view.animation.BounceInterpolator
import android.view.animation.OvershootInterpolator
import android.view.animation.AnticipateOvershootInterpolator

// BounceInterpolator — effet de rebond à la fin
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — recul, puis dépassement
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — une interface avec la méthode evaluate(fraction, startValue, endValue) qui calcule la valeur intermédiaire entre le début et la fin. Intégrés : ArgbEvaluator (couleur int), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. Pour les types de données personnalisés (par exemple, animer une classe personnalisée avec trois champs), implémentez votre propre TypeEvaluator. Pour animer plusieurs Views avec les mêmes paramètres, utilisez PropertyValuesHolder — il accepte un tableau de noms de propriétés et de valeurs correspondantes.

// TypeEvaluator personnalisé pour la classe ProgressState
data class ProgressState(val progress: Float, val color: Int)

class ProgressEvaluator : TypeEvaluator<ProgressState> {
    override fun evaluate(
        fraction: Float,
        startValue: ProgressState,
        endValue: ProgressState
    ): ProgressState {
        val progress = startValue.progress + fraction * (endValue.progress - startValue.progress)
        val color = ArgbEvaluator().evaluate(
            fraction, startValue.color, endValue.color
        ) as Int
        return ProgressState(progress, color)
    }
}

"> PropertyValuesHolder — performances maximales
val pvh1 = PropertyValuesHolder.ofFloat("scaleX", 1f, 1.5f)
val pvh2 = PropertyValuesHolder.ofFloat("scaleY", 1f, 1.5f)
val pvhAnim = ObjectAnimator.ofPropertyValuesHolder(myView, pvh1, pvh2).apply {
    duration = 300L
    start()
}