स्प्रिंग फ़िज़िक्स का इस्तेमाल करके, हलचल को ऐनिमेट करें

Compose को आज़माएं

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

Spring AnimationSpec →

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

अगर आपको अपने ऐप्लिकेशन के ऐनिमेशन को सिर्फ़ एक दिशा में धीमा करना है, तो फ़्लिंग ऐनिमेशन का इस्तेमाल करें. यह फ़्रिक्शन पर आधारित होता है.

स्प्रिंग ऐनिमेशन का लाइफ़साइकल

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

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

पहली इमेज में, स्प्रिंग इफ़ेक्ट को दिखाया गया है. सर्कल के बीच में मौजूद प्लस का निशान (+), टच जेस्चर से लगाए गए फ़ोर्स को दिखाता है.

स्प्रिंग ऐनिमेशन बनाना

अपने ऐप्लिकेशन के लिए स्प्रिंग ऐनिमेशन बनाने का सामान्य तरीका यहां दिया गया है:

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

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

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

यहां दिए गए सेक्शन में, स्प्रिंग ऐनिमेशन बनाने के सामान्य चरणों के बारे में विस्तार से बताया गया है.

Support Library जोड़ना

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

1. अपने ऐप्लिकेशन मॉड्यूल के लिए build.gradle फ़ाइल खोलें.

2. dependencies सेक्शन में, सपोर्ट लाइब्रेरी जोड़ें.

   शानदार

           dependencies {
               def dynamicanimation_version = '1.0.0'
               implementation "androidx.dynamicanimation:dynamicanimation:$dynamicanimation_version"
           }
           

   Kotlin

           dependencies {
               val dynamicanimation_version = "1.0.0"
               implementation("androidx.dynamicanimation:dynamicanimation:$dynamicanimation_version")
           }
           

   इस लाइब्रेरी के मौजूदा वर्शन देखने के लिए, वर्शन पेज पर जाकर, Dynamicanimation के बारे में जानकारी देखें.

स्प्रिंग ऐनिमेशन बनाना

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

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

val springAnim = findViewById<View>(R.id.imageView).let { img ->
    // Setting up a spring animation to animate the view’s translationY property with the final
    // spring position at 0.
    SpringAnimation(img, DynamicAnimation.TRANSLATION_Y, 0f)
}

final View img = findViewById(R.id.imageView);
// Setting up a spring animation to animate the view’s translationY property with the final
// spring position at 0.
final SpringAnimation springAnim = new SpringAnimation(img, DynamicAnimation.TRANSLATION_Y, 0);

स्प्रिंग-आधारित ऐनिमेशन, व्यू ऑब्जेक्ट में मौजूद असल प्रॉपर्टी बदलकर स्क्रीन पर व्यू को ऐनिमेट कर सकता है. सिस्टम में ये व्यू उपलब्ध हैं:

• ALPHA: इससे व्यू में ऐल्फ़ा ट्रांसपैरेंसी के बारे में पता चलता है. डिफ़ॉल्ट रूप से, वैल्यू 1 (ओपेक) होती है. वैल्यू 0 का मतलब है कि पूरी तरह से पारदर्शी (दिखाई नहीं देता).
• TRANSLATION_X, TRANSLATION_Y, और TRANSLATION_Z: ये प्रॉपर्टी कंट्रोल करती हैं कि व्यू कहां मौजूद है. यह जानकारी, व्यू के बाएं कोऑर्डिनेट, टॉप कोऑर्डिनेट, और ऊंचाई के डेल्टा के तौर पर मिलती है. ये वैल्यू, लेआउट कंटेनर सेट करता है.
  • TRANSLATION_X बाईं ओर के कोऑर्डिनेट के बारे में बताता है.
  • TRANSLATION_Y टॉप कोऑर्डिनेट के बारे में बताता है.
  • TRANSLATION_Z से, व्यू की गहराई के बारे में पता चलता है. यह गहराई, व्यू की ऊंचाई के हिसाब से तय होती है.
