प्रॉपर्टी ऐनिमेशन की खास जानकारी

लिखने का तरीका आज़माएं

Android के लिए, Jetpack Compose, सुझाया गया यूज़र इंटरफ़ेस (यूआई) टूलकिट है. Compose में ऐनिमेशन इस्तेमाल करने का तरीका जानें.

ऐनिमेट करें*AsState →

प्रॉपर्टी ऐनिमेशन सिस्टम एक मज़बूत फ़्रेमवर्क है, जिससे आपको करने के लिए इस्तेमाल किया जा सकता है. समय के साथ किसी भी ऑब्जेक्ट प्रॉपर्टी को बदलने के लिए, ऐनिमेशन सेट किया जा सकता है, स्क्रीन पर दिखाई देता है या नहीं. प्रॉपर्टी ऐनिमेशन किसी प्रॉपर्टी की (किसी ऑब्जेक्ट में फ़ील्ड) वैल्यू. किसी चीज़ को ऐनिमेट करने के लिए, वह ऑब्जेक्ट प्रॉपर्टी जिसे आप ऐनिमेट करना चाहते हैं, जैसे कि स्क्रीन पर किसी ऑब्जेक्ट की स्थिति, कितनी देर तक को ऐनिमेट करना है और किन वैल्यू के बीच ऐनिमेट करना है.

प्रॉपर्टी ऐनिमेशन सिस्टम की मदद से, ऐनिमेशन:

• अवधि: आप ऐनिमेशन की अवधि तय कर सकते हैं. डिफ़ॉल्ट तौर पर, यह अवधि 300 मि॰से॰ होती है.
• टाइम इंटरपोलेशन: यह तय किया जा सकता है कि प्रॉपर्टी की वैल्यू, एनिमेशन के वर्तमान बीते समय का फ़ंक्शन.
• दोहराव की गणना और व्यवहार: आप यह निर्दिष्ट कर सकते हैं कि किसी एनिमेशन को निम्न के रूप में दोहराया जाए या नहीं यह अवधि के अंत तक पहुंचता है और ऐनिमेशन को कितनी बार दोहराना होता है. आप यह भी कर सकते हैं यह तय करें कि क्या आपको ऐनिमेशन को उलटा चलाना है. इसे रिवर्स प्ले पर सेट करना ऐनिमेशन बार-बार, आगे और फिर पीछे की ओर तब तक आगे बढ़ता है, जब तक कि उसे दोहराने की संख्या पूरी न हो जाए.
• ऐनिमेटर सेट: आपके पास ऐनिमेशन को लॉजिकल सेट में ग्रुप करने का विकल्प होता है. ये ग्रुप एक साथ चलते हैं या क्रम से या तय देरी के बाद.
• फ़्रेम रीफ़्रेश होने में लगा समय: आपके पास यह तय करने का विकल्प होता है कि ऐनिमेशन के फ़्रेम को कितनी बार रीफ़्रेश करना है. कॉन्टेंट बनाने डिफ़ॉल्ट रूप से हर 10 मि॰से॰ में रीफ़्रेश होने पर सेट होता है. हालांकि, आपका ऐप्लिकेशन फ़्रेम को कितनी तेज़ी से रीफ़्रेश कर सकता है आम तौर पर, यह इस बात पर निर्भर करता है कि सिस्टम कितना व्यस्त है और सेट किए गए टाइमर को सिस्टम कितनी तेज़ी से ठीक कर सकता है.

प्रॉपर्टी ऐनिमेशन का पूरा उदाहरण देखने के लिए, कस्टम ट्रांज़िशन में ChangeColor क्लास GitHub पर सैंपल देखें.

प्रॉपर्टी ऐनिमेशन कैसे काम करता है

सबसे पहले, आइए एक आसान उदाहरण से जानते हैं कि ऐनिमेशन कैसे काम करता है. पहली इमेज में एक काल्पनिक ऑब्जेक्ट जो अपनी x प्रॉपर्टी के साथ ऐनिमेशन किया गया है. इससे पता चलता है कि हॉरिज़ॉन्टल लोकेशन. ऐनिमेशन की अवधि 40 मि॰से॰ और दूरी का समय 40 पिक्सल है. हर 10 मि॰से॰ में, जो डिफ़ॉल्ट फ़्रेम रीफ़्रेश दर होती है उसके आधार पर ऑब्जेक्ट मूव करता है हॉरिज़ॉन्टल तौर पर 10 पिक्सल. 40 मि॰से॰ के बाद, ऐनिमेशन बंद हो जाता है और ऑब्जेक्ट इतनी देर पर खत्म होता है हॉरिज़ॉन्टल पोज़िशन 40. यह लीनियर इंटरपोलेशन वाले ऐनिमेशन का एक उदाहरण है, जिसका मतलब है ऑब्जेक्ट एक जैसी रफ़्तार से चलता है.

पहला डायग्राम. लीनियर ऐनिमेशन का उदाहरण

नॉन-लीनियर इंटरपोलेशन के लिए भी ऐनिमेशन तय किए जा सकते हैं. दूसरी इमेज में दिखाया गया है कि वह काल्पनिक ऑब्जेक्ट जो ऐनिमेशन की शुरुआत में तेज़ी से बढ़ता है और ऐनिमेशन खत्म हो जाता है. ऑब्जेक्ट अब भी 40 मि॰से॰ में 40 पिक्सल मूव करता है, लेकिन लीनियर नहीं है. इस की शुरुआत में, यह एनिमेशन बीच के बिंदु तक बढ़ता है और फिर रुक जाता है, तो ऐनिमेशन खत्म होने तक बीच में पॉइंट करता है. जैसा कि दूसरी इमेज में दिखाया गया है, तय की गई दूरी ऐनिमेशन के शुरुआत और आखिर में, बीच के मुकाबले कम होता है.

दूसरा डायग्राम. नॉन-लीनियर ऐनिमेशन का उदाहरण

आइए, समझते हैं कि प्रॉपर्टी ऐनिमेशन सिस्टम के ज़रूरी कॉम्पोनेंट ऊपर बताए गए एनिमेशन की गणना करेंगे. इमेज 3 में दिखाया गया है कि मुख्य क्लास एक-दूसरे के साथ काम करते हैं.

तीसरी इमेज. ऐनिमेशन का हिसाब कैसे लगाया जाता है

ValueAnimator ऑब्जेक्ट आपके ऐनिमेशन के समय को ट्रैक करता है, जैसे कि ऐनिमेशन कितनी देर से चल रहा है और प्रॉपर्टी का मौजूदा मान ऐनिमेट किया जा रहा है.

ValueAnimator, TimeInterpolator को एनकैप्सुलेट करता है, जो ऐनिमेशन इंटरपोलेशन को परिभाषित करता है. साथ ही, TypeEvaluator, जो प्रॉपर्टी की वैल्यू कैलकुलेट करने का तरीका बताता है ऐनिमेशन वाला. उदाहरण के लिए, दूसरी इमेज में, इस्तेमाल किया गया TimeInterpolator AccelerateDecelerateInterpolator और TypeEvaluator IntEvaluator होंगे.

