Property Animation: यह क्या है, ObjectAnimator और ValueAnimator

Property Animation क्या है?

Property Animation Android SDK (android.animation पैकेज) में एक फ्रेमवर्क है जो किसी भी ऑब्जेक्ट (View, Drawable, कस्टम क्लास) के किसी भी गुण को निर्दिष्ट समय में एनिमेट करता है। View Animation के विपरीत, जो केवल View के साथ काम करता है और केवल दृश्य प्रतिनिधित्व (matrix transform) बदलता है, Property Animation ऑब्जेक्ट के वास्तविक फ़ील्ड को संशोधित करता है। इसका मतलब है कि translationX एनिमेशन के बाद, ऑब्जेक्ट वास्तव में नई स्थिति में होता है, और क्लिक नए स्थान पर संसाधित होते हैं।

Property Animation आर्किटेक्चर तीन मुख्य क्लासों पर बनाया गया है: ValueAnimator — आधार मान जनरेटर, ObjectAnimator — ऑब्जेक्ट गुण से बंधने के लिए उपक्लास, AnimatorSet — समूह एनिमेशन के लिए ऑर्केस्ट्रेटर। तीनों Interpolator (गति वक्र) और TypeEvaluator (मानों के बीच प्रक्षेप नियम) का समर्थन करते हैं।

Android Performance Patterns (Google, 2025) के अनुसार, Property Animation सही ढंग से कॉन्फ़िगर किए गए Interpolator और onAnimationUpdate() में भारी गणना के बिना 60 FPS तक चलता है। जटिल एनिमेशन (3D, फिजिक्स) के लिए, Android 12+ में RenderThread (RenderNode Animations) की सिफारिश की जाती है। Property Animation View गुणों — translationX, rotationY, scaleX, alpha और अन्य — को एनिमेट करने के लिए प्राथमिक विकल्प बना हुआ है।

ObjectAnimator: ऑब्जेक्ट गुणों का एनिमेशन

ObjectAnimator Property Animation का सबसे लोकप्रिय क्लास है। यह ValueAnimator का विस्तार करता है और एनिमेटेड मानों के साथ निर्दिष्ट ऑब्जेक्ट गुण के setter को स्वचालित रूप से कॉल करता है। ObjectAnimator के काम करने के लिए, ऑब्जेक्ट के पास एनिमेट किए जा रहे गुण के लिए एक सार्वजनिक setter होना चाहिए (उदाहरण के लिए, "translationX" गुण के लिए setTranslationX(float))।

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()
}

समर्थित View गुण: translationX, translationY, translationZ, rotation, rotationX, rotationY, scaleX, scaleY, alpha, x, y, elevation। ObjectAnimator.ofFloat() float गुणों के लिए, ofInt() int के लिए, ofObject() कस्टम प्रकारों (रंग, बिंदु) के लिए उपयोग किया जाता है। रंग एनिमेशन के लिए, ArgbEvaluator या HsvEvaluator के साथ ofObject() का उपयोग करें।

// ObjectAnimator कस्टम TypeEvaluator (रंग) के साथ
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()
}

// एक साथ कई गुणों को एनिमेट करना
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 — एनिमेशन ईवेंट ट्रैक करने के लिए एक इंटरफ़ेस: onAnimationStart, onAnimationEnd, onAnimationCancel, onAnimationRepeat। केवल आवश्यक विधियों को ओवरराइड करने के लिए AnimatorListenerAdapter का उपयोग करें। Android 12 से शुरू होकर, suspendAnimationFrame के माध्यम से कोरूटीन समर्थन के साथ Animator.AnimationCallback जोड़ा गया है।

ValueAnimator: एनिमेटेड मान उत्पन्न करना

ValueAnimator Property Animation का आधार क्लास है जो एक निर्धारित समय में शुरू से अंत तक एनिमेटेड मान उत्पन्न करता है। ObjectAnimator के विपरीत, ValueAnimator किसी ऑब्जेक्ट से बंधा नहीं होता — यह केवल मध्यवर्ती मानों की गणना करता है और एक श्रोता के माध्यम से सूचित करता है। डेवलपर तय करता है कि प्राप्त मानों के साथ क्या करना है: View गुण सेट करना, Drawable पैरामीटर बदलना, onDraw() में कस्टम ड्रॉइंग अपडेट करना।

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

"> ValueAnimator: लोडिंग प्रगति एनिमेशन
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() — पूर्णांक गुणों (चौड़ाई, ऊँचाई, चरणों की संख्या) के लिए उपयोग किया जाता है। ValueAnimator.ofObject() — TypeEvaluator के साथ कस्टम प्रकारों के लिए। ValueAnimator.ofPropertyValuesHolder() — एक टाइमर के साथ कई गुणों के समानांतर एनिमेशन के लिए, प्रत्येक गुण के लिए अलग Animators की तुलना में संसाधनों की बचत होती है।

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

