NavController

const val KEY_DEEP_LINK_INTENT: String

The Intent that triggered a deep link to the current destination.

@NavDeepLinkSaveStateControl
fun enableDeepLinkSaveState(saveState: Boolean): Unit

By default, handleDeepLink will automatically add calls to NavOptions.Builder.setPopUpTo with a saveState of true when the deep link takes you to another graph (e.g., a different navigation graph than the one your start destination is in).

You can disable this behavior by passing false for saveState.

open fun addOnDestinationChangedListener(
    listener: NavController.OnDestinationChangedListener
): Unit

Adds an OnDestinationChangedListener to this controller to receive a callback whenever the currentDestination or its arguments change.

The current destination, if any, will be immediately sent to your listener.

@MainThread
inline fun <T : Any> clearBackStack(): Boolean

Clears any saved state associated with KClass T that was previously saved via popBackStack when using a saveState value of true.

@MainThread
fun clearBackStack(destinationId: @IdRes Int): Boolean

Clears any saved state associated with destinationId that was previously saved via popBackStack when using a saveState value of true.

@MainThread
fun <T : Any> clearBackStack(route: T): Boolean

Clears any saved state associated with KClass T that was previously saved via popBackStack when using a saveState value of true.

@MainThread
fun clearBackStack(route: String): Boolean

Clears any saved state associated with route that was previously saved via popBackStack when using a saveState value of true.

open fun createDeepLink(): NavDeepLinkBuilder

Create a deep link to a destination within this NavController.

inline fun <T : Any> getBackStackEntry(): NavBackStackEntry

Gets the topmost NavBackStackEntry for a route from KClass.

This is always safe to use with the current destination or its parent or grandparent navigation graphs as these destinations are guaranteed to be on the back stack.

open fun getBackStackEntry(destinationId: @IdRes Int): NavBackStackEntry

Gets the topmost NavBackStackEntry for a destination id.

This is always safe to use with the current destination or its parent or grandparent navigation graphs as these destinations are guaranteed to be on the back stack.

fun <T : Any> getBackStackEntry(route: T): NavBackStackEntry

Gets the topmost NavBackStackEntry for a route from an Object.

This is always safe to use with the current destination or its parent or grandparent navigation graphs as these destinations are guaranteed to be on the back stack.

fun getBackStackEntry(route: String): NavBackStackEntry

Gets the topmost NavBackStackEntry for a route.

This is always safe to use with the current destination or its parent or grandparent navigation graphs as these destinations are guaranteed to be on the back stack.

open fun getViewModelStoreOwner(navGraphId: @IdRes Int): ViewModelStoreOwner

Gets the ViewModelStoreOwner for a NavGraph. This can be passed to androidx.lifecycle.ViewModelProvider to retrieve a ViewModel that is scoped to the navigation graph - it will be cleared when the navigation graph is popped off the back stack.

@MainThread
open fun handleDeepLink(intent: Intent?): Boolean

Checks the given Intent for a Navigation deep link and navigates to the deep link if present. This is called automatically for you the first time you set the graph if you've passed in an Activity as the context when constructing this NavController, but should be manually called if your Activity receives new Intents in Activity.onNewIntent.

The types of Intents that are supported include:

Intents created by NavDeepLinkBuilder or createDeepLink. This assumes that the current graph shares the same hierarchy to get to the deep linked destination as when the deep link was constructed. Intents that include a data Uri. This Uri will be checked against the Uri patterns in the NavDeepLinks added via NavDestination.addDeepLink.

The navigation graph should be set before calling this method.

@MainThread
fun handleDeepLink(request: NavDeepLinkRequest): Boolean

Checks the given NavDeepLinkRequest for a Navigation deep link and navigates to the destination if present.

The navigation graph should be set before calling this method.

@MainThread
open fun navigate(deepLink: Uri): Unit

Navigate to a destination via the given deep link Uri. NavDestination.hasDeepLink should be called on the navigation graph prior to calling this method to check if the deep link is valid. If an invalid deep link is given, an IllegalArgumentException will be thrown.

@MainThread
open fun navigate(directions: NavDirections): Unit

Navigate via the given NavDirections

