Navigation Component in Android Java: Guida Completa
In questa guida completa vedrai come utilizzare il Navigation Component di Android Jetpack in un progetto Android basato su Java, uno strumento essenziale nel navigation component android java moderno. Partiremo dai concetti fondamentali, passeremo alla configurazione (Gradle, Navigation Graph, NavHostFragment) e arriveremo a casi d’uso reali come la navigazione tra Fragment, il passaggio di dati (Safe Args), la gestione del pulsante Back, l’integrazione con BottomNavigationView e Toolbar/ActionBar, fino ai deep link e agli errori più comuni.
Per seguire al meglio questa guida, è utile avere già dimestichezza con Activity e ciclo di vita, con i Fragment in Android Java e con la definizione dei layout in XML (ad esempio usando ConstraintLayout, LinearLayout, ecc.), per cui puoi vedere la guida dedicata ai Layout XML in Android.
Cos’è il Navigation Component Android Java e perché usarlo
Il Navigation Component è una libreria di Android Jetpack che semplifica la gestione della navigazione all’interno di un’app, soprattutto quando usi più Fragment all’interno di un’unica Activity (spesso chiamata Single-Activity architecture). Che tu stia sviluppando con il navigation component android java per la prima volta o stia cercando di approfondire le tue conoscenze, questa libreria rappresenta lo standard moderno per gestire i flussi di navigazione. Invece di gestire manualmente le transazioni di Fragment, il back stack e il passaggio di argomenti, puoi definire la navigazione in un file XML (Navigation Graph) e lasciare che il framework gestisca il resto.
Con la gestione “manuale” dei Fragment è facile commettere errori: transazioni non aggiunte correttamente al back stack, incongruenze sul pulsante Back, passaggi di dati fra Fragment fragili o poco tipizzati, duplicazione di codice nella gestione della Toolbar. Il Navigation Component risolve molti di questi problemi introducendo:
- Un Navigation Graph centrale in XML che descrive tutte le destinazioni (Fragment, Activity, dialog) e le azioni di navigazione.
- Un NavController che gestisce il back stack e l’animazione delle transizioni.
- Supporto per argomenti tipizzati tra Fragment tramite Safe Args.
- Integrazione con Toolbar/ActionBar e BottomNavigationView.
- Supporto integrato per deep link.
Se stai usando architetture moderne come MVVM con ViewModel o componenti come RecyclerView, il Navigation Component si integra molto bene e riduce notevolmente il codice “collante” all’interno della tua Activity.
3. Aggiungere le dipendenze Gradle per il Navigation Component Android Java
Per usare il Navigation Component con Java devi aggiungere le librerie necessarie al tuo progetto. Supponendo di usare Gradle con AndroidX, apri il file build.gradle (Module: app) e aggiungi queste dipendenze (usa sempre le ultime versioni disponibili nella documentazione ufficiale):
dependencies {
// Navigation Component (Fragment + UI)
def nav_version = "2.7.7" // Esempio: controlla l'ultima versione su developer.android.com
implementation "androidx.navigation:navigation-fragment:$nav_version"
implementation "androidx.navigation:navigation-ui:$nav_version"
// Se usi il plugin Safe Args per Java/Kotlin
classpath "androidx.navigation:navigation-safe-args-gradle-plugin:$nav_version" // Da aggiungere nel build.gradle del progetto
}Nel file build.gradle a livello di progetto (Project), dentro buildscript { dependencies { ... } }, aggiungi il plugin Safe Args:
buildscript {
repositories {
google()
mavenCentral()
}
dependencies {
classpath "com.android.tools.build:gradle:8.0.2" // versione di esempio
def nav_version = "2.7.7"
classpath "androidx.navigation:navigation-safe-args-gradle-plugin:$nav_version"
}
}Nel file build.gradle (Module: app), abilita il plugin Safe Args:
plugins {
id 'com.android.application'
id 'androidx.navigation.safeargs'
}Dopo aver modificato i file Gradle, esegui una sincronizzazione del progetto (Sync Now) in Android Studio.
4. Creare il Navigation Graph nel Navigation Component Android Java
Il Navigation Graph è un file XML (solitamente res/navigation/nav_graph.xml) che contiene l’elenco di tutte le “destinazioni” raggiungibili (Fragment, Activity, dialog) e le azioni che collegano queste destinazioni.
Per creare il Navigation Graph in Android Studio:
- Clic destro su
res→ New → Android Resource File. - Inserisci il nome (es.
nav_graph), Resource type: Navigation. - Conferma con OK.
Esempio di un semplice nav_graph.xml con due Fragment: HomeFragment e DetailFragment.
<?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/homeFragment">
<fragment
android:id="@+id/homeFragment"
android:name="com.example.app.ui.home.HomeFragment"
android:label="Home"
tools:layout="@layout/fragment_home">
<action
android:id="@+id/action_homeFragment_to_detailFragment"
app:destination="@id/detailFragment" />
</fragment>
<fragment
android:id="@+id/detailFragment"
android:name="com.example.app.ui.detail.DetailFragment"
android:label="Detail"
tools:layout="@layout/fragment_detail" />
</navigation>Spiegazione dei punti chiave:
app:startDestination: indica il Fragment di partenza (iniziale) della navigazione.- Ogni
<fragment>definisce una destinazione. L’attributoandroid:namedeve contenere il nome completo della classe Java del Fragment. - All’interno di
homeFragmentdefiniamo un’azioneaction_homeFragment_to_detailFragmentche rappresenta il “collegamento” versodetailFragment.
5. Configurare il NavHostFragment nel Navigation Component Android Java
Il NavHostFragment è un contenitore speciale che mostra le destinazioni definite nel Navigation Graph. Di solito viene inserito nel layout principale dell’Activity, ad esempio in activity_main.xml.
Esempio di activity_main.xml con un NavHostFragment a schermo intero (usando ConstraintLayout):
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<fragment
android:id="@+id/nav_host_fragment"
android:name="androidx.navigation.fragment.NavHostFragment"
android:layout_width="0dp"
android:layout_height="0dp"
app:defaultNavHost="true"
app:navGraph="@navigation/nav_graph"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>Punti importanti:
android:name="androidx.navigation.fragment.NavHostFragment": indica che questo Fragment è un NavHost.app:navGraph: collega il NavHost al filenav_graph.xml.app:defaultNavHost="true": indica che questo NavHost gestisce il pulsante Back fisico (o il gesto back) di Android.
6. Navigare tra Fragment con NavController nel Navigation Component Android Java
Ora che hai un Navigation Graph e un NavHostFragment, puoi navigare tra i Fragment usando il NavController, il cuore del navigation component android java. Scoprirai come implementare questa navigazione tramite codice Java in modo semplice e intuitivo. In genere, la navigazione viene avviata da un evento UI, ad esempio il click su un pulsante.
Esempio di HomeFragment scritto in Java che naviga verso DetailFragment quando l’utente preme un pulsante:
public class HomeFragment extends Fragment {
public HomeFragment() {
// Costruttore vuoto richiesto
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate del layout per questo fragment
return inflater.inflate(R.layout.fragment_home, container, false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
Button buttonGoToDetail = view.findViewById(R.id.button_go_to_detail);
buttonGoToDetail.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
NavController navController = Navigation.findNavController(v);
navController.navigate(R.id.action_homeFragment_to_detailFragment);
}
});
}
}Layout XML di esempio per fragment_home.xml con un pulsante che avvia la navigazione:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical">
<Button
android:id="@+id/button_go_to_detail"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Vai al dettaglio" />
</LinearLayout>In questo esempio usiamo Navigation.findNavController(view) per ottenere il NavController associato al NavHostFragment corrente, e poi chiamiamo navigate() passando l’ID dell’azione definita nel Navigation Graph.
7. Passare dati tra Fragment con Safe Args nel Navigation Component Android Java
Safe Args è un plugin che genera classi helper tipizzate per passare argomenti tra le destinazioni del Navigation Component. Questo approccio è più sicuro che usare direttamente un Bundle, perché i tipi vengono verificati a compile time.
7.1 Definire gli argomenti nel Navigation Graph
Supponiamo di voler passare un String (es. itemId) da HomeFragment a DetailFragment. Modifica il detailFragment nel tuo nav_graph.xml aggiungendo un argomento:
<fragment
android:id="@+id/detailFragment"
android:name="com.example.app.ui.detail.DetailFragment"
android:label="Detail"
tools:layout="@layout/fragment_detail">
<argument
android:name="itemId"
app:argType="string"
android:defaultValue="" />
</fragment>7.2 Navigare passando argomenti (Java)
Dopo aver sincronizzato il progetto (Build → Rebuild Project), Safe Args genererà una classe HomeFragmentDirections. Puoi usarla così in HomeFragment:
buttonGoToDetail.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String itemId = "12345"; // Valore di esempio
HomeFragmentDirections.ActionHomeFragmentToDetailFragment action =
HomeFragmentDirections.actionHomeFragmentToDetailFragment(itemId);
NavController navController = Navigation.findNavController(v);
navController.navigate(action);
}
});7.3 Ricevere gli argomenti nel Fragment di destinazione
Nel DetailFragment puoi recuperare l’argomento in modo tipizzato usando la classe DetailFragmentArgs generata da Safe Args:
public class DetailFragment extends Fragment {
private String itemId;
public DetailFragment() {
// Costruttore vuoto
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_detail, container, false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
if (getArguments() != null) {
DetailFragmentArgs args = DetailFragmentArgs.fromBundle(getArguments());
itemId = args.getItemId();
}
TextView textView = view.findViewById(R.id.text_view_item_id);
textView.setText("Item ID: " + itemId);
}
}Layout XML semplificato per fragment_detail.xml:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical">
<TextView
android:id="@+id/text_view_item_id"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Item ID:" />
</LinearLayout>8. Gestire il pulsante Back e il Back Stack in Android Navigation Java
Uno dei vantaggi principali del Navigation Component è che gestisce automaticamente il back stack dei Fragment. Quando chiami NavController.navigate(), la destinazione corrente viene aggiunta al back stack. Quando l’utente preme il pulsante Back (hardware o software), il NavController cerca di tornare alla destinazione precedente.
Se hai impostato app:defaultNavHost="true" nel NavHostFragment, non devi scrivere codice speciale per il pulsante Back di sistema. Tuttavia, potresti voler gestire manualmente il pulsante Back nella tua MainActivity per fare operazioni particolari (ad esempio chiudere l’app quando sei sulla prima destinazione).
public class MainActivity extends AppCompatActivity {
private NavController navController;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
NavHostFragment navHostFragment = (NavHostFragment) getSupportFragmentManager()
.findFragmentById(R.id.nav_host_fragment);
if (navHostFragment != null) {
navController = navHostFragment.getNavController();
}
}
@Override
public void onBackPressed() {
if (navController != null && !navController.popBackStack()) {
// Se non ci sono più destinazioni nel back stack, chiudi l'Activity
finish();
}
}
}Il metodo popBackStack() prova a tornare alla destinazione precedente nel Navigation Graph; se restituisce false significa che non ci sono più voci nel back stack da poppare.
9. Integrazione BottomNavigationView con Navigation Component Android Java
Molte app usano una BottomNavigationView per passare tra sezioni principali (tab). Il Navigation Component fornisce un’integrazione diretta tramite NavigationUI. Se non conosci ancora bene questo widget, puoi vedere la guida dedicata a BottomNavigationView in Android Java.
9.1 Layout con NavHostFragment + BottomNavigationView
Esempio di activity_main.xml con NavHostFragment e BottomNavigationView ancorato in basso:
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout 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:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<androidx.fragment.app.FragmentContainerView
android:id="@+id/nav_host_fragment"
android:name="androidx.navigation.fragment.NavHostFragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
app:defaultNavHost="true"
app:navGraph="@navigation/nav_graph" />
<com.google.android.material.bottomnavigation.BottomNavigationView
android:id="@+id/bottom_nav_view"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="bottom"
app:menu="@menu/bottom_nav_menu" />
</androidx.coordinatorlayout.widget.CoordinatorLayout>Esempio di bottom_nav_menu.xml (in res/menu):
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item
android:id="@+id/homeFragment"
android:icon="@drawable/ic_home"
android:title="Home" />
<item
android:id="@+id/detailFragment"
android:icon="@drawable/ic_detail"
android:title="Detail" />
</menu>Nota: gli ID delle voci del menu (homeFragment, detailFragment) devono corrispondere agli ID delle destinazioni nel Navigation Graph.
9.2 Collegare BottomNavigationView al NavController
In MainActivity.java collega la BottomNavigationView al NavController:
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
BottomNavigationView bottomNavView = findViewById(R.id.bottom_nav_view);
NavHostFragment navHostFragment = (NavHostFragment) getSupportFragmentManager()
.findFragmentById(R.id.nav_host_fragment);
if (navHostFragment != null) {
NavController navController = navHostFragment.getNavController();
NavigationUI.setupWithNavController(bottomNavView, navController);
}
}
}In questo modo, quando l’utente seleziona una voce della BottomNavigationView, il Navigation Component esegue automaticamente la navigazione verso la destinazione corrispondente.
10. Integrazione Toolbar e ActionBar con NavController Android Java
Il Navigation Component si integra facilmente con una Toolbar personalizzata o con l’ActionBar predefinita per mostrare il titolo corrente e il pulsante “Up” (freccia indietro) quando necessario.
10.1 Usare una Toolbar nel layout
Esempio di activity_main.xml con una Toolbar in alto e un NavHostFragment sotto (usando AppBarLayout):
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout 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:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<com.google.android.material.appbar.AppBarLayout
android:layout_width="match_parent"
android:layout_height="wrap_content">
<androidx.appcompat.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="wrap_content"
app:title="Navigation Demo" />
</com.google.android.material.appbar.AppBarLayout>
<androidx.fragment.app.FragmentContainerView
android:id="@+id/nav_host_fragment"
android:name="androidx.navigation.fragment.NavHostFragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
app:defaultNavHost="true"
app:navGraph="@navigation/nav_graph"
app:layout_behavior="@string/appbar_scrolling_view_behavior" />
</androidx.coordinatorlayout.widget.CoordinatorLayout>10.2 Collegare Toolbar e NavController via NavigationUI
In MainActivity.java imposta la Toolbar come ActionBar e collega il NavController con NavigationUI:
public class MainActivity extends AppCompatActivity {
private AppBarConfiguration appBarConfiguration;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toolbar toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
NavHostFragment navHostFragment = (NavHostFragment) getSupportFragmentManager()
.findFragmentById(R.id.nav_host_fragment);
if (navHostFragment != null) {
NavController navController = navHostFragment.getNavController();
// Specifichiamo quali destinazioni sono di primo livello (senza pulsante Up)
appBarConfiguration = new AppBarConfiguration.Builder(
R.id.homeFragment
).build();
NavigationUI.setupActionBarWithNavController(this, navController, appBarConfiguration);
}
}
@Override
public boolean onSupportNavigateUp() {
NavHostFragment navHostFragment = (NavHostFragment) getSupportFragmentManager()
.findFragmentById(R.id.nav_host_fragment);
if (navHostFragment != null) {
NavController navController = navHostFragment.getNavController();
return NavigationUI.navigateUp(navController, appBarConfiguration)
|| super.onSupportNavigateUp();
}
return super.onSupportNavigateUp();
}
}In questo modo, il titolo mostrato nella Toolbar viene aggiornato automaticamente in base all’attributo android:label di ogni destinazione nel Navigation Graph, e il pulsante Up viene mostrato solo quando non sei su una destinazione di primo livello.
11. Deep Link con Navigation Component Android Java
I deep link ti permettono di aprire una destinazione specifica dell’app a partire da un link esterno (URL, notifica, ecc.). Il Navigation Component offre un supporto integrato per i deep link definiti direttamente nel Navigation Graph.
11.1 Definire un deep link nel Navigation Graph
Supponiamo di voler aprire DetailFragment quando viene cliccato un link del tipo https://www.example.com/detail/{itemId}. Nel detailFragment del tuo nav_graph.xml puoi aggiungere:
<fragment
android:id="@+id/detailFragment"
android:name="com.example.app.ui.detail.DetailFragment"
android:label="Detail"
tools:layout="@layout/fragment_detail">
<argument
android:name="itemId"
app:argType="string" />
<deepLink
android:id="@+id/deepLinkDetail"
app:uri="https://www.example.com/detail/{itemId}" />
</fragment>11.2 Intent filter nel Manifest
Perché Android possa associare l’URL alla tua app, devi aggiungere un intent-filter all’Activity che contiene il NavHostFragment (ad esempio MainActivity) nel file AndroidManifest.xml:
<activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data
android:scheme="https"
android:host="www.example.com"
android:pathPrefix="/detail" />
</intent-filter>
</activity>Quando l’utente apre un link che corrisponde all’URI definito, l’app verrà avviata e il Navigation Component si occuperà di navigare automaticamente verso DetailFragment, passando l’argomento itemId estratto dall’URL.
12. Errori comuni nel Navigation Component Android Java e come risolverli
Usando il Navigation Component è facile incappare in alcuni errori ricorrenti. Vediamo i più frequenti e come risolverli.
12.1 “Could not find destination” / “unknown destination”
Questo errore compare tipicamente quando chiami navigate(R.id.action_xxx) o navigate(R.id.someFragment) e il Navigation Graph non contiene una destinazione o un’azione con quell’ID.
- Verifica che l’ID che usi in
navigate()esista davvero nelnav_graph.xml. - Accertati di aver sincronizzato il progetto (Build → Rebuild Project) dopo modifiche al Navigation Graph.
12.2 Crash su Safe Args: classi Directions/Args non trovate
Se provi a usare HomeFragmentDirections o DetailFragmentArgs e Android Studio non li riconosce, di solito è perché:
- Non hai abilitato il plugin
androidx.navigation.safeargsnel filebuild.gradle(Module: app). - Non hai eseguito una ricompilazione completa dopo aver aggiunto o modificato argomenti nel Navigation Graph.
Soluzione: controlla il build.gradle, aggiungi il plugin, poi esegui Build → Rebuild Project.
12.3 Problemi con il pulsante Back che chiude l’app troppo presto
Se premendo Back l’app si chiude anche quando ti aspetteresti di tornare al Fragment precedente, controlla che:
- Il tuo NavHostFragment abbia
app:defaultNavHost="true". - Non stai sovrascrivendo
onBackPressed()in modo da chiamare semprefinish()senza prima gestire ilNavController. Usa lo schema illustrato nella sezione dedicata al back stack.
12.4 Errore “java.lang.IllegalArgumentException: navigation destination … is unknown to this NavController”
Questo succede quando usi un NavController non associato al NavHostFragment corretto. Ad esempio, potresti cercare di usare Navigation.findNavController(getActivity(), R.id.nav_host_fragment) in un contesto sbagliato, o quando il Fragment non è ancora attaccato.
- Nel Fragment, preferisci sempre
Navigation.findNavController(view)nelonViewCreated(). - Assicurati che l’ID usato (
R.id.nav_host_fragment) corrisponda esattamente all’ID del NavHostFragment nel layout.
12.5 Problemi con BottomNavigationView + Navigation
Se la BottomNavigationView non cambia selezione in modo corretto o la navigazione si comporta in modo strano:
- Verifica che gli ID delle voci del menu in
bottom_nav_menu.xmlcorrispondano esattamente agli ID delle destinazioni di primo livello nel Navigation Graph. - Usa
NavigationUI.setupWithNavController(bottomNavView, navController)una sola volta, preferibilmente inonCreate()della tua Activity.
Conclusione: Navigation Component Android Java
Il Navigation Component di Android Jetpack è uno strumento potente per gestire la navigazione in app moderne basate sui Fragment. Utilizzare il navigation component android java ti permette di definire in modo dichiarativo le destinazioni e i flussi di navigazione, riducendo la complessità del codice e migliorando la coerenza dell’esperienza utente, soprattutto quando l’app cresce in funzionalità.
In questa guida hai visto come configurare le dipendenze, creare un Navigation Graph, impostare il NavHostFragment, navigare tra Fragment con NavController, passare dati in modo sicuro con Safe Args, gestire il back stack, integrare la navigazione con BottomNavigationView e Toolbar/ActionBar, configurare deep link e risolvere i problemi più comuni.
Per approfondire ulteriormente, ti consiglio di consolidare i concetti relativi a Fragment, alle Activity e il loro ciclo di vita e ai layout XML. Una volta padroneggiati questi aspetti, integrare il Navigation Component in architetture più avanzate come MVVM con ViewModel diventerà naturale e ti permetterà di costruire app scalabili, testabili e più facili da manutenere.
Rispondi