Android Compose 框架的导航与路由模块之导航控制器：从原理到实践(三十五)

深入剖析 Android Compose 框架的导航与路由模块之导航控制器：从原理到实践

一、引言

在 Android 应用开发中，构建高效、流畅且易于维护的用户界面导航系统至关重要。Android Compose 作为新一代的声明式 UI 框架，为开发者提供了一套全新的方式来处理应用中的导航与路由。其中，导航控制器（Navigation Controller）是 Compose 导航系统的核心组件之一，它负责管理屏幕之间的导航逻辑、维护导航栈以及处理各种导航相关的操作。通过深入理解导航控制器的工作原理和源码实现，开发者能够更加灵活地构建复杂的应用导航结构，提升用户体验。本文将从源码级别深入分析 Android Compose 框架中的导航控制器，涵盖其核心功能、关键类和方法的实现细节，并结合实际代码示例进行讲解，最后对其未来发展进行总结与展望。

二、导航控制器基础概念

2.1 导航控制器的作用

导航控制器在 Compose 导航体系中扮演着 "交通指挥员" 的角色。它管理着应用中不同屏幕（Composable 函数）之间的导航流程。例如，当用户点击一个按钮从主屏幕跳转到详情屏幕时，导航控制器负责处理这个跳转请求，将目标屏幕添加到导航栈中，并负责在用户点击返回按钮时，从导航栈中正确地弹出当前屏幕，回到上一个屏幕。简单来说，它负责维护应用的导航状态，确保用户在应用内的导航操作流畅且符合预期。

2.2 与传统 Android 导航的区别

在传统的 Android 开发中，导航通常依赖于FragmentManager和Intent来实现屏幕之间的切换。例如，通过FragmentTransaction来添加、替换或移除Fragment，使用Intent来启动新的Activity。这种方式虽然可行，但存在一些问题，比如代码较为繁琐，需要处理大量的生命周期回调和状态管理逻辑。

而在 Compose 中，导航控制器基于 Composable 函数构建，一切都是声明式的。开发者只需描述不同屏幕之间的导航关系，导航控制器会自动处理导航过程中的状态变化和动画过渡等细节。例如，在传统方式中启动一个新的Activity需要这样写：

java

// 创建一个Intent对象，指定要启动的目标Activity类
Intent intent = new Intent(this, TargetActivity.class);
// 启动目标Activity
startActivity(intent);

在 Compose 中，通过导航控制器实现类似的导航逻辑可能是这样（简化示例）：

kotlin

// 定义一个导航操作，跳转到名为"detail"的屏幕
navController.navigate("detail")

可以看到，Compose 的导航方式更加简洁直观，减少了样板代码，使得开发者能够更专注于应用的业务逻辑和界面设计。

三、导航控制器的核心类与结构

3.1 NavHost

NavHost是 Compose 导航系统的基础组件，它负责管理导航图（Navigation Graph）并提供导航功能。导航图是一个描述应用中所有屏幕及其导航关系的树形结构。

3.1.1 NavHost 的源码定义

kotlin

@Composable
fun NavHost(
    // 导航控制器实例，用于管理导航操作
    navController: NavController,
    // 导航图的起始目的地，应用启动时首先显示的屏幕
    startDestination: String,
    // 用于配置导航图的内容，通过DSL描述各个屏幕及其导航关系
    content: @Composable NavGraphBuilder.() -> Unit
) {
    // 创建一个可组合的导航图
    NavGraph(
        navController = navController,
        startDestination = startDestination,
        content = content
    )
}

在这段代码中，NavHost接收一个NavController实例、起始目的地字符串以及一个content lambda 表达式。content lambda 使用NavGraphBuilder DSL 来构建导航图，定义各个屏幕之间的导航关系。

3.1.2 NavHost 的使用示例

kotlin

@Composable
fun AppNavigation() {
    val navController = rememberNavController()
    NavHost(
        navController = navController,
        startDestination = "home"
    ) {
        composable("home") {
            HomeScreen(navController)
        }
        composable("detail") {
            DetailScreen()
        }
    }
}

在这个例子中，创建了一个NavHost，并通过rememberNavController()获取一个NavController实例。startDestination设置为 "home"，表示应用启动时显示HomeScreen。在content lambda 中，使用composable函数定义了两个屏幕："home" 和 "detail"，并指定了每个屏幕对应的 Composable 函数。

3.2 NavController

NavController是导航控制器的核心类，它负责执行实际的导航操作，管理导航栈，并提供与导航相关的各种功能。

3.2.1 NavController 的重要方法

• navigate(String route) ：根据给定的路由字符串跳转到对应的目的地。

kotlin

// 跳转到名为"settings"的屏幕
navController.navigate("settings")

• popBackStack() ：从导航栈中弹出当前屏幕，返回上一个屏幕。

kotlin

// 模拟用户点击返回按钮，返回上一个屏幕
navController.popBackStack()

• currentBackStackEntry ：获取当前位于导航栈顶的屏幕的BackStackEntry。

kotlin

// 获取当前屏幕的BackStackEntry，可用于获取屏幕相关信息
val currentEntry = navController.currentBackStackEntry

3.2.2 NavController 的部分源码实现

kotlin