@MainThread
open fun navigate(request: NavDeepLinkRequest): Unit

Navigate to a destination via the given NavDeepLinkRequest. NavDestination.hasDeepLink should be called on the navigation graph prior to calling this method to check if the deep link is valid. If an invalid deep link is given, an IllegalArgumentException will be thrown.

@MainThread
open fun navigate(resId: @IdRes Int): Unit

Navigate to a destination from the current navigation graph. This supports both navigating via an action and directly navigating to a destination.

@MainThread
open fun navigate(deepLink: Uri, navOptions: NavOptions?): Unit

Navigate to a destination via the given deep link Uri. NavDestination.hasDeepLink should be called on the navigation graph prior to calling this method to check if the deep link is valid. If an invalid deep link is given, an IllegalArgumentException will be thrown.

@MainThread
open fun navigate(directions: NavDirections, navOptions: NavOptions?): Unit

Navigate via the given NavDirections

@MainThread
open fun navigate(directions: NavDirections, navigatorExtras: Navigator.Extras): Unit

Navigate via the given NavDirections

@MainThread
open fun navigate(request: NavDeepLinkRequest, navOptions: NavOptions?): Unit

Navigate to a destination via the given NavDeepLinkRequest. NavDestination.hasDeepLink should be called on the navigation graph prior to calling this method to check if the deep link is valid. If an invalid deep link is given, an IllegalArgumentException will be thrown.

@MainThread
open fun navigate(resId: @IdRes Int, args: Bundle?): Unit

Navigate to a destination from the current navigation graph. This supports both navigating via an action and directly navigating to a destination.

@MainThread
fun <T : Any> navigate(route: T, builder: NavOptionsBuilder.() -> Unit): Unit

Navigate to a route from an Object in the current NavGraph. If an invalid route is given, an IllegalArgumentException will be thrown.

The target NavDestination must have been created with route from a KClass

If given NavOptions pass in NavOptions.restoreState true, any args passed here as part of the route will be overridden by the restored args.

@MainThread
fun navigate(route: String, builder: NavOptionsBuilder.() -> Unit): Unit

Navigate to a route in the current NavGraph. If an invalid route is given, an IllegalArgumentException will be thrown.

If given NavOptions pass in NavOptions.restoreState true, any args passed here as part of the route will be overridden by the restored args.

@MainThread
open fun navigate(
    deepLink: Uri,
    navOptions: NavOptions?,
    navigatorExtras: Navigator.Extras?
): Unit

Navigate to a destination via the given deep link Uri. NavDestination.hasDeepLink should be called on the navigation graph prior to calling this method to check if the deep link is valid. If an invalid deep link is given, an IllegalArgumentException will be thrown.

@MainThread
open fun navigate(
    request: NavDeepLinkRequest,
    navOptions: NavOptions?,
    navigatorExtras: Navigator.Extras?
): Unit

Navigate to a destination via the given NavDeepLinkRequest. NavDestination.hasDeepLink should be called on the navigation graph prior to calling this method to check if the deep link is valid. If an invalid deep link is given, an IllegalArgumentException will be thrown.

@MainThread
open fun navigate(resId: @IdRes Int, args: Bundle?, navOptions: NavOptions?): Unit

Navigate to a destination from the current navigation graph. This supports both navigating via an action and directly navigating to a destination.

If given NavOptions pass in NavOptions.restoreState true, any args passed here will be overridden by the restored args.

@MainThread
fun <T : Any> navigate(
    route: T,
    navOptions: NavOptions? = null,
    navigatorExtras: Navigator.Extras? = null
): Unit

Navigate to a route from an Object in the current NavGraph. If an invalid route is given, an IllegalArgumentException will be thrown.

The target NavDestination must have been created with route from a KClass

If given NavOptions pass in NavOptions.restoreState true, any args passed here as part of the route will be overridden by the restored args.

@MainThread
fun navigate(
    route: String,
    navOptions: NavOptions? = null,
    navigatorExtras: Navigator.Extras? = null
): Unit

Navigate to a route in the current NavGraph. If an invalid route is given, an IllegalArgumentException will be thrown.

If given NavOptions pass in NavOptions.restoreState true, any args passed here as part of the route will be overridden by the restored args.

