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.
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.
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.
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.
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
- 10 Best Practices for Moving to a Single Activity
- Single Activity: Why, When, and How (Android Dev Summit '18)
- Android Jetpack: manage UI navigation with Navigation Controller (Google I/O '18)