Connetti i componenti della UI a NavController utilizzando NavigationUI

Il componente Navigation include una classe NavigationUI. Questa classe contiene metodi statici che gestiscono la navigazione con la barra dell'app in alto, il riquadro di navigazione a scomparsa e la barra di navigazione in basso.

Barra dell'app in alto

La barra dell'app superiore fornisce un punto coerente nella parte superiore dell'app per visualizzare informazioni e azioni dalla schermata corrente.

schermata che mostra una barra dell'app in alto
Figura 1. Una schermata che mostra una barra dell'app in alto.

NavigationUI contiene metodi che aggiornano automaticamente i contenuti nella barra dell'app in alto mentre gli utenti navigano nell'app. Ad esempio, NavigationUI utilizza le etichette di destinazione del grafico di navigazione per mantenere aggiornato il titolo della barra dell'app in alto.

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

Quando utilizzi NavigationUI con le implementazioni della barra delle app in alto descritte di seguito, l'etichetta che alleghi alle destinazioni può essere compilata automaticamente dagli argomenti forniti alla destinazione utilizzando il formato {argName} nell'etichetta.

NavigationUI fornisce assistenza per i seguenti tipi di barre dell'app in alto:

Per ulteriori informazioni sulle barre delle app, consulta Configura la barra delle app.

AppBarConfiguration

NavigationUI utilizza un oggetto AppBarConfiguration per gestire il comportamento del pulsante di navigazione nell'angolo in alto a sinistra dell'area di visualizzazione dell'app. Il comportamento del pulsante di navigazione cambia a seconda che l'utente si trovi o meno in una destinazione di primo livello.

Una destinazione di primo livello è la destinazione principale o di livello più alto in un insieme di destinazioni correlate gerarchicamente. Le destinazioni di primo livello non mostrano un pulsante Su nella barra dell'app in alto perché non esiste una destinazione di livello superiore. Per impostazione predefinita, la destinazione iniziale dell'app è l'unica destinazione di primo livello.

Quando l'utente si trova in una destinazione di primo livello, il pulsante di navigazione diventa un'icona del riquadro a scomparsa se la destinazione utilizza un DrawerLayout. Se la destinazione non utilizza un DrawerLayout, il pulsante Navigazione è nascosto. Quando l'utente si trova in un'altra destinazione, il pulsante di navigazione viene visualizzato come pulsante Su . Per configurare il pulsante di navigazione utilizzando solo la destinazione iniziale come destinazione di primo livello, crea un oggetto AppBarConfiguration e passa il grafico di navigazione corrispondente, come mostrato di seguito:

Kotlin

val appBarConfiguration = AppBarConfiguration(navController.graph)

Java

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

In alcuni casi, potrebbe essere necessario definire più destinazioni di primo livello anziché utilizzare la destinazione iniziale predefinita. L'utilizzo di un BottomNavigationView è un caso d'uso comune per questo, in cui potresti avere schermate di pari livello che non sono correlate gerarchicamente tra loro e che potrebbero avere ciascuna il proprio insieme di destinazioni correlate. In questi casi, puoi passare un insieme di ID destinazione al costruttore, come mostrato di seguito:

Kotlin

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

Java

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

Crea una barra degli strumenti

Per creare una barra degli strumenti con NavigationUI, definisci innanzitutto la barra nell'attività principale, come mostrato:

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

Successivamente, chiama setupWithNavController() dal metodo onCreate() dell'attività principale, come mostrato nell'esempio seguente:

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

Per configurare il pulsante di navigazione in modo che venga visualizzato come pulsante Su per tutte le destinazioni, passa un insieme vuoto di ID destinazione per le destinazioni di primo livello durante la creazione di AppBarConfiguration. Questo può essere utile se, ad esempio, hai una seconda attività che deve mostrare un pulsante Su nella Toolbar in tutte le destinazioni. In questo modo, l'utente può tornare all'attività principale quando non ci sono altre destinazioni nel back stack. Puoi utilizzare setFallbackOnNavigateUpListener() per controllare il comportamento di riserva quando navigateUp() non farebbe nulla, come mostrato nell'esempio seguente:

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

Includi CollapsingToolbarLayout

