UI-Komponenten über NavigationUI mit NavController verbinden

Die Navigationskomponente enthält eine NavigationUI-Klasse. Diese Klasse enthält statische Methoden, mit denen die Navigation über die obere App-Leiste, die Navigationsleiste und die untere Navigationsleiste verwaltet wird.

Obere App-Leiste

Die obere App-Leiste bietet einen einheitlichen Bereich am oberen Rand Ihrer App, in dem Informationen und Aktionen vom aktuellen Bildschirm angezeigt werden.

Bildschirm mit einer oberen App-Leiste
Abbildung 1. Ein Bildschirm mit einer oberen App-Leiste.

NavigationUI enthält Methoden, mit denen Inhalte in der oberen App-Leiste automatisch aktualisiert werden, wenn Nutzer durch Ihre App navigieren. NavigationUI verwendet beispielsweise die Ziellabels aus Ihrem Navigationsgraphen, um den Titel der oberen App-Leiste auf dem neuesten Stand zu halten.

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

Wenn Sie NavigationUI mit den unten beschriebenen Implementierungen der oberen App-Leiste verwenden, kann das Label, das Sie Zielen zuweisen, automatisch aus den Argumenten ausgefüllt werden, die dem Ziel bereitgestellt werden. Verwenden Sie dazu das Format {argName} in Ihrem Label.

NavigationUI unterstützt die folgenden Typen von oberen App-Leisten:

Weitere Informationen zu App-Leisten finden Sie unter App-Leiste einrichten.

AppBarConfiguration

NavigationUI verwendet ein AppBarConfiguration-Objekt, um das Verhalten der Navigationsschaltfläche in der oberen linken Ecke des Anzeigebereichs Ihrer App zu verwalten. Das Verhalten der Navigationsschaltfläche ändert sich je nachdem, ob sich der Nutzer auf einem Ziel auf oberster Ebene befindet.

Ein Ziel auf oberster Ebene ist das Stammziel oder das Ziel auf der höchsten Ebene in einer Gruppe hierarchisch verwandter Ziele. Auf oberster Ebene wird in der oberen App-Leiste keine Schaltfläche „Nach oben“ angezeigt, da es keine übergeordnete Ebene gibt. Standardmäßig ist das Startziel Ihrer App das einzige Ziel auf oberster Ebene.

Wenn sich der Nutzer auf einem Ziel der obersten Ebene befindet, wird die Navigationsschaltfläche zu einem Drawer-Symbol , wenn das Ziel eine DrawerLayout verwendet. Wenn das Ziel keine DrawerLayout verwendet, wird die Navigationsschaltfläche ausgeblendet. Wenn sich der Nutzer auf einem anderen Ziel befindet, wird die Navigationsschaltfläche als Aufwärtsschaltfläche  angezeigt. Wenn Sie die Navigationsschaltfläche nur mit dem Startziel als Ziel auf oberster Ebene konfigurieren möchten, erstellen Sie ein AppBarConfiguration-Objekt und übergeben Sie das entsprechende Navigationsdiagramm, wie unten gezeigt:

Kotlin

val appBarConfiguration = AppBarConfiguration(navController.graph)

Java

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

In einigen Fällen müssen Sie möglicherweise mehrere Ziele auf oberster Ebene definieren, anstatt das Standardstartziel zu verwenden. Ein häufiger Anwendungsfall hierfür ist die Verwendung einer BottomNavigationView, bei der Sie möglicherweise gleichgeordnete Bildschirme haben, die nicht hierarchisch miteinander verknüpft sind und jeweils eigene zugehörige Ziele haben können. In solchen Fällen können Sie stattdessen eine Reihe von Ziel-IDs an den Konstruktor übergeben, wie unten gezeigt:

Kotlin

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

Java

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

Symbolleiste erstellen

Wenn Sie eine Symbolleiste mit NavigationUI erstellen möchten, definieren Sie die Leiste zuerst in Ihrer Hauptaktivität, wie hier gezeigt:

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

Rufen Sie als Nächstes setupWithNavController() über die Methode onCreate() Ihrer Hauptaktivität auf, wie im folgenden Beispiel gezeigt:

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

Wenn Sie die Navigationsschaltfläche so konfigurieren möchten, dass sie für alle Ziele als Aufwärtsschaltfläche angezeigt wird, übergeben Sie beim Erstellen von AppBarConfiguration einen leeren Satz von Ziel-IDs für Ihre Ziele auf oberster Ebene. Das kann nützlich sein, wenn Sie beispielsweise eine zweite Aktivität haben, die auf allen Zielen eine Aufwärtsschaltfläche in der Toolbar anzeigen soll. So kann der Nutzer zur übergeordneten Aktivität zurückkehren, wenn sich keine anderen Ziele im Back Stack befinden. Mit setFallbackOnNavigateUpListener() können Sie das Fallback-Verhalten steuern, wenn navigateUp() sonst nichts tun würde, wie im folgenden Beispiel gezeigt:

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 einbeziehen