@MainThread
open fun navigate(
    resId: @IdRes Int,
    args: Bundle?,
    navOptions: NavOptions?,
    navigatorExtras: Navigator.Extras?
): Unit

Navigate to a destination from the current navigation graph. This supports both navigating via an action and directly navigating to a destination.

If given NavOptions pass in NavOptions.restoreState true, any args passed here will be overridden by the restored args.

@MainThread
open fun navigateUp(): Boolean

Attempts to navigate up in the navigation hierarchy. Suitable for when the user presses the "Up" button marked with a left (or start)-facing arrow in the upper left (or starting) corner of the app UI.

The intended behavior of Up differs from Back when the user did not reach the current destination from the application's own task. e.g. if the user is viewing a document or link in the current app in an activity hosted on another app's task where the user clicked the link. In this case the current activity (determined by the context used to create this NavController) will be finished and the user will be taken to an appropriate destination in this app on its own task.

@MainThread
open fun popBackStack(): Boolean

Attempts to pop the controller's back stack. Analogous to when the user presses the system Back button when the associated navigation host has focus.

@MainThread
open fun popBackStack(destinationId: @IdRes Int, inclusive: Boolean): Boolean

Attempts to pop the controller's back stack back to a specific destination.

@MainThread
inline fun <T : Any> popBackStack(inclusive: Boolean, saveState: Boolean = false): Boolean

Attempts to pop the controller's back stack back to a specific destination.

@MainThread
open fun popBackStack(
    destinationId: @IdRes Int,
    inclusive: Boolean,
    saveState: Boolean
): Boolean

Attempts to pop the controller's back stack back to a specific destination.

@MainThread
fun <T : Any> popBackStack(route: T, inclusive: Boolean, saveState: Boolean = false): Boolean

Attempts to pop the controller's back stack back to a specific destination.

@MainThread
fun popBackStack(route: String, inclusive: Boolean, saveState: Boolean = false): Boolean

Attempts to pop the controller's back stack back to a specific destination.

open fun removeOnDestinationChangedListener(
    listener: NavController.OnDestinationChangedListener
): Unit

Removes an OnDestinationChangedListener from this controller. It will no longer receive callbacks.

@CallSuper
open fun restoreState(navState: Bundle?): Unit

Restores all navigation controller state from a bundle. This should be called before any call to setGraph.

State may be saved to a bundle by calling saveState. Restoring controller state is the responsibility of a NavHost.

@CallSuper
open fun saveState(): Bundle?

Saves all navigation controller state to a Bundle.

State may be restored from a bundle returned from this method by calling restoreState. Saving controller state is the responsibility of a NavHost.

@MainThread
@CallSuper
open fun setGraph(graphResId: @NavigationRes Int): Unit

Sets the navigation graph to the specified resource. Any current navigation graph data (including back stack) will be replaced.

The inflated graph can be retrieved via graph.

@MainThread
@CallSuper
open fun setGraph(graph: NavGraph, startDestinationArgs: Bundle?): Unit

Sets the navigation graph to the specified graph. Any current navigation graph data (including back stack) will be replaced.

The graph can be retrieved later via graph.

@MainThread
@CallSuper
open fun setGraph(graphResId: @NavigationRes Int, startDestinationArgs: Bundle?): Unit

Sets the navigation graph to the specified resource. Any current navigation graph data (including back stack) will be replaced.

The inflated graph can be retrieved via graph.

open val currentBackStackEntry: NavBackStackEntry?

The topmost NavBackStackEntry.

val currentBackStackEntryFlow: Flow<NavBackStackEntry>

A Flow that will emit the currently active NavBackStackEntry whenever it changes. If there is no active NavBackStackEntry, no item will be emitted.

open val currentDestination: NavDestination?

The current destination.

open var graph: NavGraph

The topmost navigation graph associated with this NavController.

When this is set any current navigation graph data (including back stack) will be replaced.

open val navInflater: NavInflater

The inflater for this controller.

open val navigatorProvider: NavigatorProvider

The NavController's NavigatorProvider. All Navigators used to construct the navigation graph for this nav controller should be added to this navigator provider before the graph is constructed.

