Jetpack AppState Transform:让 Compose 的响应式状态走出 UI 层

0 阅读14分钟

一个任务页面,往往不只是把数据库里的列表显示出来。它还要根据网络状态选择数据源,根据用户选择的分类过滤任务,再根据偏好决定是否显示已完成的任务。

困难在于,这些输入不一定采用同一种状态模型:数据库返回 Kotlin Flow,用户选择保存在 Compose State 中,网络状态又决定当前应该订阅哪个来源。过滤条件本身很简单,把这些输入连接起来却需要额外代码。

Jetpack AppState Transform 处理的正是这部分工作。它让我们在 ViewModel 等非 UI 组件中运行一个 Composable 代码块,在里面读取 State、收集 Flow、计算结果,最终对外提供一个 Compose State。

下面从一个简单的任务列表开始,逐步加入筛选、在线与离线切换、搜索。在每一步中,都使用相同的输入和需求比较不同方案。

1. 从两个输入开始:任务列表和筛选开关

假设应用已经有一个任务模型:

data class Task(
    val id: Int,
    val title: String,
    val category: String,
    val isCompleted: Boolean
)

数据库通过 Flow 持续提供任务。用户的“显示已完成任务”开关保存在 Compose State 中:

// 以下属性位于 ViewModel 中。
private val tasksFlow: Flow<List<Task>> = repository.observeTasks()

var showCompleted by mutableStateOf(false)
    private set

需求只有一条:列表更新或开关变化时,重新计算可见任务。

使用 Flow:先统一输入,再组合

combine 可以组合多个 Flow。不过,showCompleted 是 Compose State,需要先通过 snapshotFlow 接入:

val visibleTasks: StateFlow<List<Task>> = combine(
    tasksFlow,
    snapshotFlow { showCompleted }
) { tasks, show ->
    tasks.filter { show || !it.isCompleted }
}.stateIn(
    scope = viewModelScope,
    started = SharingStarted.Eagerly,
    initialValue = emptyList()
)

这段代码分成三步:snapshotFlow 把开关的变化转换为 Flow,combine 在任一输入更新时重新过滤,stateIn 保存最新结果并提供初始值。

这里使用 Eagerly,让收集随 ViewModel 作用域持续运行,便于和下面的 Transform 比较。实际应用也可以使用 WhileSubscribed,让上游根据订阅情况启停。

使用 Transform:在计算中直接读取输入

同样的需求,Transform 可以这样写:

val visibleTasks: State<List<Task>> = transform(
    initialValue = emptyList(),
    scope = viewModelScope
) {
    val tasks = tasksFlow.collectAsState(initial = emptyList()).value
    val show = showCompleted

    tasks.filter { show || !it.isCompleted }
}

过滤逻辑没有变化。变化的是依赖的建立方式:不再把所有输入先转换成 Flow、放进 combine 参数列表,而是在转换块中读取它们。

collectAsState 负责收集任务 Flow,并将最新列表保存为 Compose State。Transform 运行这段代码时,会追踪对任务 State 和 showCompleted 的读取。任一状态变化,转换块就会被安排重新执行,新的返回值成为 visibleTasks 的最新值。

例如,列表里有任务 A(未完成)和 B(已完成)。开关关闭时,两种方案都显示 A;开关打开后,两种方案都会显示 A、B。Flow 方案通过输入流触发组合,Transform 方案通过 State 依赖触发重组。

两段代码实现相同的展示目标,但初始值与更新调度并非逐步一致:combine 会等待各输入首次发出值;Transform 示例在任务尚未到达时,会先使用空列表计算。

2. 为什么 Composable 代码可以放进 ViewModel?

我们经常在界面中使用 collectAsState:收集 Flow,然后把结果传给 Text 或 LazyColumn。但它依赖的是 Compose 的运行机制,而不是这些 UI 控件。

Compose runtime 既能追踪 State 的读取,也能在状态变化时安排代码重新执行。Transform 利用这套机制创建一个不绘制界面的 Composition,即“无界面组合”(headless Composition)。

普通的界面组合根据状态生成 UI;Transform 中的组合根据状态计算一个值。上面的转换块只返回任务列表,因此不会创建任何界面元素。

从调用者看,Transform 的结构是:

val result: State<Result> = transform(
    initialValue = initialResult,
    scope = viewModelScope
) { previousResult ->
    // 读取状态、收集数据,最后返回本次计算结果。
    calculateResult()
}

initialValue 是第一次计算完成前可读取的结果;scope 决定这个转换能运行多久;previousResult 是上一次输出,第一次执行时等于初始值。

因此,即使 ViewModel 没有自己的 UI Composition,也可以在这个转换块中使用 collectAsState、remember、LaunchedEffect 等 Composable API。

