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

Compose का इस्तेमाल करके मैसेज लिखना

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

SpringSpringSpecification →

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

पहली इमेज. फ़्लिंग ऐनिमेशन

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

• भौतिकी (फ़िज़िक्स) पर आधारित मोशन
• स्प्रिंग फ़िज़िक्स का इस्तेमाल करके, ऐनिमेशन में गति जोड़ना

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

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

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

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

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

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

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

KotlinJava

val fling = FlingAnimation(view, DynamicAnimation.SCROLL_X)

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

वेलोसिटी सेट करें

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

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

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

ध्यान दें: GestureDetector.OnGestureListener और वापस पाने और कंप्यूट करने के लिए VelocityTracker क्लास टच जेस्चर की वेलोसिटी भी होती है.

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

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

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

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

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

setFriction() तरीका आपको ऐनिमेशन के दिक्कत. इससे यह तय होता है कि ऐनिमेशन में वेग कितनी तेज़ी से कम होता है.

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

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

नमूना कोड

नीचे दिया गया उदाहरण हॉरिज़ॉन्टल फ़्लिंग दिखाता है. इनसे लिया गया वेग वेलोसिटी ट्रैकर velocityX है और स्क्रोल के बाउंड 0 पर सेट किया गया और ज़्यादा से ज़्यादा स्क्रोल करें. घर्षण को 1.1 पर सेट किया गया है.

KotlinJava

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() तरीका कॉल करें और दिखने वाली कम से कम वैल्यू में से किसी एक को या फिर ऐसी वैल्यू को पास करें जिसका आपको कस्टम प्रॉपर्टी के लिए हिसाब लगाना है. इस वैल्यू का हिसाब लगाने के बारे में ज़्यादा जानने के लिए, कम से कम दिखने वाले बदलाव की वैल्यू का हिसाब लगाना सेक्शन देखें.

KotlinJava

anim.minimumVisibleChange = DynamicAnimation.MIN_VISIBLE_CHANGE_SCALE

anim.setMinimumVisibleChange(DynamicAnimation.MIN_VISIBLE_CHANGE_SCALE);

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

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

किसी कस्टम प्रॉपर्टी के लिए दिखाई देने वाले कम से कम बदलाव मान की गणना करने के लिए, नीचे दिया गया फ़ॉर्मूला:

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

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