Property Animation: ano ito, ObjectAnimator at ValueAnimator

Ano ang Property Animation?

Property Animation — ay isang framework sa Android SDK (package android.animation) na nag-a-animate ng anumang mga property ng anumang bagay (View, Drawable, custom class) sa isang tinukoy na oras. Hindi tulad ng View Animation na gumagana lamang sa View at nagbabago lamang ng visual na representasyon (matrix transform), binabago ng Property Animation ang tunay na mga field ng bagay. Nangangahulugan ito na pagkatapos ng animasyon ng translationX, ang bagay ay aktuwal na nasa bagong posisyon, at ang mga click ay pinoproseso sa bagong lokasyon.

Ang arkitektura ng Property Animation ay binuo sa tatlong pangunahing klase: ValueAnimator — base generator ng mga halaga, ObjectAnimator — subclass para sa pag-binding sa property ng bagay, AnimatorSet — orkestrator para sa group animation. Lahat ng tatlo ay sumusuporta sa Interpolator (speed curve) at TypeEvaluator (interpolation rule sa pagitan ng mga halaga).

Ayon sa Android Performance Patterns (Google, 2025), ang Property Animation ay gumagana sa frequency na hanggang 60 FPS na may tamang configured na Interpolator at walang mabibigat na kalkulasyon sa onAnimationUpdate(). Para sa mga kumplikadong animasyon (3D, physics) inirerekomenda ang RenderThread (RenderNode Animations) sa Android 12+. Ang Property Animation ay nananatiling pangunahing pagpipilian para sa animasyon ng mga property ng View — translationX, rotationY, scaleX, alpha at iba pa.

ObjectAnimator: animasyon ng mga property ng bagay

ObjectAnimator — ang pinakasikat na klase ng Property Animation. Nagmamana ito mula sa ValueAnimator at awtomatikong tumatawag sa setter ng tinukoy na property ng bagay na may mga animate na halaga. Para sa paggana, ang ObjectAnimator ay nangangailangan na ang bagay ay may pampublikong setter para sa ina-animate na property (halimbawa, setTranslationX(float) para sa property na «translationX»).

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

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

Mga suportadong property ng View: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation. Ang ObjectAnimator.ofFloat() ay ginagamit para sa float properties, ofInt() — para sa int, ofObject() — para sa custom na uri (kulay, punto). Para sa animasyon ng kulay gamitin ang ofObject() na may ArgbEvaluator o HsvEvaluator.

// ObjectAnimator na may custom na TypeEvaluator (kulay)
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()
}

// Animasyon ng maraming property nang sabay-sabay
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 — interface para sa pagsubaybay ng mga event ng animasyon: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat. Gamitin ang AnimatorListenerAdapter para i-override lamang ang mga kinakailangang pamamaraan. Simula sa Android 12, idinagdag ang Animator.AnimationCallback na may suporta para sa coroutines sa pamamagitan ng suspendAnimationFrame.

ValueAnimator: pagbuo ng mga animate na halaga

ValueAnimator — base na klase ng Property Animation na bumubuo ng mga animate na halaga mula start hanggang end sa isang tinukoy na oras. Hindi tulad ng ObjectAnimator, ang ValueAnimator ay hindi nakatali sa isang bagay — kinakalkula lamang nito ang mga intermediate na halaga at nagpapaalam sa pamamagitan ng listener. Ang developer mismo ang nagpapasya kung ano ang gagawin sa mga natanggap na halaga: mag-set ng property ng View, magbago ng parameter ng Drawable, mag-update ng custom na pagguhit sa onDraw().

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

"> ValueAnimator: animation ng progress ng pag-load
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() — ginagamit para sa integer properties (lapad, taas, bilang ng mga hakbang). ValueAnimator.ofObject() — para sa custom na uri na may TypeEvaluator. ValueAnimator.ofPropertyValuesHolder() — para sa parallel animasyon ng maraming property na may isang timer, na nakakatipid ng resources kumpara sa hiwalay na Animator para sa bawat property.

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

Pagganap ng ValueAnimator: sa frequency na 60 FPS, ang onAnimationUpdate ay tinatawag tuwing ~16.7 ms. Iwasan sa loob ng listener: pag-allocate ng mga bagay (gumawa ng PointF/RectF nang isang beses), pagtawag ng findViewById(), mabibigat na kalkulasyon (file I/O, network). Para sa animasyon ng 20+ sabay-sabay na elemento gamitin ang PropertyValuesHolder sa isang Animator sa halip na 20 hiwalay na Animator. Para sa animasyon na may pagbabago ng laki gamitin ang View.setLayoutParams() lamang sa dulo ng animasyon (sa pamamagitan ng AnimatorListenerAdapter.onAnimationEnd).

AnimatorSet: komposisyon ng mga animasyon

AnimatorSet — orkestrator na nagbibigay-daan sa pagpapatakbo ng maraming Animator (ObjectAnimator, ValueAnimator) sa isang tiyak na pagkakasunod-sunod: sunud-sunod (playSequentially), paralel (playTogether), na may mga pagkaantala (after, before, with). Ang AnimatorSet ay sumusuporta sa nesting — ang AnimatorSet ay maaaring maglaman ng iba pang AnimatorSet para sa mga kumplikadong scenario.

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

// AnimatorSet: sunud-sunod at paralel na animasyon
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 {
    // Paralel: fadeIn + slideUp
    play(fadeIn).with(slideUp)
        "> Pagkatapos: bounce na may 200ms na delay
    play(bounce).after(200L)

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

AnimatorSet.Builder ay nagbibigay ng fluent API para sa pagbuo ng mga chain: with() — paralel, before() — bago, after() — pagkatapos. Ang AnimatorSet ay sumusuporta sa cancel() para ihinto ang lahat ng animasyon sa set. Para sa mga kumplikadong scenario (25+ animator) gamitin ang PropertyValuesHolder — mas mahusay ito dahil gumagamit ito ng isang shared timer sa halip na hiwalay na timer para sa bawat Animator.

Interpolator at TypeEvaluator: pamamahala ng bilis at uri

Interpolator ay tumutukoy sa curve ng pagbabago ng bilis ng animasyon mula 0 hanggang 1. Ang Android ay nagbibigay ng mga built-in na Interpolator: LinearInterpolator (uniform), AccelerateDecelerateInterpolator (mabagal-mabilis-mabagal), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (na may paglampas sa target), BounceInterpolator (na may pagtalbog), AnticipateOvershootInterpolator (na may pag-atras bago magsimula at paglampas sa target). Ang custom na Interpolator ay ipinapatupad sa pamamagitan ng TimeInterpolator.

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

// BounceInterpolator — epekto ng pagtalbog sa dulo
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

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

TypeEvaluator — interface na may pamamaraang evaluate(fraction, startValue, endValue) na kinakalkula ang intermediate na halaga sa pagitan ng start at end. Mga built-in: ArgbEvaluator (kulay int), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator. Para sa custom na uri ng data (halimbawa, animasyon ng isang custom class na may tatlong field) ipatupad ang iyong sariling TypeEvaluator. Para sa animasyon ng maraming View na may parehong mga setting gamitin ang PropertyValuesHolder — tumatanggap ito ng array ng mga pangalan ng property at kaukulang halaga.

// Custom na TypeEvaluator para sa klase ng 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 — pinakamataas na 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()
}