class NavController internal constructor(
    // 上下文对象，用于获取资源等
    private val context: Context,
    // 用于保存和恢复导航状态的状态保存器
    private val stateSaver: NavBackStackStateSaver
) : NavigatorProvider {
    // 存储导航栈的列表
    private val backStack = mutableListOf<BackStackEntry>()
    // 当前导航栈的深度
    private var currentBackStackDepth = 0
    // 当前位于导航栈顶的屏幕的BackStackEntry
    override val currentBackStackEntry: BackStackEntry?
        get() = backStack.getOrNull(currentBackStackDepth)
    // 导航到指定路由的方法
    fun navigate(route: String) {
        val destination = findDestination(route)
        if (destination!= null) {
            val newEntry = createBackStackEntry(destination)
            backStack.add(newEntry)
            currentBackStackDepth++
            // 触发屏幕切换的动画等操作（简化示意）
            onNavigate(newEntry)
        }
    }
    // 从导航栈中弹出当前屏幕的方法
    fun popBackStack() {
        if (currentBackStackDepth > 0) {
            currentBackStackDepth--
            val removedEntry = backStack.removeAt(currentBackStackDepth)
            // 处理屏幕移除后的相关操作（简化示意）
            onPop(removedEntry)
        }
    }
    // 根据路由查找对应的目的地
    private fun findDestination(route: String): Destination? {
        // 简化实现，实际可能需要更复杂的逻辑从导航图中查找
        return when (route) {
            "home" -> HomeDestination
            "detail" -> DetailDestination
            else -> null
        }
    }
    // 创建BackStackEntry的方法
    private fun createBackStackEntry(destination: Destination): BackStackEntry {
        return BackStackEntry(destination)
    }
}

在这段代码中，NavController维护了一个backStack列表来存储导航栈中的屏幕BackStackEntry。navigate方法根据给定的路由查找对应的目的地，创建新的BackStackEntry并添加到导航栈中，同时更新当前栈深度。popBackStack方法则从导航栈中移除当前屏幕对应的BackStackEntry，并更新栈深度。

3.3 BackStackEntry

BackStackEntry代表导航栈中的一个屏幕实例，它包含了屏幕的相关信息，如目的地、参数等。

3.3.1 BackStackEntry 的源码定义

kotlin

class BackStackEntry(
    // 对应的目的地
    val destination: Destination,
    // 用于存储屏幕相关的参数
    val arguments: Bundle? = null
) {
    // 屏幕的唯一标识符
    val id: Long = generateUniqueId()
    // 生成唯一标识符的方法（简化实现）
    private fun generateUniqueId(): Long {
        return System.currentTimeMillis()
    }
}

在这个类中，destination表示屏幕对应的目的地，arguments用于传递屏幕之间的参数。id是每个BackStackEntry的唯一标识符，通过generateUniqueId方法生成，这里简单地使用当前时间戳作为唯一标识。

3.3.2 BackStackEntry 的作用

在导航过程中，BackStackEntry用于保存屏幕的状态和相关信息。例如，当从一个屏幕跳转到另一个屏幕时，新屏幕的BackStackEntry会被添加到导航栈中，当返回时，对应的BackStackEntry会从导航栈中移除。同时，BackStackEntry中的参数可以在屏幕之间传递，方便实现数据共享和页面间的交互。

3.4 Destination

Destination定义了导航图中的一个节点，即一个可导航到的屏幕。它包含了屏幕的路由信息、是否为起始目的地等属性。

3.4.1 Destination 的源码定义

kotlin

sealed class Destination(
    // 目的地的路由字符串，用于导航时标识该目的地
    val route: String,
    // 是否为起始目的地
    val startDestination: Boolean = false
) {
    // 示例：定义一个名为HomeDestination的具体目的地
    class HomeDestination : Destination("home", startDestination = true)
    // 示例：定义一个名为DetailDestination的具体目的地
    class DetailDestination : Destination("detail")
}

在这段代码中，Destination是一个密封类，通过不同的子类来定义具体的目的地。每个目的地都有一个唯一的route字符串和一个startDestination标志，用于标识该目的地是否为导航图的起始点。

3.4.2 Destination 在导航中的作用

在导航过程中，NavController通过route来查找对应的Destination。当调用navigate方法时，NavController会根据传入的route在导航图中找到对应的Destination，然后创建相应的BackStackEntry并进行导航操作。例如：

kotlin

navController.navigate("detail")

在这个例子中，NavController会查找route为 "detail" 的Destination，如果找到，就会执行相应的导航逻辑，将对应的屏幕添加到导航栈中。

四、导航控制器的导航操作实现

4.1 简单导航操作

4.1.1 navigate 方法的详细实现

在NavController中，navigate方法负责处理导航请求，将用户带到指定的屏幕。下面是更详细的navigate方法源码及注释：

kotlin

fun navigate(route: String) {
    // 根据路由查找对应的目的地
    val destination = findDestination(route)
    if (destination!= null) {
        // 创建新的BackStackEntry，包含目的地信息
        val newEntry = createBackStackEntry(destination)
        // 将新的BackStackEntry添加到导航栈中
        backStack.add(newEntry)
        // 更新当前导航栈的深度
        currentBackStackDepth++
        // 通知监听器导航操作发生，可用于触发动画等
        onNavigate(newEntry)
        // 保存导航状态，以便在配置变化等情况下恢复
        saveState()
    } else {
        // 如果未找到对应的目的地，抛出异常或进行错误处理
        throw IllegalArgumentException("Destination not found for route: $route")
    }
}