Wenn Sie eine CollapsingToolbarLayout in Ihre Symbolleiste einfügen möchten, definieren Sie zuerst die Symbolleiste und das umgebende Layout in Ihrer Aktivität, wie unten gezeigt:

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

Rufen Sie als Nächstes setupWithNavController() über die Methode onCreate Ihrer Hauptaktivität auf, wie unten dargestellt:

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

Aktionsleiste

Wenn Sie der Standard-App-Leiste Navigationsunterstützung hinzufügen möchten, rufen Sie setupActionBarWithNavController() über die onCreate()-Methode Ihrer Hauptaktivität auf, wie unten gezeigt. Beachten Sie, dass Sie AppBarConfiguration außerhalb von onCreate() deklarieren müssen, da Sie es auch beim Überschreiben von onSupportNavigateUp() verwenden:

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

Überschreibe als Nächstes onSupportNavigateUp(), um die Aufwärtsnavigation zu verarbeiten:

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

Varianten der App-Leiste unterstützen

Das Hinzufügen der oberen App-Leiste zu Ihrer Aktivität funktioniert gut, wenn das Layout der App-Leiste für jedes Ziel in Ihrer App ähnlich ist. Wenn sich die obere App-Leiste jedoch je nach Ziel erheblich ändert, sollten Sie die obere App-Leiste aus Ihrer Aktivität entfernen und stattdessen in jedem Zielfragment definieren.

Beispielsweise kann eines Ihrer Ziele eine Standard-Toolbar verwenden, während ein anderes eine AppBarLayout verwendet, um eine komplexere App-Leiste mit Tabs zu erstellen, wie in Abbildung 2 dargestellt.

Zwei Varianten der oberen App-Leiste: eine Standard-Symbolleiste auf der linken Seite und ein App-Leisten-Layout mit einer Symbolleiste und Tabs auf der rechten Seite
Abbildung 2: Zwei Varianten der App-Leiste. Links ein Standard-Toolbar. Rechts ein AppBarLayout mit einem Toolbar und Tabs.

Wenn Sie dieses Beispiel in Ihren Zielfragmenten mit NavigationUI implementieren möchten, definieren Sie zuerst die App-Leiste in jedem Ihrer Fragmentlayouts. Beginnen Sie mit dem Zielfragment, das eine Standardsymbolleiste verwendet:

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

Definiere als Nächstes das Zielfragment, das eine App-Leiste mit Tabs verwendet:

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

Die Logik für die Navigationskonfiguration ist für beide Fragmente gleich, allerdings sollten Sie setupWithNavController() in der onViewCreated()-Methode des jeweiligen Fragments aufrufen, anstatt sie über die Aktivität zu initialisieren:

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

Ziele mit Menüpunkten verknüpfen

NavigationUI bietet auch Hilfsprogramme, mit denen Ziele mit menügesteuerten UI-Komponenten verknüpft werden können. NavigationUI enthält die Hilfsmethode onNavDestinationSelected(), die ein MenuItem zusammen mit dem NavController akzeptiert, das das zugehörige Ziel hostet. Wenn die id des MenuItem mit der id des Ziels übereinstimmt, kann das NavController zu diesem Ziel navigieren.

In den folgenden XML-Snippets werden beispielsweise ein Menüpunkt und ein Ziel mit einer gemeinsamen id, details_page_fragment, definiert:

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

Wenn Ihr Menü beispielsweise mit der onCreateOptionsMenu() der Aktivität hinzugefügt wurde, können Sie die Menüpunkte mit Zielen verknüpfen, indem Sie die onOptionsItemSelected() der Aktivität überschreiben, um onNavDestinationSelected() aufzurufen, wie im folgenden Beispiel gezeigt:

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

Wenn ein Nutzer jetzt auf den Menüpunkt details_page_fragment klickt, navigiert die App automatisch zum entsprechenden Ziel mit derselben id.

Navigationsleiste hinzufügen

Die Navigationsleiste ist ein UI-Bereich, in dem das Hauptnavigationsmenü Ihrer App angezeigt wird. Der Drawer wird angezeigt, wenn der Nutzer das Drawer-Symbol  in der App-Leiste berührt oder mit dem Finger vom linken Bildschirmrand wischt.

eine geöffnete Leiste mit einem Navigationsmenü
Abbildung 3: Eine geöffnete Leiste mit einem Navigationsmenü.

Das Symbol für die Navigationsleiste wird auf allen Zielen der obersten Ebene angezeigt, die eine DrawerLayout verwenden.

Wenn Sie eine Navigationsleiste hinzufügen möchten, deklarieren Sie zuerst ein DrawerLayout als Stammansicht. Füge im DrawerLayout ein Layout für den Haupt-UI-Inhalt und eine weitere Ansicht mit dem Inhalt der Navigationsleiste hinzu.

