प्रॉपर्टी ऐनिमेशन सिस्टम एक मज़बूत फ़्रेमवर्क है, जिससे आपको करने के लिए इस्तेमाल किया जा सकता है. समय के साथ किसी भी ऑब्जेक्ट प्रॉपर्टी को बदलने के लिए, ऐनिमेशन सेट किया जा सकता है, स्क्रीन पर दिखाई देता है या नहीं. प्रॉपर्टी ऐनिमेशन किसी प्रॉपर्टी की (किसी ऑब्जेक्ट में फ़ील्ड) वैल्यू. किसी चीज़ को ऐनिमेट करने के लिए, वह ऑब्जेक्ट प्रॉपर्टी जिसे आप ऐनिमेट करना चाहते हैं, जैसे कि स्क्रीन पर किसी ऑब्जेक्ट की स्थिति, कितनी देर तक को ऐनिमेट करना है और किन वैल्यू के बीच ऐनिमेट करना है.
प्रॉपर्टी ऐनिमेशन सिस्टम की मदद से, ऐनिमेशन:
- अवधि: आप ऐनिमेशन की अवधि तय कर सकते हैं. डिफ़ॉल्ट तौर पर, यह अवधि 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
को बढ़ा देती हैं:
कक्षा | ब्यौरा |
---|---|
ValueAnimator |
प्रॉपर्टी ऐनिमेशन के लिए मुख्य टाइमिंग इंजन, जो
प्रॉपर्टी को ऐनिमेट किया जाना चाहिए. इसमें वे सभी मुख्य फ़ंक्शन होते हैं जो ऐनिमेशन को कैलकुलेट करते हैं
और इसमें प्रत्येक ऐनिमेशन के समय का विवरण होता है, साथ ही जानकारी
ऐनिमेशन का बार-बार इस्तेमाल, अपडेट इवेंट पाने वाले लिसनर, और अपने हिसाब से कस्टम सेट करने की सुविधा
टाइप करें. प्रॉपर्टी को ऐनिमेट करने के दो तरीके हैं: ऐनिमेटेड प्रॉपर्टी को कैलकुलेट करना
वैल्यू सेट करना और उन वैल्यू को सेट करना. ValueAnimator दूसरा टुकड़ा नहीं देता है, इसलिए आपको इसे सुनना चाहिए
और ValueAnimator और
उन ऑब्जेक्ट में बदलाव करें जिन्हें अपने लॉजिक से ऐनिमेट करना है. इसके बारे में सेक्शन देखें
ज़्यादा जानकारी के लिए ValueAnimator के साथ ऐनिमेट किया जा रहा है. |
ObjectAnimator |
ValueAnimator की एक सब-क्लास, जो आपको टारगेट सेट करने की अनुमति देती है
ऐनिमेट करने के लिए ऑब्जेक्ट और ऑब्जेक्ट प्रॉपर्टी का इस्तेमाल करता है. यह क्लास प्रॉपर्टी को ज़रूरत के मुताबिक तब अपडेट करती है, जब
यह ऐनिमेशन के लिए एक नई वैल्यू कैलकुलेट करता है. आप इसका इस्तेमाल करना चाहते हैं
ज़्यादातर मामलों में ObjectAnimator ,
क्योंकि इससे टारगेट ऑब्जेक्ट पर वैल्यू को ऐनिमेट करने की प्रोसेस बहुत आसान हो जाती है. हालांकि,
आपको कभी-कभी सीधे तौर पर ValueAnimator का इस्तेमाल करना चाहिए, क्योंकि ObjectAnimator पर कुछ और पाबंदियां भी लागू होती हैं, जैसे कि
ऐक्सेसर के तरीके भी शामिल करें. |
AnimatorSet |
ऐनिमेशन को एक साथ ग्रुप करने का तरीका उपलब्ध कराता है, ताकि वे आपस में चल सकें एक-दूसरे के जुड़ाव को महसूस कराते हैं. ऐनिमेशन को एक साथ, एक क्रम में या बाद में चलाने के लिए सेट किया जा सकता है तय की गई देरी. कई कोरियोग्राफ़िंग ज़्यादा जानकारी के लिए, ऐनिमेटर सेट वाले ऐनिमेशन. |
आकलन करने वाले, प्रॉपर्टी ऐनिमेशन सिस्टम को बताते हैं कि दी गई वैल्यू को कैलकुलेट कैसे करना है
प्रॉपर्टी. वे Animator
से मिले समय के हिसाब से डेटा लेते हैं
क्लास, ऐनिमेशन के शुरुआती और आखिरी मान, और प्रॉपर्टी की ऐनिमेशन वैल्यू कैलकुलेट करना
पर आधारित होता है. प्रॉपर्टी ऐनिमेशन सिस्टम से ये समीक्षक मिलते हैं:
क्लास/इंटरफ़ेस | ब्यौरा |
---|---|
IntEvaluator |
यह डिफ़ॉल्ट समीक्षक, int प्रॉपर्टी की वैल्यू कैलकुलेट करता है. |
FloatEvaluator |
यह डिफ़ॉल्ट समीक्षक, float प्रॉपर्टी की वैल्यू कैलकुलेट करता है. |
ArgbEvaluator |
यह डिफ़ॉल्ट आकलनकर्ता होता है, जो दिखाए गए रंग प्रॉपर्टी के मानों की गणना करता है को हेक्साडेसिमल मानों के रूप में शामिल करना चाहिए. |
TypeEvaluator |
ऐसा इंटरफ़ेस जो आपको अपना खुद का समीक्षक बनाने की सुविधा देता है. अगर आपको किसी
वह ऑब्जेक्ट प्रॉपर्टी जो int , float या रंग नहीं है,
आपको TypeEvaluator इंटरफ़ेस लागू करना होगा, ताकि यह बताया जा सके कि
का इस्तेमाल करें. आपके पास int , float , और रंग के लिए, अपनी पसंद के मुताबिक TypeEvaluator तय करने का विकल्प भी है
है, और आप उन प्रकारों को डिफ़ॉल्ट व्यवहार से अलग तरीके से प्रोसेस करना चाहते हैं.
ज़्यादा जानकारी के लिए, TypeEvaluator का इस्तेमाल करने से जुड़ा सेक्शन देखें
कस्टम आकलनकर्ता लिखने के तरीके के बारे में जानकारी. |
टाइम इंटरपोलेटर से तय होता है कि ऐनिमेशन में खास वैल्यू को कैलकुलेट करने के लिए,
समय का फ़ंक्शन. उदाहरण के लिए, आप यह तय कर सकते हैं कि ऐनिमेशन पूरे क्रम में लीनियर तौर पर हों
ऐनिमेशन, जिसका मतलब है कि ऐनिमेशन पूरे समय समान रूप से चलता है, या आप ऐनिमेशन तय कर सकते हैं
नॉन-लीनियर टाइम का इस्तेमाल किया हो. उदाहरण के लिए, टाइम की शुरुआत में एक्सेलरेटर और
ऐनिमेशन खत्म हो जाता है. टेबल 3 में, android.view.animation
में मौजूद इंटरपोलेटर के बारे में बताया गया है. अगर दिए गए इंटरपोलेटर सूट में से कोई नहीं
TimeInterpolator
इंटरफ़ेस को लागू करें और खुद का इंटरफ़ेस बनाएं. कस्टम वैल्यू लिखने के तरीके के बारे में ज़्यादा जानकारी के लिए, इंटरपोलेटर का इस्तेमाल करना लेख पढ़ें
इंटरपोलेटर.
क्लास/इंटरफ़ेस | ब्यौरा |
---|---|
AccelerateDecelerateInterpolator |
इंटरपोलेटर, जिसके बदलाव की दर से शुरू और खत्म होने में ज़्यादा समय लगता है, लेकिन यह तेज़ी से बढ़ता है बीच में से शुरू करें. |
AccelerateInterpolator |
एक इंटरपोलेटर, जिसके बदलाव की दर धीरे-धीरे शुरू होती है और फिर इससे तेज़ी मिलती है. |
AnticipateInterpolator |
एक इंटरपोलेटर, जिसका बदलाव पीछे की ओर शुरू होता है और फिर आगे की ओर बढ़ता है. |
AnticipateOvershootInterpolator |
एक इंटरपोलेटर, जिसका बदलाव पीछे की ओर शुरू होता है, आगे की ओर बढ़ता है और ओवरशॉट होता है फिर अंत में वह आखिरी मान पर वापस चला जाता है. |
BounceInterpolator |
एक इंटरपोलेटर, जिसका बदलाव अंत में बाउंस हो जाता है. |
CycleInterpolator |
ऐसा इंटरपोलेटर, जिसका ऐनिमेशन एक तय साइकल तक दोहराया जाता है. |
DecelerateInterpolator |
एक इंटरपोलेटर, जिसके बदलाव की दर तेज़ी से शुरू होती है और फिर कम हो जाता है. |
LinearInterpolator |
ऐसा इंटरपोलेटर जिसके बदलाव की दर स्थिर होती है. |
OvershootInterpolator |
एक इंटरपोलेटर, जो आगे की ओर बढ़ता है और फिर अंतिम मान को ओवरशॉट करता है वापस आ जाए. |
TimeInterpolator |
ऐसा इंटरफ़ेस जो आपको अपना इंटरपोलेटर लागू करने की अनुमति देता है. |
ValueAnimator का इस्तेमाल करके ऐनिमेट करें
ValueAnimator
क्लास आपको
int
, float
या रंग का सेट तय करके ऐनिमेशन की अवधि
वैल्यू को ऐनिमेट करना होगा. इनमें से किसी एक पर कॉल करने पर, आपको ValueAnimator
मिलता है
इसकी फ़ैक्ट्री तरीके: ofInt()
, ofFloat()
या ofObject()
. उदाहरण के लिए:
Kotlin
ValueAnimator.ofFloat(0f, 100f).apply { duration = 1000 start() }
Java
ValueAnimator animation = ValueAnimator.ofFloat(0f, 100f); animation.setDuration(1000); animation.start();
इस कोड में, ValueAnimator
ऐनिमेशन, 0 से 100 के बीच, 1,000 मि॰से॰ की अवधि के लिए, जब start()
तरीका चलता है.
यहां दिए गए काम करके, ऐनिमेट करने के लिए अपनी पसंद का कोई टाइप तय किया जा सकता है:
Kotlin
ValueAnimator.ofObject(MyTypeEvaluator(), startPropertyValue, endPropertyValue).apply { duration = 1000 start() }
Java
ValueAnimator animation = ValueAnimator.ofObject(new MyTypeEvaluator(), startPropertyValue, endPropertyValue); animation.setDuration(1000); animation.start();
इस कोड में, ValueAnimator
ऐनिमेशन, startPropertyValue
और endPropertyValue
के बीच
start()
तरीका इस्तेमाल होने पर, 1,000 मि॰से॰ के लिए MyTypeEvaluator
से मिला लॉजिक.
ऐनिमेशन की वैल्यू इस्तेमाल करने के लिए,
AnimatorUpdateListener
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
ValueAnimator
ऑब्जेक्ट में, जैसा कि
यह कोड डालें:
Kotlin
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 } ... }
Java
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
की तरह ही है, लेकिन आप ऑब्जेक्ट और उस ऑब्जेक्ट की प्रॉपर्टी का नाम भी तय कर सकते हैं (जैसा कि
और इनके बीच ऐनिमेट करने के लिए वैल्यू के साथ:
Kotlin
ObjectAnimator.ofFloat(textView, "translationX", 100f).apply { duration = 1000 start() }
Java
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
चलाता है
ऑब्जेक्ट सबमिट करते समय इस तरह से शामिल करें:
bounceAnim
नाटक होगा.squashAnim1
,squashAnim2
,stretchAnim1
, और नाटक करती हैstretchAnim2
शामिल है.bounceBackAnim
नाटक होगा.fadeAnim
नाटक होगा.
Kotlin
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() }
Java
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()
के लिए
कॉलबैक:
Kotlin
ObjectAnimator.ofFloat(newBall, "alpha", 1f, 0f).apply { duration = 250 addListener(object : AnimatorListenerAdapter() { override fun onAnimationEnd(animation: Animator) { balls.remove((animation as ObjectAnimator).target) } }) }
Java
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 स्केल को बदलता है इसे दबाए रखने पर दृश्य:
<?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
क्लास दिखाती है
इसे कैसे करें:
Kotlin
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) } } }
Java
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
Kotlin
override fun getInterpolation(input: Float): Float = (Math.cos((input + 1) * Math.PI) / 2.0f).toFloat() + 0.5f
Java
@Override public float getInterpolation(float input) { return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f; }
लीनियर इंटरपोलेटर
Kotlin
override fun getInterpolation(input: Float): Float = input
Java
@Override public float getInterpolation(float input) { return input; }
नीचे दी गई टेबल में वे अनुमानित वैल्यू दी गई हैं जिन्हें इन पैरामीटर के आधार पर कैलकुलेट किया जाता है 1000 मि॰से॰ तक चलने वाले ऐनिमेशन के लिए इंटरपोलेटर:
मि॰से॰ बीत चुके | बीता हुआ अंश/इंटरपोलेटेड अंश (लीनियर) | इंटरपोलेट किया गया फ़्रैक्शन (ऐक्टिवेट/डिलीरेट करें) |
---|---|---|
0 | 0 | 0 |
200 | .2 | .1 |
400 | .4 | .345 |
600 | .6 | 0.8 |
800 | 0.8 | 0.9 |
1000 | 1 | 1 |
जैसा कि टेबल में दिखाया गया है, LinearInterpolator
से वैल्यू बदल जाती हैं
समान गति से, हर 200 मि॰से॰ के लिए .2. AccelerateDecelerateInterpolator
, LinearInterpolator
से 200 मि॰से॰ से 600 मि॰से॰ के बीच की वैल्यू तेज़ी से बदलता है और वैल्यू 600 मि॰से॰ के बीच कम होती है
1000 मिलीसेकंड.
कीफ़्रेम तय करना
Keyframe
ऑब्जेक्ट में समय/वैल्यू का ऐसा पेयर होता है जो आपको
ऐनिमेशन के किसी खास समय में कोई खास स्थिति. हर मुख्य-फ़्रेम का अपना अलग से एक मुख्य-फ़्रेम हो सकता है
पिछले वीडियो के बीच के अंतराल में ऐनिमेशन के व्यवहार को कंट्रोल करने के लिए इंटरपोलेटर
और इस मुख्य-फ़्रेम का समय.
Keyframe
ऑब्जेक्ट को इंस्टैंशिएट करने के लिए, आपको किसी फ़ैक्ट्री का इस्तेमाल करना होगा
तरीके, ofInt()
, ofFloat()
, या ofObject()
का सही प्रकार Keyframe
पाने के लिए. फिर आप कॉल करें
ofKeyframe()
फ़ैक्ट्री मेथड से
PropertyValuesHolder
ऑब्जेक्ट पाएं. जब आपको ऑब्जेक्ट मिल जाए, तो
PropertyValuesHolder
ऑब्जेक्ट को पास करके, ऐनिमेटर पाएं और
ऑब्जेक्ट को ऐनिमेट करना है. नीचे दिया गया कोड स्निपेट यह काम करने का तरीका बताता है:
Kotlin
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 }
Java
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 वैल्यू के तौर पर सेट किया जाता है. यह पूरी पारदर्शिता का प्रतिनिधित्व करता है (यह नहीं दिखता).
किसी व्यू ऑब्जेक्ट की प्रॉपर्टी, जैसे कि उसका रंग या रोटेशन वैल्यू को ऐनिमेट करने के लिए, आपको सिर्फ़ ये काम करने होंगे एक प्रॉपर्टी ऐनिमेटर बनाएं और अपनी पसंद की प्रॉपर्टी देखें ऐनिमेट करें. उदाहरण के लिए:
Kotlin
ObjectAnimator.ofFloat(myView, "rotation", 0f, 360f)
Java
ObjectAnimator.ofFloat(myView, "rotation", 0f, 360f);
ऐनिमेशन बनाने के बारे में ज़्यादा जानकारी के लिए, 'ऐनिमेटर' के लिए दिए गए सेक्शन देखें. ValueAnimator और ObjectAnimator.
Viewप्रॉपर्टी Animator का इस्तेमाल करके ऐनिमेट करें
ViewPropertyAnimator
की मदद से, कई ऐनिमेशन आसानी से दिखाए जा सकते हैं
View
की प्रॉपर्टी, साथ-साथ एक बुनियादी Animator
का इस्तेमाल करके
ऑब्जेक्ट है. यह काफ़ी हद तक ObjectAnimator
की तरह काम करता है, क्योंकि यह
यह व्यू की प्रॉपर्टी की असल वैल्यू होती है. हालांकि, यह एआर में कई प्रॉपर्टी को ऐनिमेट करते समय
एक बार. इसके अलावा, ViewPropertyAnimator
का इस्तेमाल करने के लिए कोड में
छोटा और पढ़ने में आसान होता है. नीचे दिए गए कोड स्निपेट, एक से ज़्यादा प्रॉपर्टी इस्तेमाल करने में अंतर दिखाते हैं
ObjectAnimator
ऑब्जेक्ट, एक
ObjectAnimator
और ViewPropertyAnimator
तब
साथ ही, व्यू की x
और y
प्रॉपर्टी को ऐनिमेट करता है.
एक से ज़्यादा ObjectAnimator ऑब्जेक्ट
Kotlin
val animX = ObjectAnimator.ofFloat(myView, "x", 50f) val animY = ObjectAnimator.ofFloat(myView, "y", 100f) AnimatorSet().apply { playTogether(animX, animY) start() }
Java
ObjectAnimator animX = ObjectAnimator.ofFloat(myView, "x", 50f); ObjectAnimator animY = ObjectAnimator.ofFloat(myView, "y", 100f); AnimatorSet animSetXY = new AnimatorSet(); animSetXY.playTogether(animX, animY); animSetXY.start();
एक ऑब्जेक्ट ऐनिमेशन
Kotlin
val pvhX = PropertyValuesHolder.ofFloat("x", 50f) val pvhY = PropertyValuesHolder.ofFloat("y", 100f) ObjectAnimator.ofPropertyValuesHolder(myView, pvhX, pvhY).start()
Java
PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("x", 50f); PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("y", 100f); ObjectAnimator.ofPropertyValuesHolder(myView, pvhX, pvhY).start();
Viewप्रॉपर्टी Animator
Kotlin
myView.animate().x(50f).y(100f)
Java
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
के सभी बच्चों के लिए एक ही टारगेट ऑब्जेक्ट सेट हो जाता है. ऐसा करना आसान होता है. यह कोड बताता है कि इसे कैसे किया जा सकता है:
Kotlin
(AnimatorInflater.loadAnimator(myContext, R.animator.property_animator) as AnimatorSet).apply { setTarget(myObject) start() }
Java
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
,
अपडेट की गई ऐनिमेशन वैल्यू पाएं और उसे अपने किसी व्यू की प्रॉपर्टी में इस्तेमाल करें,
जैसा कि नीचे दिए गए कोड में दिखाया गया है:
Kotlin
(AnimatorInflater.loadAnimator(this, R.animator.animator) as ValueAnimator).apply { addUpdateListener { updatedAnimation -> textView.translationX = updatedAnimation.animatedValue as Float } start() }
Java
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();
प्रॉपर्टी ऐनिमेशन परिभाषित करने के लिए एक्सएमएल सिंटैक्स के बारे में जानकारी पाने के लिए, ऐनिमेशन देखें संसाधन .
यूज़र इंटरफ़ेस (यूआई) की परफ़ॉर्मेंस पर संभावित असर
यूज़र इंटरफ़ेस (यूआई) को अपडेट करने वाले ऐनिमेटर, इसमें हर फ़्रेम के लिए ज़्यादा रेंडरिंग काम करते हैं जिस पर ऐनिमेशन चलता है. इसी वजह से, ज़्यादा रिसॉर्स वाली ऐनिमेशन का इस्तेमाल करना आपके ऐप्लिकेशन की परफ़ॉर्मेंस पर बुरा असर पड़ सकता है.
आपके यूज़र इंटरफ़ेस (यूआई) को ऐनिमेट करने के लिए ज़रूरी काम को इसके ऐनिमेशन स्टेज में जोड़ा गया है: रेंडरिंग पाइपलाइन में. यह पता लगाया जा सकता है कि क्या आपके ऐनिमेशन, प्रोफ़ाइल जीपीयू रेंडरिंग चालू करके और अपने ऐप्लिकेशन के परफ़ॉर्मेंस को बेहतर बनाना ऐनिमेशन स्टेज पर नज़र बनाए रखते हैं. ज़्यादा जानकारी के लिए, प्रोफ़ाइल जीपीयू रेंडरिंग देखें सिलसिलेवार तरीके से दिए गए निर्देश देखें.