(译) LiveData 概览

原文链接

LiveData 是一个可观察的数据持有者类。与常规可观察对象不同,LiveData是具有生命周期感知力的,这意味着它重视其它应用程序组件的生命周期,例如 Activity ,Fragment 或 Service。这种对生命周期的感知能力,确保 LiveData 仅更新处于活动生命周期状态的应用程序组件观察者。

注意:要将 LiveData 组件导入 Android 项目,请参阅向项目添加组件

如果 Observer 类表示的观察者的生命周期处于 STARTED 或 RESUMED 状态,则LiveData 会将其视为处于活动状态。 LiveData 仅通知活动的观察者有关更新的信息。注册观察 LiveData 对象的非活动观察者不会收到有关更改的通知。

你可以注册与实现 LifecycleOwner 接口的对象配对的观察者。此关系允许在相应Lifecycle 对象的状态更改为 DESTROYED 时移除观察者。这对于 Activity 和 Fragment 特别有用,因为它们可以安全地观察 LiveData 对象而不用担心泄漏 - Activity 和 Fragment 在其生命周期被销毁时立即取消订阅。

有关如何使用 LiveData 的详细信息,请参阅使用 LiveData 对象。

使用 LiveData 的优势

使用 LiveData 具有以下优势:

确保 UI 跟数据状态匹配

LiveData 遵循观察者模式。生命周期状态更改时,LiveData 会通知 Observer 对象。你可以合并你的更新 UI 的代码放到这些观察者对象中去。每当应用程序数据变化时,你的观察者可以替你更新 UI,而不是每当数据变化的时候去各自的地方更新 UI。

没有内存泄漏

观察者被绑定到 Lifecycle 对象,并在其相关的 Lifecycle 被销毁后自行清理。

没有因停止状态的 Activity 而产生的崩溃

如果观察者的生命周期处于非活动状态,例如 Activity 在处于后台堆栈的情况下,它就不会收到任何 LiveData 事件。

不再需要手动的生命周期处理

UI 组件只是观察相关数据,不会停止或恢复观察。 LiveData 自动管理所有这些,因为它在观察时意识到了相关的生命周期状态变化。

始终保持最新数据

如果一个 lifecycle 变为非活动状态,它将在再次变为活动状态时接收最新数据。例如,后台 Activity 在返回前台后,立即接收到最新数据。

适当的配置更改

如果由于配置更改(例如设备转向)而重新创建 Activity 或 Fragment ,则会立即接收最新的可用数据。

共享资源

你可以使用单例模式扩展 LiveData 对象以包装系统服务,以便可以在应用程序中共享它们。 LiveData 对象连接到系统服务一次,然后任何需要该资源的观察者都可以只观察 LiveData 对象。有关更多信息,请参阅扩展 LiveData

使用 LiveData 对象

请按照以下步骤使用 LiveData 对象:

  • 创建 LiveData 实例以保存特定类型的数据。这通常在你的 ViewModel 类中完成。

  • 创建一个 Observer 对象,该对象定义了 onChanged() 方法,该方法控制了 LiveData 对象持有的数据变化时发生什么事情。你通常在 UI 控制器(例如 Activity 或 Fragment )中创建一个 Observer 对象。

  • 使用 observe() 方法将 Observer 对象附加到 LiveData 对象。 observe()方法的入参是 一个 LifecycleOwner 对象。这个对象使 Observer 对象订阅了 LiveData 对象,以便通知它更改。你通常将 Observer 对象附加到 UI 控制器中,例如 Activity 或 Fragment。

注意:你可以使用 observeForever(Observer)方法注册没有关联的 LifecycleOwner 对象的观察者。在这种情况下,观察者被认为始终处于活动状态,因此始终会收到有关修改的通知。你可以通过调用 removeObserver(Observer)移除这些观察者。

更新存储在 LiveData 对象中的值时,只要附加的 LifecycleOwner 处于活动状态,它就会触发所有已注册的观察者。

LiveData 允许 UI 控制器观察者订阅更新。当 LiveData 对象持有的数据发生更改时,UI会自动更新做出响应。

创建 LiveData 对象

LiveData 是一个可以与任何数据一起使用的包装,包括实现 Collections 的对象,例如ListLiveData 对象通常存储在 ViewModel 对象中,并通过 getter 方法访问,如以下示例所示:

1
2
3
4
5
6
7
8
9
class NameViewModel : ViewModel() {

// Create a LiveData with a String
val currentName: MutableLiveData<String> by lazy {
MutableLiveData<String>()
}

// Rest of the ViewModel...
}

最初,LiveData 对象中的数据没有被设置。

注意:确保更新UI的 LiveData 对象是存储在 ViewModel 对象中,而不是Activity 或 Fragment,原因如下:

  • 避免臃肿的 Activty 和 Fragment。现在,这些UI控制器负责显示数据但不持有数据状态。
  • LiveData 实例与特定 Activity 或 Fragment 实例解耦,并允许 LiveData 对象在配置更改后继续存在。