AppState 还提供 StateStore,用于存储和共享应用状态。本文讨论的 Transform 则负责把已有输入转换为派生状态。

3. 只是从已有 State 算一个值时,使用 derivedStateOf

再把需求缩小一点:如果任务已经保存在 Compose State 中,不需要收集数据库 Flow,会怎样?

var tasks by mutableStateOf(emptyList<Task>())
    private set

var showCompleted by mutableStateOf(false)
    private set

val visibleTasks: State<List<Task>> = derivedStateOf {
    tasks.filter { showCompleted || !it.isCompleted }
}

这时使用 derivedStateOf 就足够了。它同样会追踪代码块读取的 Compose State,但计算过程是同步的:输入改变后派生值失效,下次读取时重新计算,不需要初始值或协程作用域。

Transform 在上一节有用,是因为任务来自异步 Flow,计算块需要调用 collectAsState。derivedStateOf 接收的是普通 Kotlin lambda,不能在里面调用这个 Composable API。

当然,也可以在外部启动协程,把 Flow 收集到一个 Compose State,再交给 derivedStateOf。这种方案同样可行,只是数据收集和生命周期由外部代码负责。

比较项derivedStateOfAppState TransformFlow.combine
怎样建立输入依赖追踪计算块读取的 State追踪 Composable 块读取的 State;Flow 可通过 collectAsState 接入显式传入输入 Flow
怎样处理异步来源先在外部转换为 State在块内调用 Composable API 接入使用 Flow 操作符组织
怎样得到输出读取时同步计算派生值Composition 执行后更新 State发出组合结果,可用 stateIn 保存最新值
适合的起点输入已经是 Compose State输入混合 State、Flow,并需要 Compose 能力输入本来都是 Flow

如果输入全是 Flow,combine 依然直接。如果输入全是 State,只做同步计算,通常也不需要 Transform。Transform 的用处会在混合输入和条件式收集时更加明显。

4. 加入网络状态:在线和离线时订阅不同来源

现在让任务页面支持离线模式:在线时读取远程任务,离线时读取本地 Room 数据。筛选开关仍然有效。

先保存两个 Flow,避免在每次状态计算时重新调用 Repository 创建对象:

private val remoteTasksFlow = repository.observeRemoteTasks()
private val localTasksFlow = repository.observeLocalTasks()

var isOnline by mutableStateOf(true)
    private set

实际项目可由网络监视器维护 isOnline,这里用 Compose State 表示它。

Flow 方案:用 flatMapLatest 切换收集

private val activeTasksFlow = snapshotFlow { isOnline }
    .flatMapLatest { online ->
        if (online) remoteTasksFlow else localTasksFlow
    }

val visibleTasks: StateFlow<List<Task>> = combine(
    activeTasksFlow,
    snapshotFlow { showCompleted }
) { tasks, show ->
    tasks.filter { show || !it.isCompleted }
}.stateIn(
    scope = viewModelScope,
    started = SharingStarted.Eagerly,
    initialValue = emptyList()
)

flatMapLatest 表达“网络状态改变后,取消旧来源的收集,改为收集新来源”。combine 继续负责组合任务与筛选开关。

Transform 方案:在条件分支中收集

val visibleTasks: State<List<Task>> = transform(
    initialValue = emptyList(),
    scope = viewModelScope
) {
    val tasks = if (isOnline) {
        remoteTasksFlow.collectAsState(initial = emptyList()).value
    } else {
        localTasksFlow.collectAsState(initial = emptyList()).value
    }

    val show = showCompleted
    tasks.filter { show || !it.isCompleted }
}

这里不再额外构建 activeTasksFlow。转换块读取 isOnline 后,进入当前分支,并收集对应的数据源。

网络状态改变时,Compose 安排转换块重组。原分支离开 Composition,其中的收集任务被取消;新分支进入 Composition,开始收集新的 Flow。

起作用的是 Composition 对分支内收集任务的管理。仅仅写一个普通 if,并不会自动获得订阅和取消能力。

两种方案都能切换来源。区别是:Flow 用操作符明确连接处理步骤;Transform 用 Compose 的执行分支和依赖追踪表达相同的业务条件。

5. 把筛选条件汇总为一个页面状态

接下来加入分类选择,让页面同时知道当前任务和网络状态。

data class TaskUiState(
    val tasks: List<Task> = emptyList(),
    val isOnline: Boolean = true,
    val isLoading: Boolean = true
)

下面的 ViewModel 汇总了前面的逻辑:

class TaskViewModel(
    repository: TaskRepository,
    private val networkMonitor: NetworkMonitor
) : ViewModel() {
    private val remoteTasksFlow = repository.observeRemoteTasks()
    private val localTasksFlow = repository.observeLocalTasks()

    var selectedCategory by mutableStateOf<String?>(null)
        private set

    var showCompleted by mutableStateOf(false)
        private set

    val uiState: State<TaskUiState> = transform(
        initialValue = TaskUiState(
            isOnline = networkMonitor.isOnline.value
        ),
        scope = viewModelScope
    ) { previous ->
        val online = networkMonitor.isOnline.value
        val category = selectedCategory
        val show = showCompleted

        val tasks = if (online) {
            remoteTasksFlow.collectAsState(initial = null).value
        } else {
            localTasksFlow.collectAsState(initial = null).value
        }

        if (tasks == null) {
            // 新来源还未提供数据:保留原列表,同时更新网络和加载状态。
            previous.copy(isOnline = online, isLoading = true)
        } else {
            TaskUiState(
                tasks = tasks.filter { task ->
                    (show || !task.isCompleted) &&
                        (category == null || task.category == category)
                },
                isOnline = online,
                isLoading = false
            )
        }
    }

    fun selectCategory(category: String?) {
        selectedCategory = category
    }

    fun setCompletedVisible(visible: Boolean) {
        showCompleted = visible
    }
}

这个示例假设 Repository 提供两个 Flow<List<Task>>,网络监视器提供 State<Boolean>。示例省略 import、依赖注入和错误处理。

现在,网络状态、分类和显示偏好都在转换块中被读取,任务 Flow 则通过 collectAsState 接入。改变任一相关输入,都能重新计算最终状态。

这里还用到了上一次输出 previous。当数据源切换、新 Flow 尚未发出列表时,页面保留原任务,显示加载进度,并立即更新联网标志。新列表到达后,再用当前分类和偏好过滤。

这是一种产品选择:加载期间暂时显示的旧列表不保证符合最新筛选条件。如果切换分类后必须立刻隐藏旧内容,可以在 tasks == null 时返回空列表和加载状态。

UI 只需读取最终结果:

@Composable
fun TaskScreen(viewModel: TaskViewModel) {
    val state by viewModel.uiState

    Column {
        Text(if (state.isOnline) "在线" else "离线")

        if (state.isLoading) {
            LinearProgressIndicator()
        }

        LazyColumn {
            items(state.tasks, key = { it.id }) { task ->
                Text(task.title)
            }
        }
    }
}

页面无需决定订阅远程还是本地数据,也不负责把多个输入重新拼装起来。这些规则已经汇总在 ViewModel 的一个状态中。

6. 搜索防抖:用 Compose 的副作用 API 管理等待和取消

Transform 的另一个用途,是在状态计算中使用 LaunchedEffect 等 API。以任务搜索为例:用户停止输入 300 毫秒后发起搜索,新查询到来时取消旧查询,并持续接收当前查询的结果。

使用 Flow 时,可以这样组织:

val searchResults: Flow<List<Task>> = snapshotFlow { searchQuery }
    .debounce(300)
    .distinctUntilChanged()
    .flatMapLatest { query ->
        if (query.isBlank()) {
            flowOf(emptyList())
        } else {
            repository.searchTasks(query)
        }
    }

debounce 等待输入稳定,flatMapLatest 切换到最新搜索流。这里假设 searchQuery 是 Compose State,Repository 返回 Flow<List<Task>>。

使用 Transform,则可以让 LaunchedEffect 管理这段异步工作:

val searchResults: State<List<Task>> = transform(
    initialValue = emptyList(),
    scope = viewModelScope
) {
    val query = searchQuery
    var results by remember { mutableStateOf(emptyList<Task>()) }

    LaunchedEffect(query) {
        delay(300)

        if (query.isBlank()) {
            results = emptyList()
        } else {
            repository.searchTasks(query).collect { tasks ->
                results = tasks
            }
        }
    }

    results
}

转换块读取 searchQuery 后,查询变化会触发重组。LaunchedEffect(query) 的键随之变化,旧协程被取消,新协程开始等待。用户在等待期间继续输入,旧搜索就不会执行;搜索已经开始时,旧流的收集也会被取消。

remember 保留中间结果,LaunchedEffect 更新它,Transform 再把最新结果作为输出。这展示了 Transform 比同步派生计算多出的能力:它可以在一个 Composition 中同时组织状态和异步工作。

这里两种写法都保留原结果,直到新查询产生结果;空查询也等待 300 毫秒后清空。二者具有相同的交互目标,但 Flow 和 Compose 采用不同的调度机制,不应据此假定每次中间更新都完全一致。

如果搜索只需要第一个结果,可以改用 first()。那样后续更新不会继续被接收,应根据 Repository 的数据语义选择。

7. 哪些数据不适合交给 Transform?

任务页面只需要知道“现在应该显示什么”。当输入快速变化时,通常不需要把每一个中间画面都展示出来。

Transform 适合这样的当前状态计算。假设某个输入在下一次重组之前经历了 A → B → C,计算可能只使用最新的 C;新的输出与旧输出相等时,也不会产生新的状态变化。

