Connetti i componenti della UI a NavController utilizzando NavigationUI

Il componente Navigazione include un file NavigationUI . Questa classe contiene metodi statici che gestiscono la navigazione con l'elenco barra delle app, riquadro di navigazione a scomparsa e navigazione in basso.

Barra delle app in alto

La barra delle app in alto fornisce una posizione uniforme nella parte superiore dell'app per mostrare le informazioni e le azioni della schermata corrente.

NavigationUI contiene metodi che aggiornano automaticamente i contenuti nella parte superiore della pagina barra delle app mentre gli utenti navigano nell'app. Ad esempio, NavigationUI utilizza la classe le etichette della destinazione dal grafico di navigazione per mantenere il titolo dell'app principale aggiornato.

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

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

NavigationUI fornisce supporto per i seguenti tipi di barre delle app principali:

• Toolbar
• CollapsingToolbarLayout
• ActionBar

Per ulteriori informazioni sulle barre delle app, vedi Configurare la barra delle app.

ConfigurazioneAppBar

NavigationUI utilizza un AppBarConfiguration per gestire il comportamento del pulsante di navigazione nell'angolo superiore sinistro dell'area di visualizzazione della tua app. Il comportamento del pulsante di navigazione cambia a seconda sulla presenza o meno dell'utente in una destinazione di primo livello.

Una destinazione di primo livello è la destinazione principale, o di livello più elevato, in un insieme di destinazioni correlate alla gerarchia. Per le destinazioni di primo livello non viene visualizzato Pulsante Su nella barra delle app in alto perché non esiste una destinazione di livello superiore. Di 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 riquadro a scomparsa se la destinazione utilizza un DrawerLayout. Se la destinazione non utilizza un DrawerLayout, il pulsante di navigazione è nascosto. Quando l'utente si trova in un'altra destinazione, il pulsante di navigazione appare come pulsante Su . Per configurare il pulsante di navigazione utilizzando solo la destinazione di partenza destinazione di primo livello, crea un oggetto AppBarConfiguration e passa al grafico di navigazione corrispondente, come mostrato di seguito:

val appBarConfiguration = AppBarConfiguration(navController.graph)

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

In alcuni casi, potrebbe essere necessario definire più destinazioni di primo livello anziché utilizzare la destinazione di partenza predefinita. L'utilizzo di un BottomNavigationView è un il caso d'uso comune, in cui potrebbero esserci schermi gemelli che non sono sono gerarchicamente correlati tra loro e possono avere il proprio insieme di destinazioni. In casi come questi, puoi passare un insieme di parametri ID al costruttore, come mostrato di seguito:

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

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, devi prima definire la barra nell'app 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 di seguito esempio:

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

@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 tutti di destinazione, trasmetti un insieme vuoto di ID destinazione per l'account durante la creazione di AppBarConfiguration. Può essere utile se, ad esempio, hai una seconda attività che dovrebbe mostrare il pulsante Su in Toolbar su tutte le destinazioni. In questo modo l'utente può tornare indietro all'attività del genitore se non ci sono altre destinazioni sul retro stack. Puoi utilizzare setFallbackOnNavigateUpListener() per controllare il comportamento di riserva per quando navigateUp() in caso contrario non eseguire alcuna operazione, come illustrato nell'esempio seguente:

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

@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 il layout comprimibile

Per includere un CollapsingToolbarLayout nella barra degli strumenti, devi innanzitutto definire il Barra degli strumenti e 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:

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

@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 per la navigazione alla barra delle azioni predefinita, chiama setupActionBarWithNavController() dal metodo onCreate() dell'attività principale, come mostrato di seguito. Tieni presente che devi dichiarare il tuo AppBarConfiguration all'esterno di onCreate(), dato che utilizzalo anche quando esegui l'override di onSupportNavigateUp():

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

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

Poi, sostituisci onSupportNavigateUp() per gestire la navigazione verso l'alto:

override fun onSupportNavigateUp(): Boolean {
    val navController = findNavController(R.id.nav_host_fragment)
    return navController.navigateUp(appBarConfiguration)
            || super.onSupportNavigateUp()
}

@Override
public boolean onSupportNavigateUp() {
    NavController navController = Navigation.findNavController(this, R.id.nav_host_fragment);
    return NavigationUI.navigateUp(navController, appBarConfiguration)
            || super.onSupportNavigateUp();
}

Supporta varianti della barra delle app

L'aggiunta della barra delle app in alto alla tua attività funziona bene quando il layout della barra delle app è simili per ogni destinazione nella tua app. Se, invece, la barra delle app in alto cambia in modo sostanziale tra le varie destinazioni, pertanto valuta la possibilità di rimuovere la barra delle app in alto l'attività e la definisci in ogni frammento di destinazione.

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

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

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

Successivamente, definisci il frammento di destinazione che utilizza una barra delle 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 questi frammenti, ad eccezione del fatto che devi chiamare setupWithNavController() dal metodo onViewCreated() di ogni frammento, invece di inizializzare dall'attività:

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    val navController = findNavController()
    val appBarConfiguration = AppBarConfiguration(navController.graph)

    view.findViewById<Toolbar>(R.id.toolbar)
            .setupWithNavController(navController, appBarConfiguration)
}

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

Collegare le destinazioni alle voci del menu

