Property Animation: mi ez, ObjectAnimator és ValueAnimator

Mi az a Property Animation?

Property Animation — egy keretrendszer az Android SDK-ban (android.animation csomag), amely bármely objektum (View, Drawable, egyéni osztály) bármely tulajdonságát animálja megadott idő alatt. Azzal szemben, hogy a View Animation csak View-val dolgozik és csak a vizuális megjelenítést változtatja (matrix transform), a Property Animation az objektum valós mezőit változtatja meg. Ez azt jelenti, hogy a translationX animáció után az objektum ténylegesen az új pozícióban van, és a kattintások az új helyen kerülnek feldolgozásra.

A Property Animation architektúrája három kulcsfontosságú osztályra épül: ValueAnimator — alapérték-generátor, ObjectAnimator — alosztály az objektum tulajdonságához való kötéshez, AnimatorSet — orkesztrátor csoportos animációhoz. Mindhárom támogatja az Interpolator-t (sebességgörbe) és a TypeEvaluator-t (interpolációs szabály az értékek között).

A Android Performance Patterns (Google, 2025) szerint a Property Animation akár 60 FPS frekvencián működik megfelelően konfigurált Interpolator és nehéz számítások nélkül az onAnimationUpdate()-ben. Összetett animációkhoz (3D, fizika) Android 12+-ban a RenderThread (RenderNode Animations) ajánlott. A Property Animation marad a fő választás a View tulajdonságainak — translationX, rotationY, scaleX, alpha és mások — animálásához.

ObjectAnimator: objektumtulajdonságok animálása

ObjectAnimator — a Property Animation legnépszerűbb osztálya. A ValueAnimator-ból származik, és automatikusan meghívja az objektum megadott tulajdonságának setter-ét animált értékekkel. A működéshez az ObjectAnimator-nak szüksége van arra, hogy az objektumnak legyen publikus setter-je az animált tulajdonsághoz (pl. setTranslationX(float) a «translationX» tulajdonsághoz).

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

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

Támogatott View tulajdonságok: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. Az ObjectAnimator.ofFloat() float tulajdonságokhoz használatos, ofInt() — int-hez, ofObject() — egyéni típusokhoz (szín, pont). Színanimációhoz használja az ofObject()-et ArgbEvaluator vagy HsvEvaluator segítségével.

// ObjectAnimator egyéni TypeEvaluator-ral (szín)
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()
}

// Több tulajdonság egyidejű animálása
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 — interfész az animációs események nyomon követéséhez: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Használja az AnimatorListenerAdapter-t a csak szükséges metódusok felülírásához. Android 12-től kezdve hozzáadásra került az Animator.AnimationCallback korutin támogatással a suspendAnimationFrame segítségével.

ValueAnimator: animált értékek generálása

ValueAnimator — a Property Animation alaposztálya, amely animált értékeket generál start-tól end-ig adott idő alatt. Az ObjectAnimator-tól eltérően a ValueAnimator nincs objektumhoz kötve — csak a köztes értékeket számítja ki, és a listeneren keresztül értesít. A fejlesztő maga dönti el, mit kezd a kapott értékekkel: View tulajdonság beállítása, Drawable paraméter módosítása, egyéni rajzolás frissítése onDraw()-ban.

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

"> ValueAnimator: a betöltési folyamat animációja
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() — egész tulajdonságokhoz (szélesség, magasság, lépésszám) használatos. ValueAnimator.ofObject() — egyéni típusokhoz TypeEvaluator segítségével. ValueAnimator.ofPropertyValuesHolder() — több tulajdonság párhuzamos animálásához egy időzítővel, ami erőforrásokat takarít meg a különálló Animator-okkal szemben.

// ValueAnimator.ofObject PointEvaluator segítségével
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()
}

A ValueAnimator teljesítménye: 60 FPS frekvencián az onAnimationUpdate ~16.7 ms-ként hívódik meg. Kerülje a listeneren belül: objektumok allokációját (PointF/RectF egyszer hozza létre), findViewById() hívását, nehéz számításokat (fájl I/O, hálózat). 20+ egyidejű elem animálásához használjon PropertyValuesHolder-t egy Animator-ban a 20 különálló Animator helyett. Méretváltozással járó animációhoz a View.setLayoutParams() csak az animáció végén használja (AnimatorListenerAdapter.onAnimationEnd segítségével).

AnimatorSet: animációk kompozíciója

AnimatorSet — orkesztrátor, amely lehetővé teszi több Animator (ObjectAnimator, ValueAnimator) meghatározott sorrendben történő futtatását: szekvenciálisan (playSequentially), párhuzamosan (playTogether), késleltetésekkel (after, before, with). Az AnimatorSet támogatja a beágyazást — az AnimatorSet tartalmazhat más AnimatorSet-eket összetett forgatókönyvekhez.

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

// AnimatorSet: szekvenciális és párhuzamos animáció
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 {
    // Párhuzamos: fadeIn + slideUp
    play(fadeIn).with(slideUp)
        "> Utána: bounce 200 ms késleltetéssel
    play(bounce).after(200L)

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

AnimatorSet.Builder folyékony API-t biztosít láncok építéséhez: with() — párhuzamosan, before() — előtte, after() — utána. Az AnimatorSet támogatja a cancel()-t az összes animáció leállításához a halmazban. Összetett forgatókönyvekhez (25+ animátor) használjon PropertyValuesHolder-t — hatékonyabb, mert egy megosztott időzítőt használ a különálló időzítők helyett minden Animator-hoz.

Interpolator és TypeEvaluator: sebesség és típus kezelése

Interpolator határozza meg az animáció sebességváltozásának görbéjét 0-tól 1-ig. Az Android beépített Interpolator-okat biztosít: LinearInterpolator (egyenletes), AccelerateDecelerateInterpolator (lassú-gyors-lassú), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (a cél túllövésével), BounceInterpolator (patrogással), AnticipateOvershootInterpolator (visszahúzással indulás előtt és cél túllövésével). Egyéni Interpolator a TimeInterpolator segítségével implementálható.

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

// BounceInterpolator — pattogó effekt a végén
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — visszahúzás, majd túllövés
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — interfész az evaluate(fraction, startValue, endValue) metódussal, amely kiszámítja a köztes értéket start és end között. Beépített: ArgbEvaluator (szín int), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. Egyéni adattípusokhoz (pl. egyéni osztály animálása három mezővel) implementálja saját TypeEvaluator-ját. Több View azonos beállításokkal történő animálásához használja a PropertyValuesHolder-t — tulajdonságnevek és megfelelő értékek tömbjét fogadja.

// Egyéni TypeEvaluator a ProgressState osztályhoz
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ális teljesítmény
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()
}