基于
androidx.lifecycle:lifecycle-livedata:2.7.0源码。先说结论 :
asLiveData并没有把 Flow 里的数据"搬"进 LiveData。它只是把"收集 Flow"这个动作,塞进了一个由 LiveData 生命周期控制的协程块里。真正的魔法不在数据转换,而在 "有活跃观察者才开始 collect,观察者走了就延迟取消" ------LiveData 是开关,Flow 是水管,collect 是水流。
一、全貌:一次调用经过的三层
先把调用链摊开,后面逐层拆:
css
Flow.asLiveData() ← 扩展函数,包一层 collect
└─ liveData { ... } ← 构建器,造一个 CoroutineLiveData
└─ CoroutineLiveData : MediatorLiveData
└─ BlockRunner → launch { 执行那个 collect 块 }
三个文件、三个角色,一层比一层靠近引擎:
| 层 | 所在文件 | 角色 |
|---|---|---|
asLiveData |
FlowLiveData.kt |
把 Flow 包装成 { collect { emit(it) } } |
liveData |
CoroutineLiveData.kt |
构建器,返回 CoroutineLiveData |
CoroutineLiveData |
CoroutineLiveData.kt |
引擎:监听生命周期、调度协程、回写数据 |
二、第一层:asLiveData 只做了一件事
概念:它是 Flow<T> 的扩展函数,函数体短得惊人------把"收集 + 发射"交给 liveData 构建器,顺手处理一下 StateFlow 的初值。
kotlin
// FlowLiveData.kt
@JvmOverloads
public fun <T> Flow<T>.asLiveData(
context: CoroutineContext = EmptyCoroutineContext,
timeoutInMs: Long = DEFAULT_TIMEOUT // 默认 5000ms
): LiveData<T> = liveData(context, timeoutInMs) {
collect { // 这个块不会立刻执行,等 LiveData 变 active
emit(it) // 上游每来一个值,就交给 LiveData
}
}.also { liveData ->
val flow = this
if (flow is StateFlow<T>) { // StateFlow 有初值,单独照顾(后文讲)
if (ArchTaskExecutor.getInstance().isMainThread) {
liveData.value = flow.value // 主线程直接设
} else {
liveData.postValue(flow.value) // 非主线程抛到主线程
}
}
}
原理:注意那个 collect { emit(it) } 是一个 suspend lambda,此刻它只是一段"待执行的代码",没有启动任何协程。谁来决定它什么时候跑?往下看。
三、第二层:liveData 构建器 ------ 造一个 CoroutineLiveData
概念:liveData 是个普通工厂,没有任何搬运逻辑,直接 new 出一个 CoroutineLiveData。
kotlin
// CoroutineLiveData.kt
@JvmOverloads
public fun <T> liveData(
context: CoroutineContext = EmptyCoroutineContext,
timeoutInMs: Long = DEFAULT_TIMEOUT,
block: suspend LiveDataScope<T>.() -> Unit
): LiveData<T> = CoroutineLiveData(context, timeoutInMs, block)
原理:这里的 block 就是上一层传进来的 { collect { emit(it) } }。它被原封不动交给引擎保管。至此,asLiveData 的活基本干完了------接下来全是 CoroutineLiveData 的事。
四、第三层:CoroutineLiveData ------ 真正的引擎
概念:它继承 MediatorLiveData,本体不存 Flow,只存三样东西:一个协程作用域 scope、一个执行器 BlockRunner、以及那个待执行的 block。
kotlin
// CoroutineLiveData.kt(精简,注释已译为中文)
internal class CoroutineLiveData<T>(
context: CoroutineContext = EmptyCoroutineContext,
timeoutInMs: Long = DEFAULT_TIMEOUT,
block: Block<T> // 就是 { collect { emit(it) } }
) : MediatorLiveData<T>() {
private var blockRunner: BlockRunner<T>?
init {
// 用一层 SupervisorJob 隔离:失活时只取消本次运行,不牵连传入的父 context
val supervisorJob = SupervisorJob(context[Job])
// 默认跑在 Main.immediate,调用方可用 context 覆盖(比如切到 IO)
val scope = CoroutineScope(Dispatchers.Main.immediate + context + supervisorJob)
blockRunner = BlockRunner(this, block, timeoutInMs, scope) {
blockRunner = null // block 正常结束(或非失活取消)后,执行器作废
}
}
override fun onActive() {
super.onActive()
blockRunner?.maybeRun() // 有观察者了 → 启动 collect
}
override fun onInactive() {
super.onInactive()
blockRunner?.cancel() // 没人看了 → 准备取消
}
}
原理:这三行是整个设计的地基。
- 继承
MediatorLiveData:为了复用addSource/removeSource,给emitSource用。 SupervisorJob(context[Job]):如果直接把外部context拿来做父 Job,失活取消时会把调用方(如viewModelScope)也一起取消;加一层隔离后,取消只作用于本次 collect 运行。Dispatchers.Main.immediate打底:保证 emit 回写数据天然在主线程,省去手动切线程。
五、生命周期才是开关:collect 何时开始、何时停止
概念:BlockRunner 是引擎里的"司机",它管两个 Job------正在收集数据的 runningJob,和延迟取消用的 cancellationJob。
kotlin
// BlockRunner(精简,注释已译为中文)
internal class BlockRunner<T>(...) {
private var runningJob: Job? = null // 正在跑的 collect 协程
private var cancellationJob: Job? = null // 延迟取消任务
@MainThread
fun maybeRun() {
cancellationJob?.cancel() // 失活后又激活:撤销那次还没触发的取消
cancellationJob = null
if (runningJob != null) return // 已经在收集,别重复启动
runningJob = scope.launch {
val liveDataScope = LiveDataScopeImpl(liveData, coroutineContext)
block(liveDataScope) // ★ 此刻才真正执行 collect
onDone() // 正常结束,引擎作废
}
}
@MainThread
fun cancel() {
cancellationJob = scope.launch(Dispatchers.Main.immediate) {
delay(timeoutInMs) // 先等 5 秒
if (!liveData.hasActiveObservers()) { // 再确认一次仍没人观察
runningJob?.cancel() // 真的取消 collect
runningJob = null
}
}
}
}
原理:这段解释了两个最常见的疑惑。
为什么转个屏不会导致重复请求? 屏幕旋转时旧 Activity 的观察者短暂离开,onInactive 触发 cancel(),但它不立刻取消,而是 delay(5000)。如果新 Activity 在 5 秒内重新订阅,onActive 里的 maybeRun() 会先 cancellationJob?.cancel() 把这次取消撤掉,而 runningJob 一直在跑------于是收集无缝续上,数据不丢、请求不重。
为什么有时候数据"卡住"要等 5 秒? 如果观察者离开超过 5 秒,取消真正生效,runningJob 被干掉;等下次再 active,maybeRun() 从头启动 block,Flow 从零重新收集。这就是网上那篇"Flow 收不到更新,改成 timeoutInMs = 0 就好了"的根因------超时到了、收集被取消、重新订阅才重启。
链路串起来就是:
scss
observe 激活 → onActive → maybeRun → launch{ collect } → emit → 主线程 setValue
observe 离开 → onInactive → cancel → delay(5s) → 仍无观察者 → runningJob.cancel()
↖ 5 秒内重新激活 → maybeRun 撤销取消 → 无缝续上
六、emit:数据怎么安全回到主线程
概念:block 里的 emit(it) 来自 LiveDataScopeImpl,它不是直接写 LiveData,而是先切回主线程再写。
kotlin
// LiveDataScopeImpl(精简,注释已译为中文)
internal class LiveDataScopeImpl<T>(
internal var target: CoroutineLiveData<T>,
context: CoroutineContext
) : LiveDataScope<T> {
// 用构建器的 context + Main.immediate 与目标 LiveData 通信
private val coroutineContext = context + Dispatchers.Main.immediate
override suspend fun emit(value: T) = withContext(coroutineContext) {
target.clearSource() // 若之前 emitSource 过,先把那个源移除
target.value = value // 最终落到 MutableLiveData.setValue(主线程)
}
}
原理:withContext 做了两件事------保证主线程安全 (LiveData 的 setValue 必须在主线程),以及配合取消 (withContext 是可取消的挂起点,协程被取消后即使 emit 也不会再把值写进 LiveData,这正对应文档里那句"被取消的 block 发出的值会被忽略")。
七、StateFlow 的"插队":初值立即到位
概念:普通 Flow 是冷流,没有值要等 collect;StateFlow 天生有 value,如果也等 active 才 collect,页面一上来就会先看到一段空数据。
原理:所以 asLiveData 在 .also 里对 StateFlow 单独开小灶------构造 LiveData 的当下 就把 flow.value 同步进去(主线程用 value,非主线程用 postValue)。这个初值和生命周期无关,只求首屏不闪空。
scss
val stateFlow = MutableStateFlow(0) // 初值 0
val liveData = stateFlow.asLiveData()
// liveData.value 立刻就是 0,不必等 observe
八、两个参数,两个坑
概念:asLiveData 只有两个参数,但都值得说道。
context:决定在哪收集。 默认是 EmptyCoroutineContext,最终被 Dispatchers.Main.immediate 打底,意味着 collect 默认在主线程执行。如果上游有耗时操作,两种正确做法:
scss
// 做法一:用 flowOn 把上游切到 IO(推荐,职责清晰)
val user = repository.flowUser(id)
.flowOn(Dispatchers.IO)
.asLiveData()
// 做法二:用 context 指定(注意此时 emit 仍会被强制切回 Main)
val user = flow.asLiveData(context = viewModelScope.coroutineContext + Dispatchers.IO)
另外,传 viewModelScope.coroutineContext 还有个隐藏好处:ViewModel 销毁时上游 Flow 会自动取消,不用等 LiveData 失活的 5 秒超时。
timeoutInMs:决定失活后等多久取消。 默认 5000ms 是为旋转屏幕这类短暂失活留的缓冲。调小 → 更快释放资源、更少无效 emit,但旋转屏更容易触发重收集;调大 → 更抗抖动,但没人看时协程多活一会儿。设成 0 就是"失活立刻取消"。
九、小结:一句话记住整条链路
asLiveData 把 Flow 包成一个 collect 块,交给 CoroutineLiveData;后者继承 MediatorLiveData,用 BlockRunner 把"收集"这件事挂到生命周期上------active 才开始、inactive 延迟 5 秒再取消、emit 全程回主线程;StateFlow 额外同步一个初值。
所谓"转换",转的从来不是数据,而是控制权:把 Flow 的收集时机,交给了 LiveData 的生命周期。
参考源码:AndroidX lifecycle-livedata 2.7.0 中的 FlowLiveData.kt 与 CoroutineLiveData.kt。