नेविगेशन यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करके NavController से यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट कनेक्ट करना

नेविगेशन कॉम्पोनेंट में NavigationUI क्लास शामिल होती है. इस क्लास में स्टैटिक तरीके शामिल हैं. इनकी मदद से, टॉप ऐप्लिकेशन बार, नेविगेशन पैनल, और पेज या स्क्रीन के नीचे मौजूद नेविगेशन बार के साथ नेविगेशन को मैनेज किया जाता है.

टॉप ऐप्लिकेशन बार

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

स्क्रीन पर सबसे ऊपर ऐप्लिकेशन बार दिख रहा है
पहली इमेज. टॉप ऐप्लिकेशन बार दिखाने वाली स्क्रीन.

NavigationUI में ऐसे तरीके शामिल हैं जो आपके ऐप्लिकेशन में नेविगेट करने पर, टॉप ऐप्लिकेशन बार में मौजूद कॉन्टेंट को अपने-आप अपडेट करते हैं. उदाहरण के लिए, NavigationUI आपके नेविगेशन ग्राफ़ से डेस्टिनेशन लेबल का इस्तेमाल करता है, ताकि टॉप ऐप्लिकेशन बार का टाइटल अप-टू-डेट रहे.

<navigation>
    <fragment ...
              android:label="Page title">
      ...
    </fragment>
</navigation>

नीचे बताए गए टॉप ऐप्लिकेशन बार के साथ NavigationUI का इस्तेमाल करने पर, डेस्टिनेशन के साथ अटैच किया गया लेबल, डेस्टिनेशन को दिए गए आर्ग्युमेंट से अपने-आप पॉप्युलेट हो सकता है. इसके लिए, आपको अपने लेबल में {argName} फ़ॉर्मैट का इस्तेमाल करना होगा.

NavigationUI में, टॉप ऐप्लिकेशन बार के इन टाइप का इस्तेमाल किया जा सकता है:

ऐप्लिकेशन बार के बारे में ज़्यादा जानने के लिए, ऐप्लिकेशन बार सेट अप करना लेख पढ़ें.

AppBarConfiguration

NavigationUI, AppBarConfiguration ऑब्जेक्ट का इस्तेमाल करके, आपके ऐप्लिकेशन के डिसप्ले एरिया के सबसे ऊपर बाएं कोने में मौजूद नेविगेशन बटन के काम करने के तरीके को मैनेज करता है. नेविगेशन बटन का व्यवहार इस बात पर निर्भर करता है कि उपयोगकर्ता टॉप-लेवल डेस्टिनेशन पर है या नहीं.

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

जब उपयोगकर्ता टॉप-लेवल डेस्टिनेशन पर होता है, तो नेविगेशन बटन, ड्रॉअर आइकॉन में बदल जाता है. ऐसा तब होता है, जब डेस्टिनेशन में DrawerLayout का इस्तेमाल किया जाता है. अगर डेस्टिनेशन में DrawerLayout का इस्तेमाल नहीं किया जाता है, तो नेविगेशन बटन छिपा होता है. जब उपयोगकर्ता किसी अन्य डेस्टिनेशन पर होता है, तो नेविगेशन बटन, अप बटन के तौर पर दिखता है. सिर्फ़ स्टार्ट डेस्टिनेशन को टॉप-लेवल डेस्टिनेशन के तौर पर इस्तेमाल करके, नेविगेशन बटन को कॉन्फ़िगर करने के लिए, एक AppBarConfiguration ऑब्जेक्ट बनाएं. इसके बाद, उससे जुड़ा नेविगेशन ग्राफ़ पास करें, जैसा कि यहां दिखाया गया है:

Kotlin

val appBarConfiguration = AppBarConfiguration(navController.graph)

Java

AppBarConfiguration appBarConfiguration =
        new AppBarConfiguration.Builder(navController.getGraph()).build();

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

Kotlin

val appBarConfiguration = AppBarConfiguration(setOf(R.id.main, R.id.profile))

Java

AppBarConfiguration appBarConfiguration =
        new AppBarConfiguration.Builder(R.id.main, R.id.profile).build();

टूलबार बनाना

