पिछले पेज पर वापस जाने के जेस्चर का इस्तेमाल करने की सुविधा जोड़ें

पीछे जाने पर झलक दिखाने वाला हाथ का जेस्चर, जेस्चर वाले नेविगेशन की एक सुविधा है. इससे उपयोगकर्ताओं को यह झलक दिखती है कि पीछे जाने के लिए स्वाइप करने पर, वे किस पेज पर पहुंचेंगे.

उदाहरण के लिए, पिछले पेज पर जाने के लिए हाथ के जेस्चर का इस्तेमाल करने पर, आपके ऐप्लिकेशन के पीछे होम स्क्रीन की झलक दिख सकती है. पहली इमेज में दिए गए मॉकअप में इसे दिखाया गया है.

Android 15 से, पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर के लिए, 'डेवलपर के लिए सेटिंग और टूल' विकल्प अब उपलब्ध नहीं है. सिस्टम के ऐनिमेशन, जैसे कि होम स्क्रीन पर वापस जाना, एक टास्क से दूसरे टास्क पर जाना, और एक गतिविधि से दूसरी गतिविधि पर जाना अब उन ऐप्लिकेशन के लिए दिखते हैं जिन्होंने पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की सुविधा चालू की है. यह सुविधा, पूरे ऐप्लिकेशन या किसी गतिविधि के लेवल पर चालू की जा सकती है.

होम स्क्रीन पर वापस जाने वाले इस ऐनिमेशन को टेस्ट किया जा सकता है. इसके बारे में इस पेज के अगले सेक्शन में बताया गया है.

पीछे जाने पर झलक दिखाने वाले जेस्चर की सुविधा देने के लिए, आपको अपना ऐप्लिकेशन अपडेट करना होगा. इसके लिए, AndroidX Activity 1.6.0 या इसके बाद के वर्शन वाले एपीआई में, पुराने सिस्टम के साथ काम करने वाले OnBackPressedCallback का इस्तेमाल करें. इसके अलावा, नए OnBackInvokedCallback प्लैटफ़ॉर्म एपीआई का इस्तेमाल करें. ज़्यादातर ऐप्लिकेशन, पुराने सिस्टम के साथ काम करने वाले AndroidX API का इस्तेमाल करते हैं.

इस अपडेट में, पीछे जाने की प्रोसेस को सही तरीके से इंटरसेप्ट करने के लिए, माइग्रेशन पाथ उपलब्ध कराया गया है. इसमें KeyEvent.KEYCODE_BACK और onBackPressed मेथड वाली किसी भी क्लास, जैसे कि Activity और Dialog से पीछे जाने की प्रोसेस को इंटरसेप्ट करने की सुविधा को नए सिस्टम Back API से बदलना शामिल है.

कोडलैब और Google I/O वीडियो

इस पेज पर मौजूद दस्तावेज़ का इस्तेमाल करने के अलावा, हमारा कोडलैब (कोड बनाना सीखना) आज़माएं. यह WebView को लागू करने का एक सामान्य उदाहरण है. इसमें AndroidX Activity API का इस्तेमाल करके, पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर को हैंडल किया जाता है.

Google I/O वीडियो भी देखा जा सकता है. इसमें AndroidX और प्लैटफ़ॉर्म एपीआई को लागू करने के अन्य उदाहरण शामिल हैं.

Compose में, पसंद के मुताबिक बनाए गए बैक जेस्चर को हैंडल करना

Compose, पसंद के मुताबिक बनाए गए बैक जेस्चर को मैनेज करने के लिए, PredictiveBackHandler कंपोज़ेबल उपलब्ध कराता है. इस एपीआई की मदद से, बैक जेस्चर पर प्रतिक्रिया दी जा सकती है. साथ ही, यह BackEventCompat ऑब्जेक्ट का Flow उपलब्ध कराता है. इसका इस्तेमाल करके, उपयोगकर्ता के स्वाइप करने पर कस्टम ऐनिमेशन या ट्रांज़िशन लागू किए जा सकते हैं.

PredictiveBackHandler का इस्तेमाल करने के लिए, पक्का करें कि आपके ऐप्लिकेशन में androidx.activity:activity-compose डिपेंडेंसी (वर्शन 1.8.0 या इसके बाद का वर्शन) शामिल हो:

