Sûreté du typage dans le DSL Kotlin et Navigation Compose

Vous pouvez utiliser des API intégrées avec sûreté du typage pour fournir une sûreté du typage au moment de la compilation pour votre graphique de navigation. Ces API sont disponibles lorsque votre application utilise Navigation Compose ou le DSL Kotlin de Navigation. Ils sont disponibles à partir du Navigation 2.8.0.

Ces API sont équivalentes à celles fournies par Safe Args aux graphiques de navigation créés à l'aide de XML.

Définir des routes

Pour utiliser des routes avec sécurité du typage dans Compose, vous devez d'abord définir des classes ou des objets sérialisables qui représentent vos routes.

Pour définir des objets sérialisables, utilisez l'annotation @Serializable fournie par le plug-in de sérialisation Kotlin. Vous pouvez ajouter ce plug-in à votre projet en ajoutant ces dépendances.

Utilisez les règles suivantes pour déterminer le type à utiliser pour votre itinéraire :

  • Objet : utilisez un objet pour les routes sans arguments.
  • Classe : utilisez une classe ou une classe de données pour les routes avec des arguments.
  • KClass<T> : à utiliser si vous n'avez pas besoin de transmettre d'arguments, par exemple une classe sans paramètres ou une classe où tous les paramètres ont des valeurs par défaut
    1. Par exemple : Profile::class

Dans tous les cas, l'objet ou la classe doivent être sérialisables.

Exemple :

// Define a home route that doesn't take any arguments
@Serializable
object Home

// Define a profile route that takes an ID
@Serializable
data class Profile(val id: String)

Créer votre graphique

Ensuite, vous devez définir votre graphique de navigation. Utilisez la fonction composable() pour définir des composables comme destinations dans votre graphique de navigation.

NavHost(navController, startDestination = Home) {
     composable<Home> {
         HomeScreen(onNavigateToProfile = { id ->
             navController.navigate(Profile(id))
         })
     }
     composable<Profile> { backStackEntry ->
         val profile: Profile = backStackEntry.toRoute()
         ProfileScreen(profile.id)
     }
}

Dans cet exemple, notez les points suivants :

  • composable() accepte un paramètre de type. Par exemple, composable<Profile>.
  • Définir le type de destination est une approche plus robuste que de transmettre une route chaîne comme dans composable("profile").
  • La classe de route définit le type de chaque argument de navigation, comme dans val id: String. Il n'est donc pas nécessaire d'utiliser NavArgument.
  • Pour la route du profil, la méthode d'extension toRoute() recrée l'objet Profile à partir de NavBackStackEntry et de ses arguments.

Pour en savoir plus sur la conception de votre graphique en général, consultez la page Concevoir votre graphique de navigation.

Accéder aux arguments dans un ViewModel

Pour accéder aux arguments d'un itinéraire avec sûreté du typage dans un ViewModel, vous pouvez récupérer l'itinéraire à partir de SavedStateHandle en appelant SavedStateHandle.toRoute<T>(), où T est votre classe d'itinéraire :

class ProfileViewModel(
    savedStateHandle: SavedStateHandle
) : ViewModel() {
    private val profile = savedStateHandle.toRoute<Profile>()
    private val userInfo: Flow<UserInfo> = userInfoRepository.getUserInfo(profile.id)
}

Enfin, vous pouvez accéder à votre composable à l'aide de la fonction navigate() en transmettant l'instance de la route :

navController.navigate(Profile(id = 123))

Cela permet à l'utilisateur d'accéder à la destination composable<Profile> dans le graphique de navigation. Tous les arguments de navigation, tels que id, peuvent être obtenus en reconstruisant Profile à l'aide de NavBackStackEntry.toRoute et en lisant ses propriétés.

Ressources supplémentaires