El componente Navigation ofrece maneras de crear determinados elementos de navegación y también interactuar con ellos de manera programática.
Cómo crear un NavHostFragment
Puedes usar NavHostFragment.create() para crear de manera programática un NavHostFragment con un recurso de gráfico específico, como se muestra en el siguiente ejemplo:
Kotlin
val finalHost = NavHostFragment.create(R.navigation.example_graph)
supportFragmentManager.beginTransaction()
.replace(R.id.nav_host, finalHost)
.setPrimaryNavigationFragment(finalHost) // equivalent to app:defaultNavHost="true"
.commit()
Java
NavHostFragment finalHost = NavHostFragment.create(R.navigation.example_graph);
getSupportFragmentManager().beginTransaction()
.replace(R.id.nav_host, finalHost)
.setPrimaryNavigationFragment(finalHost) // equivalent to app:defaultNavHost="true"
.commit();
Ten presente que setPrimaryNavigationFragment(finalHost) permite que el NavHostintercepte las activaciones del botón Atrás del sistema. También puedes implementar este comportamiento en el XML del NavHostagregando app:defaultNavHost="true". Si implementas un comportamiento personalizado del botón Atrás y no quieres que tu NavHost intercepte las presiones del botón Atrás, puedes pasar null a setPrimaryNavigationFragment().
Cómo hacer referencia a un destino con NavBackStackEntry
A partir de Navigation 2.2.0, puedes obtener una referencia a NavBackStackEntry para cualquier destino de la pila de navegación llamando a NavController.getBackStackEntry() y pasándole un ID de destino. Si la pila de actividades contiene más de una instancia del destino especificado, getBackStackEntry() devuelve la instancia superior de la pila.
El NavBackStackEntry que se muestra proporciona los siguientes objetos a nivel del destino:
Estos objetos son válidos durante toda la vida útil del destino en la pila de actividades.
Cuando se quita el destino asociado de la pila de actividades, se destruye el Lifecycle, ya no se guarda el estado y se borran todos los objetos ViewModel.
Estas propiedades te brindan un Lifecycle y un almacén para objetos y clases ViewModel que funcionan con el estado guardado, sin importar el tipo de destino que uses.
Esto es especialmente útil cuando se trabaja con tipos de destino que no tienen automáticamente un Lifecycle asociado, como los destinos personalizados.
Por ejemplo, puedes observar el Lifecycle de una NavBackStackEntry como lo harías con el Lifecycle de un fragmento o una actividad. Además, NavBackStackEntry es un LifecycleOwner, lo que significa que puedes usarla cuando se observa LiveData o con otros componentes optimizados para ciclos de vida, como se muestra en el siguiente ejemplo:
Kotlin
myViewModel.liveData.observe(backStackEntry, Observer { myData ->
// react to live data update
})
Java
myViewModel.getLiveData().observe(backStackEntry, myData -> {
// react to live data update
});
El estado del ciclo de vida se actualiza automáticamente cada vez que llamas a navigate().
Los estados del ciclo de vida de los destinos que no están en la parte superior de la pila de actividades pasan de RESUMED a STARTED si los destinos aún están visibles en un destino FloatingWindow, como un destino de diálogo o, de lo contrario, STOPPED.
Cómo mostrar un resultado al destino anterior
En Navigation 2.3 y versiones posteriores, NavBackStackEntry otorga acceso a un SavedStateHandle. Un SavedStateHandle es un mapa de pares clave-valor que se puede
usar para almacenar y recuperar datos. Estos valores persisten durante la finalización del proceso, incluidos los cambios de configuración, y permanecen disponibles a través del mismo objeto.
Si usas un objeto SavedStateHandle determinado, puedes acceder a los datos y pasarlos entre destinos. Esto es particularmente útil como un mecanismo para recuperar datos de un destino después de que se quita de la pila.
A fin de pasar datos de vuelta al destino A desde el destino B, primero configura el destino A para que detecte un resultado en su SavedStateHandle.
Para hacerlo, recupera la NavBackStackEntry mediante la API getCurrentBackStackEntry() y, luego, implementa observe en el elemento LiveData proporcionado por SavedStateHandle.
Kotlin
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
val navController = findNavController();
// We use a String here, but any type that can be put in a Bundle is supported
navController.currentBackStackEntry?.savedStateHandle?.getLiveData<String>("key")?.observe(
viewLifecycleOwner) { result ->
// Do something with the result.
}
}
Java
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
NavController navController = NavHostFragment.findNavController(this);
// We use a String here, but any type that can be put in a Bundle is supported
MutableLiveData<String> liveData = navController.getCurrentBackStackEntry()
.getSavedStateHandle()
.getLiveData("key");
liveData.observe(getViewLifecycleOwner(), new Observer<String>() {
@Override
public void onChanged(String s) {
// Do something with the result.
}
});
}