This can only be set before the graph is set via setGraph().

Generally, the Navigators are set for you by the NavHost hosting this NavController and you do not need to manually interact with the navigator provider.

open val previousBackStackEntry: NavBackStackEntry?

The previous visible NavBackStackEntry.

This skips over any NavBackStackEntry that is associated with a NavGraph.

val visibleEntries: StateFlow<List<NavBackStackEntry>>

A StateFlow that will emit the currently visible NavBackStackEntries whenever they change. If there is no visible NavBackStackEntry, this will be set to an empty list.

• CREATED entries are listed first and include all entries that are in the process of completing their exit transition. Note that this can include entries that have been popped off the Navigation back stack.

• STARTED entries on the back stack are next and include all entries that are running their enter transition and entries whose destination is partially covered by a FloatingWindow destination

• The last entry in the list is the topmost entry in the back stack and is in the RESUMED state only if its enter transition has completed. Otherwise it too will be STARTED.

Note that the Lifecycle of any entry cannot be higher than the containing Activity/Fragment - if the Activity is not RESUMED, no entry will be RESUMED, no matter what the transition state is.

inline fun NavController.createGraph(
    id: @IdRes Int = 0,
    startDestination: @IdRes Int,
    builder: NavGraphBuilder.() -> Unit
): NavGraph

Construct a new NavGraph

inline fun NavController.createGraph(
    id: @IdRes Int = 0,
    startDestination: @IdRes Int,
    builder: DynamicNavGraphBuilder.() -> Unit
): NavGraph

Construct a new androidx.navigation.NavGraph that supports dynamic navigation destinations

inline fun NavController.createGraph(
    startDestination: String,
    route: String? = null,
    builder: NavGraphBuilder.() -> Unit
): NavGraph

Construct a new NavGraph

inline fun NavController.createGraph(
    startDestination: String,
    route: String? = null,
    builder: DynamicNavGraphBuilder.() -> Unit
): NavGraph

Construct a new androidx.navigation.NavGraph that supports dynamic navigation destinations

inline fun NavController.createGraph(
    startDestination: Any,
    route: KClass<*>? = null,
    typeMap: Map<KType, NavType<*>> = emptyMap(),
    builder: NavGraphBuilder.() -> Unit
): NavGraph

Construct a new NavGraph

inline fun NavController.createGraph(
    startDestination: Any,
    route: KClass<*>? = null,
    typeMap: Map<KType, NavType<*>> = emptyMap(),
    builder: DynamicNavGraphBuilder.() -> Unit
): NavGraph

Construct a new androidx.navigation.NavGraph that supports dynamic navigation destinations

inline fun NavController.createGraph(
    startDestination: KClass<*>,
    route: KClass<*>? = null,
    typeMap: Map<KType, NavType<*>> = emptyMap(),
    builder: NavGraphBuilder.() -> Unit
): NavGraph

Construct a new NavGraph

inline fun NavController.createGraph(
    startDestination: KClass<*>,
    route: KClass<*>? = null,
    typeMap: Map<KType, NavType<*>> = emptyMap(),
    builder: DynamicNavGraphBuilder.() -> Unit
): NavGraph

Construct a new androidx.navigation.NavGraph that supports dynamic navigation destinations

fun NavController.navigateUp(appBarConfiguration: AppBarConfiguration): Boolean

Handles the Up button by delegating its behavior to the given NavController.

fun NavController.navigateUp(drawerLayout: Openable?): Boolean

Handles the Up button by delegating its behavior to the given NavController.

This is equivalent to calling NavController.navigateUp if the Openable layout is null.

@Composable
fun NavController.currentBackStackEntryAsState(): State<NavBackStackEntry?>

Gets the current navigation back stack entry as a MutableState. When the given navController changes the back stack due to a NavController.navigate or NavController.popBackStack this will trigger a recompose and return the top entry on the back stack.

@Composable
fun NavController.currentBackStackEntryAsState(): State<NavBackStackEntry?>

Gets the current navigation back stack entry as a State. When the given navController changes the back stack due to a NavController.navigate or NavController.popBackStack this will trigger a recompose and return the top entry on the back stack.