Im folgenden Layout wird beispielsweise ein DrawerLayout mit zwei untergeordneten Ansichten verwendet: ein NavHostFragment für den Hauptinhalt und ein NavigationView für den Inhalt der Navigationsleiste.

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

Verbinden Sie als Nächstes die DrawerLayout mit Ihrem Navigationsgraphen, indem Sie sie an AppBarConfiguration übergeben, wie im folgenden Beispiel gezeigt:

Kotlin

val appBarConfiguration = AppBarConfiguration(navController.graph, drawerLayout)

Java

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

Rufen Sie als Nächstes in der Hauptklasse der Aktivität setupWithNavController() über die Methode onCreate() der Hauptaktivität auf, wie unten gezeigt:

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

Ab Navigation 2.4.0-alpha01 wird der Status jedes Menüpunkts gespeichert und wiederhergestellt, wenn Sie setupWithNavController verwenden.

Untere Navigationsleiste

NavigationUI kann auch die untere Navigationsleiste verarbeiten. Wenn ein Nutzer einen Menüpunkt auswählt, ruft die NavController die Methode onNavDestinationSelected() auf und aktualisiert automatisch das ausgewählte Element in der unteren Navigationsleiste.

App-Bildschirm mit einer unteren Navigationsleiste
Abbildung 4: Eine untere Navigationsleiste.

Wenn Sie in Ihrer App eine untere Navigationsleiste erstellen möchten, definieren Sie die Leiste zuerst in Ihrer Hauptaktivität, wie unten gezeigt:

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

Rufen Sie als Nächstes in der Hauptklasse der Aktivität setupWithNavController() über die Methode onCreate() der Hauptaktivität auf, wie unten gezeigt:

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

Ab Navigation 2.4.0-alpha01 wird der Status jedes Menüpunkts gespeichert und wiederhergestellt, wenn Sie setupWithNavController verwenden.

Auf Navigationsereignisse warten

Die Interaktion mit der NavController ist die primäre Methode, um zwischen Zielen zu navigieren. Der NavController ist dafür verantwortlich, den Inhalt des NavHost durch das neue Ziel zu ersetzen. In vielen Fällen befinden sich UI-Elemente wie eine obere App-Leiste oder andere dauerhafte Steuerelemente zur Navigation wie ein BottomNavigationBar außerhalb des NavHost und müssen aktualisiert werden, wenn Sie zwischen Zielen wechseln.

NavController bietet eine OnDestinationChangedListener-Schnittstelle, die aufgerufen wird, wenn sich das aktuelle Ziel oder die Argumente von NavController ändern. Ein neuer Listener kann mit der Methode addOnDestinationChangedListener() registriert werden. Wenn Sie addOnDestinationChangedListener() aufrufen und das aktuelle Ziel vorhanden ist, wird es sofort an den Listener gesendet.

NavigationUI verwendet OnDestinationChangedListener, um diese gängigen UI-Komponenten navigationsfähig zu machen. Sie können OnDestinationChangedListener aber auch eigenständig verwenden, um benutzerdefinierte UI- oder Geschäftslogik über Navigationsereignisse zu informieren.

Beispielsweise haben Sie möglicherweise gängige UI-Elemente, die Sie in einigen Bereichen Ihrer App anzeigen und in anderen ausblenden möchten. Mit Ihrem eigenen OnDestinationChangedListener können Sie diese UI-Elemente je nach Ziel selektiv ein- oder ausblenden, wie im folgenden Beispiel gezeigt:

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

Argumentbasierte Listener

Alternativ können Sie auch Argumente mit Standardwerten im Navigationsgraphen verwenden, die vom entsprechenden UI-Controller verwendet werden können, um seinen Status zu aktualisieren. Anstatt die Logik in der OnDestinationChangedListener wie im vorherigen Beispiel auf der Ziel-ID zu basieren, können wir ein Argument in der NavGraph erstellen:

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

Dieses Argument wird nicht für die Navigation zum Ziel verwendet, sondern um dem Ziel mithilfe von defaultValue zusätzliche Informationen hinzuzufügen. In diesem Fall gibt der Wert an, ob die App-Leiste angezeigt werden soll, wenn sich der Nutzer auf diesem Ziel befindet.

Wir können jetzt ein OnDestinationChangedListener in der Activity hinzufügen:

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

Der NavController ruft diesen Callback immer dann auf, wenn sich das Navigationsziel ändert. Activity kann jetzt den Status oder die Sichtbarkeit der eigenen UI-Komponenten basierend auf den im Callback empfangenen Argumenten aktualisieren.

Ein Vorteil dieses Ansatzes ist, dass die Activity nur die Argumente im Navigationsgraphen sieht und die einzelnen Rollen und Verantwortlichkeiten der Fragment nicht kennt. Ebenso wissen die einzelnen Fragmente nichts über die enthaltende Activity und die zugehörigen UI-Komponenten.

Zusätzliche Ressourcen

Weitere Informationen zur Navigation finden Sie in den folgenden zusätzlichen Ressourcen.

Blogposts

Videos