विकल्पों की मदद से नेविगेट करें

Kotlin DSL का इस्तेमाल करके, नेविगेशन ग्राफ़ में कोई कार्रवाई तय करने पर, नेविगेशन से जुड़ी NavAction क्लास जनरेट होती है. इसमें उस कार्रवाई के लिए तय किए गए कॉन्फ़िगरेशन शामिल होते हैं. इनमें ये कॉन्फ़िगरेशन भी शामिल होते हैं:

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

Compose के साथ विकल्प

डिफ़ॉल्ट रूप से, navigate() आपके नए डेस्टिनेशन को बैक स्टैक में जोड़ता है. navigate() कॉल में, नेविगेशन के अन्य विकल्प पास करके, navigate() के बिहेवियर में बदलाव किया जा सकता है.

सामान्य लैम्डा का इस्तेमाल करके, NavOptions का इंस्टेंस बनाया जा सकता है. navigate() में वे आर्ग्युमेंट पास करें जिन्हें आपको NavOptions.Builder में साफ़ तौर पर पास करना पड़ सकता है. यहां दिए गए उदाहरण देखें:

उदाहरण के लिए, कॉन्टेक्स्ट में विकल्प पास करने का तरीका जानने के लिए, बैक स्टैक के बारे में बनी गाइड देखें.navigate()

एक्सएमएल के साथ विकल्प

यहां एक ग्राफ़ का उदाहरण दिया गया है. इसमें दो स्क्रीन के साथ-साथ, एक से दूसरी स्क्रीन पर जाने की कार्रवाई शामिल है:

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
            xmlns:app="http://schemas.android.com/apk/res-auto"
            xmlns:tools="http://schemas.android.com/tools"
            android:id="@+id/nav_graph"
            app:startDestination="@id/a">

    <fragment android:id="@+id/a"
              android:name="com.example.myapplication.FragmentA"
              android:label="a"
              tools:layout="@layout/a">
        <action android:id="@+id/action_a_to_b"
                app:destination="@id/b"
                app:enterAnim="@anim/nav_default_enter_anim"
                app:exitAnim="@anim/nav_default_exit_anim"
                app:popEnterAnim="@anim/nav_default_pop_enter_anim"
                app:popExitAnim="@anim/nav_default_pop_exit_anim"/>
    </fragment>

    <fragment android:id="@+id/b"
              android:name="com.example.myapplication.FragmentB"
              android:label="b"
              tools:layout="@layout/b">
        <action android:id="@+id/action_b_to_a"
                app:destination="@id/a"
                app:enterAnim="@anim/nav_default_enter_anim"
                app:exitAnim="@anim/nav_default_exit_anim"
                app:popEnterAnim="@anim/nav_default_pop_enter_anim"
                app:popExitAnim="@anim/nav_default_pop_exit_anim"
                app:popUpTo="@+id/a"
                app:popUpToInclusive="true"/>
    </fragment>
</navigation>

नेविगेशन ग्राफ़ को बड़ा करने पर, इन कार्रवाइयों को पार्स किया जाता है. इसके बाद, ग्राफ़ में तय किए गए कॉन्फ़िगरेशन के साथ, NavAction के ऑब्जेक्ट जनरेट किए जाते हैं. उदाहरण के लिए, action_b_to_a को डेस्टिनेशन b से डेस्टिनेशन a पर जाने के तौर पर तय किया गया है. इस कार्रवाई में ऐनिमेशन के साथ-साथ, popTo बिहेवियर शामिल है. इससे बैकस्टैक से सभी डेस्टिनेशन हट जाते हैं. इन सभी सेटिंग को NavOptions के तौर पर कैप्चर किया जाता है और इन्हें NavAction से जोड़ा जाता है.

NavAction का इस्तेमाल करने के लिए, NavController.navigate() का इस्तेमाल करें. इसमें कार्रवाई का आईडी पास करें. जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

    navController.navigate(R.id.action_b_to_a)

प्रोग्राम के ज़रिए विकल्प लागू करना

पिछले उदाहरणों में, नेविगेशन ग्राफ़ के एक्सएमएल में NavOptions तय करने का तरीका बताया गया है. हालांकि, कुछ विकल्प, बिल्ड के समय अज्ञात कंस्ट्रेंट के आधार पर अलग-अलग हो सकते हैं. ऐसे मामलों में, NavOptions को प्रोग्राम के ज़रिए बनाना और सेट करना ज़रूरी है. जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

findNavController().navigate(
R.id.action_fragmentOne_to_fragmentTwo,
null,
navOptions { // Use the Kotlin DSL for building NavOptions
    anim {
        enter = android.R.animator.fade_in
        exit = android.R.animator.fade_out
    }
  }
)

NavController navController = NavHostFragment.findNavController(this);
  navController.navigate(
    R.id.action_fragmentOne_to_fragmentTwo,
    null,
    new NavOptions.Builder()
      .setEnterAnim(android.R.animator.fade_in)
      .setExitAnim(android.R.animator.fade_out)
      .build()
  );

इस उदाहरण में, navigate() के बढ़े हुए फ़ॉर्म का इस्तेमाल किया गया है. इसमें अतिरिक्त Bundle और NavOptions आर्ग्युमेंट शामिल हैं. navigate() के सभी वैरिएंट के बढ़े हुए वर्शन होते हैं. इनमें NavOptions का आर्ग्युमेंट स्वीकार किया जाता है.

इम्प्लिसिट डीप लिंक पर नेविगेट करते समय भी, प्रोग्राम के ज़रिए NavOptions लागू किए जा सकते हैं:

findNavController().navigate(
    deepLinkUri,
    navOptions { // Use the Kotlin DSL for building NavOptions
        anim {
            enter = android.R.animator.fade_in
            exit = android.R.animator.fade_out
        }
    }
)

NavController navController = NavHostFragment.findNavController(this);
navController.navigate(
        deepLinkUri,
        new NavOptions.Builder()
                .setEnterAnim(android.R.animator.fade_in)
                .setExitAnim(android.R.animator.fade_out)
                .build()
);

navigate() के इस वैरिएंट में, इम्प्लिसिट डीप लिंक के लिए Uri के साथ-साथ, NavOptions का इंस्टेंस भी शामिल होता है.