NavigationUI की मदद से टूलबार बनाने के लिए, पहले अपनी मुख्य गतिविधि में बार को तय करें, जैसा कि यहां दिखाया गया है:

<LinearLayout>
    <androidx.appcompat.widget.Toolbar
        android:id="@+id/toolbar" />
    <androidx.fragment.app.FragmentContainerView
        android:id="@+id/nav_host_fragment"
        ... />
    ...
</LinearLayout>

इसके बाद, अपनी मुख्य गतिविधि के onCreate() तरीके से setupWithNavController() को कॉल करें, जैसा कि इस उदाहरण में दिखाया गया है:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    setContentView(R.layout.activity_main)

    ...

    val navController = findNavController(R.id.nav_host_fragment)
    val appBarConfiguration = AppBarConfiguration(navController.graph)
    findViewById<Toolbar>(R.id.toolbar)
        .setupWithNavController(navController, appBarConfiguration)
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_main);

    ...

    NavController navController = Navigation.findNavController(this, R.id.nav_host_fragment);
    AppBarConfiguration appBarConfiguration =
            new AppBarConfiguration.Builder(navController.getGraph()).build();
    Toolbar toolbar = findViewById(R.id.toolbar);
    NavigationUI.setupWithNavController(
            toolbar, navController, appBarConfiguration);
}

नेविगेशन बटन को सभी डेस्टिनेशन के लिए, अप बटन के तौर पर कॉन्फ़िगर करने के लिए, AppBarConfiguration बनाते समय अपने टॉप-लेवल डेस्टिनेशन के लिए, डेस्टिनेशन आईडी का खाली सेट पास करें. उदाहरण के लिए, अगर आपके पास कोई दूसरी गतिविधि है, तो यह सुविधा काम की हो सकती है. इस गतिविधि में, सभी डेस्टिनेशन पर Toolbar में 'ऊपर जाएं' बटन दिखना चाहिए. इससे उपयोगकर्ता, पिछली गतिविधियों में कोई अन्य डेस्टिनेशन न होने पर, पैरंट ऐक्टिविटी पर वापस जा सकता है. setFallbackOnNavigateUpListener() का इस्तेमाल करके, फ़ॉलबैक के व्यवहार को कंट्रोल किया जा सकता है. ऐसा तब किया जा सकता है, जब navigateUp() कुछ न करे. इसके बारे में यहां दिए गए उदाहरण में बताया गया है:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    ...

    val navHostFragment =
        supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
    val navController = navHostFragment.navController
    val appBarConfiguration = AppBarConfiguration(
        topLevelDestinationIds = setOf(),
        fallbackOnNavigateUpListener = ::onSupportNavigateUp
    )
    findViewById<Toolbar>(R.id.toolbar)
        .setupWithNavController(navController, appBarConfiguration)
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...

    NavHostFragment navHostFragment = (NavHostFragment) supportFragmentManager.findFragmentById(R.id.nav_host_fragment);
    NavController navController = navHostFragment.getNavController();
    AppBarConfiguration appBarConfiguration = new AppBarConfiguration.Builder()
        .setFallbackOnNavigateUpListener(::onSupportNavigateUp)
        .build();
    Toolbar toolbar = findViewById(R.id.toolbar);
    NavigationUI.setupWithNavController(
            toolbar, navController, appBarConfiguration);
}

CollapsingToolbarLayout शामिल करें

अपने टूलबार में CollapsingToolbarLayout को शामिल करने के लिए, सबसे पहले अपनी गतिविधि में टूलबार और उसके आस-पास के लेआउट को तय करें. इसके लिए, यहां दिया गया तरीका अपनाएं:

<LinearLayout>
    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="@dimen/tall_toolbar_height">

        <com.google.android.material.appbar.CollapsingToolbarLayout
            android:id="@+id/collapsing_toolbar_layout"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:contentScrim="?attr/colorPrimary"
            app:expandedTitleGravity="top"
            app:layout_scrollFlags="scroll|exitUntilCollapsed|snap">

            <androidx.appcompat.widget.Toolbar
                android:id="@+id/toolbar"
                android:layout_width="match_parent"
                android:layout_height="?attr/actionBarSize"
                app:layout_collapseMode="pin"/>
        </com.google.android.material.appbar.CollapsingToolbarLayout>
    </com.google.android.material.appbar.AppBarLayout>

    <androidx.fragment.app.FragmentContainerView
        android:id="@+id/nav_host_fragment"
        ... />
    ...
