Property Animation: o que é, ObjectAnimator e ValueAnimator

O que é Property Animation?

Property Animation é um framework no Android SDK (pacote android.animation) que anima quaisquer propriedades de qualquer objeto (View, Drawable, classe personalizada) durante um tempo especificado. Ao contrário da View Animation, que funciona apenas com View e altera apenas a representação visual (matrix transform), a Property Animation modifica os campos reais do objeto. Isso significa que após uma animação de translationX, o objeto está realmente na nova posição e os cliques são processados no novo local.

A arquitetura da Property Animation é construída sobre três classes principais: ValueAnimator — o gerador base de valores, ObjectAnimator — uma subclasse para vincular a uma propriedade do objeto, AnimatorSet — um orquestrador para animação em grupo. Todas as três suportam Interpolator (curva de velocidade) e TypeEvaluator (regra de interpolação entre valores).

De acordo com Android Performance Patterns (Google, 2025), a Property Animation funciona a até 60 FPS com um Interpolator configurado corretamente e sem cálculos pesados em onAnimationUpdate(). Para animações complexas (3D, física), recomenda-se RenderThread (RenderNode Animations) no Android 12+. A Property Animation continua sendo a escolha principal para animar propriedades de View — translationX, rotationY, scaleX, alpha e outras.

ObjectAnimator: animação de propriedades de objetos

ObjectAnimator é a classe mais popular da Property Animation. Ela estende ValueAnimator e chama automaticamente o setter da propriedade especificada do objeto com valores animados. Para que ObjectAnimator funcione, o objeto deve ter um setter público para a propriedade que está sendo animada (por exemplo, setTranslationX(float) para a propriedade "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()
}

Propriedades de View suportadas: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. ObjectAnimator.ofFloat() é usado para propriedades float, ofInt() para int, ofObject() para tipos personalizados (cor, ponto). Para animação de cor, use ofObject() com ArgbEvaluator ou HsvEvaluator.

// ObjectAnimator com TypeEvaluator personalizado (cor)
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()
}

// Animando várias propriedades simultaneamente
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 — uma interface para rastrear eventos de animação: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Use AnimatorListenerAdapter para sobrescrever apenas os métodos necessários. A partir do Android 12, foi adicionado Animator.AnimationCallback com suporte a corrotinas via suspendAnimationFrame.

ValueAnimator: geração de valores animados

ValueAnimator é a classe base da Property Animation que gera valores animados do início ao fim durante um tempo determinado. Ao contrário do ObjectAnimator, o ValueAnimator não está vinculado a um objeto — ele simplesmente calcula valores intermediários e notifica através de um listener. O desenvolvedor decide o que fazer com os valores obtidos: definir uma propriedade de View, alterar um parâmetro de Drawable, atualizar a renderização personalizada em onDraw().

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

"> ValueAnimator: animação do progresso do carregamento
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() — usado para propriedades inteiras (largura, altura, número de passos). ValueAnimator.ofObject() — para tipos personalizados com TypeEvaluator. ValueAnimator.ofPropertyValuesHolder() — para animação paralela de múltiplas propriedades com um único temporizador, economizando recursos em comparação com Animators separados para cada propriedade.

// ValueAnimator.ofObject com 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()
}

Desempenho do ValueAnimator: a 60 FPS, onAnimationUpdate é chamado a cada ~16,7 ms. Evite dentro do listener: alocações de objetos (crie PointF/RectF uma vez), chamar findViewById(), cálculos pesados (E/S de arquivo, rede). Para animar 20+ elementos simultâneos, use PropertyValuesHolder em um Animator em vez de 20 Animators separados. Para animação com alteração de tamanho, use View.setLayoutParams() apenas no final da animação (via AnimatorListenerAdapter.onAnimationEnd).

AnimatorSet: composição de animações

AnimatorSet é um orquestrador que permite executar várias instâncias de Animator (ObjectAnimator, ValueAnimator) em uma ordem específica: sequencialmente (playSequentially), em paralelo (playTogether), com atrasos (after, before, with). AnimatorSet suporta aninhamento — um AnimatorSet pode conter outros AnimatorSets para cenários complexos.

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

// AnimatorSet: animação sequencial e paralela
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 {
    // Em paralelo: fadeIn + slideUp
    play(fadeIn).with(slideUp)
        "> Depois: bounce com atraso 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 fornece uma API fluente para construir cadeias: with() — em paralelo, before() — antes, after() — depois. AnimatorSet suporta cancel() para parar todas as animações no conjunto. Para cenários complexos (25+ animadores), use PropertyValuesHolder — é mais eficiente porque usa um único temporizador compartilhado em vez de um separado para cada Animator.

Interpolator e TypeEvaluator: controle de velocidade e tipo

Interpolator define a curva de velocidade da animação de 0 a 1. O Android fornece Interpolators integrados: LinearInterpolator (uniforme), AccelerateDecelerateInterpolator (lento-rápido-lento), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (com ultrapassagem), BounceInterpolator (com ricochete), AnticipateOvershootInterpolator (com recuo antes do início e ultrapassagem do alvo). O Interpolator personalizado é implementado via TimeInterpolator.

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

// BounceInterpolator — efeito de ricochete no final
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — recuo, depois ultrapassagem
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — uma interface com o método evaluate(fraction, startValue, endValue) que calcula o valor intermediário entre início e fim. Integrados: ArgbEvaluator (cor int), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. Para tipos de dados personalizados (por exemplo, animar uma classe personalizada com três campos), implemente seu próprio TypeEvaluator. Para animar várias Views com as mesmas configurações, use PropertyValuesHolder — ele aceita uma matriz de nomes de propriedades e valores correspondentes.

// TypeEvaluator personalizado para a 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 — máxima performance
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()
}