你可以在 ViewModel 指南 中阅读有关 ViewModel 类的优点和用法的更多信息。

观察 LiveData 对象

在大多数情况下,应用组件的 onCreate() 方法是开始观察 LiveData 对象的正确位置,原因如下:

  • 确保系统不会 从Activity 或 Fragment 的onResume()方法进行冗余调用。
  • 确保 Activity 或 Fragment 具有可在其变为活动状态时立即显示的数据。只要应用程序组件处于 STARTED 状态,它就会从它正在观察的 LiveData 对象中接收最新值。只有在设置了要观察的 LiveData 对象时才会出现这种情况。

通常,LiveData 仅在数据更改时才提供更新,并且仅对处于活动状态的观察者时提供更新。此行为的一个例外是,观察者在从非活动状态更改为活动状态时也会收到更新。此外,如果观察者第二次从非活动状态变为活动状态,自上次变为活动状态之后,它只有在值发生变化时才会接受到更新。

以下示例代码说明了如何开始观察一个 LiveData 对象:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class NameActivity : AppCompatActivity() {

private lateinit var model: NameViewModel

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)

// Other code to setup the activity...

// Get the ViewModel.
model = ViewModelProviders.of(this).get(NameViewModel::class.java)


// Create the observer which updates the UI.
val nameObserver = Observer<String> { newName ->
// Update the UI, in this case, a TextView.
nameTextView.text = newName
}

// Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
model.currentName.observe(this, nameObserver)
}
}

在使用 nameObserver 作为参数传递调用 observe() 之后,立即调用 onChanged(),提供存储在 mCurrentName 中的最新值。如果 LiveData 对象未在 mCurrentName 中设置值,则不会调用onChanged()。

更新LiveData对象

LiveData 没有公开的方法来更新存储的数据。 MutableLiveData 类公开公开 setValue(T)postValue(T) 方法,如果需要编辑存储在LiveData对象中的值,则必须使用这些方法。通常在 MutableLiveData 是在 ViewModel 中使用的,然后 ViewModel 仅向观察者公开不可变的 LiveData 对象。

设置观察者关系后,可以更新 LiveData 对象的值,如以下示例所示,当用户点击按钮时触发所有观察者:

1
2
3
4
button.setOnClickListener {
val anotherName = "John Doe"
model.currentName.setValue(anotherName)
}

在示例中调用 setValue(T)会导致观察者使用值 John Doe 调用其 onChanged()方法。该示例显示按下按钮,但可以调用 setValue() 或postValue() 来更新 mName,原因有多种,包括响应网络请求或数据库加载完成;在所有情况下,对setValue() 或 postValue() 的调用都会触发观察者并更新UI。

注意:必须调用 setValue(T) 方法才能从主线程更新 LiveData 对象。如果代码在工作线程中执行,则可以使用 postValue(T)方法来更新 LiveData 对象。

将 LiveData 与 Room 一起使用

Room持久性库支持可观察的查询,这些查询返回LiveData对象。可观察查询作为数据库访问对象(DAO)的一部分编写。

在更新数据库时,Room会生成更新LiveData对象所需的所有代码。生成的代码在需要时在后台线程上异步运行查询。此模式对于使UI中显示的数据与存储在数据库中的数据保持同步非常有用。您可以在Room持久性库指南中阅读有关Room和DAO的更多信息。

将协程与 LiveData 一起使用

LiveData 包括对 Kotlin 协程 的支持。有关更多信息,请参阅将 Kotlin 协程 与Android 体系结构组件一起使用

扩展 LiveData

如果观察者的生命周期处于 STARTEDRESUMED 状态,LiveData 会将观察者视为处于活动状态。以下示例代码说明了如何扩展 LiveData 类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
private val stockManager = StockManager(symbol)

private val listener = { price: BigDecimal ->
value = price
}

override fun onActive() {
stockManager.requestPriceUpdates(listener)
}

override fun onInactive() {
stockManager.removeUpdates(listener)
}
}

此示例中价格监听器的实现包括以下重要方法:

  • 当 LiveData 对象具有活动观察者时,onActive() 方法将被调用。这意味着你需要从此方法开始观察股票价格更新。
  • 当 LiveData 对象没有任何活动观察者时,onInactive() 方法将被调用。由于没有观察者正在监听,因此没有理由保持与 StockManager 服务的连接。
  • setValue(T) 方法更新 LiveData 实例的值,并通知所有活动观察者有关更改的信息。

你可以像下面这样使用 StockLiveData

1
2
3
4
5
6
7
override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)
val myPriceListener: LiveData<BigDecimal> = ...
myPriceListener.observe(this, Observer<BigDecimal> { price: BigDecimal? ->
// Update the UI.
})
}

observe() 方法将 fragment( LifecycleOwner 的一个实例)作为第一个参数传递。这样做表示此观察者绑定到与所有者关联的 Lifecycle 对象,这意味着:

  • 如果 Lifecycle 对象未处于活动状态,则即使值发生更改,也不会调用观察者。
  • 销毁 Lifecycle 对象后,会自动删除观察者。