在这个实现中，首先调用findDestination方法根据传入的route查找对应的Destination。如果找到，创建新的BackStackEntry并添加到backStack导航栈中，更新栈深度。然后调用onNavigate方法通知相关监听器导航操作的发生，这里可以触发屏幕切换的动画等逻辑。最后调用saveState方法保存当前的导航状态，以便在应用发生配置变化（如屏幕旋转）时能够恢复到正确的导航状态。如果未找到对应的Destination，则抛出IllegalArgumentException异常，提示路由对应的目的地未找到。

4.1.2 简单导航示例

kotlin

@Composable
fun HomeScreen(navController: NavController) {
    Column {
        Text("Welcome to the Home Screen")
        Button(
            onClick = {
                // 点击按钮，导航到"detail"屏幕
                navController.navigate("detail")
            }
        ) {
            Text("Go to Detail Screen")
        }
    }
}

在这个HomeScreen的 Composable 函数中，包含一个按钮。当用户点击按钮时，调用navController.navigate("detail")方法，触发导航操作，将用户带到路由为 "detail" 的屏幕。在实际应用中，detail屏幕可能会显示更详细的信息，比如商品详情、文章详情等。

4.2 带参数的导航操作

4.2.1 传递参数的原理

在 Compose 导航中，可以通过BackStackEntry的arguments属性来传递参数。当创建BackStackEntry时，可以将需要传递的参数放入Bundle中，并赋值给arguments。在目标屏幕中，可以从currentBackStackEntry的arguments中获取这些参数。

4.2.2 带参数导航的源码实现

首先，在导航发起方设置参数：

kotlin

fun navigateWithArgs(route: String, args: Bundle) {
    val destination = findDestination(route)
    if (destination!= null) {
        val newEntry = createBackStackEntry(destination)
        newEntry.arguments = args
        backStack.add(newEntry)
        currentBackStackDepth++
        onNavigate(newEntry)
        saveState()
    } else {
        throw IllegalArgumentException("Destination not found for route: $route")
    }
}

在这个方法中，navigateWithArgs接收一个路由字符串和一个Bundle参数。它首先查找目标Destination，创建BackStackEntry后，将传入的Bundle参数赋值给BackStackEntry的arguments属性，然后执行与普通navigate方法类似的导航操作。

在目标屏幕获取参数：

kotlin

@Composable
fun DetailScreen() {
    val navController = LocalNavController.current
    val currentEntry = navController.currentBackStackEntry
    val args: Bundle? = currentEntry?.arguments
    if (args!= null) {
        val param1 = args.getString("param1")
        val param2 = args.getInt("param2")
        Column {
            Text("Param 1: $param1")
            Text("Param 2: $param2")
        }
    }
}

在DetailScreen中，通过LocalNavController.current获取当前的NavController，进而获取当前屏幕的BackStackEntry。从BackStackEntry的arguments中获取传递过来的参数，并进行相应的处理和显示。

4.2.3 带参数导航示例

kotlin

@Composable
fun ProductListScreen(navController: NavController) {
    val productList = listOf(
        Product("Product 1", 10.99),
        Product("Product 2", 19.99)
    )
    LazyColumn {
        items(productList) { product ->
            Card(
                onClick = {
                    val args = Bundle()
                    args.putString("product_name", product.name)
                    args.putDouble("product_price", product.price)
                    navController.navigateWithArgs("product_detail", args)
                }
            ) {
                Column {
                    Text(product.name)
                    Text("$${product.price}")
                }
            }
        }
    }
}
data class Product(val name: String, val price: Double)

在ProductListScreen中，展示了一个产品列表。当用户点击某个产品的卡片时，创建一个Bundle并放入产品的名称和价格参数，然后调用navigateWithArgs方法导航到 "product_detail" 屏幕，并传递参数。在 "product_detail" 屏幕中，就可以获取这些参数并显示产品的详细信息。

4.3 条件导航

4.3.1 条件导航的实现思路

条件导航是指根据某些条件来决定是否进行导航以及导航到哪个屏幕。在 Compose 中，可以在导航操作的触发逻辑中添加条件判断来实现。例如，根据用户的登录状态、权限等条件来决定用户是否能够访问某个屏幕。

4.3.2 条件导航的代码示例

kotlin

@Composable
fun LoginScreen(navController: NavController) {
    var username by remember { mutableStateOf("") }
    var password by remember { mutableStateOf("") }
    Column {
        TextField(
            value = username,
            onValueChange = { username = it },
            label = { Text("Username") }
        )
        TextField(
            value = password,
            onValueChange = { password = it },
            label = { Text("Password") }
        )
        Button(
            onClick = {
                if (username == "admin" && password == "123456") {
                    navController.navigate("home")
                } else {
                    // 显示错误提示
                    Toast.makeText(LocalContext.current, "Invalid credentials", Toast.LENGTH_SHORT).show()

接上一部分内容，继续深入分析 Android Compose 框架导航与路由模块中的导航控制器：

4.3.2 条件导航的代码示例

kotlin

                }
            }
        ) {
            Text("Login")
        }
    }
}

