Android 开发技术——从 LiveData 迁移到 Kotlin 数据流，安卓app开发软件工具

△ 把一次性操作的结果暴露出来 (LiveData)

class MyViewModel(…) : ViewModel() {

val result: LiveData<Result> = liveData {

emit(Result.Loading)

emit(repository.fetchItem())

}

}

由于状态容器总是有值的，那么我们就可以通过某种 Result 类来把 UI 状态封装起来，比如加载中、成功、错误等状态。

与之对应的数据流方式则需要您多做一点_配置_:

△ 把一次性操作的结果暴露出来 (StateFlow)

class MyViewModel(…) : ViewModel() {

val result: StateFlow<Result> = flow {

emit(repository.fetchItem())

}.stateIn(

scope = viewModelScope,

started = WhileSubscribed(5000), //由于是一次性操作，也可以使用 Lazily

initialValue = Result.Loading

)

}

stateIn 是专门将数据流转换为 StateFlow 的运算符。由于需要通过更复杂的示例才能更好地解释它，所以这里暂且把这些参数放在一边。

#3: 带参数的一次性数据加载

比方说您想要加载一些依赖用户 ID 的数据，而信息来自一个提供数据流的 AuthManager:

△ 带参数的一次性数据加载 (LiveData)

使用 LiveData 时，您可以用类似这样的代码:

class MyViewModel(authManager…, repository…) : ViewModel() {

private val userId: LiveData<String?> =

authManager.observeUser().map { user -> user.id }.asLiveData()

val result: LiveData<Result> = userId.switchMap { newUserId ->

liveData { emit(repository.fetchItem(newUserId)) }

}

}

switchMap 是数据变换中的一种，它订阅了 userId 的变化，并且其代码体会在感知到 userId 变化时执行。

如非必须要将 userId 作为 LiveData 使用，那么更好的方案是将流式数据和 Flow 结合，并将最终的结果 (result) 转化为 LiveData。

class MyViewModel(authManager…, repository…) : ViewModel() {

private val userId: Flow = authManager.observeUser().map { user -> user.id }

val result: LiveData<Result> = userId.mapLatest { newUserId ->

repository.fetchItem(newUserId)

}.asLiveData()

}

如果改用 Kotlin Flow 来编写，代码其实似曾相识:

△ 带参数的一次性数据加载 (StateFlow)

class MyViewModel(authManager…, repository…) : ViewModel() {

private val userId: Flow = authManager.observeUser().map { user -> user.id }

val result: StateFlow<Result> = userId.mapLatest { newUserId ->

repository.fetchItem(newUserId)

}.stateIn(

scope = viewModelScope,

started = WhileSubscribed(5000),

initialValue = Result.Loading

)

}

假如说您想要更高的灵活性，可以考虑显式调用 transformLatest 和 emit 方法:

val result = userId.transformLatest { newUserId ->

emit(Result.LoadingData)

emit(repository.fetchItem(newUserId))

}.stateIn(

scope = viewModelScope,

started = WhileSubscribed(5000),

initialValue = Result.LoadingUser //注意此处不同的加载状态

)

#4: 观察带参数的数据流

接下来我们让刚才的案例变得更具交互性。数据不再被读取，而是被观察，因此我们对数据源的改动会直接被传递到 UI 界面中。

继续刚才的例子: 我们不再对源数据调用 fetchItem 方法，而是通过假定的 observeItem 方法获取一个 Kotlin 数据流。

若使用 LiveData，可以将数据流转换为 LiveData 实例，然后通过 emitSource 传递数据的变化。

△ 观察带参数的数据流 (LiveData)

class MyViewModel(authManager…, repository…) : ViewModel() {

private val userId: LiveData<String?> =

authManager.observeUser().map { user -> user.id }.asLiveData()

val result = userId.switchMap { newUserId ->

repository.observeItem(newUserId).asLiveData()

}

}

