Navigation Compose: cos'è, architettura e lavoro nello sviluppo

Cos'è Navigation Compose?

Navigation Compose è una libreria della suite Jetpack che fornisce un framework di navigazione per applicazioni Compose. La libreria si basa sugli stessi principi del Componente di Navigazione per il sistema View, ma è adattata alla natura dichiarativa di Compose: invece di FragmentTransaction, vengono utilizzate funzioni composable e il grafo di navigazione viene costruito tramite Kotlin DSL.

La differenza principale tra Navigation Compose e la navigazione classica è l'assenza di FragmentManager. Ogni schermata è una funzione composable che viene renderizzata in NavHost quando la rotta corrisponde. Lo stack arretrato memorizza non un Fragment, ma un record con rotta, argomenti e stato. Questo semplifica l'architettura ed elimina i conflitti del ciclo di vita tipici della navigazione basata su Fragment.

Secondo Google (2025), Navigation Compose è passato da sperimentale a stabile e fa parte di Jetpack dalla versione 2.8.0. La libreria supporta Material3, navigazione type-safe (tramite Kotlin Serialization), grafi annidati e modularizzazione. L'unica limitazione è che la libreria non supporta lo stack arretrato multiplo per BottomNavigation senza configurazione manuale, sebbene Google stia lavorando su questo.

L'architettura di Navigation Compose ruota attorno a tre entità: NavController (gestione dello stack), NavHost (contenitore del grafo) e NavDestination (rotta individuale con composable). L'interazione tra di esse è dichiarativa: lo sviluppatore descrive le rotte e gli argomenti, e la libreria gestisce gli stati di caricamento, conservazione e ripristino.

NavController: creazione e metodi di navigazione

NavController è l'elemento centrale di Navigation Compose, che gestisce lo stack di navigazione. Viene creato tramite rememberNavController() e passato a NavHost. NavController memorizza lo stack arretrato, il punto di ingresso corrente e supporta azioni differite (deeplink dopo l'inizializzazione del grafo).

@Composable
fun AppNavigation() {
    val navController = rememberNavController()
    NavHost(navController = navController, startDestination = "home") {
        composable("home") { HomeScreen(navController) }
        composable("profile/{userId}") { backStackEntry ->
            ProfileScreen(
                userId = backStackEntry.arguments?.getString("userId") ?: ""
            )
        }
    }
}

Metodi principali di NavController: navigate(route) — navigare verso una rotta, popBackStack() — tornare alla schermata precedente, navigateAndClear(route) — navigare e pulire lo stack. NavOptions specificano il comportamento: launchSingleTop previene duplicati, popUpTo pulisce lo stack fino alla rotta specificata, restoreState ripristina lo stato precedente.

Per accedere a NavController da funzioni composable profondamente annidate, utilizzare NavHostController tramite CompositionLocal. LocalNavController viene fornito in ScopedNavController all'interno di NavHost. Al di fuori di NavHost (ad esempio, in BottomNavigation), il controller viene passato tramite parametri o ViewModel.

NavHost: costruzione del grafo di rotte

NavHost è un contenitore composable che collega NavController al grafo di rotte. Ogni rotta viene dichiarata tramite composable(route, arguments, deepLinks), dove route è una stringa di rotta con segnaposto {param} opzionali. Quando la rotta corrente corrisponde, NavHost renderizza il blocco composable corrispondente.

Il grafo di rotte viene costruito gerarchicamente: i grafi possono essere annidati tramite navigation() per raggruppare le rotte all'interno di un modulo. I grafi annidati hanno il proprio startDestination e vengono combinati sotto un prefisso di rotta comune. Questo consente di organizzare un'architettura modulare dove ogni modulo di funzionalità registra il proprio sottografo.

NavHost(
    navController = navController,
    startDestination = "main"
) {
    composable("main") { MainScreen(navController) }
    navigation(
        route = "auth",
        startDestination = "auth/login"
    ) {
        composable("auth/login") { LoginScreen(navController) }
        composable("auth/register") { RegisterScreen(navController) }
    }
}

NavHost gestisce automaticamente il pulsante Indietro di sistema (back press) tramite LocalBackDispatcher. In Material3 Scaffold, acquisisce per impostazione predefinita NavController per il corretto funzionamento di BottomNavigation. NavHost ricrea il composable quando la rotta cambia, ma preserva lo stato tramite rememberSaveable per i campi di input e lo scorrimento.

Passaggio di argomenti tra schermate

Navigation Compose supporta il passaggio di argomenti tipizzati tra schermate tramite parametri di rotta e NavType. I parametri vengono specificati nella rotta come {paramName} con il tipo indicato tramite arguments in composable(). NavType supporta String, Int, Long, Float, Boolean, Parcelable e Serializable.

