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

लिखने का तरीका आज़माएं

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

SpringSpringspec →

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

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

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

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

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

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

   ग्रूवी

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

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

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

नमूना कोड

नीचे दिए गए उदाहरण में हॉरिज़ॉन्टल फ़्लिंग दिखाया गया है. इनसे लिया गया वेग वेलोसिटी ट्रैकर velocityX है और स्क्रोल के बाउंड 0 पर सेट करें और ज़्यादा से ज़्यादा स्क्रोल करें. घर्षण को 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 क्योंकि दिखने वाला सबसे छोटा बदलाव, प्रॉपर्टी से लिया जाता है. उदाहरण के लिए:

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