</LinearLayout>

इसके बाद, अपनी मुख्य गतिविधि के onCreate तरीके से setupWithNavController() को कॉल करें, जैसा कि यहां दिखाया गया है:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    setContentView(R.layout.activity_main)

    ...

    val layout = findViewById<CollapsingToolbarLayout>(R.id.collapsing_toolbar_layout)
    val toolbar = findViewById<Toolbar>(R.id.toolbar)
    val navHostFragment =
        supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
    val navController = navHostFragment.navController
    val appBarConfiguration = AppBarConfiguration(navController.graph)
    layout.setupWithNavController(toolbar, navController, appBarConfiguration)
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_main);

    ...

    CollapsingToolbarLayout layout = findViewById(R.id.collapsing_toolbar_layout);
    Toolbar toolbar = findViewById(R.id.toolbar);
    NavHostFragment navHostFragment = supportFragmentManager.findFragmentById(R.id.nav_host_fragment);
    NavController navController = navHostFragment.getNavController();
    AppBarConfiguration appBarConfiguration =
            new AppBarConfiguration.Builder(navController.getGraph()).build();
    NavigationUI.setupWithNavController(layout, toolbar, navController, appBarConfiguration);
}

कार्रवाई बार

डिफ़ॉल्ट ऐप्लिकेशन बार में नेविगेशन की सुविधा जोड़ने के लिए, अपनी मुख्य गतिविधि के onCreate() तरीके से setupActionBarWithNavController() को कॉल करें. इसके बारे में यहां बताया गया है. ध्यान दें कि आपको AppBarConfiguration को onCreate() के बाहर डिक्लेयर करना होगा, क्योंकि इसका इस्तेमाल onSupportNavigateUp() को ओवरराइड करते समय भी किया जाता है:

Kotlin

private lateinit var appBarConfiguration: AppBarConfiguration

...

override fun onCreate(savedInstanceState: Bundle?) {
    ...

    val navHostFragment =
        supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
    val navController = navHostFragment.navController
    appBarConfiguration = AppBarConfiguration(navController.graph)
    setupActionBarWithNavController(navController, appBarConfiguration)
}

Java

AppBarConfiguration appBarConfiguration;

...

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...

    NavHostFragment navHostFragment = supportFragmentManager.findFragmentById(R.id.nav_host_fragment);
    NavController navController = navHostFragment.getNavController();
    appBarConfiguration = new AppBarConfiguration.Builder(navController.getGraph()).build();
    NavigationUI.setupActionBarWithNavController(this, navController, appBarConfiguration);
}

इसके बाद, Up नेविगेशन को मैनेज करने के लिए, onSupportNavigateUp() को बदलें:

Kotlin

override fun onSupportNavigateUp(): Boolean {
    val navController = findNavController(R.id.nav_host_fragment)
    return navController.navigateUp(appBarConfiguration)
            || super.onSupportNavigateUp()
}

Java

@Override
public boolean onSupportNavigateUp() {
    NavController navController = Navigation.findNavController(this, R.id.nav_host_fragment);
    return NavigationUI.navigateUp(navController, appBarConfiguration)
            || super.onSupportNavigateUp();
}

ऐप्लिकेशन बार के अलग-अलग वर्शन के साथ काम करना

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

उदाहरण के लिए, आपके किसी डेस्टिनेशन में स्टैंडर्ड Toolbar का इस्तेमाल किया जा सकता है. वहीं, दूसरे डेस्टिनेशन में AppBarLayout का इस्तेमाल करके, टैब के साथ ज़्यादा जटिल ऐप्लिकेशन बार बनाया जा सकता है. जैसा कि दूसरी इमेज में दिखाया गया है.

टॉप ऐप्लिकेशन बार के दो वैरिएंट; बाईं ओर एक स्टैंडर्ड टूलबार और दाईं ओर टूलबार और टैब वाला ऐप्लिकेशन बार लेआउट
दूसरी इमेज. ऐप्लिकेशन बार के दो वैरिएशन. बाईं ओर, स्टैंडर्ड Toolbar. दाईं ओर, AppBarLayout, Toolbar, और टैब.

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

