IssueTracker

Component used: Navigation Version used: 2.8.2 Devices/Android versions reproduced on: N/A

Working with navigation DSL in a big project means we get flexibility and similar api as with compose navgraph builder api, but we still have plenty of activities and fragments. Since compose has been introduced, a fair % of our screens have gotten rewritten/written in compose, but all of them have a shell fragment to host them. With navigation 2.8.0 comes support for compose destinations inside ComposableNavHostFragment, but only possible to use if using xml graph declaration.

example implementation

package androidx.navigation.fragment.compose

import androidx.compose.runtime.Composable
import androidx.navigation.NamedNavArgument
import androidx.navigation.NavArgument
import androidx.navigation.NavDeepLink
import androidx.navigation.NavDestinationBuilder
import androidx.navigation.NavDestinationDsl
import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavType
import androidx.navigation.fragment.FragmentNavigator
import androidx.navigation.get
import kotlin.reflect.KClass
import kotlin.reflect.KType

/**
 * Add the [Composable] to the [NavGraphBuilder], to be displayed in a [ComposableNavHostFragment]
 *
 * @param route route for the destination
 * @param arguments list of arguments to associate with destination
 * @param deepLinks list of deep links to associate with the destinations
 * @param content composable for the destination
 */
public fun NavGraphBuilder.composable(
    route: String,
    arguments: List<NamedNavArgument> = emptyList(),
    deepLinks: List<NavDeepLink> = emptyList(),
    fullyQualifiedName: String,
) {
    destination(
        ComposableNavigatorDestinationBuilder(
            navigator = provider[ComposableFragmentNavigator::class],
            route = route,
            fullyQualifiedName = fullyQualifiedName,
        ).apply {
            arguments.forEach { (argumentName, argument) -> argument(argumentName, argument) }
            deepLinks.forEach { deepLink -> deepLink(deepLink) }
        },
    )
}

/**
 * Add the [Composable] to the [NavGraphBuilder], to be displayed in a [ComposableNavHostFragment]
 *
 * @param T route from a [KClass] for the destination
 * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
 *   [NavType]. May be empty if [T] does not use custom NavTypes.
 * @param deepLinks list of deep links to associate with the destinations
 * @param content composable for the destination
 */
public inline fun <reified T : Any> NavGraphBuilder.composable(
    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
    deepLinks: List<NavDeepLink> = emptyList(),
    fullyQualifiedName: String,
) {
    destination(
        ComposableNavigatorDestinationBuilder(
            provider[ComposableFragmentNavigator::class],
            T::class,
            typeMap,
            fullyQualifiedName,
        ).apply {
            deepLinks.forEach { deepLink -> deepLink(deepLink) }
        }
    )
}

/** DSL for constructing a new [FragmentNavigator.Destination] that takes a composable function as
 *  a parameter.
 */
@NavDestinationDsl
public class ComposableNavigatorDestinationBuilder :
    NavDestinationBuilder<FragmentNavigator.Destination> {

    private val composableFragmentNavigator: ComposableFragmentNavigator
    private val fullyQualifiedName: String

    /**
     * DSL for constructing a new [FragmentNavigator.Destination]
     *
     * @param navigator navigator used to create the destination
     * @param route the destination's unique route
     * @param content composable for the destination
     */
    constructor(
        navigator: ComposableFragmentNavigator,
        route: String,
        fullyQualifiedName: String,
    ) : super(navigator, route) {
        this.composableFragmentNavigator = navigator
        this.fullyQualifiedName = fullyQualifiedName
    }

    /**
     * DSL for constructing a new [FragmentNavigator.Destination]
     *
     * @param navigator navigator used to create the destination
     * @param route the destination's unique route from a [KClass]
     * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
     *   [NavType]. May be empty if [route] does not use custom NavTypes.
     * @param content composable for the destination
     */
    public constructor(
        navigator: ComposableFragmentNavigator,
        route: KClass<*>,
        typeMap: Map<KType, @JvmSuppressWildcards NavType<*>>,
        fullyQualifiedName: String,
    ) : super(navigator, route, typeMap) {
        this.composableFragmentNavigator = navigator
        this.fullyQualifiedName = fullyQualifiedName
    }

    override fun instantiateDestination(): FragmentNavigator.Destination {
        return composableFragmentNavigator.createDestination().apply {
            // The className that was parsed out is actually the fully
            // qualified name of the Composable Function to run, so extract
            // that and add it as a default argument on the destination
            val navArgument =
                NavArgument.Builder()
                    .setType(NavType.StringType)
                    .setDefaultValue(fullyQualifiedName)
                    .build()
            addArgument(ComposableFragment.FULLY_QUALIFIED_NAME, navArgument)
            // And then ensure that the actual Fragment that is constructed
            // is our ComposableFragment
            setClassName(ComposableFragment::class.java.name)
        }
    }
}