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.
![schermata che mostra una barra delle app in alto](https://developer.android.google.cn/static/topic/libraries/architecture/images/top-app-bar.png?authuser=9&hl=it)
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:
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:
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 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:
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
, 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:
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 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:
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 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:
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 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()
:
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); }
Poi, sostituisci 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(); }
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.
![due varianti della barra delle app principali; una barra degli strumenti standard a sinistra e una
appbarlayout con una barra degli strumenti e schede a destra](https://developer.android.google.cn/static/images/guide/navigation/app-bar-variations.png?authuser=9&hl=it)
Toolbar
. A destra, una AppBarLayout
con una
Toolbar
e schede.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à:
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); }
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:
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 del riquadro a scomparsa.
nella barra delle app o quando l'utente fa scorrere un dito dal bordo sinistro
schermo.
![un riquadro a scomparsa aperto che mostra un menu di navigazione](https://developer.android.google.cn/static/images/topic/libraries/architecture/navigation-drawer.png?authuser=9&hl=it)
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:
Kotlin
val appBarConfiguration = AppBarConfiguration(navController.graph, drawerLayout)
Java
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:
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
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.
![barra di navigazione in basso](https://developer.android.google.cn/static/topic/libraries/architecture/images/bottom-navigation.png?authuser=9&hl=it)
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:
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
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:
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 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
:
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); } } } );
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
Blog post
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)