// In your build.gradle.kts file:
dependencies {
    implementation("androidx.activity:activity-compose:1.8.0")
}

PredictiveBackHandler(enabled = isBackHandlerEnabled) { progress: Flow<BackEventCompat> ->
    try {
        progress.collect { backEvent ->
            // Update your UI or animation based on backEvent.progress.
        }
        // Handle the final back action (e.g., navigate back).
    } catch (e: CancellationException) {
        // Back gesture was cancelled, reset your UI.
    }
}
PredictiveBackSnippets.kt

अगर आपको प्रोग्रेस को ट्रैक किए बिना सिर्फ़ बैक जेस्चर को इंटरसेप्ट करना है, तो BackHandler का इस्तेमाल करें.

पीछे जाने के लिए डिफ़ॉल्ट जेस्चर का इस्तेमाल करने वाले ऐप्लिकेशन को अपडेट करना

पीछे जाने पर झलक दिखाने वाला हाथ का जेस्चर, डिफ़ॉल्ट रूप से चालू होता है.

अगर आपका ऐप्लिकेशन, फ़्रैगमेंट या नेविगेशन कॉम्पोनेंट का इस्तेमाल करता है, तो AndroidX Activity 1.6.0 या इसके बाद के वर्शन पर भी अपग्रेड करें.

पीछे जाने की प्रोसेस के लिए कस्टम नेविगेशन का इस्तेमाल करने वाले ऐप्लिकेशन को अपडेट करना

अगर आपके ऐप्लिकेशन में पीछे जाने के लिए कस्टम जेस्चर सेट किया गया है, तो माइग्रेशन के अलग-अलग पाथ होते हैं. यह इस बात पर निर्भर करता है कि ऐप्लिकेशन में AndroidX का इस्तेमाल किया जाता है या नहीं और पीछे जाने की प्रोसेस को कैसे मैनेज किया जाता है.

AndroidX में पीछे जाने की प्रोसेस को माइग्रेट करना

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

यह पक्का करने के लिए कि OnBackPressedDispatcher का इस्तेमाल करने वाले एपीआई (जैसे, फ़्रैगमेंट और नेविगेशन कॉम्पोनेंट), पीछे जाने पर झलक दिखाने वाले जेस्चर के साथ आसानी से काम करें, AndroidX Activity 1.6.0 या इसके बाद वाले वर्शन पर अपग्रेड करें.

// In your build.gradle file:
dependencies {
    // Add this in addition to your other dependencies
    implementation "androidx.activity:activity:1.6.0"
}

AndroidX के ऐसे ऐप्लिकेशन को AndroidX API पर माइग्रेट करना जिसमें पीछे जाने की प्रोसेस के लिए इस्तेमाल होने वाले ऐसे एपीआई मौजूद हैं जो काम नहीं करते

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

इस्तेमाल न किए जा सकने वाले एपीआई को AndroidX एपीआई पर माइग्रेट करने के लिए:

1. अपने सिस्टम के बैक हैंडलिंग लॉजिक को AndroidX के OnBackPressedDispatcher पर माइग्रेट करें. इसके लिए, OnBackPressedCallback को लागू करें. ज़्यादा जानकारी के लिए, पीछे जाने की प्रोसेस को पसंद के मुताबिक बनाने का तरीका लेख पढ़ें.

2. जब आपको बैक जेस्चर को इंटरसेप्ट करना बंद करना हो, तो OnBackPressedCallback को बंद कर दें.

3. OnBackPressed या KeyEvent.KEYCODE_BACK का इस्तेमाल करके, बैक इवेंट को इंटरसेप्ट करना बंद करें.

4. AndroidX Activity 1.6.0 या इसके बाद के वर्शन पर अपग्रेड करना न भूलें.

   // In your build.gradle file:
   dependencies {
       // Add this in addition to your other dependencies
       implementation "androidx.activity:activity:1.6.0"
   }
   

पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर से ऑप्ट आउट करना

ऑप्ट आउट करने के लिए, AndroidManifest.xml में <application> टैग में जाकर, android:enableOnBackInvokedCallback फ़्लैग को false पर सेट करें.

<application
    ...
    android:enableOnBackInvokedCallback="false"
    ... >
...
</application>

इस नीति को false पर सेट करने से ये काम होते हैं:

• इससे, पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर का सिस्टम ऐनिमेशन बंद हो जाता है.
• OnBackInvokedCallback को अनदेखा करता है, लेकिन OnBackPressedCallback कॉल काम करते रहते हैं.

गतिविधि के लेवल पर ऑप्ट आउट करना

android:enableOnBackInvokedCallback फ़्लैग की मदद से, गतिविधि के लेवल पर प्रिडिक्टिव सिस्टम ऐनिमेशन से ऑप्ट आउट किया जा सकता है. इस तरीके से, कई गतिविधियों वाले बड़े ऐप्लिकेशन को पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर पर माइग्रेट करना आसान हो जाता है.

यहां दिए गए कोड में, enableOnBackInvokedCallback को सेट करने का उदाहरण दिखाया गया है. इससे MainActivity से होम पेज पर वापस जाने वाले सिस्टम ऐनिमेशन को चालू किया जा सकता है:

<manifest ...>
    <application . . .

        android:enableOnBackInvokedCallback="false">

        <activity
            android:name=".MainActivity"
            android:enableOnBackInvokedCallback="true"
            ...
        </activity>
        <activity
            android:name=".SecondActivity"
            android:enableOnBackInvokedCallback="false"
            ...
        </activity>
    </application>
</manifest>

android:enableOnBackInvokedCallback फ़्लैग का इस्तेमाल करते समय, इन बातों का ध्यान रखें:

• android:enableOnBackInvokedCallback=false को सेट करने से, पीछे जाने पर झलक दिखाने वाले ऐनिमेशन बंद हो जाते हैं. ऐसा ऐक्टिविटी लेवल या ऐप्लिकेशन लेवल पर होता है. यह इस बात पर निर्भर करता है कि आपने टैग कहां सेट किया है. साथ ही, यह सिस्टम को OnBackInvokedCallback प्लैटफ़ॉर्म एपीआई के कॉल को अनदेखा करने का निर्देश देता है. हालांकि, OnBackPressedCallback के कॉल काम करते रहेंगे, क्योंकि OnBackPressedCallback पुराने सिस्टम के साथ काम करता है. साथ ही, यह onBackPressed एपीआई को कॉल करता है, जो Android 13 से पहले के वर्शन पर काम नहीं करता.
• ऐप्लिकेशन लेवल पर enableOnBackInvokedCallback फ़्लैग सेट करने से, ऐप्लिकेशन में मौजूद सभी गतिविधियों के लिए डिफ़ॉल्ट वैल्यू सेट हो जाती है. गतिविधि के लेवल पर फ़्लैग सेट करके, हर गतिविधि के लिए डिफ़ॉल्ट वैल्यू को बदला जा सकता है. इसके बारे में ऊपर दिए गए कोड के उदाहरण में बताया गया है.

कॉलबैक के लिए दिशा-निर्देश

सिस्टम के साथ काम करने वाले बैक कॉलबैक का इस्तेमाल करते समय, इन दिशा-निर्देशों का पालन करें: PredictiveBackHandler या BackHandler (Compose के लिए), OnBackPressedCallback या OnBackInvokedCallback.

यूज़र इंटरफ़ेस (यूआई) की वह स्थिति तय करें जो हर कॉलबैक को चालू और बंद करती है

यूज़र इंटरफ़ेस (यूआई) स्टेट एक ऐसी प्रॉपर्टी है जो यूज़र इंटरफ़ेस (यूआई) के बारे में बताती है. हमारा सुझाव है कि आप इन ज़रूरी चरणों को पूरा करें.

1. यूज़र इंटरफ़ेस (यूआई) की वह स्थिति तय करें जो हर कॉलबैक को चालू और बंद करती है.

2. मॉनिटर किए जा सकने वाले डेटा होल्डर टाइप का इस्तेमाल करके, उस स्थिति को तय करें. जैसे, StateFlow या Compose State. साथ ही, स्थिति बदलने पर कॉलबैक को चालू या बंद करें.

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

यूज़र इंटरफ़ेस (यूआई) लॉजिक के लिए, सिस्टम बैक कॉलबैक का इस्तेमाल करना

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