NavigationUI fornisce anche degli aiuti per collegare le destinazioni all'interfaccia utente basata su menu componenti. NavigationUI contiene un metodo helper, onNavDestinationSelected(), che prende una MenuItem insieme NavController che ospita destinazione associata. Se id di MenuItem corrisponde a id di la destinazione, NavController può quindi raggiungerla.

Ad esempio, gli snippet XML riportati di seguito definiscono una voce di menu e una destinazione con un id, details_page_fragment comune:

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

Se il tuo menu è stato aggiunto tramite l'onCreateOptionsMenu() dell'attività, ad esempio, puoi associare le voci di menu alle destinazioni, eseguendo l'override del campo Attività onOptionsItemSelected() per chiamare onNavDestinationSelected(), come mostrato in nell'esempio seguente:

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    val navController = findNavController(R.id.nav_host_fragment)
    return item.onNavDestinationSelected(navController) || super.onOptionsItemSelected(item)
}

@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 del riquadro a scomparsa. nella barra delle app o quando l'utente fa scorrere un dito dal bordo sinistro schermo.

L'icona del riquadro a scomparsa è visualizzata su tutti destinazioni di primo livello che utilizzano DrawerLayout.

Per aggiungere un riquadro di navigazione a scomparsa, devi prima dichiarare DrawerLayout come principale vista. All'interno di DrawerLayout, aggiungi un layout per i contenuti principali dell'interfaccia utente e un'altra visualizzazione che include i contenuti del riquadro di navigazione a scomparsa.

Ad esempio, il seguente layout utilizza un elemento DrawerLayout con due viste secondarie: Da NavHostFragment a che includono 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>

A questo punto, collega le DrawerLayout al grafico di navigazione passando a AppBarConfiguration, come mostrato in nell'esempio seguente:

val appBarConfiguration = AppBarConfiguration(navController.graph, drawerLayout)

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

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

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

@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 Navigazione 2.4.0-alpha01, lo stato di ogni voce di menu viene salvato e ripristinato quando utilizzi setupWithNavController.

Navigazione in basso

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

Per creare una barra di navigazione inferiore nella tua app, devi prima definirla nell'app 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>

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

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

@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 Navigazione 2.4.0-alpha01, lo stato di ogni voce di menu viene salvato e ripristinato quando utilizzi setupWithNavController.

Per un esempio completo che include la navigazione in basso, consulta la Esempio di navigazione avanzata dei componenti dell'architettura Android su GitHub.

Ascolta gli eventi di navigazione

Interazione con NavController è il metodo principale per spostarsi tra le destinazioni. NavController è responsabile della sostituzione dei contenuti dei file NavHost con la nuova destinazione. In molti casi, elementi dell'interfaccia utente, come la barra delle app in alto Altri controlli di navigazione permanenti come BottomNavigationBar, che risiedono all'esterno delle NavHost e devono essere aggiornate mentre ti sposti da una destinazione all'altra.

NavController offre un'interfaccia OnDestinationChangedListener che verrà chiamato quando la destinazione attuale di NavController o i suoi argomenti cambiano. È possibile registrare un nuovo listener tramite il metodo addOnDestinationChangedListener() . Tieni presente che quando chiami addOnDestinationChangedListener(), se destinazione corrente esistente, viene inviata immediatamente al listener.

NavigationUI utilizza OnDestinationChangedListener per creare queste UI comuni per la navigazione tra i componenti. Tieni presente, tuttavia, che puoi utilizzare anche OnDestinationChangedListener da sola per creare UI o attività aziendali personalizzate della logica degli eventi di navigazione.

Ad esempio, potresti avere elementi comuni dell'interfaccia utente che intendi mostrare alcune aree della tua app nascondendole in altre. Utilizzo dei tuoi OnDestinationChangedListener, puoi mostrare o nascondere selettivamente queste UI in base alla destinazione, come illustrato nell'esempio seguente:

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

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 di grafico di navigazione, che può essere usato dal controller UI appropriato per aggiornarne lo stato. Ad esempio, invece di basare la logica sui OnDestinationChangedListener sull'ID destinazione come indicato in precedenza Ad esempio, possiamo creare un argomento nel campo 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 quando verso la destinazione, ma piuttosto che un modo per allegare informazioni aggiuntive alla destinazione utilizzando defaultValue. In questo caso, il valore indica se la barra delle app deve essere mostrato quando si trova in questa destinazione.

Ora possiamo aggiungere OnDestinationChangedListener in Activity:

navController.addOnDestinationChangedListener { _, _, arguments ->
    appBar.isVisible = arguments?.getBoolean("ShowAppBar", false) == true
}

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

La NavController richiama questo callback ogni volta che la destinazione di navigazione cambia. La Ora Activity può aggiornare lo stato o la visibilità dei componenti dell'interfaccia utente di sua proprietà, in base agli argomenti ricevuti nel callback.

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

Risorse aggiuntive

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

Campioni

• Esempio di navigazione di base per i componenti dell'architettura Android
• Esempio di navigazione avanzata dei componenti dell'architettura Android

Codelab

• Codelab sulla navigazione

Blog post

• LiveData con SnackBar, Navigazione e altri eventi (caso SingleLiveEvent)

Video

• 10 best practice per passare a una singola attività
• Singola attività: perché, quando e come (Android Dev Summit '18)
• Android Jetpack: gestire la navigazione nell'UI con il controller di navigazione (Google I/O '18)