Connetti i componenti della UI a NavController utilizzando NavigationUI

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

Barra delle app superiore

La barra superiore dell'app fornisce una posizione coerente nella parte superiore dell'app per visualizzare le informazioni e le azioni della schermata corrente.

NavigationUI include metodi che aggiornano automaticamente i contenuti nella barra superiore dell'app quando gli utenti navigano all'interno dell'app. Ad esempio, NavigationUI utilizza le etichette di destinazione del grafico di navigazione per mantenere aggiornato il titolo della barra dell'app principale.

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

Quando utilizzi NavigationUI con le implementazioni principali della barra dell'app discusse di seguito, l'etichetta allegata alle destinazioni può essere completata automaticamente a partire dagli argomenti forniti alla destinazione utilizzando il formato {argName} nell' etichetta.

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

• Toolbar
• CollapsingToolbarLayout
• ActionBar

Per ulteriori informazioni sulle barre delle app, vedi Configurare 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 superiore, in un insieme di destinazioni correlate gerarchicamente. Le destinazioni di primo livello non visualizzano il pulsante Freccia su nella barra dell'app in alto perché non esiste una destinazione di livello superiore. Per impostazione predefinita, la destinazione iniziale della tua 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 cassetto se la destinazione utilizza un DrawerLayout. Se la destinazione non utilizza DrawerLayout, il pulsante di navigazione è nascosto. Quando l'utente si trova su qualsiasi 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 inseriscilo nel 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. Un caso d'uso comune di questo tipo è l'utilizzo di BottomNavigationView, in cui potresti avere schermate di pari livello non correlate gerarchicamente tra loro e ognuna di queste può avere il proprio insieme di destinazioni correlate. In casi come questi, puoi passare un insieme di ID destinazione 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'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 che segue:

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 tutte le destinazioni, trasmetti un insieme vuoto di ID destinazione per le destinazioni di primo livello quando crei la tua AppBarConfiguration. Questo può essere utile se, ad esempio, hai una seconda attività che dovrebbe mostrare un pulsante Su nella sezione Toolbar su tutte le destinazioni. In questo modo l'utente può tornare all'attività padre quando non ci sono altre destinazioni nello stack posteriore. Puoi utilizzare setFallbackOnNavigateUpListener() per controllare il comportamento di fallback per i casi in cui navigateUp() non farà nulla, come mostrato 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 layout barra degli strumentiCollapsing

Per includere un elemento CollapsingToolbarLayout con la barra degli strumenti, innanzitutto definisci 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:

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 della navigazione alla barra delle azioni predefinita, chiama setupActionBarWithNavController() dal metodo onCreate() dell'attività principale, come mostrato di seguito. Tieni presente che devi dichiarare AppBarConfiguration al di fuori di onCreate(), poiché lo utilizzi anche quando sostituisci 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);
}

Quindi, esegui l'override di 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 le varianti della barra dell'app

Aggiungere la barra superiore dell'app all'attività funziona bene quando il layout della barra dell'app è simile per ogni destinazione nell'app. Se, tuttavia, la barra dell'app superiore cambia sostanzialmente da una destinazione all'altra, valuta la possibilità di rimuoverla dall'attività e definirla in ogni frammento di destinazione.

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

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

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

A questo punto, 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, tranne per il fatto che devi chiamare setupWithNavController() dall'interno del metodo onViewCreated() di ogni frammento, anziché inizializzarlo 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);
}

Associa le destinazioni alle voci di menu

NavigationUI fornisce anche aiutanti per associare le destinazioni ai componenti dell'interfaccia utente basati su menu. NavigationUI contiene un metodo helper, onNavDestinationSelected(), che prende MenuItem insieme al NavController che ospita la destinazione associata. Se id del MenuItem corrisponde al id della destinazione, il NavController può raggiungere la destinazione.

Ad esempio, gli snippet XML riportati di seguito definiscono una voce di menu e una destinazione con un elemento 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 sostituendo onOptionsItemSelected() dell'attività in modo che chiami onNavDestinationSelected(), come mostrato 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 vai automaticamente alla destinazione corrispondente con lo stesso id.

Aggiungi un riquadro di navigazione a scomparsa

Il riquadro di navigazione a scomparsa è un riquadro dell'interfaccia utente 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 dello schermo.

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, devi prima dichiarare DrawerLayout come vista principale. 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 visualizzazioni secondarie: un elemento NavHostFragment per contenere i contenuti principali e un'elemento 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>

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

val appBarConfiguration = AppBarConfiguration(navController.graph, drawerLayout)

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

Successivamente, nella classe di attività principale, chiama setupWithNavController() utilizzando il 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 elemento del menu viene salvato e ripristinato quando utilizzi setupWithNavController.

Navigazione in basso

NavigationUI può anche gestire la 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.

Per creare una barra di navigazione nella parte inferiore dell'app, innanzitutto definisci la barra 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() utilizzando il 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 elemento del menu viene salvato e ripristinato quando utilizzi setupWithNavController.

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

Ascolta gli eventi di navigazione

L'interazione con NavController è il metodo principale per navigare tra le destinazioni. NavController è responsabile della sostituzione dei contenuti di NavHost con la nuova destinazione. In molti casi, gli elementi dell'interfaccia utente, come la barra superiore dell'app o altri controlli di navigazione permanenti come BottomNavigationBar, risiedono al di fuori del NavHost e devono essere aggiornati durante la navigazione tra le destinazioni.

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

NavigationUI utilizza OnDestinationChangedListener per rendere sensibile alla navigazione questi componenti comuni dell'interfaccia utente. Tuttavia, tieni presente che puoi anche utilizzare OnDestinationChangedListener in modo autonomo per rendere sensibile qualsiasi interfaccia utente o logica di business personalizzata degli eventi di navigazione.

Ad esempio, potresti avere elementi UI comuni che intendi mostrare in alcune aree della tua app e nasconderli in altre. Utilizzando OnDestinationChangedListener, puoi mostrare o nascondere selettivamente questi elementi dell'interfaccia utente in base alla destinazione di destinazione, come mostrato 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 del grafico di navigazione, che possono essere utilizzati dal controller UI appropriato per aggiornarne lo stato. Ad esempio, anziché 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 quando navighi verso la destinazione, ma piuttosto come un modo per collegare informazioni aggiuntive alla destinazione utilizzando defaultValue. In questo caso, il valore indica se la barra delle app deve essere visualizzata in questa destinazione.

Ora possiamo aggiungere un 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);
                }
            }
        }
);

L'elemento NavController attiva questo callback ogni volta che la destinazione di navigazione viene modificata. 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 gli argomenti nel grafico di navigazione e non conosce i singoli ruoli e responsabilità di Fragment. Allo stesso modo, i singoli frammenti non conoscono il Activity contenitore e i componenti dell'interfaccia utente di sua proprietà.

Risorse aggiuntive

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

Samples

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

Codelab

• Codelab sulla navigazione

Post del blog

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

Video

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