LiveData 对象可感知生命周期这一事实意味着你可以在多个 Activity,Fragment 和 Service 之间共享它们。为了简化示例,你可以将 LiveData 类实现为单例,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
private val stockManager: StockManager = StockManager(symbol)

private val listener = { price: BigDecimal ->
value = price
}

override fun onActive() {
stockManager.requestPriceUpdates(listener)
}

override fun onInactive() {
stockManager.removeUpdates(listener)
}

companion object {
private lateinit var sInstance: StockLiveData

@MainThread
fun get(symbol: String): StockLiveData {
sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol)
return sInstance
}
}
}

你可以在 Fragment 中使用它,如下所示:

1
2
3
4
5
6
7
8
class MyFragment : Fragment() {

override fun onActivityCreated(savedInstanceState: Bundle?) {
StockLiveData.get(symbol).observe(this, Observer<BigDecimal> { price: BigDecimal? ->
// Update the UI.
})

}

多个 Fragment 和 Activity 可以观察 MyPriceListener 实例。 LiveData 仅在系统服务中的一个或多个可见且处于活动状态时才连接到系统服务。

转换 LiveData

你可能希望在将 LiveData 对象分派给观察者之前更改存储在 LiveData 对象中的值,或者你可能需要根据另一个 LiveData 对象的值返回不同的 LiveData 实例。 Lifecycle 包提供 Transformations 类,其中包括支持这些方案的帮助程序方法。

Transformations.map()

对存储在 LiveData 对象中的值应用函数,并将结果传播到下游。

1
2
3
4
val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> = Transformations.map(userLiveData) {
user -> "${user.name} ${user.lastName}"
}

Transformations.switchMap()

map() 类似,将函数应用于存储在 LiveData 对象中的值,并将结果解包并发送到下游。传递给 switchMap() 的函数必须返回一个 LiveData 对象,如以下示例所示:

1
2
3
4
5
private fun getUser(id: String): LiveData<User> {
...
}
val userId: LiveData<String> = ...
val user = Transformations.switchMap(userId) { id -> getUser(id) }

你可以使用转换方法在观察者的生命周期中传递信息。除非观察者正在观察返回的 LiveData 对象,否则不会计算变换。由于转换是延迟计算的,因此生命周期相关的行为会被隐式传递下去,而不需要额外的显式调用或依赖项。

如果你认为在 ViewModel 对象中需要 Lifecycle 对象,则转换可能是更好的解决方案。例如,假设你有一个接受地址的 UI 组件并返回该地址的邮政编码。您可以为此组件实现朴素的ViewModel,如以下示例代码所示:

1
2
3
4
5
6
7
class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {

private fun getPostalCode(address: String): LiveData<String> {
// DON'T DO THIS
return repository.getPostCode(address)
}
}

然后,UI 组件需要从先前的 LiveData 对象取消注册,并在每次调用getPostalCode() 时注册到新实例。此外,如果重新创建UI组件,它将触发对 repository.getPostCode() 方法的另一次调用,而不是使用先前调用的结果。

相反,您可以将邮政编码查找实现为地址输入的转换,如以下示例所示:

1
2
3
4
5
6
7
8
9
10
class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {
private val addressInput = MutableLiveData<String>()
val postalCode: LiveData<String> = Transformations.switchMap(addressInput) {
address -> repository.getPostCode(address) }


private fun setInput(address: String) {
addressInput.value = address
}
}

在这种情况下,postalCode 字段被定义为 addressInput 的转换。只要你的应用程序具有与 postalCode 字段关联的活动观察者,只要 addressInput 更改,就会重新计算并检索字段的值。

此机制允许较低级别的应用程序创建按需延迟计算的 LiveData 对象。 ViewModel 对象可以轻松获取对 LiveData 对象的引用,然后在它们之上定义转换规则。

创建新的转换

有十几种不同的特定转换可能对你的应用有用,但默认情况下不提供。要实现自己的转换,可以使用 MediatorLiveData 类,该类监听其他 LiveData 对象并处理它们发出的事件。 MediatorLiveData 正确地将其状态传播到源 LiveData 对象。要了解有关此模式的更多信息,请参阅 Transformations 类的参考文档。

合并多个 LiveData 源

MediatorLiveData 是 LiveData 的子类,允许你合并多个 LiveData 源。只要任何原始LiveData 源对象发生更改,就会触发 MediatorLiveData 对象的观察者。

例如,如果 UI 中有可以从本地数据库或网络更新的 LiveData 对象,则可以将以下源添加到MediatorLiveData 对象:

  • 与存储在数据库中的数据关联的 LiveData 对象。
  • 与从网络访问的数据关联的 LiveData 对象。

你的 Activity 只需要观察 MediatorLiveData 对象以从两个源接收更新。有关详细示例,请参阅“应用程序体系结构指南”中的“附录:暴露网络状态”部分。

非典型前端coder wechat
想要随时Follow我的最新博客,可扫码关注我的公众号