<LinearLayout>
    <androidx.appcompat.widget.Toolbar
        android:id="@+id/toolbar"
        ... />
    ...
</LinearLayout>

इसके बाद, उस डेस्टिनेशन फ़्रैगमेंट को तय करें जो टैब वाले ऐप्लिकेशन बार का इस्तेमाल करता है:

<LinearLayout>
    <com.google.android.material.appbar.AppBarLayout
        ... />

        <androidx.appcompat.widget.Toolbar
            android:id="@+id/toolbar"
            ... />

        <com.google.android.material.tabs.TabLayout
            ... />

    </com.google.android.material.appbar.AppBarLayout>
    ...
</LinearLayout>

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

Kotlin

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    val navController = findNavController()
    val appBarConfiguration = AppBarConfiguration(navController.graph)

    view.findViewById<Toolbar>(R.id.toolbar)
            .setupWithNavController(navController, appBarConfiguration)
}

Java

@Override
public void onViewCreated(@NonNull View view,
                          @Nullable Bundle savedInstanceState) {
    NavController navController = Navigation.findNavController(view);
    AppBarConfiguration appBarConfiguration =
            new AppBarConfiguration.Builder(navController.getGraph()).build();
    Toolbar toolbar = view.findViewById(R.id.toolbar);

    NavigationUI.setupWithNavController(
            toolbar, navController, appBarConfiguration);
}

मेन्यू आइटम के साथ डेस्टिनेशन जोड़ना

NavigationUI, डेस्टिनेशन को मेन्यू-ड्रिवन यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट से जोड़ने के लिए हेल्पर भी उपलब्ध कराता है. NavigationUI में एक हेल्पर मेथड, onNavDestinationSelected() शामिल है. यह MenuItem के साथ-साथ, उस NavController को लेता है जो असोसिएटेड डेस्टिनेशन को होस्ट करता है. अगर MenuItem का id, डेस्टिनेशन के id से मैच करता है, तो NavController उस डेस्टिनेशन पर जा सकता है.

उदाहरण के लिए, यहां दिए गए एक्सएमएल स्निपेट, एक ही id, details_page_fragment वाले मेन्यू आइटम और डेस्टिनेशन को तय करते हैं:

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

    ...

    <fragment android:id="@+id/details_page_fragment"
         android:label="@string/details"
         android:name="com.example.android.myapp.DetailsFragment" />
</navigation>
<menu xmlns:android="http://schemas.android.com/apk/res/android">

    ...

    <item
        android:id="@+id/details_page_fragment"
        android:icon="@drawable/ic_details"
        android:title="@string/details" />
</menu>

उदाहरण के लिए, अगर आपका मेन्यू, गतिविधि के onCreateOptionsMenu() का इस्तेमाल करके जोड़ा गया था, तो मेन्यू आइटम को डेस्टिनेशन से जोड़ा जा सकता है. इसके लिए, गतिविधि के onOptionsItemSelected() को बदलकर onNavDestinationSelected() को कॉल करें, जैसा कि इस उदाहरण में दिखाया गया है:

Kotlin

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    val navController = findNavController(R.id.nav_host_fragment)
    return item.onNavDestinationSelected(navController) || super.onOptionsItemSelected(item)
}

Java

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    NavController navController = Navigation.findNavController(this, R.id.nav_host_fragment);
    return NavigationUI.onNavDestinationSelected(item, navController)
            || super.onOptionsItemSelected(item);
}

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

नेविगेशन पैनल जोड़ना

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

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

ड्रॉअर आइकॉन, DrawerLayout का इस्तेमाल करने वाले सभी टॉप-लेवल डेस्टिनेशन पर दिखता है.

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

उदाहरण के लिए, यहां दिए गए लेआउट में दो चाइल्ड व्यू के साथ DrawerLayout का इस्तेमाल किया गया है: मुख्य कॉन्टेंट के लिए NavHostFragment और नेविगेशन पैनल के कॉन्टेंट के लिए NavigationView.