• ROTATION, ROTATION_X, और ROTATION_Y: ये प्रॉपर्टी, पिवट पॉइंट के चारों ओर 2D (rotation प्रॉपर्टी) और 3D में रोटेशन को कंट्रोल करती हैं.
• SCROLL_X और SCROLL_Y: ये प्रॉपर्टी, सोर्स के बाएं और ऊपर के किनारे के स्क्रोल ऑफ़सेट को पिक्सल में दिखाती हैं. इससे यह भी पता चलता है कि पेज को कितना स्क्रोल किया गया है.
• SCALE_X और SCALE_Y: ये प्रॉपर्टी, व्यू के पिवट पॉइंट के आस-पास 2D स्केलिंग को कंट्रोल करती हैं.
• X, Y, और Z: ये बुनियादी यूटिलिटी प्रॉपर्टी हैं. इनका इस्तेमाल, व्यू की कंटेनर में मौजूद फ़ाइनल जगह के बारे में बताने के लिए किया जाता है.
  • X, बाईं ओर मौजूद वैल्यू और TRANSLATION_X का योग है.
  • Y, टॉप वैल्यू और TRANSLATION_Y का योग है.
  • Z, ऊंचाई की वैल्यू और TRANSLATION_Z का योग है.

लिसनर रजिस्टर करना

DynamicAnimation क्लास, दो लिसनर उपलब्ध कराती है: OnAnimationUpdateListener और OnAnimationEndListener. ये लिसनर, ऐनिमेशन में होने वाले अपडेट को सुनते हैं. जैसे, ऐनिमेशन की वैल्यू में बदलाव होने पर और ऐनिमेशन खत्म होने पर.

OnAnimationUpdateListener

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

1. addUpdateListener() तरीके को कॉल करें और लिसनर को ऐनिमेशन से अटैच करें.

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

2. onAnimationUpdate() तरीके को बदलें, ताकि कॉलर को मौजूदा ऑब्जेक्ट में हुए बदलाव के बारे में सूचना दी जा सके. नीचे दिए गए सैंपल कोड में, OnAnimationUpdateListener के इस्तेमाल का पूरा उदाहरण दिया गया है.

// Setting up a spring animation to animate the view1 and view2 translationX and translationY properties
val (anim1X, anim1Y) = findViewById<View>(R.id.view1).let { view1 ->
    SpringAnimation(view1, DynamicAnimation.TRANSLATION_X) to
            SpringAnimation(view1, DynamicAnimation.TRANSLATION_Y)
}
val (anim2X, anim2Y) = findViewById<View>(R.id.view2).let { view2 ->
    SpringAnimation(view2, DynamicAnimation.TRANSLATION_X) to
            SpringAnimation(view2, DynamicAnimation.TRANSLATION_Y)
}

// Registering the update listener
anim1X.addUpdateListener { _, value, _ ->
    // Overriding the method to notify view2 about the change in the view1’s property.
    anim2X.animateToFinalPosition(value)
}

anim1Y.addUpdateListener { _, value, _ -> anim2Y.animateToFinalPosition(value) }

// Creating two views to demonstrate the registration of the update listener.
final View view1 = findViewById(R.id.view1);
final View view2 = findViewById(R.id.view2);

// Setting up a spring animation to animate the view1 and view2 translationX and translationY properties
final SpringAnimation anim1X = new SpringAnimation(view1,
        DynamicAnimation.TRANSLATION_X);
final SpringAnimation anim1Y = new SpringAnimation(view1,
    DynamicAnimation.TRANSLATION_Y);
final SpringAnimation anim2X = new SpringAnimation(view2,
        DynamicAnimation.TRANSLATION_X);
final SpringAnimation anim2Y = new SpringAnimation(view2,
        DynamicAnimation.TRANSLATION_Y);

// Registering the update listener
anim1X.addUpdateListener(new DynamicAnimation.OnAnimationUpdateListener() {

// Overriding the method to notify view2 about the change in the view1’s property.
    @Override
    public void onAnimationUpdate(DynamicAnimation dynamicAnimation, float value,
                                  float velocity) {
        anim2X.animateToFinalPosition(value);
    }
});