在这个LoginScreen的示例中，用户输入用户名和密码后点击登录按钮。在点击事件处理逻辑中，进行条件判断。如果用户名是 "admin" 且密码是 "123456"，则调用navController.navigate("home")导航到主屏幕；否则，使用Toast提示用户 "Invalid credentials"。这是一个简单的基于用户输入验证的条件导航示例。在实际应用中，条件判断可能会基于更复杂的业务逻辑，比如检查用户的网络连接状态、用户权限等。

再比如，根据用户是否已经完成新手引导来决定导航到不同屏幕：

kotlin

@Composable
fun SplashScreen(navController: NavController) {
    val isFirstTimeUser = remember { mutableStateOf(true) } // 这里假设通过某种方式获取到是否为首次用户的状态
    LaunchedEffect(Unit) {
        delay(2000) // 模拟启动加载延迟
        if (isFirstTimeUser.value) {
            navController.navigate("onboarding")
        } else {
            navController.navigate("main")
        }
    }
    // 这里可以展示启动画面的UI元素，如应用logo等
    Box(
        contentAlignment = Alignment.Center,
        modifier = Modifier.fillMaxSize()
    ) {
        Text("Splash Screen")
    }
}

在SplashScreen中，通过LaunchedEffect在启动延迟 2 秒后，根据isFirstTimeUser的值决定导航到 "onboarding"（新手引导屏幕）还是 "main"（主屏幕）。这种方式使得应用能够根据用户的不同状态提供个性化的导航体验。

4.4 深层链接导航

4.4.1 深层链接原理

深层链接（Deep Linking）允许用户通过点击链接直接进入应用内的特定屏幕，而不仅仅是应用的首页。在 Android Compose 中，深层链接的实现依赖于在AndroidManifest.xml中配置相关的intent-filter，以及在导航控制器中处理深层链接的逻辑。当用户点击一个深层链接时，系统会根据链接的内容匹配到对应的应用，并将链接传递给应用。应用通过解析链接中的信息，决定导航到哪个屏幕以及是否需要传递参数等。

4.4.2 配置深层链接

首先，在AndroidManifest.xml中为需要支持深层链接的Activity配置intent-filter：

xml

<activity
    android:name=".MainActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:scheme="myapp"
            android:host="details"
            android:path="/product/{productId}" />
    </intent-filter>
</activity>

在这段配置中，定义了一个intent-filter，表示该Activity可以处理VIEW类型的Intent，并且支持通过浏览器访问（BROWSABLE类别）。data标签指定了深层链接的格式，这里定义了一个scheme为 "myapp"，host为 "details"，路径为 "/product/{productId}" 的深层链接格式，其中{productId}是一个占位符，表示产品 ID。

4.4.3 处理深层链接导航

在 Compose 应用中，需要在NavController中处理深层链接的解析和导航操作。通常在MainActivity中进行相关设置：

kotlin

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val navController = rememberNavController()
            NavHost(
                navController = navController,
                startDestination = "home"
            ) {
                composable("home") {
                    HomeScreen(navController)
                }
                composable(
                    "product_detail/{productId}",
                    arguments = listOf(navArgument("productId") { type = NavType.IntType })
                ) { backStackEntry ->
                    val productId = backStackEntry.arguments?.getInt("productId")
                    ProductDetailScreen(productId)
                }
            }
            handleDeepLink(navController)
        }
    }
    private fun handleDeepLink(navController: NavController) {
        val deepLinkIntent = intent
        if (Intent.ACTION_VIEW == deepLinkIntent.action) {
            deepLinkIntent.data?.let { uri ->
                val productId = uri.getQueryParameter("productId")?.toIntOrNull()
                if (productId!= null) {
                    navController.navigate("product_detail/$productId")
                }
            }
        }
    }
}

在MainActivity的onCreate方法中，设置了 Compose 的内容，包括定义NavHost和各个屏幕的导航关系。其中，在定义 "product_detail" 屏幕时，使用navArgument指定了路径参数 "productId" 的类型为IntType。

handleDeepLink方法用于处理深层链接。首先获取当前Activity接收到的Intent，检查其action是否为ACTION_VIEW，如果是，则获取Intent中的数据Uri。从Uri中解析出 "productId" 参数（这里假设深层链接通过查询参数传递产品 ID），如果解析成功，则调用navController.navigate导航到 "product_detail/$productId" 屏幕，实现深层链接导航到特定产品详情屏幕的功能。

4.5 导航动画与过渡效果

4.5.1 导航动画原理

在 Android Compose 中，导航动画是通过AnimatedContent等组件以及NavController的状态变化来实现的。当导航操作发生时，NavController的状态（如导航栈的变化）会触发相应的动画逻辑。通过定义不同屏幕之间的进入和退出动画，可以为用户提供更加流畅和吸引人的导航体验。例如，可以设置淡入淡出、滑动、缩放等动画效果。

4.5.2 实现导航动画的代码示例

为了实现简单的淡入淡出导航动画，可以利用AnimatedContent组件：

kotlin