<?xml version="1.0" encoding="utf-8"?>
<!-- Use DrawerLayout as root container for activity -->
<androidx.drawerlayout.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/drawer_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">

    <!-- Layout to contain contents of main body of screen (drawer will slide over this) -->
    <androidx.fragment.app.FragmentContainerView
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:id="@+id/nav_host_fragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:defaultNavHost="true"
        app:navGraph="@navigation/nav_graph" />

    <!-- Container for contents of drawer - use NavigationView to make configuration easier -->
    <com.google.android.material.navigation.NavigationView
        android:id="@+id/nav_view"
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:layout_gravity="start"
        android:fitsSystemWindows="true" />

</androidx.drawerlayout.widget.DrawerLayout>

इसके बाद, DrawerLayout को अपने नेविगेशन ग्राफ़ से कनेक्ट करें. इसके लिए, इसे AppBarConfiguration में पास करें, जैसा कि इस उदाहरण में दिखाया गया है:

Kotlin

val appBarConfiguration = AppBarConfiguration(navController.graph, drawerLayout)

Java

AppBarConfiguration appBarConfiguration =
        new AppBarConfiguration.Builder(navController.getGraph())
            .setDrawerLayout(drawerLayout)
            .build();

इसके बाद, अपनी मुख्य गतिविधि क्लास में, अपनी मुख्य गतिविधि के onCreate() तरीके से setupWithNavController() को कॉल करें, जैसा कि यहां दिखाया गया है:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    setContentView(R.layout.activity_main)

    ...

    val navHostFragment =
        supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
    val navController = navHostFragment.navController
    findViewById<NavigationView>(R.id.nav_view)
        .setupWithNavController(navController)
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_main);

    ...

    NavHostFragment navHostFragment = supportFragmentManager.findFragmentById(R.id.nav_host_fragment);
    NavController navController = navHostFragment.getNavController();
    NavigationView navView = findViewById(R.id.nav_view);
    NavigationUI.setupWithNavController(navView, navController);
}

Navigation 2.4.0-alpha01 से, setupWithNavController का इस्तेमाल करने पर, हर मेन्यू आइटम की स्थिति सेव और वापस लाई जाती है.

पेज या स्क्रीन के नीचे मौजूद नेविगेशन बार

NavigationUI, पेज या स्क्रीन के नीचे मौजूद नेविगेशन बार को भी मैनेज कर सकता है. जब कोई उपयोगकर्ता मेन्यू आइटम चुनता है, तो NavController, onNavDestinationSelected() को कॉल करता है और पेज या स्क्रीन के नीचे मौजूद नेविगेशन बार में चुने गए आइटम को अपने-आप अपडेट कर देता है.

ऐप्लिकेशन की स्क्रीन पर सबसे नीचे मौजूद नेविगेशन बार
चौथी इमेज. पेज या स्क्रीन के नीचे मौजूद नेविगेशन बार.

अपने ऐप्लिकेशन में पेज या स्क्रीन के नीचे मौजूद नेविगेशन बार बनाने के लिए, सबसे पहले अपनी मुख्य गतिविधि में बार को तय करें, जैसा कि यहां दिखाया गया है:

<LinearLayout>
    ...
    <androidx.fragment.app.FragmentContainerView
        android:id="@+id/nav_host_fragment"
        ... />
    <com.google.android.material.bottomnavigation.BottomNavigationView
        android:id="@+id/bottom_nav"
        app:menu="@menu/menu_bottom_nav" />
</LinearLayout>

इसके बाद, अपनी मुख्य गतिविधि क्लास में, अपनी मुख्य गतिविधि के onCreate() तरीके से setupWithNavController() को कॉल करें, जैसा कि यहां दिखाया गया है:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    setContentView(R.layout.activity_main)

    ...

    val navHostFragment =
        supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
    val navController = navHostFragment.navController
    findViewById<BottomNavigationView>(R.id.bottom_nav)
        .setupWithNavController(navController)
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_main);

    ...

    NavHostFragment navHostFragment = supportFragmentManager.findFragmentById(R.id.nav_host_fragment);
    NavController navController = navHostFragment.getNavController();
    BottomNavigationView bottomNav = findViewById(R.id.bottom_nav);
    NavigationUI.setupWithNavController(bottomNav, navController);
}

