רכיב הניווט כולל מחלקה מסוג 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 הוא תרחיש לדוגמה נפוץ לכך, שבו יכולים להיות מסכים אחים שלא קשורים זה לזה באופן היררכי, ולכל אחד מהם יכולה להיות קבוצה משלו של יעדים קשורים. במקרים כאלה, אפשר להעביר קבוצה של מזהי יעדים ל-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.
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.
הוספת חלונית הזזה לניווט
חלונית ההזזה לניווט היא חלונית בממשק המשתמש שבה מוצג תפריט הניווט הראשי של האפליקציה.
התפריט מופיע כשהמשתמש לוחץ על סמל התפריט
בסרגל האפליקציה, או כשהמשתמש מחליק אצבע מהקצה השמאלי של המסך.
סמל חלונית ההזזה מוצג בכל היעדים ברמה העליונה שמשתמשים ב-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() ומעדכן באופן אוטומטי את הפריט שנבחר בסרגל הניווט התחתון.
כדי ליצור סרגל ניווט תחתון באפליקציה, קודם צריך להגדיר את הסרגל בפעילות הראשית, כמו שמוצג בהמשך:
<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
פוסטים בבלוגים
סרטונים
- 10 שיטות מומלצות למעבר לפעילות אחת
- Single Activity: Why, When, and How (Android Dev Summit '18)
- Android Jetpack: ניהול הניווט בממשק המשתמש באמצעות Navigation Controller (Google I/O '18)