一行 asLiveData,背后是一座生命周期的桥

基于 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。

相关推荐
用户93381043484515 分钟前
MyBatis-Plus LambdaQueryWrapper 隐式转换踩坑:不知不觉索引失效
java
用户37215742613522 分钟前
Java 在 PDF 中查找关键词:获取页码和坐标,并高亮匹配结果
java
Forget the Dream1 小时前
Spring AI 2.0 系列(三):ChatClient 与 ChatModel:Spring AI 2.0 的两层职责
java·人工智能·spring·springai
阿杰m1 小时前
Android源码第二十三章:Telephony、RIL 与 IMS——来电怎么到应用?
android
booboosui1 小时前
没人认领 .md:安卓把报告交给了音乐播放器打开
android
Rain的Java大神之路2 小时前
把数组本身变成哈希表:原地哈希搞定 LeetCode 41「缺失的第一个正数」
java·后端·leetcode
山楂树の2 小时前
Java 泛型:泛型类、泛型方法、泛型接口与通配符
java·开发语言·笔记
跳跳的小古风3 小时前
前端转全栈:一条接口从前端请求到 SQL 完整流程
java·前端
用户60709759149064 小时前
AOSP 14 OTA 升级指导(四):update_engine 内部机制——Action 流水线与写盘
android