但有些业务关心的是每一次发生:

场景为什么不能只保留当前状态
记录支付流程待支付、处理中、成功等每次转换都可能需要留档
计算传感器累计值或平均值连续两次相同读数也各自代表一条有效样本
维护撤销历史中间修改不能因为下一次更新到来而丢失
发送命令、处理队列项相同命令连续出现两次,也可能需要执行两次

这些场景应先由合适的事件管道处理。例如,使用 Flow 的 scan 或 runningFold 计算累计结果,再把结果接入 Transform,与其他展示状态组合。

是否能保留每个输入,还取决于上游的缓冲、合并和消费方式。单纯把类型换成 Flow,并不会自动恢复已经丢弃的事件。

同样,如果生产者必须等待消费者处理完当前数据,应该在流处理层设计背压。Compose State 的赋值不会为了等待消费者而挂起。

8. 使用前先确定执行线程和生命周期

转换可能运行在后台线程

Transform 的 dispatcher 默认是 Dispatchers.Default,也可以显式指定:

val state = transform(
    initialValue = TaskUiState(),
    scope = viewModelScope,
    dispatcher = Dispatchers.Default
) {
    // 读取状态并计算结果。
    TaskUiState()
}

因此,转换不一定在主线程执行。过滤较大的集合时,这能把计算放到后台,但不会自动降低计算量;高频更新或复杂算法仍需要实际测量。

如果转换访问的外部对象要求在特定线程使用,应选择合适的调度器。Compose State 可以被追踪,并不意味着块内任意对象都可以安全地跨线程访问。

ViewModel 存活时,转换可以持续工作

传入 viewModelScope 后,Transform 会在这个作用域存活期间持续运行。页面退到后台,并不会自动停止其中的 Flow 收集。

这与下面的 Flow 策略有区别:

repository.observeTasks().stateIn(
    scope = viewModelScope,
    started = SharingStarted.WhileSubscribed(5000),
    initialValue = emptyList()
)

该策略允许上游在没有订阅者持续五秒后停止。是否适合它,取决于任务是否需要在没有界面观察时继续更新。

如果转换应该跟随调用方的 UI Composition,可以使用 @Composable transform 重载;如果需要 ViewModel 存活期间持续维护状态,则可以使用本文的作用域重载。

更新不是同步完成的

derivedStateOf 可以在读取时同步计算。Transform 则需要等待 Composition 执行,输入变化后马上读取输出,不应假定已经拿到新结果。

相应地,测试也需要同时推进协程调度和重组。AppState 提供 transformTest 与 TransformTestScope,用于控制测试中的执行过程。

9. 配置依赖

以下以 AppState Transform 1.0.0-alpha01 为例,说明依赖配置方式。

在版本目录中声明运行库和测试库:

[versions]
appstate = "1.0.0-alpha01"

[libraries]
androidx-appstate-transform = { module = "androidx.appstate.transform:transform", version.ref = "appstate" }
androidx-appstate-transform-testing = { module = "androidx.appstate.transform:transform-testing", version.ref = "appstate" }

在模块中添加依赖:

dependencies {
    implementation(libs.androidx.appstate.transform)
    testImplementation(libs.androidx.appstate.transform.testing)
}

模块还需要启用 Compose 构建功能,并应用 Compose Compiler Gradle 插件。即使模块不包含任何界面,只要调用了这些 Composable API,也需要相应配置。

本文示例用于说明状态组织方式,未在完整 Android 工程中编译或运行;导入、协程 API 的 opt-in 要求及插件配置,应按实际项目版本补齐。本文使用的 AppState 版本处于 alpha 阶段,接入前应查看版本说明。

10. 把 Transform 放在合适的位置

在一个已有清晰 Flow 架构的应用里,Repository 和偏好层如果都提供 Flow,继续使用 combine、flatMapLatest 等操作符通常很自然。没有必要仅仅为了引入新库而重写整条链路。

当展示状态同时依赖 Compose State、数据库 Flow、网络条件和异步操作时,Transform 提供了另一种组织方法:在一个代码块中读取输入、选择来源、计算输出,让 Compose 维护这些读取关系。

Repository 仍负责数据访问,用例仍负责业务规则。Transform 可以放在状态持有者中,把这些结果与用户选择组合成最终页面状态。它也能够用于其他非 UI 组件,但应先明确生命周期和线程要求。

从本文的任务页面可以看到,Transform 没有改变过滤规则,也没有让数据库 Flow 消失。它改变了状态之间的连接方式:开发者可以用 Compose 的读取追踪、条件分支和副作用 API,在 ViewModel 中维护一个持续更新的结果。

对于复杂的展示状态,这种写法值得在小范围功能中评估,再根据测试、性能和生命周期表现决定是否采用。