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:
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:
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. 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:
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'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:
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, 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:
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 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:
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 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()
:
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); }
Quindi, 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(); }
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à:
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 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:
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
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:
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()
utilizzando il 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 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:
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 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:
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 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
:
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); } } } );
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
Post del blog
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)