Komponent nawigacji zawiera klasę NavigationUI. Ta klasa zawiera metody statyczne, które zarządzają nawigacją za pomocą górnego paska aplikacji, panelu nawigacji i dolnego paska nawigacyjnego.
Górny pasek aplikacji
Górny pasek aplikacji to stałe miejsce u góry aplikacji, w którym wyświetlane są informacje i działania z bieżącego ekranu.
NavigationUI zawiera metody, które automatycznie aktualizują zawartość górnego paska aplikacji, gdy użytkownicy poruszają się po aplikacji. Na przykład NavigationUI używa etykiet miejsc docelowych z wykresu nawigacyjnego, aby aktualizować tytuł górnego paska aplikacji.
<navigation> <fragment ... android:label="Page title"> ... </fragment> </navigation>
Jeśli używasz NavigationUI z omówionymi poniżej implementacjami górnego paska aplikacji, etykieta dołączana do miejsc docelowych może być automatycznie wypełniana argumentami podanymi dla miejsca docelowego, jeśli użyjesz formatu {argName} w etykiecie.
NavigationUI obsługuje te typy górnych pasków aplikacji:
Więcej informacji o paskach aplikacji znajdziesz w artykule Konfigurowanie paska aplikacji.
AppBarConfiguration
NavigationUI używa obiektu AppBarConfiguration do zarządzania zachowaniem przycisku nawigacyjnego w lewym górnym rogu obszaru wyświetlania aplikacji.
Działanie przycisku nawigacji zmienia się w zależności od tego, czy użytkownik znajduje się w miejscu docelowym najwyższego poziomu.
Miejsce docelowe najwyższego poziomu to katalog główny lub miejsce docelowe najwyższego poziomu w zbiorze miejsc docelowych powiązanych hierarchicznie. Miejsca docelowe najwyższego poziomu nie wyświetlają przycisku W górę na górnym pasku aplikacji, ponieważ nie ma wyższego poziomu. Domyślnie miejsce docelowe, od którego zaczyna się aplikacja, jest jedynym miejscem docelowym najwyższego poziomu.
Gdy użytkownik znajduje się w miejscu docelowym najwyższego poziomu, przycisk nawigacji zmienia się w ikonę panelu
, jeśli miejsce docelowe korzysta z DrawerLayout. Jeśli miejsce docelowe nie używa DrawerLayout, przycisk nawigacji jest ukryty. Gdy użytkownik znajduje się w innym miejscu docelowym, przycisk nawigacji wyświetla się jako przycisk W górę
.
Aby skonfigurować przycisk nawigacji, używając tylko miejsca docelowego jako miejsca docelowego najwyższego poziomu, utwórz obiekt AppBarConfiguration i przekaż odpowiedni wykres nawigacji, jak pokazano poniżej:
Kotlin
val appBarConfiguration = AppBarConfiguration(navController.graph)
Java
AppBarConfiguration appBarConfiguration =
new AppBarConfiguration.Builder(navController.getGraph()).build();
W niektórych przypadkach może być konieczne zdefiniowanie wielu miejsc docelowych najwyższego poziomu zamiast używania domyślnego miejsca docelowego. Typowym przypadkiem użycia jest BottomNavigationView, gdzie możesz mieć ekrany równorzędne, które nie są ze sobą powiązane hierarchicznie i mogą mieć własny zestaw powiązanych miejsc docelowych. W takich przypadkach możesz przekazać do konstruktora zestaw identyfikatorów miejsc docelowych, jak pokazano poniżej:
Kotlin
val appBarConfiguration = AppBarConfiguration(setOf(R.id.main, R.id.profile))
Java
AppBarConfiguration appBarConfiguration =
new AppBarConfiguration.Builder(R.id.main, R.id.profile).build();
Tworzenie paska narzędzi
Aby utworzyć pasek narzędzi za pomocą NavigationUI, najpierw zdefiniuj pasek w głównej aktywności, jak pokazano poniżej:
<LinearLayout> <androidx.appcompat.widget.Toolbar android:id="@+id/toolbar" /> <androidx.fragment.app.FragmentContainerView android:id="@+id/nav_host_fragment" ... /> ... </LinearLayout>
Następnie wywołaj setupWithNavController() z metody onCreate() głównej aktywności, jak w tym przykładzie:
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);
}
Aby skonfigurować przycisk nawigacji tak, aby wyświetlał się jako przycisk W górę we wszystkich miejscach docelowych, podczas tworzenia obiektu AppBarConfiguration przekaż pusty zbiór identyfikatorów miejsc docelowych najwyższego poziomu. Może to być przydatne, jeśli na przykład masz drugą aktywność, która powinna wyświetlać przycisk W górę w Toolbar we wszystkich miejscach docelowych. Dzięki temu użytkownik może wrócić do aktywności nadrzędnej, gdy na stosie wstecznym nie ma innych miejsc docelowych. Możesz użyć setFallbackOnNavigateUpListener(), aby kontrolować działanie kreacji zastępczej, gdy navigateUp() nie wykona żadnej czynności, jak w tym przykładzie:
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);
}
Uwzględnij CollapsingToolbarLayout
Aby dołączyć CollapsingToolbarLayout do paska narzędzi, najpierw zdefiniuj pasek narzędzi i otaczający go układ w aktywności, jak pokazano poniżej:
<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>
Następnie wywołaj metodę setupWithNavController() z metody onCreate głównej aktywności, jak pokazano poniżej:
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);
}
Pasek działań
Aby dodać obsługę nawigacji do domyślnego paska aplikacji, wywołaj setupActionBarWithNavController() z metody onCreate() głównej aktywności, jak pokazano poniżej. Pamiętaj, że musisz zadeklarować AppBarConfiguration poza onCreate(), ponieważ używasz go również podczas zastępowania 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);
}
Następnie zastąp onSupportNavigateUp(), aby obsłużyć nawigację w górę:
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();
}
Obsługa różnych wersji paska aplikacji
Dodanie górnego paska aplikacji do aktywności sprawdza się, gdy układ paska aplikacji jest podobny w każdym miejscu docelowym w aplikacji. Jeśli jednak górny pasek aplikacji znacznie się zmienia w różnych miejscach docelowych, rozważ usunięcie go z aktywności i zdefiniowanie go w każdym fragmencie miejsca docelowego.
Na przykład jedno z miejsc docelowych może używać standardowego elementu Toolbar, a inne – elementu AppBarLayout, aby utworzyć bardziej złożony pasek aplikacji z kartami, jak pokazano na rysunku 2.
Toolbar. Po prawej stronie AppBarLayout z Toolbar i kartami.Aby zaimplementować ten przykład we fragmentach miejsca docelowego za pomocą NavigationUI, najpierw zdefiniuj pasek aplikacji w każdym układzie fragmentu, zaczynając od fragmentu miejsca docelowego, który używa standardowego paska narzędzi:
<LinearLayout>
<androidx.appcompat.widget.Toolbar
android:id="@+id/toolbar"
... />
...
</LinearLayout>
Następnie zdefiniuj fragment miejsca docelowego, który używa paska aplikacji z kartami:
<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>
Logika konfiguracji nawigacji jest taka sama w przypadku obu tych fragmentów, ale w metodzie onViewCreated() każdego fragmentu należy wywołać setupWithNavController(), zamiast inicjować je z poziomu aktywności:
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);
}
Powiąż miejsca docelowe z pozycjami menu
NavigationUI udostępnia też funkcje pomocnicze do wiązania miejsc docelowych z komponentami interfejsu opartymi na menu. NavigationUI zawiera metodę pomocniczą onNavDestinationSelected(), która przyjmuje MenuItem wraz z NavController, który hostuje powiązane miejsce docelowe. Jeśli id MenuItem odpowiada id miejsca docelowego, NavController może przejść do tego miejsca docelowego.
Na przykład poniższe fragmenty kodu XML definiują pozycję menu i miejsce docelowe ze wspólnymi wartościami 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>
Jeśli na przykład menu zostało dodane za pomocą metody onCreateOptionsMenu() aktywności, możesz powiązać elementy menu z miejscami docelowymi, zastępując metodę onOptionsItemSelected() aktywności, aby wywołać metodę onNavDestinationSelected(), jak w tym przykładzie:
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);
}
Teraz, gdy użytkownik kliknie element menu details_page_fragment, aplikacja automatycznie przejdzie do odpowiedniego miejsca docelowego z tym samym id.
Dodawanie panelu nawigacji
Panel nawigacji to panel interfejsu, który wyświetla główne menu nawigacyjne aplikacji.
Panel boczny pojawia się, gdy użytkownik kliknie ikonę panelu bocznego
na pasku aplikacji lub przesunie palcem od lewej krawędzi ekranu.
Ikona panelu bocznego jest wyświetlana we wszystkich miejscach docelowych najwyższego poziomu, które używają elementu DrawerLayout.
Aby dodać panel nawigacji, najpierw zadeklaruj DrawerLayout jako widok główny. Wewnątrz elementu DrawerLayout dodaj układ głównej zawartości interfejsu i inny widok zawierający zawartość panelu nawigacji.
Na przykład ten układ używa elementu DrawerLayout z 2 widokami podrzędnymi: NavHostFragment, który zawiera główną treść, i NavigationView, który zawiera treść panelu nawigacji.
<?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>
Następnie połącz DrawerLayout z wykresem nawigacji, przekazując go do AppBarConfiguration, jak w tym przykładzie:
Kotlin
val appBarConfiguration = AppBarConfiguration(navController.graph, drawerLayout)
Java
AppBarConfiguration appBarConfiguration =
new AppBarConfiguration.Builder(navController.getGraph())
.setDrawerLayout(drawerLayout)
.build();
Następnie w klasie głównej aktywności wywołaj metodę setupWithNavController() z metody onCreate() głównej aktywności, jak pokazano poniżej:
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);
}
Od wersji Navigation 2.4.0-alpha01 stan każdego elementu menu jest zapisywany i przywracany, gdy używasz setupWithNavController.
Dolny pasek nawigacyjny
NavigationUI może też obsługiwać dolny pasek nawigacyjny. Gdy użytkownik wybierze element menu, NavController wywołuje onNavDestinationSelected() i automatycznie aktualizuje wybrany element na dolnym pasku nawigacyjnym.
Aby utworzyć dolny pasek nawigacyjny w aplikacji, najpierw zdefiniuj go w głównej aktywności, jak pokazano poniżej:
<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>
Następnie w klasie głównej aktywności wywołaj metodę setupWithNavController() z metody onCreate() głównej aktywności, jak pokazano poniżej:
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);
}
Od wersji Navigation 2.4.0-alpha01 stan każdego elementu menu jest zapisywany i przywracany, gdy używasz setupWithNavController.
Nasłuchiwanie zdarzeń nawigacji
Interakcja z NavController to główny sposób przechodzenia między miejscami docelowymi. NavController odpowiada za zastąpienie zawartości NavHost nowym miejscem docelowym. W wielu przypadkach elementy interfejsu, takie jak górny pasek aplikacji lub inne stałe elementy sterujące nawigacją, np. BottomNavigationBar, znajdują się poza elementem NavHost i muszą być aktualizowane podczas przechodzenia między miejscami docelowymi.
NavController udostępnia interfejs OnDestinationChangedListener, który jest wywoływany, gdy zmienia się bieżące miejsce docelowe lub argumenty NavController. Nowy obiekt nasłuchujący można zarejestrować za pomocą metody addOnDestinationChangedListener(). Pamiętaj, że gdy wywołujesz addOnDestinationChangedListener(), jeśli bieżące miejsce docelowe istnieje, jest ono natychmiast wysyłane do detektora.
NavigationUI używa OnDestinationChangedListener, aby te typowe komponenty interfejsu były świadome nawigacji. Pamiętaj jednak, że możesz też używać samego OnDestinationChangedListener, aby dowolny niestandardowy interfejs użytkownika lub logika biznesowa były świadome zdarzeń nawigacyjnych.
Możesz na przykład mieć wspólne elementy interfejsu, które chcesz wyświetlać w niektórych obszarach aplikacji, a w innych je ukrywać. Za pomocą własnego elementu OnDestinationChangedListener możesz selektywnie wyświetlać lub ukrywać te elementy interfejsu na podstawie miejsca docelowego, jak w tym przykładzie:
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);
}
}
});
Detektory oparte na argumentach
Możesz też użyć argumentów z wartościami domyślnymi w grafie nawigacji, które mogą być używane przez odpowiedni kontroler UI do aktualizowania stanu. Na przykład zamiast opierać logikę w OnDestinationChangedListener na identyfikatorze miejsca docelowego, jak w poprzednim przykładzie, możemy utworzyć argument w 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>
Ten argument nie jest używany podczas nawigowania do miejsca docelowego, ale jako sposób dołączania dodatkowych informacji do miejsca docelowego za pomocą defaultValue. W tym przypadku wartość wskazuje, czy pasek aplikacji powinien być widoczny w tym miejscu docelowym.
Możemy teraz dodać OnDestinationChangedListener w 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 wywołuje to wywołanie zwrotne za każdym razem, gdy zmienia się miejsce docelowe nawigacji. Activity może teraz aktualizować stan lub widoczność komponentów interfejsu, które posiada, na podstawie argumentów otrzymanych w wywołaniu zwrotnym.
Jedną z zalet tego podejścia jest to, że Activity widzi tylko argumenty w grafie nawigacji i nie zna poszczególnych ról i obowiązków Fragment. Podobnie poszczególne fragmenty nie wiedzą o zawierającym je elemencie Activity ani o komponentach interfejsu, które do niego należą.
Dodatkowe materiały
Więcej informacji o nawigacji znajdziesz w tych materiałach:
Codelabs
Posty na blogu
Filmy
- 10 sprawdzonych metod dotyczących przejścia na jedną aktywność
- Single Activity: Why, When, and How (Android Dev Summit '18)
- Android Jetpack: manage UI navigation with Navigation Controller (Google I/O '18)