@Composable
fun AnimatedNavHost(navController: NavController) {
    val currentRoute = remember { mutableStateOf("home") }
    LaunchedEffect(navController.currentBackStackEntry) {
        currentRoute.value = navController.currentBackStackEntry?.destination?.route?:"home"
    }
    AnimatedContent(
        targetState = currentRoute.value,
        transitionSpec = {
            if (targetState == "home") {
                slideOutVertically { it } + fadeOut() with slideInVertically { -it } + fadeIn()
            } else {
                slideOutVertically { -it } + fadeOut() with slideInVertically { it } + fadeIn()
            }
        }
    ) { targetRoute ->
        when (targetRoute) {
            "home" -> HomeScreen(navController)
            "detail" -> DetailScreen(navController)
            else -> EmptyScreen()
        }
    }
}

在这个示例中，AnimatedNavHost组件通过LaunchedEffect监听NavController的当前BackStackEntry变化，从而更新currentRoute状态。AnimatedContent根据currentRoute的变化来显示不同的屏幕。transitionSpec参数定义了屏幕切换时的动画过渡效果。当目标屏幕是 "home" 时，设置了一个从底部滑出并淡出，然后从顶部滑入并淡入的动画组合；当目标屏幕是其他屏幕时，动画方向相反。这样，在导航过程中就会呈现出淡入淡出和滑动的动画效果，提升了用户体验。

还可以通过自定义Transition来实现更复杂的导航动画：

kotlin

val customEnterTransition = slideInHorizontally(
    initialOffsetX = { fullWidth -> fullWidth },
    animationSpec = tween(500)
)
val customExitTransition = slideOutHorizontally(
    targetOffsetX = { fullWidth -> -fullWidth },
    animationSpec = tween(500)
)
@Composable
fun CustomAnimatedNavHost(navController: NavController) {
    val currentRoute = remember { mutableStateOf("home") }
    LaunchedEffect(navController.currentBackStackEntry) {
        currentRoute.value = navController.currentBackStackEntry?.destination?.route?:"home"
    }
    AnimatedContent(
        targetState = currentRoute.value,
        transitionSpec = {
            if (targetState == "home") {
                customExitTransition with customEnterTransition
            } else {
                customEnterTransition with customExitTransition
            }
        }
    ) { targetRoute ->
        when (targetRoute) {
            "home" -> HomeScreen(navController)
            "detail" -> DetailScreen(navController)
            else -> EmptyScreen()
        }
    }
}

在这个例子中，定义了自定义的进入和退出动画customEnterTransition和customExitTransition，它们分别实现了从右侧滑入和从左侧滑出的动画效果，并且设置了动画时长为 500 毫秒。在AnimatedContent的transitionSpec中，根据目标屏幕是 "home" 还是其他屏幕，来组合使用这些自定义动画，实现了具有个性化的导航动画效果。

五、导航控制器与 ViewModel 的协作

5.1 ViewModel 在导航中的作用

ViewModel 在 Android Compose 的导航场景中扮演着至关重要的角色，它主要负责管理与屏幕相关的数据和业务逻辑，同时保持数据的一致性和独立性，不受屏幕重建（如配置变化导致的 Activity 重建）的影响。在导航过程中，ViewModel 可以用于共享数据、处理导航相关的业务逻辑以及保持屏幕状态。例如，在一个电商应用中，从商品列表屏幕导航到商品详情屏幕时，商品列表屏幕的 ViewModel 可以将用户选择的商品信息传递给商品详情屏幕的 ViewModel，确保数据的准确传递和共享。同时，ViewModel 可以处理一些与导航相关的业务逻辑，如在用户点击返回按钮时，根据业务需求决定是否需要保存数据或执行其他操作。

5.2 跨屏幕数据共享

5.2.1 使用 ViewModel 共享数据的原理

在 Compose 中，每个屏幕可以关联一个 ViewModel。通过依赖注入等方式，可以确保不同屏幕的 ViewModel 能够访问共享的数据或状态。例如，可以创建一个单例的 ViewModel，在多个屏幕之间共享数据。或者通过将一个 ViewModel 的实例传递给需要共享数据的其他 ViewModel 来实现数据共享。

5.2.2 跨屏幕数据共享的代码示例

首先，创建一个共享数据的 ViewModel：

kotlin

class SharedViewModel : ViewModel() {
    val sharedData = mutableStateOf("Initial Shared Data")
    fun updateSharedData(newData: String) {
        sharedData.value = newData
    }
}

在HomeScreen中使用并更新共享数据：

kotlin

@Composable
fun HomeScreen(navController: NavController, sharedViewModel: SharedViewModel) {
    Column {
        Text("Home Screen - Shared Data: ${sharedViewModel.sharedData.value}")
        Button(
            onClick = {
                sharedViewModel.updateSharedData("Updated from Home Screen")
                navController.navigate("detail")
            }
        ) {
            Text("Go to Detail Screen")
        }
    }
}

在DetailScreen中访问共享数据：

kotlin

@Composable
fun DetailScreen(sharedViewModel: SharedViewModel) {
    Column {
        Text("Detail Screen - Shared Data: ${sharedViewModel.sharedData.value}")
    }
}

在MainActivity中进行 ViewModel 的注入和导航设置：

kotlin

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val sharedViewModel: SharedViewModel = viewModel()
            val navController = rememberNavController()
            NavHost(
                navController = navController,
                startDestination = "home"
            ) {
                composable("home") {
                    HomeScreen(navController, sharedViewModel)
                }
                composable("detail") {
                    DetailScreen(sharedViewModel)
                }
            }
        }
    }
}