अगर आपका ऐप्लिकेशन PRIORITY_DEFAULT या PRIORITY_OVERLAY के साथ OnBackPressedCallback या OnBackInvokedCallback को चालू करता है, तो पीछे जाने पर झलक दिखाने वाला हाथ का जेस्चर ऐनिमेशन नहीं चलता. ऐसे में, आपको बैक इवेंट को मैनेज करना होगा. कारोबारी नियम चलाने या लॉग करने के लिए, ये कॉलबैक न बनाएं.

अगर आपके ऐप्लिकेशन को कारोबारी नियम चलाने हैं या उपयोगकर्ता के वापस स्वाइप करने पर लॉग करना है, तो इन तरीकों का इस्तेमाल करें:

• Compose में: Compose डेस्टिनेशन से जुड़े ViewModel के onCleared() कॉलबैक में लॉग इन करें. यह जानने का सबसे अच्छा तरीका है कि Compose डेस्टिनेशन को पिछली गतिविधियों से कब हटाया गया और कब मिटाया गया.
• Android 16 और इसके बाद के वर्शन पर: PRIORITY_SYSTEM_NAVIGATION_OBSERVER के साथ OnBackInvokedCallback का इस्तेमाल करें. इससे एक ऑब्ज़र्वर कॉलबैक बनता है, जो बैक इवेंट का इस्तेमाल नहीं करता. उदाहरण के लिए, जब उपयोगकर्ता रूट ऐक्टिविटी से वापस स्वाइप करता है (आपके ऐप्लिकेशन को छोड़ता है), तो इस कॉलबैक को रजिस्टर किया जा सकता है. इससे, वापस जाने वाले इवेंट को लॉग किया जा सकता है या कारोबारी नियम को चलाया जा सकता है. साथ ही, होम पेज पर वापस जाने वाले ऐनिमेशन को चलाने की अनुमति भी दी जा सकती है.
• व्यू-आधारित ऐप्लिकेशन में: बैक इवेंट का इस्तेमाल करने के बजाय, लाइफ़साइकल या बैक स्टैक कॉलबैक में लॉग इन करें:
  • गतिविधि ट्रांज़िशन के लिए, देखें कि क्या isFinishing, Activity.onDestroy() में true है.
  • फ़्रैगमेंट ट्रांज़िशन के लिए, देखें कि फ़्रैगमेंट के व्यू लाइफ़साइकल onDestroy() में isRemoving, true है या नहीं. इसके अलावा, FragmentManager.OnBackStackChangedListener (onBackStackChangeStarted / onBackStackChangeCommitted) का इस्तेमाल करें.

सिंगल रिस्पॉन्सिबिलिटी कॉलबैक बनाना

डिस्पैचर में कई कॉलबैक जोड़े जा सकते हैं. कॉलबैक को एक स्टैक में जोड़ा जाता है. इसमें, चालू किया गया आखिरी कॉलबैक, अगले बैक जेस्चर को हैंडल करता है. हर बैक जेस्चर के लिए एक कॉलबैक होता है.

अगर किसी कॉलबैक की सिर्फ़ एक ज़िम्मेदारी है, तो उसके चालू होने की स्थिति को मैनेज करना आसान होता है. उदाहरण के लिए:

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

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

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

पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर के ऐनिमेशन की जांच करना

Android 15 से, सिस्टम के ऐनिमेशन, जैसे कि होम स्क्रीन पर वापस जाना, एक टास्क से दूसरे टास्क पर जाना, और एक गतिविधि से दूसरी गतिविधि पर जाना, उन ऐप्लिकेशन के लिए डिफ़ॉल्ट रूप से चालू होते हैं जो पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की सुविधा के साथ काम करते हैं. अब ये 'डेवलपर के लिए सेटिंग और टूल' के पीछे नहीं हैं.

Android 13 या Android 14 वाले डिवाइसों पर, डेवलपर के लिए सेटिंग और टूल चालू करके, होम स्क्रीन पर वापस जाने वाले ऐनिमेशन को टेस्ट किया जा सकता है. इसे इमेज 1 में दिखाया गया है:

1. अपने डिवाइस पर, सेटिंग > सिस्टम > डेवलपर के लिए सेटिंग और टूल पर जाएं.

2. पीछे जाने पर झलक दिखाने वाले ऐनिमेशन को चुनें.

3. अपडेट किया गया ऐप्लिकेशन लॉन्च करें और पीछे जाने वाले जेस्चर का इस्तेमाल करके देखें कि यह सुविधा काम कर रही है या नहीं.