Per includere un CollapsingToolbarLayout nella barra degli strumenti, devi prima definire la barra degli strumenti e il layout circostante nella tua attività, come mostrato di seguito:

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

Successivamente, chiama setupWithNavController() dal metodo onCreate dell'attività principale, come mostrato di seguito:

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

Barra delle azioni

Per aggiungere il supporto della navigazione alla barra dell'app predefinita, chiama setupActionBarWithNavController() dal metodo onCreate() dell'attività principale, come mostrato di seguito. Tieni presente che devi dichiarare AppBarConfiguration all'esterno di onCreate(), poiché lo utilizzi anche quando esegui l'override di 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);
}

Successivamente, esegui l'override di onSupportNavigateUp() per gestire la navigazione verso l'alto:

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

Supporto delle varianti della barra delle app

L'aggiunta della barra dell'app superiore alla tua attività funziona bene quando il layout della barra dell'app è simile per ogni destinazione nell'app. Tuttavia, se la barra dell'app superiore cambia in modo sostanziale tra le destinazioni, ti consigliamo di rimuoverla dalla tua attività e di definirla in ogni frammento di destinazione.

Ad esempio, una delle tue destinazioni potrebbe utilizzare un Toolbar standard, mentre un'altra utilizza un AppBarLayout per creare una barra dell'app più complessa con schede, come mostrato nella figura 2.

due varianti della barra dell'app in alto: una barra degli strumenti standard a sinistra e un layout della barra dell'app con una barra degli strumenti e schede a destra
Figura 2. Due varianti della barra dell'app. A sinistra, un Toolbar standard. A destra, un AppBarLayout con un Toolbar e schede.

Per implementare questo esempio nei frammenti di destinazione utilizzando NavigationUI, definisci innanzitutto la barra dell'app in ciascuno dei layout dei frammenti, iniziando con il frammento di destinazione che utilizza una barra degli strumenti standard:

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

Poi, definisci il frammento di destinazione che utilizza una barra dell'app con schede:

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

La logica di configurazione della navigazione è la stessa per entrambi i frammenti, con la differenza che devi chiamare setupWithNavController() dall'interno del metodo onViewCreated() di ogni frammento, anziché inizializzarli dall'attività:

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

Associa le destinazioni alle voci di menu

NavigationUI fornisce anche helper per collegare le destinazioni ai componenti dell'interfaccia utente basati su menu. NavigationUI contiene un metodo helper, onNavDestinationSelected(), che accetta un MenuItem insieme all'NavController che ospita la destinazione associata. Se l'id di MenuItem corrisponde all'id della destinazione, NavController può raggiungere la destinazione.

Ad esempio, gli snippet XML riportati di seguito definiscono una voce di menu e una destinazione con un id comune, 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>

Ad esempio, se il menu è stato aggiunto utilizzando onCreateOptionsMenu() dell'attività, puoi associare le voci di menu alle destinazioni eseguendo l'override di onOptionsItemSelected() dell'attività per chiamare onNavDestinationSelected(), come mostrato nell'esempio seguente:

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

Ora, quando un utente fa clic sulla voce di menu details_page_fragment, l'app passa automaticamente alla destinazione corrispondente con lo stesso id.

Aggiungi un riquadro di navigazione a scomparsa

Il riquadro di navigazione a scomparsa è un riquadro della UI che mostra il menu di navigazione principale dell'app. Il riquadro a scomparsa viene visualizzato quando l'utente tocca l'icona corrispondente nella barra dell'app o quando l'utente fa scorrere un dito dal bordo sinistro dello schermo.

un riquadro aperto che mostra un menu di navigazione
Figura 3. Un riquadro aperto che mostra un menu di navigazione.

L'icona del riquadro a scomparsa viene visualizzata in tutte le destinazioni di primo livello che utilizzano un DrawerLayout.

Per aggiungere un riquadro di navigazione a scomparsa, dichiara innanzitutto un DrawerLayout come visualizzazione principale. All'interno di DrawerLayout, aggiungi un layout per i contenuti principali della UI e un'altra visualizzazione che contiene i contenuti del riquadro di navigazione a scomparsa.

Ad esempio, il seguente layout utilizza un DrawerLayout con due viste secondarie: un NavHostFragment per contenere i contenuti principali e un NavigationView per i contenuti del riquadro di navigazione a scomparsa.

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