或者采用更推荐的方式，把两个流通过 flatMapLatest 结合起来，并且仅将最后的输出转换为 LiveData:

class MyViewModel(authManager…, repository…) : ViewModel() {

private val userId: Flow<String?> =

authManager.observeUser().map { user -> user?.id }

val result: LiveData<Result> = userId.flatMapLatest { newUserId ->

repository.observeItem(newUserId)

}.asLiveData()

}

使用 Kotlin 数据流的实现方式非常相似，但是省下了 LiveData 的转换过程:

△ 观察带参数的数据流 (StateFlow)

class MyViewModel(authManager…, repository…) : ViewModel() {

private val userId: Flow<String?> =

authManager.observeUser().map { user -> user?.id }

val result: StateFlow<Result> = userId.flatMapLatest { newUserId ->

repository.observeItem(newUserId)

}.stateIn(

scope = viewModelScope,

started = WhileSubscribed(5000),

initialValue = Result.LoadingUser

)

}

每当用户实例变化，或者是存储区 (repository) 中用户的数据发生变化时，上面代码中暴露出来的 StateFlow 都会收到相应的更新信息。

#5: 结合多种源: MediatorLiveData -> Flow.combine

MediatorLiveData 允许您观察一个或多个数据源的变化情况，并根据得到的新数据进行相应的操作。通常可以按照下面的方式更新 MediatorLiveData 的值:

val liveData1: LiveData = …

val liveData2: LiveData = …

val result = MediatorLiveData()

result.addSource(liveData1) { value ->

result.setValue(liveData1.value ?: 0 + (liveData2.value ?: 0))

}

result.addSource(liveData2) { value ->

result.setValue(liveData1.value ?: 0 + (liveData2.value ?: 0))

}

同样的功能使用 Kotlin 数据流来操作会更加直接:

val flow1: Flow = …

val flow2: Flow = …

val result = combine(flow1, flow2) { a, b -> a + b }

此处也可以使用 combineTransform 或者 zip 函数。

通过 stateIn 配置对外暴露的 StateFlow

---

早前我们使用 stateIn 中间运算符来把普通的流转换成 StateFlow，但转换之后还需要一些配置工作。如果现在不想了解太多细节，只是想知道怎么用，那么可以使用下面的推荐配置:

val result: StateFlow<Result> = someFlow

.stateIn(

scope = viewModelScope,

started = WhileSubscribed(5000),

initialValue = Result.Loading

)

不过，如果您想知道为什么会使用这个看似随机的 5 秒的 started 参数，请继续往下读。

根据文档，stateIn 有三个参数:‍

@param scope 共享开始时所在的协程作用域范围

@param started 控制共享的开始和结束的策略

@param initialValue 状态流的初始值

当使用 [SharingStarted.WhileSubscribed] 并带有 replayExpirationMillis 参数重置状态流时，也会用到 initialValue。

started 接受以下的三个值:

• Lazily: 当首个订阅者出现时开始，在 scope 指定的作用域被结束时终止。

• Eagerly: 立即开始，而在 scope 指定的作用域被结束时终止。

• WhileSubscribed: 这种情况有些复杂 (后文详聊)。

对于那些只执行一次的操作，您可以使用 Lazily 或者 Eagerly。然而，如果您需要观察其他的流，就应该使用 WhileSubscribed 来实现细微但又重要的优化工作，参见后文的解答。

WhileSubscribed 策略

---

WhileSubscribed 策略会在没有收集器的情况下取消上游数据流。通过 stateIn 运算符创建的 StateFlow 会把数据暴露给视图 (View)，同时也会观察来自其他层级或者是上游应用的数据流。让这些流持续活跃可能会引起不必要的资源浪费，例如一直通过从数据库连接、硬件传感器中读取数据等等。当您的应用转而在后台运行时，您应当保持克制并中止这些协程。

WhileSubscribed 接受两个参数:

public fun WhileSubscribed(

stopTimeoutMillis: Long = 0,

replayExpirationMillis: Long = Long.MAX_VALUE

)