कोई ऐनिमेशन शुरू करने के लिए, एक ValueAnimator बनाएं और उसे जिस प्रॉपर्टी को ऐनिमेट करना है उसकी शुरुआती और आखिरी वैल्यू. साथ ही, कुल समय क्लिक करें. start() को कॉल करने पर, ऐनिमेशन जोड़ें शुरू होता है. पूरे ऐनिमेशन के दौरान, ValueAnimator पिछले फ़्रैक्शन को कैलकुलेट करता है 0 और 1 के बीच, एनिमेशन की अवधि और बीते समय के आधार पर. कॉन्टेंट बनाने बीता हुआ अंश, एनिमेशन पूरा होने के समय का प्रतिशत दिखाता है, 0 का अर्थ 0% होता है और 1 का मतलब 100% है. उदाहरण के लिए, इमेज 1 में, t = 10 ms पर बीता हुआ अंश .25 होगा क्योंकि कुल अवधि t = 40 मि॰से॰ है.

बीते हुए अंश का हिसाब लगाने के बाद, ValueAnimator मौजूदा समय में सेट किए गए TimeInterpolator को कॉल करता है. इससे इंटरपोलेट किया गया फ़्रैक्शन. इंटरपोलेट किया गया भिन्न, बीते हुए भिन्न को एक नए वह अंश जो सेट किए गए समय इंटरपोलेशन को ध्यान में रखता है. उदाहरण के लिए, दूसरी इमेज में, क्योंकि एनिमेशन धीरे-धीरे बढ़ता है, तो इंटरपोलेट किया गया भिन्न, लगभग .15, बीता हुआ अंश, .25, t = 10 मिलीसेकंड पर. इमेज 1 में, इंटरपोलेट किया गया फ़्रैक्शन हमेशा ऐसा ही होता है बीता हुआ अंश.

इंटरपोलेट किए गए फ़्रैक्शन का हिसाब लगाने पर, ValueAnimator कॉल उचित TypeEvaluator, मान की गणना करने के लिए प्रॉपर्टी के रूप में, इंटरपोलेट किए गए फ़्रैक्शन, शुरुआती वैल्यू, और आखिरी वैल्यू दिखेगी. उदाहरण के लिए, इमेज 2 में, t = पर इंटरपोलेट किया गया फ़्रैक्शन .15 था 10 मि॰से॰, इसलिए उस समय प्रॉपर्टी की वैल्यू .15 × (40 - 0) या 6 होगी.

प्रॉपर्टी ऐनिमेशन, व्यू ऐनिमेशन से किस तरह अलग है

व्यू ऐनिमेशन सिस्टम सिर्फ़ View को ऐनिमेट करता है ऑब्जेक्ट है, इसलिए अगर आप View के अलावा अन्य ऑब्जेक्ट को ऐनिमेट करना चाहते हैं, तो आपको अपना कोड डालें. व्यू ऐनिमेशन सिस्टम इस तरह से भी सीमित है कि यह यह View ऑब्जेक्ट के कुछ पहलुओं को ऐनिमेट करता है, जैसे कि स्केलिंग और उदाहरण के लिए, व्यू का रोटेशन, लेकिन बैकग्राउंड के रंग का नहीं.

व्यू ऐनिमेशन सिस्टम का एक नुकसान यह भी है कि इसमें सिर्फ़ तब बदलाव किया जाता है, जब दृश्य बनाया गया था, न कि वास्तविक दृश्य. उदाहरण के लिए, अगर आपने मूव करने के लिए किसी बटन को ऐनिमेट किया है स्क्रीन पर, बटन ठीक से खींचता है, लेकिन वास्तविक स्थान जहां आप बटन नहीं बदलता है, इसलिए इसे मैनेज करने के लिए आपको अपना लॉजिक लागू करना होगा.

प्रॉपर्टी ऐनिमेशन सिस्टम से, ये पाबंदियां पूरी तरह से हट जाती हैं और ऐनिमेट किए जा सकते हैं किसी भी ऑब्जेक्ट की कोई भी प्रॉपर्टी (व्यू और नॉन-व्यू) होती है और ऑब्जेक्ट में ही असल में बदलाव होता है. प्रॉपर्टी ऐनिमेशन सिस्टम, ऐनिमेशन को बेहतर तरीके से दिखाने में भी ज़्यादा मज़बूत है. पर हाई लेवल का इस्तेमाल करते हैं, तो आपने उन प्रॉपर्टी को ऐनिमेटर असाइन किया होता है जिन्हें आपको ऐनिमेट करना है, जैसे कि रंग, स्थिति या आकार और ऐनिमेशन के पहलुओं को परिभाषित कर सकते हैं, जैसे इंटरपोलेशन और कई ऐनिमेशनर का सिंक होना.

हालांकि, व्यू ऐनिमेशन सिस्टम को सेट अप करने में कम समय लगता है और इसे लिखने में कम कोड की ज़रूरत होती है. अगर व्यू ऐनिमेशन वे सभी काम पूरे कर लेता है जो आपको करना है या अगर आपका मौजूदा कोड पहले से ही मौजूद है ठीक वैसे ही काम करता है जैसे आप चाहते हैं, तो प्रॉपर्टी ऐनिमेशन सिस्टम का इस्तेमाल करने की कोई ज़रूरत नहीं है. यह भी हो सकता है अगर उपयोग का मामला सामने आता है, तो अलग-अलग परिस्थितियों के लिए दोनों ऐनिमेशन सिस्टम का इस्तेमाल करना सही रहेगा.

एपीआई की खास जानकारी

आपको android.animation में, प्रॉपर्टी ऐनिमेशन सिस्टम के ज़्यादातर एपीआई मिल सकते हैं. क्योंकि व्यू ऐनिमेशन सिस्टम पहले से ही android.view.animation में कई इंटरपोलेटर के बारे में बताता है, तो इनका इस्तेमाल किया जा सकता है ऐसे इंटरपोलेटर भी देख सकते हैं, जो प्रॉपर्टी ऐनिमेशन सिस्टम में मौजूद हैं. यहां दी गई टेबल में, मुख्य कॉम्पोनेंट, प्रॉपर्टी ऐनिमेशन सिस्टम के कॉम्पोनेंट पर काम करता है.

Animator क्लास, कॉन्टेंट बनाने का बेसिक स्ट्रक्चर उपलब्ध कराती है ऐनिमेशन. आम तौर पर, इस क्लास का इस्तेमाल सीधे तौर पर नहीं किया जाता, क्योंकि इससे सिर्फ़ क्लास के लिए बहुत कम जानकारी मिलती है की जाने वाली सुविधाओं का इस्तेमाल, ऐनिमेशन वैल्यू के पूरी तरह से काम करने के लिए किया जाना चाहिए. नीचे दिए गए सब-क्लास Animator को बढ़ा देती हैं:

टेबल 1. ऐनिमेशन बनाने वाले

आकलन करने वाले, प्रॉपर्टी ऐनिमेशन सिस्टम को बताते हैं कि दी गई वैल्यू को कैलकुलेट कैसे करना है प्रॉपर्टी. वे Animator से मिले समय के हिसाब से डेटा लेते हैं क्लास, ऐनिमेशन के शुरुआती और आखिरी मान, और प्रॉपर्टी की ऐनिमेशन वैल्यू कैलकुलेट करना पर आधारित होता है. प्रॉपर्टी ऐनिमेशन सिस्टम से ये समीक्षक मिलते हैं:

दूसरी टेबल. मूल्यांकन करने वाले

टाइम इंटरपोलेटर से तय होता है कि ऐनिमेशन में खास वैल्यू को कैलकुलेट करने के लिए, समय का फ़ंक्शन. उदाहरण के लिए, आप यह तय कर सकते हैं कि ऐनिमेशन पूरे क्रम में लीनियर तौर पर हों ऐनिमेशन, जिसका मतलब है कि ऐनिमेशन पूरे समय समान रूप से चलता है, या आप ऐनिमेशन तय कर सकते हैं नॉन-लीनियर टाइम का इस्तेमाल किया हो. उदाहरण के लिए, टाइम की शुरुआत में एक्सेलरेटर और ऐनिमेशन खत्म हो जाता है. टेबल 3 में, android.view.animation में मौजूद इंटरपोलेटर के बारे में बताया गया है. अगर दिए गए इंटरपोलेटर सूट में से कोई नहीं TimeInterpolator इंटरफ़ेस को लागू करें और खुद का इंटरफ़ेस बनाएं. कस्टम वैल्यू लिखने के तरीके के बारे में ज़्यादा जानकारी के लिए, इंटरपोलेटर का इस्तेमाल करना लेख पढ़ें इंटरपोलेटर.

तीसरी टेबल. इंटरपोलेटर

ValueAnimator का इस्तेमाल करके ऐनिमेट करें

ValueAnimator क्लास आपको int, float या रंग का सेट तय करके ऐनिमेशन की अवधि वैल्यू को ऐनिमेट करना होगा. इनमें से किसी एक पर कॉल करने पर, आपको ValueAnimator मिलता है इसकी फ़ैक्ट्री तरीके: ofInt(), ofFloat() या ofObject(). उदाहरण के लिए:

ValueAnimator.ofFloat(0f, 100f).apply {
    duration = 1000
    start()
}

ValueAnimator animation = ValueAnimator.ofFloat(0f, 100f);
animation.setDuration(1000);
animation.start();

इस कोड में, ValueAnimator ऐनिमेशन, 0 से 100 के बीच, 1,000 मि॰से॰ की अवधि के लिए, जब start() तरीका चलता है.

यहां दिए गए काम करके, ऐनिमेट करने के लिए अपनी पसंद का कोई टाइप तय किया जा सकता है:

ValueAnimator.ofObject(MyTypeEvaluator(), startPropertyValue, endPropertyValue).apply {
    duration = 1000
    start()
}

ValueAnimator animation = ValueAnimator.ofObject(new MyTypeEvaluator(), startPropertyValue, endPropertyValue);
animation.setDuration(1000);
animation.start();

इस कोड में, ValueAnimator ऐनिमेशन, startPropertyValue और endPropertyValue के बीच start() तरीका इस्तेमाल होने पर, 1,000 मि॰से॰ के लिए MyTypeEvaluator से मिला लॉजिक.

ऐनिमेशन की वैल्यू इस्तेमाल करने के लिए, AnimatorUpdateListener अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है ValueAnimator ऑब्जेक्ट में, जैसा कि यह कोड डालें:

ValueAnimator.ofObject(...).apply {
    ...
    addUpdateListener { updatedAnimation ->
        // You can use the animated value in a property that uses the
        // same type as the animation. In this case, you can use the
        // float value in the translationX property.
        textView.translationX = updatedAnimation.animatedValue as Float
    }
    ...
}

animation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    @Override
    public void onAnimationUpdate(ValueAnimator updatedAnimation) {
        // You can use the animated value in a property that uses the
        // same type as the animation. In this case, you can use the
        // float value in the translationX property.
        float animatedValue = (float)updatedAnimation.getAnimatedValue();
        textView.setTranslationX(animatedValue);
    }
});

onAnimationUpdate() में तरीका है, जिससे आप अपडेट किए गए ऐनिमेशन मान को ऐक्सेस कर सकते हैं और आपके व्यू में से किसी एक को चुनें. श्रोताओं के बारे में ज़्यादा जानकारी के लिए, ऐनिमेशन लिसनर.

ObjectAnimator का इस्तेमाल करके ऐनिमेट करें

ObjectAnimator, ValueAnimator की सब-क्लास है. इसके बारे में पिछले सेक्शन में बताया गया था और इसमें समय की जानकारी शामिल होती है ValueAnimator के इंजन और वैल्यू कंप्यूटेशन में ये काम किए जा सकते हैं टारगेट ऑब्जेक्ट की नाम वाली प्रॉपर्टी को ऐनिमेट करें. इससे किसी भी ऑब्जेक्ट को ऐनिमेट करना बहुत आसान हो जाता है, अब ValueAnimator.AnimatorUpdateListener लागू करने की ज़रूरत नहीं है, क्योंकि ऐनिमेट की गई प्रॉपर्टी अपने-आप अपडेट हो जाती है.