ValueAnimator प्रदर्शन: 60 FPS पर, onAnimationUpdate हर ~16.7 ms पर कॉल किया जाता है। श्रोता के अंदर इनसे बचें: ऑब्जेक्ट आवंटन (PointF/RectF एक बार बनाएं), findViewById() कॉल करना, भारी गणना (फ़ाइल I/O, नेटवर्क)। 20+ एक साथ तत्वों को एनिमेट करने के लिए, 20 अलग Animators के बजाय एक Animator में PropertyValuesHolder का उपयोग करें। आकार बदलने वाले एनिमेशन के लिए, केवल एनिमेशन के अंत में View.setLayoutParams() का उपयोग करें (AnimatorListenerAdapter.onAnimationEnd के माध्यम से)।

AnimatorSet: एनिमेशन संयोजन

AnimatorSet एक ऑर्केस्ट्रेटर है जो कई Animator (ObjectAnimator, ValueAnimator) इंस्टेंस को एक विशिष्ट क्रम में चलाने की अनुमति देता है: अनुक्रमिक रूप से (playSequentially), समानांतर में (playTogether), देरी के साथ (after, before, with)। AnimatorSet नेस्टिंग का समर्थन करता है — एक AnimatorSet में जटिल परिदृश्यों के लिए अन्य AnimatorSets हो सकते हैं।

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

// AnimatorSet: अनुक्रमिक और समानांतर एनिमेशन
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 {
    // समानांतर में: fadeIn + slideUp
    play(fadeIn).with(slideUp)
    "> बाद में: 200ms विलंब के साथ bounce
    play(bounce).after(200L)

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

AnimatorSet.Builder चेन बनाने के लिए एक fluent API प्रदान करता है: with() — समानांतर में, before() — पहले, after() — बाद में। AnimatorSet सेट में सभी एनिमेशन को रोकने के लिए cancel() का समर्थन करता है। जटिल परिदृश्यों (25+ एनिमेटर) के लिए, PropertyValuesHolder का उपयोग करें — यह अधिक कुशल है क्योंकि यह प्रत्येक Animator के लिए अलग टाइमर के बजाय एक साझा टाइमर का उपयोग करता है।

Interpolator और TypeEvaluator: गति और प्रकार नियंत्रण

Interpolator 0 से 1 तक एनिमेशन की गति वक्र को परिभाषित करता है। Android अंतर्निहित Interpolator प्रदान करता है: LinearInterpolator (समान), AccelerateDecelerateInterpolator (धीमा-तेज़-धीमा), FastOutSlowInInterpolator (Material Design), OvershootInterpolator (लक्ष्य से आगे निकलने के साथ), BounceInterpolator (उछाल के साथ), AnticipateOvershootInterpolator (शुरू होने से पहले पीछे हटने और लक्ष्य से आगे निकलने के साथ)। कस्टम Interpolator TimeInterpolator के माध्यम से कार्यान्वित किया जाता है।

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

// BounceInterpolator — अंत में उछाल प्रभाव
val bounceAnim = ObjectAnimator.ofFloat(myView, "translationY", 0f, -50f).apply {
    duration = 600L
    interpolator = BounceInterpolator()
    start()
}

// AnticipateOvershoot — पीछे हटना, फिर आगे निकलना
val anticipateAnim = ObjectAnimator.ofFloat(myView, "scaleX", 1f, 1.3f).apply {
    duration = 500L
    interpolator = AnticipateOvershootInterpolator(2.0f)
    start()
}

TypeEvaluator — evaluate(fraction, startValue, endValue) विधि वाला एक इंटरफ़ेस जो शुरुआत और अंत के बीच मध्यवर्ती मान की गणना करता है। अंतर्निहित: ArgbEvaluator (int रंग), FloatEvaluator, IntEvaluator, PointFEvaluator, RectEvaluator। कस्टम डेटा प्रकारों के लिए (उदाहरण के लिए, तीन फ़ील्ड वाले कस्टम क्लास को एनिमेट करना), अपना स्वयं का TypeEvaluator लागू करें। समान सेटिंग्स के साथ कई Views को एनिमेट करने के लिए, PropertyValuesHolder का उपयोग करें — यह प्रॉपर्टी नामों और संबंधित मानों की एक सरणी स्वीकार करता है।

// ProgressState क्लास के लिए कस्टम TypeEvaluator
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 — अधिकतम प्रदर्शन
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()
}