חיבור רכיבים של ממשק המשתמש ל-NavController באמצעות NavigationUI

רכיב הניווט כולל מחלקה מסוג NavigationUI. המחלקה הזו מכילה שיטות סטטיות שמנהלות את הניווט באמצעות סרגל האפליקציה העליון, חלונית ההזזה לניווט וסרגל הניווט התחתון.

סרגל האפליקציה העליון

סרגל האפליקציה העליון הוא מקום קבוע בחלק העליון של האפליקציה שבו מוצגים מידע ופעולות מהמסך הנוכחי.

מסך שמוצג בו סרגל אפליקציה עליון
תרשים 1. מסך שמוצג בו סרגל אפליקציה עליון.

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 הוא תרחיש לדוגמה נפוץ לכך, שבו יכולים להיות מסכים אחים שלא קשורים זה לזה באופן היררכי, ולכל אחד מהם יכולה להיות קבוצה משלו של יעדים קשורים. במקרים כאלה, אפשר להעביר קבוצה של מזהי יעדים ל-constructor, כמו בדוגמה הבאה:

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, קודם צריך להגדיר את הסרגל ב-activity הראשי, כמו שמוצג כאן:

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

לאחר מכן, קוראים ל-setupWithNavController() מה-method onCreate() של הפעילות הראשית, כמו בדוגמה הבאה:

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 בכל היעדים. כך המשתמש יכול לחזור לפעילות ההורה כשאין יעדים אחרים במקבץ הפעילויות הקודמות (back stack). אפשר להשתמש ב-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>

בשלב הבא, קוראים ל-setupWithNavController() מה-method‏ onCreate של הפעילות הראשית, כמו שמוצג בהמשך:

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);
}

סרגל הפעולות

כדי להוסיף תמיכה בניווט לסרגל האפליקציה שמוגדר כברירת מחדל, צריך להפעיל את setupActionBarWithNavController() מה-method‏ onCreate() של הפעילות הראשית, כמו שמוצג בהמשך. שימו לב שצריך להצהיר על 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);
}

אחר כך, משנים את 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 כדי ליצור סרגל אפליקציה מורכב יותר עם כרטיסיות, כמו שמוצג באיור 2.

שתי וריאציות של סרגל האפליקציה העליון: סרגל כלים רגיל משמאל, ו-appbarlayout עם סרגל כלים וכרטיסיות מימין
איור 2. שתי וריאציות של סרגל האפליקציה. בצד שמאל, Toolbar רגיל. בצד שמאל, AppBarLayout עם Toolbar וכרטיסיות.

כדי להטמיע את הדוגמה הזו ב-fragment של היעד באמצעות NavigationUI, קודם מגדירים את סרגל האפליקציה בכל אחד מהפריסות של ה-fragment, החל מה-fragment של היעד שמשתמש בסרגל כלים רגיל:

<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>

לוגיקת הגדרת הניווט זהה בשני הפרגמנטים האלה, אבל צריך להפעיל את setupWithNavController() מתוך ה-method‏ onViewCreated() של כל פרגמנט, במקום להפעיל אותם מה-activity:

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 מכיל method מסייע, onNavDestinationSelected(), שמקבל MenuItem יחד עם NavController שמארח את היעד המשויך. אם ה-id של ה-MenuItem תואם ל-id של היעד, ה-NavController יכול לנווט ליעד הזה.

לדוגמה, קטעי הקוד הבאים ב-XML מגדירים פריט בתפריט ויעד עם 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.

הוספת חלונית הזזה לניווט

חלונית ההזזה לניווט היא חלונית בממשק המשתמש שבה מוצג תפריט הניווט הראשי של האפליקציה. התפריט מופיע כשהמשתמש לוחץ על סמל התפריט בסרגל האפליקציה, או כשהמשתמש מחליק אצבע מהקצה השמאלי של המסך.

חלונית הזזה פתוחה שמוצג בה תפריט ניווט
איור 3. חלונית הזזה פתוחה שמוצג בה תפריט ניווט.

סמל חלונית ההזזה מוצג בכל היעדים ברמה העליונה שמשתמשים ב-DrawerLayout.

כדי להוסיף חלונית הזזה לניווט, קודם צריך להצהיר על DrawerLayout בתור התצוגה ברמה הבסיסית (root). בתוך 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();

בשלב הבא, ברמת הפעילות העיקרית, צריך להפעיל את setupWithNavController() מה-method onCreate() של הפעילות העיקרית, כמו שמוצג בהמשך:

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() ומעדכן באופן אוטומטי את הפריט שנבחר בסרגל הניווט התחתון.

מסך אפליקציה עם סרגל ניווט תחתון
איור 4. סרגל ניווט תחתון.

כדי ליצור סרגל ניווט תחתון באפליקציה, קודם צריך להגדיר את הסרגל בפעילות הראשית, כמו שמוצג בהמשך:

<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>

בשלב הבא, ברמת הפעילות העיקרית, צריך להפעיל את setupWithNavController() מה-method onCreate() של הפעילות העיקרית, כמו שמוצג בהמשך:

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 ביעד החדש. במקרים רבים, רכיבים בממשק המשתמש – כמו סרגל אפליקציה עליון או אמצעי בקרה אחרים לניווט קבוע כמו BottomNavigationBar – נמצאים מחוץ ל-NavHost וצריך לעדכן אותם כשמנווטים בין יעדים.

‫NavController מציע ממשק OnDestinationChangedListener שמופעל כשהיעד הנוכחי של NavController או הארגומנטים שלו משתנים. אפשר לרשום מאזין חדש באמצעות ה-method‏ 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);
       }
   }
});

‫listeners מבוססי-ארגומנטים

לחלופין, אפשר גם להשתמש בארגומנטים עם ערכי ברירת מחדל בתוך תרשים הניווט, שבהם בקר ממשק המשתמש המתאים יכול להשתמש כדי לעדכן את המצב שלו. לדוגמה, במקום לבסס את הלוגיקה ב-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. במקרה הזה, הערך מציין אם סרגל האפליקציה צריך להופיע ביעד הזה.

עכשיו אפשר להוסיף OnDestinationChangedListener בActivity:

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 יכול לעדכן את המצב או את הרשאות הגישה של רכיבי ממשק המשתמש שבבעלותו, על סמך הארגומנטים שהתקבלו בקריאה החוזרת (callback).

אחד היתרונות של הגישה הזו הוא שה-Activity רואה רק את הארגומנטים בתרשים הניווט, ולא יודע מה התפקידים ותחומי האחריות של כל Fragment. באופן דומה, הפרגמנטים הנפרדים לא יודעים על ה-Activity שמכיל אותם ועל רכיבי ממשק המשתמש שבבעלותו.

מקורות מידע נוספים

למידע נוסף על ניווט, אפשר לעיין במקורות המידע הבאים.

Codelabs

פוסטים בבלוגים

סרטונים