在这个示例中，SharedViewModel包含一个可变状态sharedData。HomeScreen中显示并更新sharedData，然后导航到DetailScreen。在DetailScreen中可以访问到更新后的sharedData，实现了跨屏幕的数据共享。通过在MainActivity中使用viewModel()函数获取SharedViewModel的实例，并将其传递给各个屏幕的 Composable 函数，确保了不同屏幕使用的是同一个 ViewModel 实例，从而实现数据的共享。

5.3 导航相关业务逻辑处理

5.3.1 ViewModel 处理业务逻辑示例

假设在一个社交应用中，从用户列表屏幕导航到用户详情屏幕时，需要检查用户是否已经关注该用户。如果未关注，则在导航到详情屏幕后，显示一个关注按钮；如果已关注，则显示取消关注按钮。可以在 ViewModel 中处理这些业务逻辑：

kotlin

class UserViewModel : ViewModel() {
    private val _isUserFollowed = mutableStateOf(false)
    val isUserFollowed: State<Boolean> = _isUserFollowed
    fun checkUserFollowStatus(userId: String) {
        // 这里假设通过网络请求或本地数据库查询来获取用户关注状态
        // 模拟网络请求延迟
        viewModelScope.launch {
            delay(1000)
            _isUserFollowed.value = true // 假设查询结果为已关注
        }
    }
}

在用户列表屏幕中触发检查关注状态并导航：

kotlin

@Composable
fun UserListScreen(navController: NavController, userViewModel: UserViewModel) {
    val userList = listOf(
        User("User1", "user1@example.com"),
        User("User2", "user2@example.com")
    )
    LazyColumn {
        items(userList) { user ->
            Card(
                onClick = {
                    userViewModel.checkUserFollowStatus(user.id)
                    navController.navigate("user_detail/${user.id}")
                }
            ) {
                Column {
                    Text(user.name)
                }
            }
        }
    }
}
data class User(val name: String, val id: String)

在用户详情屏幕中根据 ViewModel 的状态显示不同按钮：

kotlin

@Composable
fun UserDetailScreen(userViewModel: UserViewModel, userId: String) {
    val isFollowed by userViewModel.isUserFollowed
    Column {
        Text("User Detail Screen - User ID: $userId")
        if (isFollowed) {
            Button(
                onClick = {
                    // 取消关注逻辑
                }
            ) {
                Text("Unfollow")
            }
        } else {
            Button(
                onClick = {
                    // 关注逻辑
                }
            ) {
                Text("Follow")
            }
        }
    }
}

在这个例子中，UserViewModel负责检查用户的关注状态。在UserListScreen中，当用户点击某个用户项时，调用userViewModel.checkUserFollowStatus检查关注状态，并导航到用户详情屏幕。在UserDetailScreen中，根据UserViewModel中的isUserFollowed状态显示相应的关注或取消关注按钮，通过 ViewModel 有效地处理了导航相关的业务逻辑。

5.4 处理屏幕重建时的状态恢复

5.4.1 状态恢复原理

当发生配置变化（如屏幕旋转）时，Android 系统会重建 Activity，这可能导致屏幕状态丢失。ViewModel 的生命周期与 Activity 不同，它不会因为配置变化而被销毁。因此，可以将屏幕的重要状态存储在 ViewModel 中，在 Activity 重建后，从 ViewModel 中恢复这些状态，确保用户体验的连续性。

5.4.2 状态恢复的代码示例

假设在一个笔记应用中，用户在编辑笔记屏幕输入了一些内容，此时发生屏幕旋转，需要恢复输入的内容：

kotlin

class NoteViewModel : ViewModel() {
    val noteText = mutableStateOf("")
}

在编辑笔记屏幕中使用 ViewModel 并恢复状态：

kotlin

@Composable
fun EditNoteScreen(noteViewModel: NoteViewModel) {
    Column {
        TextField(
            value = noteViewModel.noteText.value,
            onValueChange = { noteViewModel.noteText.value = it },
            label = { Text("Edit Note") }
        )
    }
}

在MainActivity中设置 ViewModel 和导航：

kotlin

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val noteViewModel: NoteViewModel = viewModel()
            val navController = rememberNavController()
            NavHost(
                navController = navController,
                startDestination = "edit_note"
            ) {
                composable("edit_note") {
                    EditNoteScreen(noteViewModel)
                }
            }
        }
    }
}