Successivamente, collega DrawerLayout al grafico di navigazione passandolo a AppBarConfiguration, come mostrato nell'esempio seguente:

Kotlin

val appBarConfiguration = AppBarConfiguration(navController.graph, drawerLayout)

Java

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

Successivamente, nella classe di attività principale, chiama setupWithNavController() dal metodo onCreate() dell'attività principale, come mostrato di seguito:

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

A partire da Navigation 2.4.0-alpha01, lo stato di ogni voce di menu viene salvato e ripristinato quando utilizzi setupWithNavController.

Barra di navigazione in basso

NavigationUI può anche gestire la barra di navigazione in basso. Quando un utente seleziona una voce di menu, NavController chiama onNavDestinationSelected() e aggiorna automaticamente l'elemento selezionato nella barra di navigazione in basso.

schermata dell'app che mostra una barra di navigazione in basso
Figura 4. Una barra di navigazione in basso.

Per creare una barra di navigazione in basso nella tua app, definiscila prima nell'attività principale, come mostrato di seguito:

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

Successivamente, nella classe di attività principale, chiama setupWithNavController() dal metodo onCreate() dell'attività principale, come mostrato di seguito:

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

A partire da Navigation 2.4.0-alpha01, lo stato di ogni voce di menu viene salvato e ripristinato quando utilizzi setupWithNavController.

Ascolta gli eventi di navigazione

L'interazione con il NavController è il metodo principale per spostarsi tra le destinazioni. NavController è responsabile della sostituzione dei contenuti di NavHost con la nuova destinazione. In molti casi, gli elementi UI, come una barra delle app in alto o altri controlli di navigazione persistenti come un BottomNavigationBar, si trovano al di fuori di NavHost e devono essere aggiornati mentre navighi tra le destinazioni.

NavController offre un'interfaccia OnDestinationChangedListener che viene chiamata quando la destinazione corrente di NavController o i relativi argomenti cambiano. È possibile registrare un nuovo listener utilizzando il metodo addOnDestinationChangedListener(). Tieni presente che quando chiami addOnDestinationChangedListener(), se la destinazione corrente esiste, viene inviata immediatamente al listener.

NavigationUI utilizza OnDestinationChangedListener per rendere questi componenti UI comuni compatibili con la navigazione. Tuttavia, tieni presente che puoi anche utilizzare OnDestinationChangedListener da solo per rendere qualsiasi UI o logica di business personalizzata consapevole degli eventi di navigazione.

Ad esempio, potresti avere elementi UI comuni che vuoi mostrare in alcune aree della tua app e nascondere in altre. Utilizzando il tuo OnDestinationChangedListener, puoi mostrare o nascondere selettivamente questi elementi UI in base alla destinazione target, come mostrato nell'esempio seguente:

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

Listener basati su argomenti

In alternativa, puoi anche utilizzare argomenti con valori predefiniti all'interno del grafico di navigazione, che possono essere utilizzati dal controller UI appropriato per aggiornare il suo stato. Ad esempio, invece di basare la logica in OnDestinationChangedListener sull'ID destinazione come nell'esempio precedente, possiamo creare un argomento in 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>

Questo argomento non viene utilizzato per navigare verso la destinazione, ma come modo per allegare informazioni aggiuntive alla destinazione utilizzando defaultValue. In questo caso, il valore indica se la barra dell'app deve essere mostrata quando ci si trova in questa destinazione.

Ora possiamo aggiungere un OnDestinationChangedListener nel 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 richiama questo callback ogni volta che la destinazione della navigazione cambia. Activity ora può aggiornare lo stato o la visibilità dei componenti della UI di sua proprietà in base agli argomenti ricevuti nel callback.

Un vantaggio di questo approccio è che Activity vede solo gli argomenti nel grafico di navigazione e non conosce i singoli ruoli e responsabilità di Fragment. Analogamente, i singoli frammenti non conoscono l'elemento Activity contenitore e i componenti UI di sua proprietà.

Risorse aggiuntive

Per scoprire di più sulla navigazione, consulta le seguenti risorse aggiuntive.

Codelab

Blog post

Video