一个任务页面,往往不只是把数据库里的列表显示出来。它还要根据网络状态选择数据源,根据用户选择的分类过滤任务,再根据偏好决定是否显示已完成的任务。
困难在于,这些输入不一定采用同一种状态模型:数据库返回 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。这种方案同样可行,只是数据收集和生命周期由外部代码负责。
| 比较项 | derivedStateOf | AppState Transform | Flow.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 中维护一个持续更新的结果。
对于复杂的展示状态,这种写法值得在小范围功能中评估,再根据测试、性能和生命周期表现决定是否采用。