在这个示例中，NoteViewModel包含一个noteText可变状态来存储笔记内容。在 `Edit

以下是继续对 Android Compose 框架中导航与路由模块之导航控制器的分析：

导航控制器的状态管理

在 Android Compose 中，导航控制器负责管理导航状态。导航状态包括当前显示的屏幕、返回栈等信息。

• 保存和恢复状态

  • 导航控制器会在配置更改（如屏幕旋转）等情况下保存当前的导航状态，以便在重建时能够恢复到之前的状态。这是通过SavedStateHandle来实现的。在导航控制器的内部，当发生配置更改时，会将当前导航栈的相关信息保存到SavedStateHandle中。

kotlin

// 示例代码，简化版的保存状态逻辑
class MyNavigationController {
    private val savedStateHandle: SavedStateHandle // 用于保存和恢复状态的对象

    fun saveState() {
        // 将当前导航栈的信息保存到SavedStateHandle中
        savedStateHandle.set("nav_stack", currentNavStack)
    }

    fun restoreState() {
        // 从SavedStateHandle中恢复导航栈信息
        val restoredStack = savedStateHandle.get<List<Screen>>("nav_stack")
        if (restoredStack!= null) {
            currentNavStack = restoredStack
        }
    }
}

这里的SavedStateHandle就像是一个小型的键值对存储，用于在不同的生命周期阶段保存和恢复数据。

• 状态更新通知

  • 导航控制器在状态发生变化时，会通知相关的组件。例如，当导航到新的屏幕或者返回上一屏幕时，需要更新界面以显示新的内容。这是通过MutableState和DerivedState来实现的。

kotlin

// 示例代码，简化版的状态更新通知逻辑
class MyNavigationController {
    private val _currentScreen = mutableStateOf<Screen>(Screen.Home)
    val currentScreen: State<Screen> = _currentScreen

    fun navigateTo(screen: Screen) {
        _currentScreen.value = screen
    }
}

// 在Compose UI中使用这个状态
@Composable
fun MyApp() {
    val navController = rememberMyNavigationController()
    val currentScreen by navController.currentScreen.collectAsState()

    when (currentScreen) {
        Screen.Home -> HomeScreen()
        Screen.Details -> DetailsScreen()
    }
}

这里通过mutableStateOf创建了一个可变状态_currentScreen，然后将其暴露为不可变的State类型currentScreen。当_currentScreen的值发生变化时，Compose 会自动重新组合相关的 UI，以反映新的屏幕状态。

导航控制器与 Compose UI 的集成

导航控制器与 Compose UI 的集成是无缝的，使得在 Compose 应用中实现导航变得非常方便。

• 在 Composable 函数中使用导航控制器

  • 可以在Composable函数中轻松获取导航控制器，并使用它来触发导航操作。

kotlin

@Composable
fun HomeScreen(navController: NavController) {
    Button(onClick = { navController.navigate(Screen.Details.route) }) {
        Text("Go to Details")
    }
}

这里的NavController是通过参数传递到HomeScreen函数中的。当用户点击按钮时，会调用navigate方法，根据指定的路由导航到Details屏幕。

• 导航控制器的依赖注入

  • 为了在整个应用中方便地使用导航控制器，通常会使用依赖注入的方式来提供它。例如，可以使用Hilt等依赖注入框架。

kotlin

// 使用Hilt进行依赖注入
@Module
@InstallIn(SingletonComponent::class)
object NavigationModule {
    @Provides
    @Singleton
    fun provideNavController(): NavController {
        // 创建并返回导航控制器实例
        return NavHostController(applicationContext)
    }
}

// 在Composable函数中注入导航控制器
@Composable
@Inject
fun MyApp(navController: NavController) {
    // 使用导航控制器构建应用的导航结构
    NavHost(navController, startDestination = Screen.Home.route) {
        // 定义各个屏幕的路由和对应的Composable函数
        composable(Screen.Home.route) { HomeScreen(navController) }
        composable(Screen.Details.route) { DetailsScreen(navController) }
    }
}

通过依赖注入，使得导航控制器可以在不同的Composable函数之间方便地传递和使用，提高了代码的可维护性和可测试性。

导航控制器的动画支持

Android Compose 的导航控制器提供了丰富的动画支持，以增强用户体验。

• 定义屏幕过渡动画

  • 可以通过navOptions参数为导航操作定义过渡动画。

kotlin

navController.navigate(Screen.Details.route, navOptions {
    // 定义进入动画
    enterTransition = { fadeIn() }
    // 定义退出动画
    exitTransition = { fadeOut() }
    // 定义弹出动画
    popEnterTransition = { fadeIn() }
    // 定义弹出退出动画
    popExitTransition = { fadeOut() }
})

这里使用了fadeIn和fadeOut动画来实现淡入淡出的效果。还可以使用其他动画，如slideIn、scaleIn等，以实现不同的过渡效果。

• 动画的定制和组合

  • 可以根据需求定制和组合不同的动画。例如，同时使用滑动和淡入动画。

kotlin

navController.navigate(Screen.Details.route, navOptions {
    enterTransition = { slideInHorizontally() + fadeIn() }
    exitTransition = { slideOutHorizontally() + fadeOut() }
    popEnterTransition = { slideInHorizontally() + fadeIn() }
    popExitTransition = { slideOutHorizontally() + fadeOut() }
})

通过将slideInHorizontally和fadeIn动画相加，实现了在滑动进入屏幕的同时进行淡入的效果，使过渡更加自然和丰富。

导航控制器的高级用法

• 深度链接

  • 导航控制器支持深度链接，允许应用通过外部链接直接打开特定的屏幕。这需要在AndroidManifest.xml中进行配置，并在导航控制器中处理深度链接的解析。

xml

<!-- 在AndroidManifest.xml中配置深度链接 -->
<activity android:name=".MainActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="myapp" android:host="www.example.com" android:path="/details" />
    </intent-filter>
</activity>

kotlin

// 在导航控制器中处理深度链接
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val navController = rememberNavController()
            NavHost(navController, startDestination = Screen.Home.route) {
                composable(Screen.Home.route) { HomeScreen(navController) }
                composable(Screen.Details.route) { DetailsScreen(navController) }
            }

            // 处理深度链接
            val deepLinkIntent = intent
            if (Intent.ACTION_VIEW == deepLinkIntent.action) {
                deepLinkIntent.data?.let { uri ->
                    if (uri.path == "/details") {
                        navController.navigate(Screen.Details.route)
                    }
                }
            }
        }
    }
}

这里配置了应用可以处理myapp://www.example.com/details这样的深度链接，并在接收到深度链接时导航到Details屏幕。

• 动态导航

  • 导航控制器可以根据不同的条件进行动态导航。例如，根据用户的登录状态导航到不同的屏幕。

kotlin

@Composable
fun MyApp() {
    val navController = rememberNavController()
    val isLoggedIn = remember { mutableStateOf(false) } // 模拟用户登录状态

    // 根据登录状态进行导航
    if (isLoggedIn.value) {
        NavHost(navController, startDestination = Screen.Home.route) {
            composable(Screen.Home.route) { HomeScreen(navController) }
            composable(Screen.Settings.route) { SettingsScreen(navController) }
        }
    } else {
        NavHost(navController, startDestination = Screen.Login.route) {
            composable(Screen.Login.route) { LoginScreen(navController) }
        }
    }
}

这里通过isLoggedIn状态来决定应用的导航结构。如果用户已登录，导航到包含Home和Settings屏幕的导航图；如果未登录，则导航到Login屏幕。

导航控制器的性能优化

• 避免过度重绘

  • 在导航过程中，要注意避免不必要的 UI 重绘。Compose 会自动根据状态变化来重新组合 UI，但如果不注意，可能会导致过度重绘。例如，在Composable函数中避免在onClick等事件处理中频繁地修改状态，以免引起不必要的 UI 更新。

kotlin

@Composable
fun MyScreen(navController: NavController) {
    val counter = remember { mutableStateOf(0) }

    // 错误示例，每次点击都会导致整个屏幕重绘
    Button(onClick = {
        counter.value++
        navController.navigate(Screen.Details.route)
    }) {
        Text("Go to Details")
    }

    // 正确示例，将状态修改和导航操作分开
    val navigateToDetails = remember {
        { navController.navigate(Screen.Details.route) }
    }

    Button(onClick = {
        counter.value++
        // 延迟导航操作，避免立即重绘
        LaunchedEffect(Unit) {
            delay(100)
            navigateToDetails()
        }
    }) {
        Text("Go to Details")
    }
}

在错误示例中，点击按钮时先修改了counter状态，然后立即导航，这会导致屏幕先重绘一次以更新counter的显示，然后再进行导航。而在正确示例中，通过LaunchedEffect延迟了导航操作，避免了在状态修改后立即重绘，提高了性能。

• 优化导航栈管理

  • 合理管理导航栈可以提高性能。避免在导航栈中堆积过多的屏幕，特别是当某些屏幕不再需要时，及时将其从导航栈中移除。例如，可以在onBackPressed事件中根据情况决定是否弹出当前屏幕或者直接返回主屏幕。

kotlin

class MyNavigationController {
    private val navStack = mutableListOf<Screen>()

    fun navigateTo(screen: Screen) {
        navStack.add(screen)
    }

    fun onBackPressed(): Boolean {
        if (navStack.size > 1) {
            navStack.removeLast()
            return true
        } else {
            // 到达根屏幕，返回false表示不处理返回事件，让系统处理
            return false
        }
    }
}

这里的onBackPressed方法实现了基本的导航栈管理逻辑。当导航栈中还有多个屏幕时，弹出当前屏幕；当到达根屏幕时，返回false让系统处理返回事件，例如退出应用。

总结与展望

• 总结

  • Android Compose 框架的导航与路由模块中的导航控制器是构建现代化 Android 应用导航系统的核心组件。它提供了简洁、高效的方式来管理屏幕之间的导航，包括状态管理、与 Compose UI 的无缝集成、丰富的动画支持以及高级功能如深度链接和动态导航。通过深入分析导航控制器的源码和使用方法，我们了解到它是如何在幕后实现这些功能的，以及如何在实际应用中充分利用它来提供优秀的用户体验。同时，我们也探讨了一些性能优化的技巧，以确保应用在导航过程中保持流畅和高效。

• 展望

  • 随着 Android Compose 的不断发展和完善，导航控制器有望在未来提供更多强大的功能和更便捷的使用方式。例如，可能会进一步简化深度链接的配置和处理，提供更灵活的动画定制选项，以及更好地支持多窗口模式和折叠屏设备。同时，与其他 Android Jetpack 组件的集成也可能会更加紧密，使得开发者能够更轻松地构建复杂的应用架构。对于开发者来说，不断关注 Compose 导航控制器的发展动态，学习和掌握新的功能和特性，将有助于打造出更优秀的 Android 应用，满足用户日益增长的需求。

以上内容对 Android Compose 框架中导航控制器的主要方面进行了较为深入的分析，希望能帮助开发者更好地理解和使用导航控制器，在实际开发中构建出更加出色的应用导航体验。当然，Android Compose 的导航系统还有很多细节和扩展功能，需要开发者在实践中不断探索和积累经验。