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

Compose को आज़माएं

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

Spring AnimationSpec →

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

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

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

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

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

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

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

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