Navigation 2.4.0-alpha01 से, setupWithNavController का इस्तेमाल करने पर, हर मेन्यू आइटम की स्थिति सेव और वापस लाई जाती है.

नेविगेशन इवेंट को मॉनिटर करने की अनुमति

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

NavController, OnDestinationChangedListener इंटरफ़ेस ऑफ़र करता है. इसे तब कॉल किया जाता है, जब NavController का मौजूदा डेस्टिनेशन या इसके आर्ग्युमेंट बदलते हैं. addOnDestinationChangedListener() तरीके का इस्तेमाल करके, नया लिसनर रजिस्टर किया जा सकता है. ध्यान दें कि addOnDestinationChangedListener() को कॉल करने पर, अगर मौजूदा डेस्टिनेशन मौजूद है, तो उसे तुरंत आपके लिसनर को भेज दिया जाता है.

NavigationUI, OnDestinationChangedListener का इस्तेमाल करता है, ताकि यूज़र इंटरफ़ेस (यूआई) के इन सामान्य कॉम्पोनेंट को नेविगेशन के बारे में जानकारी मिल सके. हालांकि, ध्यान दें कि किसी भी कस्टम यूज़र इंटरफ़ेस (यूआई) या कारोबारी नियम को नेविगेशन इवेंट के बारे में जानकारी देने के लिए, OnDestinationChangedListener का इस्तेमाल अपने-आप भी किया जा सकता है.

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

Kotlin

navController.addOnDestinationChangedListener { _, destination, _ ->
   if(destination.id == R.id.full_screen_destination) {
       toolbar.visibility = View.GONE
       bottomNavigationView.visibility = View.GONE
   } else {
       toolbar.visibility = View.VISIBLE
       bottomNavigationView.visibility = View.VISIBLE
   }
}

Java

navController.addOnDestinationChangedListener(new NavController.OnDestinationChangedListener() {
   @Override
   public void onDestinationChanged(@NonNull NavController controller,
           @NonNull NavDestination destination, @Nullable Bundle arguments) {
       if(destination.getId() == R.id.full_screen_destination) {
           toolbar.setVisibility(View.GONE);
           bottomNavigationView.setVisibility(View.GONE);
       } else {
           toolbar.setVisibility(View.VISIBLE);
           bottomNavigationView.setVisibility(View.VISIBLE);
       }
   }
});

आर्ग्युमेंट पर आधारित लिसनर

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

<?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"
    android:id="@+id/navigation\_graph"
    app:startDestination="@id/fragmentOne">
    <fragment
        android:id="@+id/fragmentOne"
        android:name="com.example.android.navigation.FragmentOne"
        android:label="FragmentOne">
        <action
            android:id="@+id/action\_fragmentOne\_to\_fragmentTwo"
            app:destination="@id/fragmentTwo" />
    </fragment>
    <fragment
        android:id="@+id/fragmentTwo"
        android:name="com.example.android.navigation.FragmentTwo"
        android:label="FragmentTwo">
        <argument
            android:name="ShowAppBar"
            android:defaultValue="true" />
    </fragment>
</navigation>

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

अब हम Activity में OnDestinationChangedListener जोड़ सकते हैं:

Kotlin

navController.addOnDestinationChangedListener { _, _, arguments ->
    appBar.isVisible = arguments?.getBoolean("ShowAppBar", false) == true
}

Java

navController.addOnDestinationChangedListener(
        new NavController.OnDestinationChangedListener() {
            @Override
            public void onDestinationChanged(
                    @NonNull NavController controller,
                    @NonNull NavDestination destination,
                    @Nullable Bundle arguments
            ) {
                boolean showAppBar = false;
                if (arguments != null) {
                    showAppBar = arguments.getBoolean("ShowAppBar", false);
                }
                if(showAppBar) {
                    appBar.setVisibility(View.VISIBLE);
                } else {
                    appBar.setVisibility(View.GONE);
                }
            }
        }
);

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

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

अन्य संसाधन

नेविगेशन के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें.

कोडलैब

ब्लॉग पोस्ट

वीडियो