फ़्लिंग ऐनिमेशन का इस्तेमाल करके व्यू ले जाना

Compose को आज़माएं

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

Spring AnimationSpec →

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

मिलते-जुलते विषयों के बारे में जानने के लिए, ये गाइड पढ़ें:

• फ़िज़िक्स पर आधारित मोशन
• स्प्रिंग फ़िज़िक्स का इस्तेमाल करके, मूवमेंट को ऐनिमेट करना

AndroidX लाइब्रेरी जोड़ना

फ़िज़िक्स पर आधारित ऐनिमेशन का इस्तेमाल करने के लिए, आपको अपने प्रोजेक्ट में AndroidX लाइब्रेरी जोड़नी होगी. इसके लिए, यह तरीका अपनाएं:

1. अपने ऐप्लिकेशन मॉड्यूल के लिए build.gradle फ़ाइल खोलें.
2. AndroidX लाइब्रेरी को dependencies सेक्शन में जोड़ें.

   Groovy

           dependencies {
               implementation 'androidx.dynamicanimation:dynamicanimation:1.0.0'
           }
           

   Kotlin

           dependencies {
               implementation("androidx.dynamicanimation:dynamicanimation:1.0.0")
           }
           

फ़्लिंग ऐनिमेशन बनाना

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

val fling = FlingAnimation(view, DynamicAnimation.SCROLL_X)

FlingAnimation fling = new FlingAnimation(view, DynamicAnimation.SCROLL_X);

वेलोसिटी सेट करना

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

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

वेलोसिटी सेट करने के लिए, setStartVelocity() तरीके को कॉल करें और पिक्सल प्रति सेकंड में वेलोसिटी पास करें. यह तरीका, उस फ़्लिंग ऑब्जेक्ट को दिखाता है जिस पर वेलोसिटी सेट की गई है.

ध्यान दें: टच जेस्चर की वेलोसिटी को वापस पाने और उसका हिसाब लगाने के लिए, GestureDetector.OnGestureListener और VelocityTracker क्लास का इस्तेमाल करें.

ऐनिमेशन की वैल्यू की रेंज सेट करना

जब आपको प्रॉपर्टी की वैल्यू को किसी तय सीमा तक सीमित रखना हो, तब ऐनिमेशन की कम से कम और ज़्यादा से ज़्यादा वैल्यू सेट की जा सकती हैं. यह रेंज कंट्रोल, खास तौर पर तब काम आता है, जब आपको ऐसी प्रॉपर्टी को ऐनिमेट करना हो जिनकी इंट्रिंसिक रेंज होती है. जैसे, ऐल्फ़ा (0 से 1 तक).

ध्यान दें: फ़्लिंग ऐनिमेशन की वैल्यू, कम से कम या ज़्यादा से ज़्यादा वैल्यू तक पहुंचने पर, ऐनिमेशन खत्म हो जाता है.

कम से कम और ज़्यादा से ज़्यादा वैल्यू सेट करने के लिए, क्रमशः setMinValue() और setMaxValue() तरीकों को कॉल करें. दोनों तरीके, उस ऐनिमेशन ऑब्जेक्ट को दिखाते हैं जिसके लिए आपने वैल्यू सेट की है.

फ़्रिक्शन सेट करना

setFriction() तरीके से, ऐनिमेशन के फ़्रिक्शन में बदलाव किया जा सकता है. इससे यह तय होता है कि ऐनिमेशन में वेलोसिटी कितनी तेज़ी से कम होती है.

ध्यान दें: अगर ऐनिमेशन की शुरुआत में फ़्रिक्शन सेट नहीं किया जाता है, तो ऐनिमेशन में फ़्रिक्शन की डिफ़ॉल्ट वैल्यू 1 का इस्तेमाल किया जाता है.

यह तरीका, उस ऑब्जेक्ट को दिखाता है जिसके ऐनिमेशन में, आपकी दी गई फ़्रिक्शन वैल्यू का इस्तेमाल किया जाता है.