anim1Y.addUpdateListener(new DynamicAnimation.OnAnimationUpdateListener() {

  @Override
    public void onAnimationUpdate(DynamicAnimation dynamicAnimation, float value,
                                  float velocity) {
        anim2Y.animateToFinalPosition(value);
    }
});

OnAnimationEndListener

OnAnimationEndListener से ऐनिमेशन के खत्म होने की सूचना मिलती है. ऐनिमेशन के स्थिर होने या रद्द होने पर, कॉलबैक पाने के लिए लिसनर सेट अप किया जा सकता है. लिसनर को रजिस्टर करने के लिए, यह तरीका अपनाएं:

1. addEndListener() तरीके को कॉल करें और लिसनर को ऐनिमेशन से अटैच करें.
2. onAnimationEnd() तरीके को बदलें, ताकि जब भी कोई ऐनिमेशन इक्विलिब्रियम पर पहुंचे या रद्द हो जाए, तो आपको सूचना मिल सके.

लिसनर हटाना

ऐनिमेशन अपडेट कॉलबैक और ऐनिमेशन खत्म होने के कॉलबैक पाने बंद करने के लिए, removeUpdateListener() और removeEndListener() तरीकों को कॉल करें.

ऐनिमेशन की शुरुआती वैल्यू सेट करना

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

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

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

• कम से कम वैल्यू सेट करने के लिए, setMinValue() तरीके को कॉल करें और प्रॉपर्टी की कम से कम वैल्यू पास करें.
• ज़्यादा से ज़्यादा वैल्यू सेट करने के लिए, setMaxValue() तरीके को कॉल करें और प्रॉपर्टी की ज़्यादा से ज़्यादा वैल्यू पास करें.

दोनों तरीके, उस ऐनिमेशन को दिखाते हैं जिसके लिए वैल्यू सेट की जा रही है.

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

शुरुआती वेलोसिटी सेट करना

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

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

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

findViewById<View>(R.id.imageView).also { img ->
    SpringAnimation(img, DynamicAnimation.TRANSLATION_Y).apply {
        …
        // Compute velocity in the unit pixel/second
        vt.computeCurrentVelocity(1000)
        val velocity = vt.yVelocity
        setStartVelocity(velocity)
    }
}

final View img = findViewById(R.id.imageView);
final SpringAnimation anim = new SpringAnimation(img, DynamicAnimation.TRANSLATION_Y);
…
// Compute velocity in the unit pixel/second
vt.computeCurrentVelocity(1000);
float velocity = vt.getYVelocity();
anim.setStartVelocity(velocity);

डीपी प्रति सेकंड को पिक्सल प्रति सेकंड में बदलना

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

val pixelPerSecond: Float =
    TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dpPerSecond, resources.displayMetrics)

float pixelPerSecond = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dpPerSecond, getResources().getDisplayMetrics());

स्प्रिंग प्रॉपर्टी सेट करना

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

अहम जानकारी: सेटर के तरीकों का इस्तेमाल करते समय, एक तरीका चेन बनाई जा सकती है, क्योंकि सेटर के सभी तरीके स्प्रिंग फ़ोर्स ऑब्जेक्ट दिखाते हैं.

डैंपिंग रेशियो

डैंपिंग रेशियो से, स्प्रिंग के ऑसिलेशन में धीरे-धीरे होने वाली कमी के बारे में पता चलता है. डैंपिंग रेशियो का इस्तेमाल करके, यह तय किया जा सकता है कि एक बाउंस से दूसरे बाउंस तक ऑसिलेशन कितनी तेज़ी से कम होता है. स्प्रिंग को चार अलग-अलग तरीकों से डैंप किया जा सकता है:

• डैंपिंग रेशियो एक से ज़्यादा होने पर, ओवरडैंपिंग होती है. इसकी मदद से, ऑब्जेक्ट को धीरे-धीरे अपनी जगह पर वापस लाया जा सकता है.
• डैंपिंग रेशियो एक के बराबर होने पर, क्रिटिकल डैंपिंग होती है. इससे ऑब्जेक्ट, कम से कम समय में अपनी शुरुआती पोज़िशन पर वापस आ जाता है.
• डैंपिंग रेशियो एक से कम होने पर, अंडरडैंपिंग होती है. इस विकल्प की मदद से, ऑब्जेक्ट को कई बार उसकी शुरुआती पोज़िशन से आगे बढ़ाया जा सकता है. इसके बाद, वह धीरे-धीरे अपनी शुरुआती पोज़िशन पर पहुंच जाता है.
• अनडैंप्ड तब होता है, जब डैंपिंग रेशियो शून्य के बराबर होता है. इससे ऑब्जेक्ट हमेशा के लिए ऑसिलेट होता रहता है.

स्प्रिंग में डैंपिंग रेशियो जोड़ने के लिए, यह तरीका अपनाएं:

1. डैंपिंग रेशियो जोड़ने के लिए, स्प्रिंग को वापस पाने के लिए getSpring() मेथड को कॉल करें.
2. setDampingRatio() तरीके को कॉल करें और स्प्रिंग में जोड़ने के लिए डैंपिंग रेशियो पास करें. यह तरीका, स्प्रिंग फ़ोर्स ऑब्जेक्ट दिखाता है. इस ऑब्जेक्ट पर डैंपिंग रेशियो सेट किया जाता है.

   ध्यान दें: डैंपिंग रेशियो, शून्य या इससे ज़्यादा का पूर्णांक होना चाहिए. अगर डैंपिंग रेशियो को शून्य पर सेट किया जाता है, तो स्प्रिंग कभी भी अपनी मूल स्थिति में नहीं आएगी. दूसरे शब्दों में, यह हमेशा बदलता रहता है.

सिस्टम में ये डैंपिंग रेशियो कॉन्स्टेंट उपलब्ध हैं:

• DAMPING_RATIO_HIGH_BOUNCY
• DAMPING_RATIO_MEDIUM_BOUNCY
• DAMPING_RATIO_LOW_BOUNCY
• DAMPING_RATIO_NO_BOUNCY

दूसरी इमेज: ज़्यादा बाउंस रेट

तीसरी इमेज: मीडियम बाउंस

चौथी इमेज: कम बाउंस

पांचवीं इमेज: कोई बाउंस नहीं

डैंपिंग रेशियो की डिफ़ॉल्ट वैल्यू DAMPING_RATIO_MEDIUM_BOUNCY पर सेट होती है.

findViewById<View>(R.id.imageView).also { img ->
    SpringAnimation(img, DynamicAnimation.TRANSLATION_Y).apply {
        …
        // Setting the damping ratio to create a low bouncing effect.
        spring.dampingRatio = SpringForce.DAMPING_RATIO_LOW_BOUNCY
        …
    }
}

final View img = findViewById(R.id.imageView);
final SpringAnimation anim = new SpringAnimation(img, DynamicAnimation.TRANSLATION_Y);
…
// Setting the damping ratio to create a low bouncing effect.
anim.getSpring().setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY);
…

जकड़न

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

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

   ध्यान दें: स्टिफ़नेस की वैल्यू पॉज़िटिव होनी चाहिए.

सिस्टम में ये स्टिफ़नेस कॉन्स्टेंट उपलब्ध हैं:

• STIFFNESS_HIGH
• STIFFNESS_MEDIUM
• STIFFNESS_LOW
• STIFFNESS_VERY_LOW

छठी इमेज: ज़्यादा स्टिफ़नेस

सातवीं इमेज: सामान्य स्टिफ़नेस

आठवीं इमेज: कम स्टिफ़नेस

नौवीं इमेज: बहुत कम स्टिफ़नेस

डिफ़ॉल्ट स्टिफ़नेस STIFFNESS_MEDIUM पर सेट होती है.