En el destino B, debes set el resultado en el SavedStateHandle del destino A mediante la API getPreviousBackStackEntry().
Kotlin
navController.previousBackStackEntry?.savedStateHandle?.set("key", result)
Java
navController.getPreviousBackStackEntry().getSavedStateHandle().set("key", result);
Si quieres controlar un resultado solo una vez, debes llamar a remove() en el SavedStateHandle para borrar el resultado. Si no quitas el resultado, el LiveData seguirá devolviendo el último resultado a cualquier instancia nueva de Observer.
Consideraciones para el uso de destinos de diálogo
Cuando implementas navigate en un destino que toma la vista completa de NavHost (como un destino <fragment>), el destino anterior tiene su ciclo de vida detenido, lo que evita cualquier devolución de llamada a LiveData, que proporciona SavedStateHandle.
Sin embargo, cuando navegas a un destino de diálogo, el destino anterior también se puede ver en la pantalla y, por lo tanto, también es STARTED, a pesar de no ser el destino actual. Esto significa que las llamadas a getCurrentBackStackEntry() desde métodos de ciclo de vida, como onViewCreated(), mostrarán la NavBackStackEntry del destino del diálogo después de un cambio en la configuración o un cierre del proceso y la recreación (desde el diálogo se restablece arriba del otro destino). Por lo tanto, debes usar getBackStackEntry() con el ID de tu destino para asegurarte de usar siempre el NavBackStackEntry correcto.
Esto también significa que cualquier Observer que configures en el resultado LiveData se activará incluso mientras los destinos del diálogo aún estén en pantalla. Si solo deseas verificar el resultado cuando se cierra el destino del diálogo y el destino subyacente se convierte en el destino actual, puedes observar el Lifecycle asociado con la NavBackStackEntry y recuperar el resultado solo cuando se convierte en RESUMED.
Kotlin
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val navController = findNavController();
// After a configuration change or process death, the currentBackStackEntry
// points to the dialog destination, so you must use getBackStackEntry()
// with the specific ID of your destination to ensure we always
// get the right NavBackStackEntry
val navBackStackEntry = navController.getBackStackEntry(R.id.your_fragment)
// Create our observer and add it to the NavBackStackEntry's lifecycle
val observer = LifecycleEventObserver { _, event ->
if (event == Lifecycle.Event.ON_RESUME
&& navBackStackEntry.savedStateHandle.contains("key")) {
val result = navBackStackEntry.savedStateHandle.get<String>("key");
// Do something with the result
}
}
navBackStackEntry.lifecycle.addObserver(observer)
// As addObserver() does not automatically remove the observer, we
// call removeObserver() manually when the view lifecycle is destroyed
viewLifecycleOwner.lifecycle.addObserver(LifecycleEventObserver { _, event ->
if (event == Lifecycle.Event.ON_DESTROY) {
navBackStackEntry.lifecycle.removeObserver(observer)
}
})
}
Java
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
NavController navController = NavHostFragment.findNavController(this);
// After a configuration change or process death, the currentBackStackEntry
// points to the dialog destination, so you must use getBackStackEntry()
// with the specific ID of your destination to ensure we always
// get the right NavBackStackEntry
final NavBackStackEntry navBackStackEntry = navController.getBackStackEntry(R.id.your_fragment);
// Create our observer and add it to the NavBackStackEntry's lifecycle
final LifecycleEventObserver observer = new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
if (event.equals(Lifecycle.Event.ON_RESUME)
&& navBackStackEntry.getSavedStateHandle().contains("key")) {
String result = navBackStackEntry.getSavedStateHandle().get("key");
// Do something with the result
}
}
};
navBackStackEntry.getLifecycle().addObserver(observer);
// As addObserver() does not automatically remove the observer, we
// call removeObserver() manually when the view lifecycle is destroyed
getViewLifecycleOwner().getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
if (event.equals(Lifecycle.Event.ON_DESTROY)) {
navBackStackEntry.getLifecycle().removeObserver(observer)
}
}
});
}
Cómo compartir datos relacionados con la IU entre destinos con ViewModel
La pila de actividades de Navigation almacena un NavBackStackEntry no solo para cada destino individual, sino también para cada gráfico de navegación superior que contenga el destino individual. Esto te permite recuperar un NavBackStackEntry que tiene como alcance un gráfico de navegación. Un NavBackStackEntry con alcance de gráfico de navegación proporciona una forma de crear un ViewModel con alcance de gráfico de navegación, lo que te permite compartir datos relacionados con la IU entre los destinos del gráfico. Cualquier objeto ViewModel que se cree de esta manera se mantendrá hasta que se borren el NavHost asociado y su ViewModelStore, o hasta que se quite el gráfico de navegación de la pila de actividades.
En el siguiente ejemplo se muestra cómo recuperar un ViewModel definido según un gráfico de navegación:
Kotlin
val viewModel: MyViewModel
by navGraphViewModels(R.id.my_graph)
Java
NavBackStackEntry backStackEntry = navController.getBackStackEntry(R.id.my_graph);
MyViewModel viewModel = new ViewModelProvider(backStackEntry).get(MyViewModel.class);
Si usas Navigation 2.2.0 o una versión anterior, debes proporcionar tu propia fábrica para usar el estado guardado con ViewModels, como se muestra en el siguiente ejemplo:
Kotlin
val viewModel: MyViewModel by navGraphViewModels(R.id.my_graph) {
SavedStateViewModelFactory(requireActivity().application, requireParentFragment())
}
Java
NavBackStackEntry backStackEntry = navController.getBackStackEntry(R.id.my_graph);
ViewModelProvider viewModelProvider = new ViewModelProvider(
backStackEntry.getViewModelStore(),
new SavedStateViewModelFactory(
requireActivity().getApplication(), requireParentFragment()));
MyViewModel myViewModel = provider.get(myViewModel.getClass());
Para obtener más información sobre ViewModel, consulta la sección Descripción general de ViewModel.
Cómo modificar gráficos de navegación aumentados
Puedes modificar un gráfico de navegación aumentado de forma dinámica durante el tiempo de ejecución.
Por ejemplo, si tienes una BottomNavigationView que está vinculada a un NavGraph, el destino predeterminado de NavGraph determina la pestaña seleccionada al iniciar la app. Sin embargo, es posible que debas anular este comportamiento, por ejemplo, cuando una preferencia del usuario especifica una pestaña preferida para cargar durante el inicio de la app.
Como alternativa, quizás la app deba cambiar la pestaña de inicio según el comportamiento anterior del usuario. Puedes admitir estos casos si especificas de forma dinámica el destino predeterminado del NavGraph.
Considera este NavGraph:
<?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/home"> <fragment android:id="@+id/home" android:name="com.example.android.navigation.HomeFragment" android:label="fragment_home" tools:layout="@layout/fragment_home" /> <fragment android:id="@+id/location" android:name="com.example.android.navigation.LocationFragment" android:label="fragment_location" tools:layout="@layout/fragment_location" /> <fragment android:id="@+id/shop" android:name="com.example.android.navigation.ShopFragment" android:label="fragment_shop" tools:layout="@layout/fragment_shop" /> <fragment android:id="@+id/settings" android:name="com.example.android.navigation.SettingsFragment" android:label="fragment_settings" tools:layout="@layout/fragment_settings" /> </navigation>
Cuando se carga este gráfico, el atributo app:startDestination especifica que se debe mostrar HomeFragment. Para anular el destino de inicio de forma dinámica, haz lo siguiente:
- Primero, aumenta el
NavGraphde forma manual. - Anula el destino de inicio.
- Por último, adjunta el gráfico al
NavControllerde forma manual.
Kotlin
val navHostFragment = supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment val navController = navHostFragment.navController val navGraph = navController.navInflater.inflate(R.navigation.bottom_nav_graph) navGraph.startDestination = R.id.shop navController.graph = navGraph binding.bottomNavView.setupWithNavController(navController)
Java
NavHostFragment navHostFragment = (NavHostFragment) getSupportFragmentManager() .findFragmentById(R.id.nav_host_fragment); NavController navController = navHostFragment.getNavController(); NavGraph navGraph = navController.getNavInflater().inflate(R.navigation.bottom_nav_graph); navGraph.setStartDestination(R.id.shop); navController.setGraph(navGraph); NavigationUI.setupWithNavController(binding.bottomNavView, navController);
Ahora, cuando se inicia la app, se muestra ShopFragment en lugar de HomeFragment.
Cuando usas vínculos directos, NavController construye automáticamente una pila de actividades para el destino del vínculo directo. Si el usuario navega al vínculo directo y luego retrocede, llegará al destino de inicio en algún momento. La anulación del destino de inicio con la técnica del ejemplo anterior garantiza que se agregue el destino de inicio correcto a la pila de actividades construida.
Ten en cuenta que esta técnica también permite anular otros aspectos del NavGraph según sea necesario. Todas las modificaciones del gráfico deben realizarse antes de la llamada a setGraph() para garantizar que se use la estructura correcta cuando se manejen vínculos directos, se restablezca el estado y se realice el traslado al destino de inicio del gráfico.