超时停止

根据其文档:

stopTimeoutMillis 控制一个以毫秒为单位的延迟值，指的是最后一个订阅者结束订阅与停止上游流的时间差。默认值是 0 (立即停止)。

这个值非常有用，因为您可能并不想因为视图有几秒钟不再监听就结束上游流。这种情况非常常见——比如当用户旋转设备时，原来的视图会先被销毁，然后数秒钟内重建。

liveData 协程构建器所使用的方法是 添加一个 5 秒钟的延迟，即如果等待 5 秒后仍然没有订阅者存在就终止协程。前文代码中的 WhileSubscribed (5000) 正是实现这样的功能:

class MyViewModel(…) : ViewModel() {

val result = userId.mapLatest { newUserId ->

repository.observeItem(newUserId)

}.stateIn(

scope = viewModelScope,

started = WhileSubscribed(5000),

initialValue = Result.Loading

)

}

这种方法会在以下场景得到体现:

• 用户将您的应用转至后台运行，5 秒钟后所有来自其他层的数据更新会停止，这样可以节省电量。

• 最新的数据仍然会被缓存，所以当用户切换回应用时，视图立即就可以得到数据进行渲染。

• 订阅将被重启，新数据会填充进来，当数据可用时更新视图。

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

数据重现的过期时间*

如果用户离开应用太久，此时您不想让用户看到陈旧的数据，并且希望显示数据正在加载中，那么就应该在 WhileSubscribed 策略中使用 replayExpirationMillis 参数。在这种情况下此参数非常适合，由于缓存的数据都恢复成了 stateIn 中定义的初始值，因此可以有效节省内存。虽然用户切回应用时可能没那么快显示有效数据，但至少不会把过期的信息显示出来。

replayExpirationMillis 配置了以毫秒为单位的延迟时间，定义了从停止共享协程到重置缓存 (恢复到 stateIn 运算符中定义的初始值 initialValue) 所需要等待的时间。它的默认值是长整型的最大值 Long.MAX_VALUE (表示永远不将其重置)。如果设置为 0，可以在符合条件时立即重置缓存的数据。

从视图中观察 StateFlow

---

我们此前已经谈到，ViewModel 中的 StateFlow 需要知道它们已经不再需要监听。然而，当所有的这些内容都与生命周期 (lifecycle) 结合起来，事情就没那么简单了。

要收集一个数据流，就需要用到协程。Activity 和 Fragment 提供了若干协程构建器:

• Activity.lifecycleScope.launch : 立即启动协程，并且在本 Activity 销毁时结束协程。

• Fragment.lifecycleScope.launch : 立即启动协程，并且在本 Fragment 销毁时结束协程。

• Fragment.viewLifecycleOwner.lifecycleScope.launch : 立即启动协程，并且在本 Fragment 中的视图生命周期结束时取消协程。

LaunchWhenStarted 和 LaunchWhenResumed

---

对于一个状态 X，有专门的 launch 方法称为 launchWhenX。它会在 lifecycleOwner 进入 X 状态之前一直等待，又在离开 X 状态时挂起协程。对此，需要注意对应的协程只有在它们的生命周期所有者被销毁时才会被取消。

△ 使用 launch/launchWhenX 来收集数据流是不安全的

当应用在后台运行时接收数据更新可能会引起应用崩溃，但这种情况可以通过将视图的数据流收集操作挂起来解决。然而，上游数据流会在应用后台运行期间保持活跃，因此可能浪费一定的资源。

这么说来，目前我们对 StateFlow 所进行的配置都是无用功；不过，现在有了一个新的 API。

lifecycle.repeatOnLifecycle 前来救场

---

这个新的协程构建器 (自 lifecycle-runtime-ktx 2.4.0-alpha01 后可用) 恰好能满足我们的需要: 在某个特定的状态满足时启动协程，并且在生命周期所有者退出该状态时停止协程。