findViewById<View>(R.id.imageView).also { img ->
    SpringAnimation(img, DynamicAnimation.TRANSLATION_Y).apply {
        …
        // Setting the spring with a low stiffness.
        spring.stiffness = SpringForce.STIFFNESS_LOW
        …
    }
}

final View img = findViewById(R.id.imageView);
final SpringAnimation anim = new SpringAnimation(img, DynamicAnimation.TRANSLATION_Y);
…
// Setting the spring with a low stiffness.
anim.getSpring().setStiffness(SpringForce.STIFFNESS_LOW);
…

स्प्रिंग फ़ोर्स को पसंद के मुताबिक बनाना

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

1. SpringForce ऑब्जेक्ट बनाएं.

   SpringForce force = new SpringForce();

2. संबंधित तरीकों को कॉल करके प्रॉपर्टी असाइन करें. आपके पास मेथड चेन बनाने का विकल्प भी होता है.

   force.setDampingRatio(DAMPING_RATIO_LOW_BOUNCY).setStiffness(STIFFNESS_LOW);

3. ऐनिमेशन में स्प्रिंग सेट करने के लिए, setSpring() तरीके को कॉल करें.

   setSpring(force);

ऐनिमेशन शुरू करें

स्प्रिंग ऐनिमेशन को दो तरीकों से शुरू किया जा सकता है: start() या animateToFinalPosition() मेथड को कॉल करके. दोनों तरीकों को मुख्य थ्रेड पर कॉल करना ज़रूरी है.

animateToFinalPosition() मेथड दो काम करता है:

• स्प्रिंग की आखिरी पोज़िशन सेट करता है.
• अगर ऐनिमेशन शुरू नहीं हुआ है, तो इसे शुरू करता है.

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

दसवीं इमेज में, चेन वाले स्प्रिंग ऐनिमेशन को दिखाया गया है. इसमें एक व्यू का ऐनिमेशन, दूसरे व्यू पर निर्भर करता है.

animateToFinalPosition() तरीके का इस्तेमाल करने के लिए, animateToFinalPosition() तरीके को कॉल करें और स्प्रिंग की बाकी पोज़िशन पास करें. setFinalPosition() तरीके को कॉल करके, स्प्रिंग की रेस्ट पोजीशन भी सेट की जा सकती है.

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

findViewById<View>(R.id.imageView).also { img ->
    SpringAnimation(img, DynamicAnimation.TRANSLATION_Y).apply {
        …
        // Starting the animation
        start()
        …
    }
}

final View img = findViewById(R.id.imageView);
final SpringAnimation anim = new SpringAnimation(img, DynamicAnimation.TRANSLATION_Y);
…
// Starting the animation
anim.start();
…

ऐनिमेशन रद्द करना

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

ऐनिमेशन को खत्म करने के लिए, इन दो तरीकों का इस्तेमाल किया जा सकता है. cancel() तरीके से, एनिमेशन को उसी वैल्यू पर खत्म किया जाता है जहां वह है. skipToEnd() तरीके से, एनिमेशन को फ़ाइनल वैल्यू पर ले जाकर खत्म किया जाता है.

ऐनिमेशन को बंद करने से पहले, स्प्रिंग की स्थिति की जांच करना ज़रूरी है. अगर स्टेट में डैंपिंग नहीं है, तो ऐनिमेशन कभी भी अपनी मूल स्थिति में नहीं पहुंच सकता. स्प्रिंग की स्थिति देखने के लिए, canSkipToEnd() तरीके को कॉल करें. अगर स्प्रिंग को डैंप किया गया है, तो यह तरीका true दिखाता है. ऐसा न होने पर, यह false दिखाता है.

स्प्रिंग की स्थिति जानने के बाद, skipToEnd() या cancel() तरीके का इस्तेमाल करके, किसी एनिमेशन को खत्म किया जा सकता है. cancel() तरीके को सिर्फ़ मुख्य थ्रेड पर कॉल किया जाना ज़रूरी है.

ध्यान दें: आम तौर पर, skipToEnd() तरीके से इमेज में अचानक बदलाव होता है.