Naviguer avec des options

Lorsque vous définissez une action dans le graphe de navigation à l'aide de Kotlin DSL, le composant Navigation génère une classe NavAction correspondante, qui contient les configurations définies pour cette action, y compris les suivantes :

  • Destination : ID de ressource de la destination cible.
  • Arguments par défaut : un android.os.Bundle contenant les valeurs par défaut de la destination cible, le cas échéant.
  • Options de navigation : options de navigation représentées par NavOptions. Cette classe contient toutes les configurations spéciales permettant d'effectuer une transition vers et depuis la destination cible, y compris la configuration des ressources d'animation, le comportement de suppression de la pile et le lancement ou non de la destination en mode haut simple.

Options avec Compose

Par défaut, navigate() ajoute votre nouvelle destination à la pile "Retour". Vous pouvez modifier le comportement de navigate() en transmettant des options de navigation supplémentaires à votre appel navigate().

Vous pouvez créer une instance de NavOptions à l'aide d'un simple lambda. Transmettez à navigate() les arguments que vous pourriez transmettre explicitement à NavOptions.Builder. Exemples :

Consultez le guide de la pile "Retour" pour découvrir comment transmettre des options à navigate() en contexte.

Options avec XML

Voici un exemple de graphe composé de deux écrans, accompagnés d'une action permettant de passer de l'un à l'autre :

<?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/a">

    <fragment android:id="@+id/a"
              android:name="com.example.myapplication.FragmentA"
              android:label="a"
              tools:layout="@layout/a">
        <action android:id="@+id/action_a_to_b"
                app:destination="@id/b"
                app:enterAnim="@anim/nav_default_enter_anim"
                app:exitAnim="@anim/nav_default_exit_anim"
                app:popEnterAnim="@anim/nav_default_pop_enter_anim"
                app:popExitAnim="@anim/nav_default_pop_exit_anim"/>
    </fragment>

    <fragment android:id="@+id/b"
              android:name="com.example.myapplication.FragmentB"
              android:label="b"
              tools:layout="@layout/b">
        <action android:id="@+id/action_b_to_a"
                app:destination="@id/a"
                app:enterAnim="@anim/nav_default_enter_anim"
                app:exitAnim="@anim/nav_default_exit_anim"
                app:popEnterAnim="@anim/nav_default_pop_enter_anim"
                app:popExitAnim="@anim/nav_default_pop_exit_anim"
                app:popUpTo="@+id/a"
                app:popUpToInclusive="true"/>
    </fragment>
</navigation>

Lorsque le graphe de navigation est gonflé, ces actions sont analysées, et les objets NavAction correspondants sont générés avec les configurations définies dans le graphe. Par exemple, action_b_to_a est défini comme allant de la destination b à la destination a. L'action inclut des animations ainsi que le comportement popTo qui supprime toutes les destinations de la pile "Retour". Tous ces paramètres sont enregistrés en tant que NavOptions et sont associés à l'élément NavAction.

Pour suivre cet élément NavAction, utilisez NavController.navigate() en transmettant l'ID de l'action, comme indiqué dans l'exemple suivant :

    navController.navigate(R.id.action_b_to_a)

Appliquer des options par programmation

Les exemples précédents montrent comment spécifier NavOptions dans le fichier XML du graphe de navigation. Cependant, certaines options peuvent varier en fonction de contraintes inconnues au moment de la compilation. Dans ce cas, les options de navigation (NavOptions) doivent être créées et définies de manière programmatique, comme indiqué dans l'exemple suivant :

Kotlin

findNavController().navigate(
R.id.action_fragmentOne_to_fragmentTwo,
null,
navOptions { // Use the Kotlin DSL for building NavOptions
    anim {
        enter = android.R.animator.fade_in
        exit = android.R.animator.fade_out
    }
  }
)

Java

NavController navController = NavHostFragment.findNavController(this);
  navController.navigate(
    R.id.action_fragmentOne_to_fragmentTwo,
    null,
    new NavOptions.Builder()
      .setEnterAnim(android.R.animator.fade_in)
      .setExitAnim(android.R.animator.fade_out)
      .build()
  );

Cet exemple utilise une forme étendue de navigate() et contient des arguments Bundle et NavOptions supplémentaires. Toutes les variantes de navigate() ont des versions étendues qui acceptent un argument NavOptions.

Vous pouvez également appliquer NavOptions de manière programmatique lorsque vous accédez à des liens profonds implicites :

Kotlin

findNavController().navigate(
    deepLinkUri,
    navOptions { // Use the Kotlin DSL for building NavOptions
        anim {
            enter = android.R.animator.fade_in
            exit = android.R.animator.fade_out
        }
    }
)

Java

NavController navController = NavHostFragment.findNavController(this);
navController.navigate(
        deepLinkUri,
        new NavOptions.Builder()
                .setEnterAnim(android.R.animator.fade_in)
                .setExitAnim(android.R.animator.fade_out)
                .build()
);

Cette variante de navigate() utilise un Uri pour le lien profond implicite, ainsi que l'instance NavOptions.