Navigation Component — Cos'è, NavHost e Navigation Graph

Cos'è Navigation Component?

Navigation Component è una libreria Android Jetpack (androidx.navigation) che fornisce un'API unificata per la navigazione. Include tre elementi chiave: Navigation Graph (grafico di navigazione), NavHostFragment (contenitore di schermate) e NavController (controllore delle transizioni). Il componente gestisce automaticamente lo stack di ritorno e supporta i collegamenti profondi.

Prima di Navigation Component, gli sviluppatori gestivano manualmente i frammenti tramite FragmentManager. Ciò portava a codice frammentato: ogni schermata aveva le proprie regole di navigazione, gli stati dello stack di ritorno variavano e i collegamenti profondi richiedevano un'implementazione separata. Navigation Component ha unificato questi scenari. Secondo Google (2026), la libreria è installata nel 90% dei nuovi progetti Android.

Navigation Component si integra con altre librerie Jetpack: LiveData, ViewModel, Material Design. Supporta sia frammenti XML che Jetpack Compose tramite l'estensione navigation-compose. Versione stabile — 2.8.x (2025), versione minima Android — API 14.

NavGraph: grafico di navigazione in XML

NavGraph è una risorsa XML (res/navigation/nav_graph.xml) che definisce tutte le schermate dell'app e le connessioni tra di esse. Ogni schermata è una destinazione, che può essere un Fragment, un'Activity o un Composable. Le connessioni tra le destinazioni sono azioni che definiscono la direzione della transizione.

<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"
    app:startDestination="@+id/homeFragment">

    <fragment
        android:id="@+id/homeFragment"
        android:name=".HomeFragment"
        android:label="Home"
        tools:layout="@layout/fragment_home">
        <action
            android:id="@+id/action_home_to_detail"
            app:destination="@+id/detailFragment"
            app:enterAnim="@anim/slide_in_right"
            app:exitAnim="@anim/slide_out_left"
            app:popEnterAnim="@anim/slide_in_left"
            app:popExitAnim="@anim/slide_out_right" />
    </fragment>

    <fragment
        android:id="@+id/detailFragment"
        android:name=".DetailFragment"
        android:label="Dettagli"
        tools:layout="@layout/fragment_detail">
        <argument android:name="itemId"
            app:argType="integer"
            android:defaultValue="0" />
    </fragment>
</navigation>

L'attributo startDestination imposta la prima schermata visualizzata all'avvio. Un'azione definisce la destinazione target e le animazioni opzionali. Gli argomenti descrivono i parametri passati alla schermata — tipo e valore predefinito.

NavHost e NavController: contenitore e controllo

NavHostFragment è un contenitore posizionato nel layout dell'Activity che mostra la schermata di navigazione corrente. NavHostFragment cambia automaticamente i frammenti quando viene chiamato NavController.navigate(). NavController è l'oggetto che gestisce la navigazione: transizioni, ritorno e verifica della rotta corrente.

// Layout Activity: activity_main.xml
// <androidx.fragment.app.FragmentContainerView
//     android:id="@+id/nav_host_fragment"
//     android:name="androidx.navigation.fragment.NavHostFragment"
//     app:navGraph="@navigation/nav_graph"
//     app:defaultNavHost="true" />

class MainActivity : AppCompatActivity() {

    private val navController by lazy {
        (findViewById<NavHostFragment>(R.id.nav_host_fragment))
            .navController
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // NavigationUI collega NavController ad AppBar
        setupActionBarWithNavController(navController)
    }

    // Naviga alla schermata dei dettagli
    fun openDetail(itemId: Long) {
        val bundle = Bundle().apply {
            putLong("itemId", itemId)
        }
        navController.navigate(R.id.action_home_to_detail, bundle)
    }

    override fun onSupportNavigateUp() = 
        navController.navigateUp() || super.onSupportNavigateUp()
}

app:defaultNavHost="true" è un attributo importante: intercetta il pulsante Indietro di sistema e passa il controllo a NavController. NavigationUI è un'utilità per collegare NavController con AppBar, BottomNavigationView, NavigationDrawer. setupActionBarWithNavController abilita la freccia Indietro sulle schermate annidate.

Transizioni e animazioni tra schermate

Navigation Component supporta animazioni di transizione personalizzate, impostate nelle azioni o a livello di codice. Le animazioni sono definite da quattro attributi: enterAnim (comparsa della nuova schermata), exitAnim (scomparsa della corrente), popEnterAnim (comparsa al ritorno) e popExitAnim (scomparsa al ritorno).

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <translate
        android:fromXDelta="100%"
        android:toXDelta="0%"
        android:duration="300" />
