רכיב הניווט כולל NavigationUI
בכיתה. הכיתה הזו מכילה שיטות סטטיות שמנהלות את הניווט באמצעות החלק העליון של המסך
את סרגל האפליקציות, את חלונית ההזזה לניווט ואת הניווט התחתון.
סרגל האפליקציה העליון
סרגל האפליקציות העליון מספק מקום עקבי בחלק העליון של האפליקציה להצגת מידע והפעולות במסך הנוכחי.
![מסך שבו מוצג סרגל אפליקציות עליון](https://developer.android.com/static/topic/libraries/architecture/images/top-app-bar.png?authuser=0&hl=he)
NavigationUI
כולל שיטות שמעדכנות באופן אוטומטי תוכן שמוצג בראש הדף
בסרגל האפליקציות בזמן שהמשתמשים מנווטים באפליקציה. לדוגמה, NavigationUI
משתמש בתחילית
תוויות היעד מתרשים הניווט כדי לשמור את הכותרת של האפליקציה העליונה
העמודה מתעדכנת.
<navigation> <fragment ... android:label="Page title"> ... </fragment> </navigation>
כשמשתמשים ב-NavigationUI
עם יישומי סרגל האפליקציות המובילים שמפורטים בהמשך,
אפשר לאכלס את התווית שמצרפים ליעדים באופן אוטומטי
ארגומנטים שסופקו ליעד באמצעות הפורמט של {argName}
התיוג.
NavigationUI
תומך בסוגים המובילים הבאים של סרגלי האפליקציות:
מידע נוסף על סרגלי אפליקציות זמין במאמר הגדרת סרגל האפליקציות.
הגדרת AppBarConfiguration
NavigationUI
משתמש ב-AppBarConfiguration
אובייקט לניהול ההתנהגות של לחצן הניווט בפינה הימנית העליונה.
של אזור התצוגה של האפליקציה. ההתנהגות של לחצן הניווט משתנה בהתאם
מציין אם המשתמש נמצא ביעד ברמה העליונה.
יעד ברמה עליונה הוא יעד ברמה הבסיסית (root), או יעד ברמה הגבוהה ביותר, בקבוצה של יעדים הקשורים בהיררכיה. ביעדים ברמה העליונה לא מוצג לחצן 'למעלה' בסרגל העליון של האפליקציה כי אין יעד ברמה גבוהה יותר. על ידי ברירת המחדל, יעד ההתחלה של האפליקציה הוא היעד היחיד ברמה העליונה.
כשהמשתמש נמצא ביעד ברמה העליונה, לחצן הניווט הופך
סמל של חלונית הזזה
אם היעד הוא
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
, קודם צריך להגדיר את הסרגל בשדה הראשי
פעילות, כפי שמוצג:
<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
בכל היעדים. הפעולה הזו תאפשר למשתמש לנווט חזרה
לפעילות ההורה כשאין יעדים אחרים מאחור
סטאק. אפשר להשתמש
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
בסרגל הכלים, תחילה צריך להגדיר
סרגל הכלים והפריסה שמסביב בפעילות שלך, כפי שמוצג בהמשך:
<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()
מ-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()
מהשיטה 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.
![שתי וריאציות מובילות של סרגל האפליקציות; סרגל כלים סטנדרטי משמאל.
עם סרגל כלים וכרטיסיות מימין](https://developer.android.com/static/images/guide/navigation/app-bar-variations.png?authuser=0&hl=he)
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>
הלוגיקה של תצורת הניווט זהה לשני המקטעים האלה,
חוץ מזה שצריך לקרוא
setupWithNavController()
מתוך השיטה onViewCreated()
של כל מקטע, במקום לאתחל
אותם מהפעילות:
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
שמארח את
יעד משויך. אם 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
.
הוספה של חלונית הזזה לניווט
חלונית ההזזה לניווט היא חלונית של ממשק משתמש שבה מוצג תפריט הניווט הראשי של האפליקציה.
חלונית ההזזה מופיעה כשהמשתמש נוגע בסמל חלונית ההזזה
בסרגל של האפליקציות או כאשר המשתמש מחליק אצבע מהקצה השמאלי של
מסך.
![חלונית הזזה פתוחה שבה מוצג תפריט ניווט](https://developer.android.com/static/images/topic/libraries/architecture/navigation-drawer.png?authuser=0&hl=he)
הסמל של חלונית ההזזה מוצג בכל המכשירים
יעדים ברמה העליונה שנעשה בהם שימוש ב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()
מ-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); }
מתחיל בעוד
ניווט 2.4.0-alpha01,
כשהמצב של כל אפשרות בתפריט נשמר ומשוחזר, כשאתם משתמשים
setupWithNavController
.
ניווט בחלק התחתון
NavigationUI
יכול גם לטפל בניווט התחתון. כשמשתמש בוחר תפריט
פריט, הקריאות של NavController
onNavDestinationSelected()
ומעדכן באופן אוטומטי את הפריט שנבחר בסרגל הניווט התחתון.
![סרגל ניווט תחתון](https://developer.android.com/static/topic/libraries/architecture/images/bottom-navigation.png?authuser=0&hl=he)
כדי ליצור סרגל ניווט תחתון באפליקציה, צריך קודם להגדיר את הסרגל בתפריט הראשי פעילות, כפי שמוצג בהמשך:
<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()
מ-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); }
מתחיל בעוד
ניווט 2.4.0-alpha01,
כשהמצב של כל אפשרות בתפריט נשמר ומשוחזר, כשאתם משתמשים
setupWithNavController
.
לדוגמה מקיפה שכוללת ניווט בחלק התחתון, ראו את דגימת ניווט מתקדמת לרכיבי הארכיטקטורה של Android ב-GitHub.
האזנה לאירועי ניווט
אינטראקציה עם NavController
היא השיטה העיקרית לניווט בין יעדים. NavController
אחראי להחלפת התוכן של NavHost
עם היעד החדש. במקרים רבים, רכיבי ממשק המשתמש — כמו סרגל אפליקציה עליון
פקדי ניווט קבועים אחרים, כמו BottomNavigationBar
– בשידור חי בחוץ
של NavHost
וצריך לעדכן אותם במהלך הניווט בין יעדים.
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
. במקרה הזה, הערך מציין אם סרגל האפליקציה
צריך להופיע ביעד הזה.
עכשיו אפשר להוסיף 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
אפשרות לעדכן את המצב או את הרשאות הגישה של רכיבי ממשק המשתמש
שבבעלותו על סמך הארגומנטים שהתקבלו בקריאה החוזרת.
אחד היתרונות של גישה זו הוא שה-Activity
רואה רק
ארגומנטים בתרשים הניווט ולא יודעים Fragment
בודדים
ובאחריותכם. באופן דומה, הקטעים הנפרדים לא יודעים
על השדה Activity
המכיל ועל רכיבי ממשק המשתמש שבבעלותו.
מקורות מידע נוספים
מידע נוסף על הניווט זמין במקורות המידע הנוספים הבאים.
דוגמיות
שיעורי Lab
פוסטים בבלוגים
סרטונים
- 10 שיטות מומלצות למעבר לפעילות יחידה
- פעילות יחידה: למה, מתי ואיך (כנס מפתחי Android לשנת 2018)
- Android Jetpack: ניהול הניווט בממשק המשתמש באמצעות בקר ניווט (Google I/O '18)