ObjectAnimator को इंस्टैंशिएट करना ValueAnimator की तरह ही है, लेकिन आप ऑब्जेक्ट और उस ऑब्जेक्ट की प्रॉपर्टी का नाम भी तय कर सकते हैं (जैसा कि और इनके बीच ऐनिमेट करने के लिए वैल्यू के साथ:

ObjectAnimator.ofFloat(textView, "translationX", 100f).apply {
    duration = 1000
    start()
}

ObjectAnimator animation = ObjectAnimator.ofFloat(textView, "translationX", 100f);
animation.setDuration(1000);
animation.start();

ObjectAnimator प्रॉपर्टी को अपडेट करने के लिए अगर हां, तो आपको ये काम करने होंगे:

• आप जिस ऑब्जेक्ट प्रॉपर्टी को ऐनिमेट कर रहे हैं उसका सेटर फ़ंक्शन (ऊट के केस में) इस रूप में होना चाहिए: set<PropertyName>(). क्योंकि ObjectAnimator ऐनिमेशन के दौरान प्रॉपर्टी अपने-आप अपडेट हो जाती है, लेकिन प्रॉपर्टी का ऐक्सेस होना ज़रूरी है इस सेटर विधि के साथ. उदाहरण के लिए, अगर प्रॉपर्टी का नाम foo है, तो आपको एक setFoo() तरीका है. अगर यह सेटर विधि मौजूद नहीं है, तो आपके पास तीन विकल्प:
  • अगर आपके पास ऐसा करने का अधिकार है, तो क्लास में सेटर मेथड जोड़ें.
  • ऐसी रैपर क्लास का इस्तेमाल करें जिसमें बदलाव करने का अधिकार आपके पास है और उस रैपर को एक मान्य सेटर तरीके के साथ मान और उसे मूल ऑब्जेक्ट पर फ़ॉरवर्ड करें.
  • इसके बजाय, ValueAnimator का इस्तेमाल करें.
• अगर आप ObjectAnimator में से किसी एक फ़ैक्ट्री तरीके में, values... पैरामीटर के लिए सिर्फ़ एक वैल्यू तय करते हैं, तो इसे आखिरी वैल्यू माना जाता है ऐनिमेशन. इसलिए, आप जिस ऑब्जेक्ट प्रॉपर्टी को ऐनिमेट कर रहे हैं उसमें गैटर फ़ंक्शन होना चाहिए जिसका इस्तेमाल ऐनिमेशन की शुरुआती वैल्यू जानने के लिए किया जाता है. गैटर फ़ंक्शन इसमें होना चाहिए get<PropertyName>() का फ़ॉर्म. उदाहरण के लिए, अगर प्रॉपर्टी का नाम foo, आपके पास getFoo() तरीका होना चाहिए.
• जिस प्रॉपर्टी को ऐनिमेट करना है उसका गैटर (अगर ज़रूरी हो) और सेटर तरीके उसी टाइप पर ऑपरेट किया जा सकता है जो ObjectAnimator के लिए तय की गई शुरुआती और आखिरी वैल्यू पर आधारित है. उदाहरण के लिए, आपके पास targetObject.setPropName(float) और targetObject.getPropName() अगर नीचे दी गई ObjectAnimator को बनाया जाता है, तो:

  ObjectAnimator.ofFloat(targetObject, "propName", 1f)
  

• इस बात पर निर्भर करते हुए कि आप किस प्रॉपर्टी या ऑब्जेक्ट को ऐनिमेट कर रहे हैं, आपको किसी व्यू पर invalidate() तरीके को कॉल करना पड़ सकता है, ताकि स्क्रीन अपडेट की गई ऐनिमेटेड वैल्यू. आप ऐसा इसमें करते हैं: onAnimationUpdate() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है कॉलबैक. उदाहरण के लिए, किसी Drawable ऑब्जेक्ट की रंग प्रॉपर्टी को ऐनिमेट करने से सिर्फ़ तो स्क्रीन पर दिखाई देता है. व्यू में मौजूद सभी प्रॉपर्टी सेटर, जैसे setAlpha() और setTranslationX() तो आपको इन्हें अमान्य करने की ज़रूरत नहीं है. नई वैल्यू का इस्तेमाल करें. श्रोताओं के बारे में ज़्यादा जानकारी के लिए, ऐनिमेशन लिसनर.

AnimatorSet का इस्तेमाल करके, कई ऐनिमेशन को कोरियोग्राफ़ करें

कई मामलों में, आपको कोई ऐसा ऐनिमेशन चलाना चाहिए जो इस बात पर निर्भर करता है कि कोई दूसरा ऐनिमेशन कब शुरू होता है या खत्म. Android सिस्टम आपको ऐनिमेशन को AnimatorSet में एक साथ बंडल करने की सुविधा देता है, ताकि आप यह तय कर सकें कि ऐनिमेशन शुरू करना है या नहीं साथ ही, क्रम से लगाना या किसी खास देरी के बाद. AnimatorSet ऑब्जेक्ट को एक-दूसरे में भी नेस्ट किया जा सकता है.

यह कोड स्निपेट यह Animator चलाता है ऑब्जेक्ट सबमिट करते समय इस तरह से शामिल करें:

1. bounceAnim नाटक होगा.
2. squashAnim1, squashAnim2, stretchAnim1, और नाटक करती है stretchAnim2 शामिल है.
3. bounceBackAnim नाटक होगा.
4. fadeAnim नाटक होगा.

val bouncer = AnimatorSet().apply {
    play(bounceAnim).before(squashAnim1)
    play(squashAnim1).with(squashAnim2)
    play(squashAnim1).with(stretchAnim1)
    play(squashAnim1).with(stretchAnim2)
    play(bounceBackAnim).after(stretchAnim2)
}
val fadeAnim = ObjectAnimator.ofFloat(newBall, "alpha", 1f, 0f).apply {
    duration = 250
}
AnimatorSet().apply {
    play(bouncer).before(fadeAnim)
    start()
}

AnimatorSet bouncer = new AnimatorSet();
bouncer.play(bounceAnim).before(squashAnim1);
bouncer.play(squashAnim1).with(squashAnim2);
bouncer.play(squashAnim1).with(stretchAnim1);
bouncer.play(squashAnim1).with(stretchAnim2);
bouncer.play(bounceBackAnim).after(stretchAnim2);
ValueAnimator fadeAnim = ObjectAnimator.ofFloat(newBall, "alpha", 1f, 0f);
fadeAnim.setDuration(250);
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.play(bouncer).before(fadeAnim);
animatorSet.start();

ऐनिमेशन लिसनर

यहां दिए गए लिसनर के साथ, ऐनिमेशन के दौरान अहम इवेंट सुने जा सकते हैं.

• Animator.AnimatorListener
  • onAnimationStart() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है - ऐनिमेशन शुरू होने पर कॉल किया जाता है.
  • onAnimationEnd() से ऐनिमेशन खत्म होने पर कॉल किया जाता है.
  • onAnimationRepeat() - यह तब कॉल किया जाता है, जब ऐनिमेशन अपने-आप दोहराता है.
  • onAnimationCancel() - ऐनिमेशन बंद होने पर कॉल किया जाता है. रद्द किया गया ऐनिमेशन onAnimationEnd() को भी कॉल करता है, इस बात से कोई फ़र्क़ नहीं पड़ता कि उन्हें कैसे खत्म किया गया था.
• ValueAnimator.AnimatorUpdateListener

  • onAnimationUpdate() - ऐनिमेशन के हर फ़्रेम पर कॉल किया जाता है. यह इवेंट इन्हें सुनें इस अवधि के दौरान ValueAnimator से जनरेट हुई कुल वैल्यू का इस्तेमाल करें ऐनिमेशन. वैल्यू का इस्तेमाल करने के लिए, ValueAnimator ऑब्जेक्ट से क्वेरी करें getAnimatedValue() तरीके से मौजूदा ऐनिमेटेड वैल्यू पाने के लिए, इवेंट में पास किया जाता है. इसे लागू करना ValueAnimator का इस्तेमाल करने पर, लिसनर होना ज़रूरी है.

    आप जिस प्रॉपर्टी या ऑब्जेक्ट को ऐनिमेट कर रहे हैं उसके आधार पर, आपको व्यू पर invalidate(), स्क्रीन की नई ऊंचाइयों को छू लें. उदाहरण के लिए, ड्रॉ करने लायक ऑब्जेक्ट की कलर प्रॉपर्टी, स्क्रीन पर सिर्फ़ तब अपडेट होती है, जब वह ऑब्जेक्ट उस घटना से जुड़ी जानकारी देती है. View पर प्रॉपर्टी सेट करने वाले सभी लोग, जैसे कि setAlpha() और setTranslationX() ने व्यू अमान्य किया ठीक है, इसलिए आपको इन तरीकों को नई वैल्यू के साथ कॉल करते समय, व्यू को अमान्य करने की ज़रूरत नहीं है.

इसके बजाय, AnimatorListenerAdapter क्लास को बढ़ाया जा सकता है Animator.AnimatorListener इंटरफ़ेस को लागू करने के बाद, अगर आप ऐसा नहीं करते हैं Animator.AnimatorListener की सभी विधियां लागू करना चाहते हैं इंटरफ़ेस पर कॉपी करने की सुविधा मिलती है. AnimatorListenerAdapter क्लास खाली है उन तरीकों को लागू करना जिन्हें बदला जा सकता है.

उदाहरण के लिए, यह कोड स्निपेट AnimatorListenerAdapter बनाता है सिर्फ़ onAnimationEnd() के लिए कॉलबैक:

ObjectAnimator.ofFloat(newBall, "alpha", 1f, 0f).apply {
    duration = 250
    addListener(object : AnimatorListenerAdapter() {
        override fun onAnimationEnd(animation: Animator) {
            balls.remove((animation as ObjectAnimator).target)
        }
    })
}

ValueAnimator fadeAnim = ObjectAnimator.ofFloat(newBall, "alpha", 1f, 0f);
fadeAnim.setDuration(250);
fadeAnim.addListener(new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator animation) {
    balls.remove(((ObjectAnimator)animation).getTarget());
}

लेआउट में किए गए बदलावों को ViewGroup ऑब्जेक्ट में ऐनिमेट करें

प्रॉपर्टी ऐनिमेशन सिस्टम, ViewGroup ऑब्जेक्ट में बदलावों को ऐनिमेट करता है साथ ही, यह व्यू ऑब्जेक्ट को ऐनिमेट करने का आसान तरीका मुहैया कराता है.

आप LayoutTransition क्लास. ViewGroup के अंदर के व्यू यह कर सकते हैं जब आप उन्हें किसी विशेषता के साथ या उन्हें किसी ViewGroup से या किसी व्यू के setVisibility() तरीका VISIBLE, INVISIBLE या GONE. ViewGroup में बचे हुए व्यू भी ये काम कर सकते हैं: व्यू जोड़ने या हटाने पर, उन्हें उनकी नई जगह पर ऐनिमेशन के तौर पर इस्तेमाल किया जा सकता है. आप LayoutTransition ऑब्जेक्ट में ये ऐनिमेशन setAnimator() पर कॉल करके और किसी Animator ऑब्जेक्ट में ये LayoutTransition कॉन्सटेंट:

• APPEARING - उन आइटम पर चलने वाले ऐनिमेशन को दिखाने वाला फ़्लैग कंटेनर में दिखाई दे रहे हैं.
• CHANGE_APPEARING - उन आइटम पर चलने वाले ऐनिमेशन को दिखाने वाला फ़्लैग कंटेनर में एक नए आइटम के दिखाई देने के कारण बदल रहा है.
• DISAPPEARING - उन आइटम पर चलने वाले ऐनिमेशन को दिखाने वाला फ़्लैग कंटेनर से गायब हो रहा है.
• CHANGE_DISAPPEARING - उन आइटम पर चलने वाले ऐनिमेशन को दिखाने वाला फ़्लैग कंटेनर से किसी आइटम के गायब होने के कारण बदल रहे हैं.

इन चार तरह के इवेंट के लिए अपने हिसाब से बनाए गए ऐनिमेशन बनाए जा सकते हैं, ताकि इवेंट का लुक अपने हिसाब से बनाया जा सके अपने लेआउट ट्रांज़िशन के बारे में बताएं या ऐनिमेशन सिस्टम को डिफ़ॉल्ट ऐनिमेशन इस्तेमाल करने का निर्देश दें.

वैल्यू के तौर पर android:animateLayoutchanges एट्रिब्यूट को true पर सेट करने के लिए ViewGroup ये काम करता है:

<LinearLayout
    android:orientation="vertical"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    android:id="@+id/verticalContainer"
    android:animateLayoutChanges="true" />

इस एट्रिब्यूट को 'सही है' पर सेट करने से, ऐसे व्यू अपने-आप ऐनिमेट होते हैं जिन्हें ViewGroup और बाकी व्यू, ViewGroup.

StateListAnimator का इस्तेमाल करके, व्यू की स्थिति में हुए बदलावों को ऐनिमेट करें

StateListAnimator क्लास की मदद से, ऐसे ऐनिमेटर तय किए जा सकते हैं जो तब चलते हैं व्यू की स्थिति बदल जाती है. यह ऑब्जेक्ट किसी Animator ऑब्जेक्ट, बताए गए समय पर उस ऐनिमेशन को कॉल कर रहा है व्यू की स्थिति में बदलाव होता है. जैसे, "दबा हुआ" या "फ़ोकस किया गया".

एक्सएमएल रिसॉर्स में, StateListAnimator को रूट के साथ तय किया जा सकता है <selector> एलिमेंट और चाइल्ड <item> एलिमेंट, जिनमें से हर एक के बारे में बताया गया है StateListAnimator क्लास के ज़रिए तय की गई एक अलग व्यू स्टेट. हर <item> में प्रॉपर्टी ऐनिमेशन सेट की परिभाषा शामिल है.

उदाहरण के लिए, यह फ़ाइल एक स्टेट लिस्ट ऐनिमेटर बनाती है, जो x और y स्केल को बदलता है इसे दबाए रखने पर दृश्य:

res/xml/animate_Scale.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- the pressed state; increase x and y size to 150% -->
    <item android:state_pressed="true">
        <set>
            <objectAnimator android:propertyName="scaleX"
                android:duration="@android:integer/config_shortAnimTime"
                android:valueTo="1.5"
                android:valueType="floatType"/>
            <objectAnimator android:propertyName="scaleY"
                android:duration="@android:integer/config_shortAnimTime"
                android:valueTo="1.5"
                android:valueType="floatType"/>
        </set>
    </item>
    <!-- the default, non-pressed state; set x and y size to 100% -->
    <item android:state_pressed="false">
        <set>
            <objectAnimator android:propertyName="scaleX"
                android:duration="@android:integer/config_shortAnimTime"
                android:valueTo="1"
                android:valueType="floatType"/>
            <objectAnimator android:propertyName="scaleY"
                android:duration="@android:integer/config_shortAnimTime"
                android:valueTo="1"
                android:valueType="floatType"/>
        </set>
    </item>
</selector>

किसी दृश्य में स्थिति सूची ऐनिमेटर अटैच करने के लिए, android:stateListAnimator एट्रिब्यूट की वैल्यू इस तरह से दी जाती है:

<Button android:stateListAnimator="@xml/animate_scale"
        ... />

अब animate_scale.xml में परिभाषित एनिमेशन का उपयोग तब किया जाता है, जब इस बटन के राज्य में बदलाव.

या इसके बजाय अपने कोड के किसी दृश्य में स्थिति सूची ऐनिमेटर असाइन करने के लिए, AnimatorInflater.loadStateListAnimator() तरीका इस्तेमाल करें और ऐनिमेटर को इन्हें असाइन करें: View.setStateListAnimator() तरीके से अपना व्यू.

या दृश्य की प्रॉपर्टी को ऐनिमेट करने के बजाय, आप AnimatedStateListDrawable का इस्तेमाल करके, स्थिति में बदलाव किया जा सकता है. इसमें कुछ सिस्टम विजेट Android 5.0 में डिफ़ॉल्ट रूप से इन ऐनिमेशन का इस्तेमाल किया जाता है. नीचे दिए गए उदाहरण में बताया गया है कि AnimatedStateListDrawable को एक्सएमएल संसाधन के रूप में परिभाषित करने के लिए:

<!-- res/drawable/myanimstatedrawable.xml -->
<animated-selector
    xmlns:android="http://schemas.android.com/apk/res/android">

    <!-- provide a different drawable for each state-->
    <item android:id="@+id/pressed" android:drawable="@drawable/drawableP"
        android:state_pressed="true"/>
    <item android:id="@+id/focused" android:drawable="@drawable/drawableF"
        android:state_focused="true"/>
    <item android:id="@id/default"
        android:drawable="@drawable/drawableD"/>

    <!-- specify a transition -->
    <transition android:fromId="@+id/default" android:toId="@+id/pressed">
        <animation-list>
            <item android:duration="15" android:drawable="@drawable/dt1"/>
            <item android:duration="15" android:drawable="@drawable/dt2"/>
            ...
        </animation-list>
    </transition>
    ...
</animated-selector>

TypeEvaluator का इस्तेमाल करें

अगर आपको किसी ऐसे टाइप को ऐनिमेट करना है जिसके बारे में Android सिस्टम के पास जानकारी नहीं है, तो अपने हिसाब से टाइप बनाए जा सकते हैं समीक्षक ने TypeEvaluator इंटरफ़ेस को लागू किया है. वे टाइप जो जिनकी पहचान Android सिस्टम को दी गई है. जैसे, int, float या रंग हैं जो IntEvaluator, FloatEvaluator, और ArgbEvaluator टाइप के साथ काम करता है समीक्षक.

TypeEvaluator में सिर्फ़ एक तरीका लागू किया जा सकता है evaluate() तरीका है. इससे आपको वह ऐनिमेटर जिसका इस्तेमाल, आपकी ऐनिमेशन वाली प्रॉपर्टी के लिए सही वैल्यू रिटर्न के लिए किया जा रहा है ऐनिमेशन का मौजूदा पॉइंट. FloatEvaluator क्लास दिखाती है इसे कैसे करें:

private class FloatEvaluator : TypeEvaluator<Any> {

    override fun evaluate(fraction: Float, startValue: Any, endValue: Any): Any {
        return (startValue as Number).toFloat().let { startFloat ->
            startFloat + fraction * ((endValue as Number).toFloat() - startFloat)
        }
    }

}

public class FloatEvaluator implements TypeEvaluator {

    public Object evaluate(float fraction, Object startValue, Object endValue) {
        float startFloat = ((Number) startValue).floatValue();
        return startFloat + fraction * (((Number) endValue).floatValue() - startFloat);
    }
}

ध्यान दें: जब ValueAnimator (या ObjectAnimator) चलता है, तो यह ऐनिमेशन (0 और 1 के बीच का कोई मान) और फिर उसके इंटरपोलेट किए गए वर्शन की गणना करता है इस्तेमाल किए जा रहे इंटरपोलेटर के आधार पर देखा जा सकता है. इंटरपोलेट किया गया अंश वह है जिसे fraction पैरामीटर से आपके TypeEvaluator को मिलता है, इसलिए ऐनिमेशन वैल्यू कैलकुलेट करते समय, इंटरपोलेटर पर ध्यान नहीं देना चाहिए.

इंटरपोलेटर का इस्तेमाल करें

इंटरपोलेटर से पता चलता है कि ऐनिमेशन में खास वैल्यू को कैलकुलेट करके, समय. उदाहरण के लिए, आपके पास यह तय करने का विकल्प है कि ऐनिमेशन, पूरे ऐनिमेशन में लीनियर तरीके से चलेगा, इसका मतलब है कि ऐनिमेशन पूरे समय समान रूप से चलता है या आप इस्तेमाल करने के लिए ऐनिमेशन तय कर सकते हैं उदाहरण के लिए, नॉन-लीनियर समय का इस्तेमाल करते समय ऐनिमेशन.

ऐनिमेशन सिस्टम में मौजूद इंटरपोलेटर को उन ऐनिमेटर से कुछ हिस्सा मिलता है जो ऐनिमेशन का बीता हुआ समय. इंटरपोलेटर इस भिन्न को इस प्रकार के प्रकार से मेल खाने के लिए संशोधित करते हैं दिखाने के लिए बनाया गया है. Android सिस्टम, यहां दिए गए कॉमन इंटरपोलेटर का एक सेट उपलब्ध कराता है android.view.animation package. अगर इनमें से कोई भी आपके की आवश्यकता है, तो आप TimeInterpolator इंटरफ़ेस लागू कर सकते हैं और अपना मालिकाना हक है.

उदाहरण के लिए, नीचे डिफ़ॉल्ट इंटरपोलेटर AccelerateDecelerateInterpolator और LinearInterpolator, इंटरपोलेट किए गए भिन्नों की तुलना कैसे करते हैं. बीते हुए अंश पर LinearInterpolator का कोई प्रभाव नहीं होता है. AccelerateDecelerateInterpolator ऐनिमेशन में तेज़ी से फ़ोकस करता है और कम हो जाता है. नीचे दिए गए तरीके से इन इंटरपोलेटर का लॉजिक तय होता है:

AcceleratedecelerateInterplator

override fun getInterpolation(input: Float): Float =
        (Math.cos((input + 1) * Math.PI) / 2.0f).toFloat() + 0.5f

@Override
public float getInterpolation(float input) {
    return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
}

लीनियर इंटरपोलेटर

override fun getInterpolation(input: Float): Float = input

@Override
public float getInterpolation(float input) {
    return input;
}

नीचे दी गई टेबल में वे अनुमानित वैल्यू दी गई हैं जिन्हें इन पैरामीटर के आधार पर कैलकुलेट किया जाता है 1000 मि॰से॰ तक चलने वाले ऐनिमेशन के लिए इंटरपोलेटर:

जैसा कि टेबल में दिखाया गया है, LinearInterpolator से वैल्यू बदल जाती हैं समान गति से, हर 200 मि॰से॰ के लिए .2. AccelerateDecelerateInterpolator, LinearInterpolator से 200 मि॰से॰ से 600 मि॰से॰ के बीच की वैल्यू तेज़ी से बदलता है और वैल्यू 600 मि॰से॰ के बीच कम होती है 1000 मिलीसेकंड.

कीफ़्रेम तय करना

Keyframe ऑब्जेक्ट में समय/वैल्यू का ऐसा पेयर होता है जो आपको ऐनिमेशन के किसी खास समय में कोई खास स्थिति. हर मुख्य-फ़्रेम का अपना अलग से एक मुख्य-फ़्रेम हो सकता है पिछले वीडियो के बीच के अंतराल में ऐनिमेशन के व्यवहार को कंट्रोल करने के लिए इंटरपोलेटर और इस मुख्य-फ़्रेम का समय.

Keyframe ऑब्जेक्ट को इंस्टैंशिएट करने के लिए, आपको किसी फ़ैक्ट्री का इस्तेमाल करना होगा तरीके, ofInt(), ofFloat(), या ofObject() का सही प्रकार Keyframe पाने के लिए. फिर आप कॉल करें ofKeyframe() फ़ैक्ट्री मेथड से PropertyValuesHolder ऑब्जेक्ट पाएं. जब आपको ऑब्जेक्ट मिल जाए, तो PropertyValuesHolder ऑब्जेक्ट को पास करके, ऐनिमेटर पाएं और ऑब्जेक्ट को ऐनिमेट करना है. नीचे दिया गया कोड स्निपेट यह काम करने का तरीका बताता है:

val kf0 = Keyframe.ofFloat(0f, 0f)
val kf1 = Keyframe.ofFloat(.5f, 360f)
val kf2 = Keyframe.ofFloat(1f, 0f)
val pvhRotation = PropertyValuesHolder.ofKeyframe("rotation", kf0, kf1, kf2)
ObjectAnimator.ofPropertyValuesHolder(target, pvhRotation).apply {
    duration = 5000
}

Keyframe kf0 = Keyframe.ofFloat(0f, 0f);
Keyframe kf1 = Keyframe.ofFloat(.5f, 360f);
Keyframe kf2 = Keyframe.ofFloat(1f, 0f);
PropertyValuesHolder pvhRotation = PropertyValuesHolder.ofKeyframe("rotation", kf0, kf1, kf2);
ObjectAnimator rotationAnim = ObjectAnimator.ofPropertyValuesHolder(target, pvhRotation);
rotationAnim.setDuration(5000);

ऐनिमेशन व्यू

प्रॉपर्टी ऐनिमेशन सिस्टम, व्यू ऑब्जेक्ट और ऑफ़र के स्ट्रीमलाइन किए गए ऐनिमेशन की अनुमति देता है कुछ फ़ायदे हैं. व्यू ऐनिमेशन सिस्टम ने व्यू ऑब्जेक्ट को ड्रॉ करने के तरीके को बदलकर उन्हें बदल दिया है. यह था हर व्यू के कंटेनर में हैंडल किया जाता है, क्योंकि व्यू में बदलाव करने के लिए कोई प्रॉपर्टी नहीं होती. इसकी वजह से व्यू ऐनिमेटेड हो गया, लेकिन व्यू ऑब्जेक्ट में कोई बदलाव नहीं हुआ. यह इसकी वजह से, कोई ऑब्जेक्ट अब भी अपनी मूल जगह पर मौजूद है. जिन्हें स्क्रीन पर किसी दूसरे स्थान पर बनाया गया हो. Android 3.0 में, नई प्रॉपर्टी और संबंधित इस कमी को दूर करने के लिए, गैटर और सेटर तरीके जोड़े गए.

प्रॉपर्टी ऐनिमेशन सिस्टम स्क्रीन पर व्यू को ऐनिमेट कर सकता है. इसके लिए, व्यू ऑब्जेक्ट में असल प्रॉपर्टी को बदलना होगा. तय सीमा में इसके अलावा, व्यू से invalidate() को अपने-आप कॉल भी किया जा सकता है का इस्तेमाल करके स्क्रीन की प्रॉपर्टी में बदलाव किया जा सकता है. View क्लास में शामिल नई प्रॉपर्टी, प्रॉपर्टी ऐनिमेशन की सुविधा देती हैं:

• translationX और translationY: ये प्रॉपर्टी कंट्रोल करती हैं कि व्यू, इसके बाएं और सबसे ऊपर के निर्देशांक से डेल्टा के रूप में स्थित होता है. ये निर्देशांक इसके लेआउट से सेट होते हैं कंटेनर.
• rotation, rotationX, और rotationY: ये प्रॉपर्टी पिवट पॉइंट के आस-पास, 2D (rotation प्रॉपर्टी) और 3D में रोटेशन कंट्रोल करना.
• scaleX और scaleY: ये प्रॉपर्टी, पिवट पॉइंट के आस-पास देखें.
• pivotX और pivotY: ये प्रॉपर्टी, पिवट पॉइंट, जिसके आस-पास रोटेशन और स्केलिंग होती है. डिफ़ॉल्ट रूप से, पिवट पॉइंट, ऑब्जेक्ट के बीच में मौजूद होता है.
• x और y: ये आसान यूटिलिटी प्रॉपर्टी हैं. इनका इस्तेमाल करके, अपने कंटेनर में व्यू की आखिरी जगह, बाएं और ऊपर के मानों के योग के रूप में और TranslationX और TranslationY के लिए इस्तेमाल करें.
• alpha: व्यू पर ऐल्फ़ा पारदर्शिता दिखाता है. यह वैल्यू 1 (ओपेक) है डिफ़ॉल्ट रूप से, 0 वैल्यू के तौर पर सेट किया जाता है. यह पूरी पारदर्शिता का प्रतिनिधित्व करता है (यह नहीं दिखता).

किसी व्यू ऑब्जेक्ट की प्रॉपर्टी, जैसे कि उसका रंग या रोटेशन वैल्यू को ऐनिमेट करने के लिए, आपको सिर्फ़ ये काम करने होंगे एक प्रॉपर्टी ऐनिमेटर बनाएं और अपनी पसंद की प्रॉपर्टी देखें ऐनिमेट करें. उदाहरण के लिए:

ObjectAnimator.ofFloat(myView, "rotation", 0f, 360f)

ObjectAnimator.ofFloat(myView, "rotation", 0f, 360f);

ऐनिमेशन बनाने के बारे में ज़्यादा जानकारी के लिए, 'ऐनिमेटर' के लिए दिए गए सेक्शन देखें. ValueAnimator और ObjectAnimator.

Viewप्रॉपर्टी Animator का इस्तेमाल करके ऐनिमेट करें

ViewPropertyAnimator की मदद से, कई ऐनिमेशन आसानी से दिखाए जा सकते हैं View की प्रॉपर्टी, साथ-साथ एक बुनियादी Animator का इस्तेमाल करके ऑब्जेक्ट है. यह काफ़ी हद तक ObjectAnimator की तरह काम करता है, क्योंकि यह यह व्यू की प्रॉपर्टी की असल वैल्यू होती है. हालांकि, यह एआर में कई प्रॉपर्टी को ऐनिमेट करते समय एक बार. इसके अलावा, ViewPropertyAnimator का इस्तेमाल करने के लिए कोड में छोटा और पढ़ने में आसान होता है. नीचे दिए गए कोड स्निपेट, एक से ज़्यादा प्रॉपर्टी इस्तेमाल करने में अंतर दिखाते हैं ObjectAnimator ऑब्जेक्ट, एक ObjectAnimator और ViewPropertyAnimator तब साथ ही, व्यू की x और y प्रॉपर्टी को ऐनिमेट करता है.

एक से ज़्यादा ObjectAnimator ऑब्जेक्ट

val animX = ObjectAnimator.ofFloat(myView, "x", 50f)
val animY = ObjectAnimator.ofFloat(myView, "y", 100f)
AnimatorSet().apply {
    playTogether(animX, animY)
    start()
}

ObjectAnimator animX = ObjectAnimator.ofFloat(myView, "x", 50f);
ObjectAnimator animY = ObjectAnimator.ofFloat(myView, "y", 100f);
AnimatorSet animSetXY = new AnimatorSet();
animSetXY.playTogether(animX, animY);
animSetXY.start();

एक ऑब्जेक्ट ऐनिमेशन

val pvhX = PropertyValuesHolder.ofFloat("x", 50f)
val pvhY = PropertyValuesHolder.ofFloat("y", 100f)
ObjectAnimator.ofPropertyValuesHolder(myView, pvhX, pvhY).start()

PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("x", 50f);
PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("y", 100f);
ObjectAnimator.ofPropertyValuesHolder(myView, pvhX, pvhY).start();

Viewप्रॉपर्टी Animator

myView.animate().x(50f).y(100f)

myView.animate().x(50f).y(100f);

ViewPropertyAnimator के बारे में ज़्यादा जानने के लिए, इनसे जुड़े Android डेवलपर देखें ब्लॉग पोस्ट.

एक्सएमएल में ऐनिमेशन का एलान करें

प्रॉपर्टी ऐनिमेशन सिस्टम से, आपको ऐसा करने के बजाय, एक्सएमएल के साथ प्रॉपर्टी ऐनिमेशन के बारे में जानकारी देने की सुविधा मिलती है को प्रोग्राम के हिसाब से बनाता है. एक्सएमएल में अपने ऐनिमेशन तय करके, अपने ऐनिमेशन आसानी से दोबारा इस्तेमाल किए जा सकते हैं कई गतिविधियों में शामिल किया जा सकता है और ऐनिमेशन क्रम में आसानी से बदलाव किया जा सकता है.

नई प्रॉपर्टी ऐनिमेशन एपीआई का इस्तेमाल करने वाली ऐनिमेशन फ़ाइलों और लेगसी व्यू ऐनिमेशन फ़्रेमवर्क, Android 3.1 और उसके बाद के वर्शन में, आपको प्रॉपर्टी ऐनिमेशन के लिए एक्सएमएल फ़ाइलें, res/animator/ डायरेक्ट्री में सेव करनी होंगी.

नीचे दी गई प्रॉपर्टी ऐनिमेशन क्लास में, एक्सएमएल एलान की सुविधा यहां दिए गए एक्सएमएल टैग में:

• ValueAnimator - <animator>
• ObjectAnimator - <objectAnimator>
• AnimatorSet - <set>

अपने एक्सएमएल एलान में जिन एट्रिब्यूट का इस्तेमाल किया जा सकता है उन्हें ढूंढने के लिए, ऐनिमेशन देखें संसाधन शामिल हैं. नीचे दिए गए उदाहरण में ऑब्जेक्ट ऐनिमेशन के दो सेट चलाए गए हैं इस क्रम में, पहले नेस्ट किए गए सेट में दो ऑब्जेक्ट वाले ऐनिमेशन एक साथ चलाए जाते हैं:

<set android:ordering="sequentially">
    <set>
        <objectAnimator
            android:propertyName="x"
            android:duration="500"
            android:valueTo="400"
            android:valueType="intType"/>
        <objectAnimator
            android:propertyName="y"
            android:duration="500"
            android:valueTo="300"
            android:valueType="intType"/>
    </set>
    <objectAnimator
        android:propertyName="alpha"
        android:duration="500"
        android:valueTo="1f"/>
</set>

इस ऐनिमेशन को चलाने के लिए, आपको अपने कोड में मौजूद एक्सएमएल संसाधनों को AnimatorSet ऑब्जेक्ट में बढ़ाना होगा. इसके बाद, सभी ऐनिमेशन के लिए टारगेट ऑब्जेक्ट सेट करने होंगे क्लिक करें. setTarget() को कॉल करने से, AnimatorSet के सभी बच्चों के लिए एक ही टारगेट ऑब्जेक्ट सेट हो जाता है. ऐसा करना आसान होता है. यह कोड बताता है कि इसे कैसे किया जा सकता है:

(AnimatorInflater.loadAnimator(myContext, R.animator.property_animator) as AnimatorSet).apply {
    setTarget(myObject)
    start()
}

AnimatorSet set = (AnimatorSet) AnimatorInflater.loadAnimator(myContext,
    R.animator.property_animator);
set.setTarget(myObject);
set.start();

एक्सएमएल में, ValueAnimator का एलान इस तरह भी किया जा सकता है नीचे दिए गए उदाहरण में दिखाया गया है:

<animator xmlns:android="http://schemas.android.com/apk/res/android"
    android:duration="1000"
    android:valueType="floatType"
    android:valueFrom="0f"
    android:valueTo="-100f" />

अपने कोड में पिछले ValueAnimator का इस्तेमाल करने के लिए, आपको ऑब्जेक्ट को इनफ़्लेट करना चाहिए, तो AnimatorUpdateListener, अपडेट की गई ऐनिमेशन वैल्यू पाएं और उसे अपने किसी व्यू की प्रॉपर्टी में इस्तेमाल करें, जैसा कि नीचे दिए गए कोड में दिखाया गया है:

(AnimatorInflater.loadAnimator(this, R.animator.animator) as ValueAnimator).apply {
    addUpdateListener { updatedAnimation ->
        textView.translationX = updatedAnimation.animatedValue as Float
    }

    start()
}

ValueAnimator xmlAnimator = (ValueAnimator) AnimatorInflater.loadAnimator(this,
        R.animator.animator);
xmlAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    @Override
    public void onAnimationUpdate(ValueAnimator updatedAnimation) {
        float animatedValue = (float)updatedAnimation.getAnimatedValue();
        textView.setTranslationX(animatedValue);
    }
});