</set>

// Transizione programmatica con animazione
val navOptions = NavOptions.Builder()
    .setEnterAnim(R.anim.slide_in_right)
    .setExitAnim(R.anim.slide_out_left)
    .setPopEnterAnim(R.anim.slide_in_left)
    .setPopExitAnim(R.anim.slide_out_right)
    .build()

navController.navigate(R.id.detailFragment, args, navOptions)

Le animazioni funzionano con Fragment a livello di FragmentTransaction. Per Jetpack Compose, le animazioni vengono impostate tramite NavOptionsCompat usando Compose Animation. Navigation Component non impone restrizioni sul tipo di animazione — translate, scale, alpha e le loro combinazioni sono supportate.

Safe Args: argomenti type-safe

Safe Args è un plugin Gradle per il trasferimento dati type-safe tra schermate. Il plugin analizza NavGraph, genera classi Directions e Args con tipi di campo specifici. La corrispondenza dei tipi viene verificata in fase di compilazione — un MissingArgumentException viene rilevato prima dell'esecuzione dell'app.

// build.gradle (module)
plugins {
    id 'androidx.navigation.safeargs.kotlin'
}

// Safe Args genera: DetailFragmentArgs, HomeFragmentDirections
// Utilizzo in HomeFragment:
val action = HomeFragmentDirections
    .actionHomeToDetail(itemId = 42L)
findNavController().navigate(action)

// Utilizzo in DetailFragment:
private val args: DetailFragmentArgs by navArgs()
// args.itemId è di tipo Long, null non può essere passato

override fun onViewCreated(...) {
    super.onViewCreated(...)
    loadItem(args.itemId)
}

navArgs() è un delegato Kotlin per recuperare gli argomenti in un Fragment o Activity. Il plugin supporta primitivi, stringhe, Parcelable, Serializable, Enum e array. Per oggetti complessi, passa un ID e carica da ViewModel o database.

Deep Links in Navigation Component

Deep Link è un collegamento esterno che apre una schermata specifica dell'app. Navigation Component gestisce i collegamenti profondi tramite l'attributo app:deepLink in NavGraph. Il sistema crea un PendingIntent che ripristina lo stack di navigazione fino alla schermata target, o crea un nuovo stack se l'app non è in esecuzione.

<fragment android:id="@+id/profileFragment"
    android:name=".ProfileFragment">
    <deepLink
        app:uri="https://example.com/profile/{userId}" />
    <argument
        android:name="userId"
        app:argType="string" />
</fragment>

// Creazione programmatica di Deep Link
val pendingIntent = NavDeepLinkBuilder(context)
    .setGraph(R.navigation.nav_graph)
    .setDestination(R.id.profileFragment)
    .setArguments(Bundle().apply {
        putString("userId", "user_123")
    })
    .createPendingIntent()

I Deep Links supportano modelli URI con percorsi e parametri di query, intent action e tipo mime. I segnaposto ({userId}) vengono automaticamente mappati agli argomenti di destinazione. Navigation Component gestisce anche i collegamenti profondi impliciti tramite AndroidManifest — basta aggiungere un intent-filter all'Activity con NavHostFragment.

Navigation Component con Jetpack Compose

Navigation Compose (androidx.navigation:navigation-compose) è un'estensione di Navigation Component per Jetpack Compose. L'API preserva il concetto di NavController e NavHost, ma le schermate sono funzioni Composable invece di Fragment. NavHost accetta un lambda composable per ogni rotta.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyAppTheme {
                val navController = rememberNavController()
                NavHost(
                    navController = navController,
                    startDestination = "home"
                ) {
                    composable("home") {
                        HomeScreen(
                            onItemClick = { id ->
                                navController.navigate("detail/$id")
                            }
                        )
                    }
                    composable(
                        route = "detail/{itemId}",
                        arguments = listOf(
                            navArgument("itemId") {
                                type = NavType.LongType
                            }
                        )
                    ) { backStackEntry ->
                        val itemId = backStackEntry
                            .arguments?.getLong("itemId") ?: 0L
                        DetailScreen(itemId = itemId)
                    }
                }
            }
        }
    }
}

Navigation Compose usa rotte di stringa invece di id. I parametri vengono passati tramite modelli di rotta ("detail/{itemId}") ed estratti da backStackEntry. rememberNavController() preserva NavController durante le ricomposizioni. Per la sicurezza dei tipi in Compose, il modulo navigation-compose-type-safety (sperimentale) è raccomandato.