Un grafico di navigazione può essere costituito da qualsiasi combinazione dei seguenti elementi:
- Una singola destinazione, ad esempio una destinazione
<fragment>. - Un grafo nidificato che incapsula un insieme di destinazioni correlate.
- Un elemento
<include>, che ti consente di incorporare un altro file del grafico di navigazione come se fosse nidificato.
Questa flessibilità ti consente di combinare grafici di navigazione più piccoli per formare il grafico di navigazione completo della tua app, anche se questi grafici di navigazione più piccoli sono forniti da moduli separati.
Per gli esempi riportati in questo argomento, ogni modulo della funzionalità è incentrato su una funzionalità e fornisce un singolo grafico di navigazione che incapsula tutte le destinazioni necessarie per implementare la funzionalità. In un'app di produzione, potresti avere molti sottomoduli a un livello inferiore che sono dettagli di implementazione di questo modulo della funzionalità di livello superiore. Ognuno di questi moduli delle funzionalità è incluso, direttamente o indirettamente, nel modulo app. L'applicazione multimodulo di esempio utilizzata in questo documento ha la seguente struttura:
Ogni modulo della funzionalità è un'unità autonoma con il proprio grafico di navigazione e le proprie destinazioni. Il modulo app dipende da ciascuno di questi moduli, aggiungendoli come dettagli di implementazione nel file build.gradle, come mostrato:
Alla moda
dependencies { ... implementation project(":feature:home") implementation project(":feature:favorites") implementation project(":feature:settings")
Kotlin
dependencies { ... implementation(project(":feature:home")) implementation(project(":feature:favorites")) implementation(project(":feature:settings"))
Il ruolo del modulo app
Il modulo app è responsabile di fornire il grafico completo per la tua app e di aggiungere NavHost alla tua UI. All'interno del grafico di navigazione del modulo app, puoi fare riferimento ai grafici della libreria utilizzando <include>. Sebbene l'utilizzo di <include> sia funzionalmente uguale all'utilizzo di un grafico nidificato, <include> supporta i grafici di altri moduli di progetto o di progetti di libreria, come mostrato nell'esempio seguente:
<?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"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/nav_graph"
app:startDestination="@id/home_nav_graph">
<include app:graph="@navigation/home_navigation" />
<include app:graph="@navigation/favorites_navigation" />
<include app:graph="@navigation/settings_navigation" />
</navigation>
Una volta inclusa una libreria nel grafico di navigazione di primo livello, puoi navigare ai grafici della libreria in base alle tue esigenze. Ad esempio, puoi creare un'azione per passare al grafico delle impostazioni da un frammento nel grafico di navigazione, come mostrato:
<?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"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/nav_graph"
app:startDestination="@id/home_nav_graph">
<include app:graph="@navigation/home_navigation" />
<include app:graph="@navigation/favorites_navigation" />
<include app:graph="@navigation/settings_navigation" />
<fragment
android:id="@+id/random_fragment"
android:name="com.example.android.RandomFragment"
android:label="@string/fragment_random" >
<!-- Launch into Settings Navigation Graph -->
<action
android:id="@+id/action_random_fragment_to_settings_nav_graph"
app:destination="@id/settings_nav_graph" />
</fragment>
</navigation>
Quando più moduli delle funzionalità devono fare riferimento a un insieme comune di destinazioni,
ad esempio un grafico di accesso, non devi includere queste destinazioni comuni
nel grafico di navigazione di ogni modulo delle funzionalità. Aggiungi invece queste destinazioni comuni al grafico di navigazione del modulo app. Ogni modulo della funzionalità può quindi navigare tra i moduli delle funzionalità per raggiungere le destinazioni comuni.
Nell'esempio precedente, l'azione specifica una destinazione di navigazione di @id/settings_nav_graph. Questo ID si riferisce a una destinazione definita all'interno del grafico incluso @navigation/settings_navigation.
Navigazione di primo livello nel modulo dell'app
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. Se le destinazioni di primo livello della tua app sono composte da elementi UI forniti dai moduli delle funzionalità, il modulo app è il luogo naturale in cui inserire gli elementi UI e di navigazione di primo livello. Poiché il modulo dell'app dipende dai moduli delle funzionalità di collaborazione, tutte le relative destinazioni sono accessibili dal codice definito all'interno del modulo dell'app. Ciò significa che puoi utilizzare NavigationUI per collegare le destinazioni alle voci di menu se l'ID dell'elemento corrisponde all'ID di una destinazione.
Nella figura 2, il modulo app di esempio definisce un BottomNavigationView nella sua attività principale. Gli ID articolo nel menu corrispondono agli ID del grafico di navigazione dei grafici della libreria:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item
android:id="@id/home_nav_graph"
android:icon="@drawable/ic_home"
android:title="Home"
app:showAsAction="ifRoom"/>
<item
android:id="@id/favorites_nav_graph"
android:icon="@drawable/ic_favorite"
android:title="Favorites"
app:showAsAction="ifRoom"/>
<item
android:id="@id/settings_nav_graph"
android:icon="@drawable/ic_settings"
android:title="Settings"
app:showAsAction="ifRoom" />
</menu>
Per consentire a NavigationUI di gestire la barra di navigazione in basso, chiama
setupWithNavController da onCreate nella classe di attività principale,
come mostrato nell'esempio seguente:
Kotlin
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
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) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
NavHostFragment navHostFragment =
(NavHostFragment) supportFragmentManager.findFragmentById(R.id.nav_host_fragment);
NavController navController = navHostFragment.getNavController();
BottomNavigationView bottomNav = findViewById(R.id.bottom_nav);
NavigationUI.setupWithNavController(bottomNav, navController);
}
Con questo codice, NavigationUI passa al grafico della libreria appropriato quando l'utente fa clic su un elemento della barra di navigazione in basso.
Tieni presente che, in genere, non è consigliabile che il modulo dell'app abbia una dipendenza rigida da una destinazione specifica incorporata in profondità nel grafico di navigazione dei moduli delle funzionalità. Nella maggior parte dei casi, è preferibile che il modulo dell'app conosca solo il punto di accesso a tutti i grafici di navigazione incorporati o inclusi (questo vale anche al di fuori dei moduli delle funzionalità). Se devi creare un link a una destinazione all'interno del grafico di navigazione della libreria, il modo migliore per farlo è utilizzare un deep link. Il deep linking è anche l'unico modo per una libreria di raggiungere una destinazione nel grafico di navigazione di un'altra libreria.
Navigazione tra i moduli delle funzionalità
Al tempo di compilazione, i moduli delle funzionalità indipendenti non possono vedersi, quindi non puoi utilizzare gli ID per raggiungere le destinazioni in altri moduli. Utilizza invece un deep link per andare direttamente a una destinazione associata a un deep link implicito.
Continuando con l'esempio precedente, immagina di dover navigare da un pulsante nel modulo :feature:home a una destinazione nidificata nel modulo :feature:settings. A questo scopo, puoi aggiungere un deep link alla destinazione nel grafico di navigazione delle impostazioni, come mostrato:
<?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"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/settings_nav_graph"
app:startDestination="@id/settings_fragment_one">
...
<fragment
android:id="@+id/settings_fragment_two"
android:name="com.example.google.login.SettingsFragmentTwo"
android:label="@string/settings_fragment_two" >
<deepLink
app:uri="android-app://example.google.app/settings_fragment_two" />
</fragment>
</navigation>
Quindi aggiungi il seguente codice a onClickListener del pulsante nel frammento
home:
Kotlin
button.setOnClickListener {
val request = NavDeepLinkRequest.Builder
.fromUri("android-app://example.google.app/settings_fragment_two".toUri())
.build()
findNavController().navigate(request)
}
Java
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
NavDeepLinkRequest request = NavDeepLinkRequest.Builder
.fromUri(Uri.parse("android-app://example.google.app/settings_fragment_two"))
.build();
NavHostFragment.findNavController(this).navigate(request);
}
});
A differenza della navigazione che utilizza gli ID azione o destinazione, puoi accedere a qualsiasi URI in qualsiasi grafico, anche tra moduli.
Quando si naviga utilizzando l'URI, il back stack non viene reimpostato. Questo comportamento è diverso dalla navigazione con deep link espliciti, in cui il back stack viene sostituito durante la navigazione.