xmlAnimator.start();

प्रॉपर्टी ऐनिमेशन परिभाषित करने के लिए एक्सएमएल सिंटैक्स के बारे में जानकारी पाने के लिए, ऐनिमेशन देखें संसाधन .

यूज़र इंटरफ़ेस (यूआई) की परफ़ॉर्मेंस पर संभावित असर

यूज़र इंटरफ़ेस (यूआई) को अपडेट करने वाले ऐनिमेटर, इसमें हर फ़्रेम के लिए ज़्यादा रेंडरिंग काम करते हैं जिस पर ऐनिमेशन चलता है. इसी वजह से, ज़्यादा रिसॉर्स वाली ऐनिमेशन का इस्तेमाल करना आपके ऐप्लिकेशन की परफ़ॉर्मेंस पर बुरा असर पड़ सकता है.

आपके यूज़र इंटरफ़ेस (यूआई) को ऐनिमेट करने के लिए ज़रूरी काम को इसके ऐनिमेशन स्टेज में जोड़ा गया है: रेंडरिंग पाइपलाइन में. यह पता लगाया जा सकता है कि क्या आपके ऐनिमेशन, प्रोफ़ाइल जीपीयू रेंडरिंग चालू करके और अपने ऐप्लिकेशन के परफ़ॉर्मेंस को बेहतर बनाना ऐनिमेशन स्टेज पर नज़र बनाए रखते हैं. ज़्यादा जानकारी के लिए, प्रोफ़ाइल जीपीयू रेंडरिंग देखें सिलसिलेवार तरीके से दिए गए निर्देश देखें.