Gli argomenti vengono estratti da NavBackStackEntry tramite arguments?.getType(key). Per i parametri obbligatori utilizzare defaultValue, per quelli opzionali — nullable. Il supporto Parcelable funziona solo con Kotlin Parcelize o la libreria kotlinx.parcelize. Per oggetti complessi, si consiglia di passare un ID e caricare i dati tramite ViewModel, invece di serializzare l'intero oggetto.

Dalla versione Navigation 2.8.0, è stata introdotta la navigazione type-safe con Kotlin Serialization: le rotte vengono definite come classi di dati e gli argomenti come campi. Questo sostituisce le rotte stringa con oggetti tipizzati ed elimina gli errori nei nomi delle rotte. La migrazione richiede il plugin Kotlin Serialization e la dipendenza navigation-compose-typesafe.

@Serializable
/* sealed class Route */
sealed class ProfileRoute(val route: String) {
    data object Home : ProfileRoute("home")
    data class Profile(val userId: String) : ProfileRoute("profile/{userId}")
}

Collegamenti profondi in Navigation Compose

I collegamenti profondi sono un meccanismo di navigazione che consente di aprire una schermata specifica dell'applicazione tramite URL o intent-filter. In Navigation Compose, i collegamenti profondi vengono configurati tramite il parametro deepLinks in composable() e vengono elaborati automaticamente quando l'URI corrisponde al modello.

Un collegamento profondo viene specificato come elenco UriPattern: "https://example.com/profile/{userId}". I parametri URI vengono mappati automaticamente agli argomenti della rotta. NavController elabora i collegamenti profondi all'avvio dell'applicazione (tramite intent) e durante il funzionamento (tramite collegamenti profondi impliciti). Per gestire i collegamenti profondi in sospeso, utilizzare handleDeepLink() in NavController dopo l'inizializzazione del grafo.

Secondo Google, i collegamenti profondi sono raccomandati per: notifiche push (Firebase Dynamic Links), verifica email, condivisione di contenuti e navigazione incrociata da collegamenti web. Per Android 12+, vengono utilizzati Digital Asset Links per verificare l'autorità del collegamento profondo. AndroidManifest.xml deve contenere un intent-filter con autoVerify="true" per aprire i collegamenti senza dialogo.

composable(
    route = "profile/{userId}",
    arguments = listOf(navArgument("userId") { type = NavType.StringType }),
    deepLinks = listOf(
        navDeepLink { uriPattern = "https://example.com/profile/{userId}" }
    )
) { backStackEntry ->
    ProfileScreen(userId = backStackEntry.arguments?.getString("userId") ?: "")
}

Limitazioni dei collegamenti profondi in Navigation Compose: la libreria non supporta collegamenti profondi differiti — un collegamento profondo viene elaborato solo dopo che NavHost ha costruito completamente il grafo. Se un collegamento profondo arriva prima dell'inizializzazione del grafo, deve essere differito tramite intent?.data e elaborato in LaunchedEffect. Per Firebase Dynamic Links, utilizzare Firebase Dynamic Links SDK insieme a Navigation Compose.

Animazioni di transizione tra schermate

Navigation Compose supporta le animazioni di transizione tramite i parametri enterTransition, exitTransition, popEnterTransition e popExitTransition in composable(). Le animazioni sono implementate utilizzando l'API di animazione Compose: fadeIn, slideInHorizontally, expandIn e altre. Per impostazione predefinita, l'animazione è disattivata — le schermate vengono sostituite istantaneamente.

Scenari tipici di animazione: slideInHorizontally per la navigazione in avanti (la schermata entra da destra), slideOutHorizontally per il ritorno (la schermata esce a destra). Per BottomNavigation, l'animazione di dissolvenza senza scorrimento è più comunemente utilizzata. Le animazioni vengono impostate tramite NavHost e si applicano a tutti i composable a meno che non vengano specificate animazioni individuali.

NavHost(
    navController = navController,
    startDestination = "home",
    enterTransition = { slideInHorizontally() + fadeIn() },
    exitTransition = { slideOutHorizontally() + fadeOut() },
    popEnterTransition = { fadeIn() },
    popExitTransition = { slideOutHorizontally() + fadeOut() }
) { /* composable */ }

Le animazioni possono essere sovrascritte per ogni composable individualmente passando parametri di animazione direttamente in composable(). È importante che le animazioni non entrino in conflitto con l'animazione di back press del sistema. Per la transizione di elementi condivisi, è necessaria la libreria accompanist-navigation-animation o un'implementazione personalizzata tramite Modifier.graphicsLayer. Secondo Android Developers (2025), l'80% delle applicazioni di produzione utilizza l'animazione di scorrimento orizzontale per la navigazione standard.