नमूना कोड

नीचे दिए गए उदाहरण में, हॉरिज़ॉन्टल फ़्लिंग को दिखाया गया है. वेलोसिटी ट्रैकर से कैप्चर की गई वेलोसिटी velocityX है. साथ ही, स्क्रोल की सीमाएं 0 और maxScroll पर सेट हैं. फ़्रिक्शन को 1.1 पर सेट किया गया है.

FlingAnimation(view, DynamicAnimation.SCROLL_X).apply {
    setStartVelocity(-velocityX)
    setMinValue(0f)
    setMaxValue(maxScroll)
    friction = 1.1f
    start()
}

FlingAnimation fling = new FlingAnimation(view, DynamicAnimation.SCROLL_X);
fling.setStartVelocity(-velocityX)
        .setMinValue(0)
        .setMaxValue(maxScroll)
        .setFriction(1.1f)
        .start();

कम से कम बदलाव सेट करना

जब पिक्सल में तय नहीं की गई किसी कस्टम प्रॉपर्टी को ऐनिमेशन दिया जाता है, तो आपको ऐनिमेशन की वैल्यू में कम से कम बदलाव सेट करना चाहिए, ताकि वह उपयोगकर्ताओं को दिखे. यह ऐनिमेशन को खत्म करने के लिए, एक सही थ्रेशोल्ड तय करता है.

DynamicAnimation.ViewProperty को ऐनिमेट करते समय, इस तरीके को कॉल करना ज़रूरी नहीं है, क्योंकि दिखने वाले बदलाव की कम से कम वैल्यू, प्रॉपर्टी से मिलती है. उदाहरण के लिए:

• व्यू प्रॉपर्टी, जैसे कि TRANSLATION_X, TRANSLATION_Y, TRANSLATION_Z, SCROLL_X, और SCROLL_Y के लिए, दिखने वाले बदलाव की डिफ़ॉल्ट कम से कम वैल्यू 1 पिक्सल होती है.
• रोटेशन का इस्तेमाल करने वाले ऐनिमेशन, जैसे कि ROTATION, ROTATION_X, और ROTATION_Y के लिए, कम से कम दिखने वाला बदलाव MIN_VISIBLE_CHANGE_ROTATION_DEGREES या 1/10 पिक्सल होता है.
• ओपैसिटी का इस्तेमाल करने वाले ऐनिमेशन के लिए, कम से कम दिखने वाला बदलाव MIN_VISIBLE_CHANGE_ALPHA या 1/256 होता है.

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

anim.minimumVisibleChange = DynamicAnimation.MIN_VISIBLE_CHANGE_SCALE

anim.setMinimumVisibleChange(DynamicAnimation.MIN_VISIBLE_CHANGE_SCALE);

ध्यान दें: आपको वैल्यू सिर्फ़ तब पास करनी होती है, जब पिक्सल में तय नहीं की गई किसी कस्टम प्रॉपर्टी को ऐनिमेट किया जाता है.

कम से कम दिखने वाले बदलाव की वैल्यू कैलकुलेट करना

कस्टम प्रॉपर्टी के लिए, दिखने वाली वैल्यू में कम से कम बदलाव का हिसाब लगाने के लिए, इस फ़ॉर्मूले का इस्तेमाल करें:

कम से कम दिखने वाला बदलाव = कस्टम प्रॉपर्टी वैल्यू की रेंज / पिक्सल में ऐनिमेशन की रेंज

उदाहरण के लिए, जिस प्रॉपर्टी को ऐनिमेट करना है उसकी वैल्यू 0 से 100 तक बढ़ती है. इससे इमेज में 200 पिक्सल का बदलाव होता है. फ़ॉर्मूले के मुताबिक, दिखने वाले बदलाव की कम से कम वैल्यू 100 / 200 है, जो 0.5 पिक्सल के बराबर है.