Property Animation: co to je, ObjectAnimator a ValueAnimator

Co je Property Animation?

Property Animation — je framework v Android SDK (balíček android.animation), který animuje libovolné vlastnosti libovolného objektu (View, Drawable, vlastní třída) v určitém čase. Na rozdíl od View Animation, která pracuje pouze s View a mění jen vizuální zobrazení (matrix transform), Property Animation mění skutečná pole objektu. To znamená, že po animaci translationX je objekt skutečně na nové pozici a kliknutí jsou zpracovávána na novém místě.

Architektura Property Animation je postavena na třech klíčových třídách: ValueAnimator — základní generátor hodnot, ObjectAnimator — podtřída pro vazbu na vlastnost objektu, AnimatorSet — orchestrátor pro skupinovou animaci. Všechny tři podporují Interpolator (křivka rychlosti) a TypeEvaluator (pravidlo interpolace mezi hodnotami).

Podle Android Performance Patterns (Google, 2025) pracuje Property Animation na frekvenci až 60 FPS při správně nakonfigurovaném Interpolator a bez těžkých výpočtů v onAnimationUpdate(). Pro složité animace (3D, fyzika) se doporučuje RenderThread (RenderNode Animations) v Android 12+. Property Animation zůstává hlavní volbou pro animaci vlastností View — translationX, rotationY, scaleX, alpha a dalších.

ObjectAnimator: animace vlastností objektu

ObjectAnimator — nejoblíbenější třída Property Animation. Dědí z ValueAnimator a automaticky volá setter zadané vlastnosti objektu s animovanými hodnotami. Pro fungování ObjectAnimator vyžaduje, aby objekt měl veřejný setter pro animovanou vlastnost (např. setTranslationX(float) pro vlastnost «translationX»).

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

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

Podporované vlastnosti View: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. ObjectAnimator.ofFloat() se používá pro float vlastnosti, ofInt() — pro int, ofObject() — pro vlastní typy (barva, bod). Pro animaci barvy použijte ofObject() s ArgbEvaluator nebo HsvEvaluator.

// ObjectAnimator s vlastním TypeEvaluator (barva)
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()
}

// Animace několika vlastností současně
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 — rozhraní pro sledování událostí animace: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Použijte AnimatorListenerAdapter pro přepsání pouze potřebných metod. Od Android 12 byl přidán Animator.AnimationCallback s podporou korutin prostřednictvím suspendAnimationFrame.

ValueAnimator: generování animovaných hodnot

ValueAnimator — základní třída Property Animation, která generuje animované hodnoty od start do end v zadaném čase. Na rozdíl od ObjectAnimator není ValueAnimator vázán na objekt — pouze vypočítává mezilehlé hodnoty a informuje prostřednictvím posluchače. Vývojář sám rozhodne, co s přijatými hodnotami udělá: nastavit vlastnost View, změnit parametr Drawable, aktualizovat vlastní kreslení v onDraw().

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

"> ValueAnimator: animace průběhu načítání
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() — používá se pro celočíselné vlastnosti (šířka, výška, počet kroků). ValueAnimator.ofObject() — pro vlastní typy s TypeEvaluator. ValueAnimator.ofPropertyValuesHolder() — pro paralelní animaci více vlastností s jedním časovačem, což šetří zdroje ve srovnání s oddělenými Animator pro každou vlastnost.

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

Výkon ValueAnimator: při frekvenci 60 FPS je onAnimationUpdate volán každých ~16.7 ms. Vyhněte se uvnitř posluchače: alokaci objektů (vytvořte PointF/RectF jednou), volání findViewById(), těžkým výpočtům (I/O souborů, síť). Pro animaci 20+ současných prvků použijte PropertyValuesHolder v jednom Animator místo 20 oddělených Animator. Pro animaci se změnou velikosti použijte View.setLayoutParams() pouze na konci animace (přes AnimatorListenerAdapter.onAnimationEnd).

AnimatorSet: kompozice animací

AnimatorSet — orchestrátor, který umožňuje spouštět více Animator (ObjectAnimator, ValueAnimator) v určitém pořadí: sekvenčně (playSequentially), paralelně (playTogether), se zpožděními (after, before, with). AnimatorSet podporuje vnoření — AnimatorSet může obsahovat další AnimatorSet pro složité scénáře.

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

// AnimatorSet: sekvenční a paralelní animace
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 {
    // Paralelně: fadeIn + slideUp
    play(fadeIn).with(slideUp)
    "> Po: bounce se zpožděním 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 poskytuje fluent API pro vytváření řetězců: with() — paralelně, before() — před, after() — po. AnimatorSet podporuje cancel() pro zastavení všech animací v sadě. Pro složité scénáře (25+ animátorů) použijte PropertyValuesHolder — je výkonnější, protože používá jeden sdílený časovač místo oddělených pro každý Animator.

Interpolator a TypeEvaluator: řízení rychlosti a typu

Interpolator určuje křivku změny rychlosti animace od 0 do 1. Android poskytuje vestavěné Interpolator: LinearInterpolator (rovnoměrně), AccelerateDecelerateInterpolator (pomalu-rychle-pomalu), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (s přeletem cíle), BounceInterpolator (s odskokem), AnticipateOvershootInterpolator (se zatažením zpět před začátkem a přeletem cíle). Vlastní Interpolator se implementuje přes TimeInterpolator.

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

// BounceInterpolator — efekt odskoku na konci
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — zatažení zpět, pak přelet
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — rozhraní s metodou evaluate(fraction, startValue, endValue), která vypočítává mezilehlou hodnotu mezi start a end. Vestavěné: ArgbEvaluator (barva int), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. Pro vlastní datové typy (např. animace vlastní třídy se třemi poli) implementujte svůj TypeEvaluator. Pro animaci více View se stejnými nastaveními použijte PropertyValuesHolder — přijímá pole názvů vlastností a odpovídajících hodnot.

// Vlastní TypeEvaluator pro třídu 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 — maximální výkon
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()
}