一、Android Jetpack简介
Android官网对Jetpack的介绍如下：
Jetpack is a suite of libraries to help developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions and devices so that developers can focus on the code they care about.
可见Jetpack是一个由多个库组成的套件，使用这个套件可以帮助开发者：
- 遵循最佳实践：
Jetpack提供的组件基于最新的设计方法构建，可以减少崩溃和内存泄漏等问题的出现； - 减少样板代码：
Jetpack提供的组件提供对繁琐的生命周期、后台任务的管理，帮助开发者实现可维护的代码； - 减少差异：实现在不同版本和设备上表现一致的应用，开发者可以集中精力编写对他们来说真正重要的代码，而不是各种版本兼容的代码。
Android官网上对Jetpack组成部分的分类如下图所示（最新官网无下图）：
Android提供的Jetpack一共分为四个部分：架构、基础、UI和行为，其中Android Architecture Component是各个应用使用最多的部分，通常在工程中使用Lifecycle、LiveData以及ViewModel来实现MVVM架构，因此下面会这三个组件进行分析，《浅析Android Jetpack ACC之Lifecycle》对Lifecycle这个生命周期感知型组件进行了分析，本文接着对LiveData这个感知生命周期的数据存储组件进行分析。
二、LiveData-感知生命周期的数据源
1. 作用目的
LiveData组件是一种可观察的数据容器类，并且具备感知Activity等组件的生命周期状态的能力，保证只在Activity等组件处于活跃状态时才会通知观察者已经发生的数据变更。由此可见，借助LiveData组件可以简化UI与数据源之间的同步逻辑，实现安全可靠的数据驱动UI刷新的效果。
不使用LiveData组件实现展示位置的页面，通常会借助MVP架构进行设计实现：
class MVPLocationActivity : ComponentActivity(), IView {
private val locationPresenter = LocationPresenter(this)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_location)
}
override fun onStart() {
super.onStart()
locationPresenter.startLocation()
}
override fun onStop() {
super.onStop()
locationPresenter.stopLocation()
}
override fun updateLocation(location: LocationImpl.Location) {
// update location
}
}
class LocationPresenter(private val view: IView) : ILocationPresenter {
override fun startLocation() {
// locate on worker thread
LocationImpl.startLocation(object : LocationImpl.LocationListener {
override fun onLocationChanged(location: LocationImpl.Location) {
Handler(Looper.getMainLooper()).post {
view.updateLocation(location)
}
}
})
}
override fun stopLocation() {
// stop locate on worker thread
LocationImpl.stopLocation()
}
}
可以看出这种实现方式存在View层和Presenter层互相耦合的问题，同时需要在Activity 的生命周期方法中写业务逻辑。下面看下使用LiveData组件进行实现的代码，从中可以发现View层和Presenter层不需要通过接口的方式进行互相耦合，从而简化了代码实现，并且避免了接口臃肿的问题。
2. 使用示例
LiveData组件的使用步骤包括：
- 创建
LiveData实例并指明数据类型； - 创建
Observer实例并定义数据发生变化时的处理逻辑； - 通过
LiveData#observe方法注册已创建的Observer实例并传入LifecycleOwner实例； - 数据发生变化后调用
LiveData#setValue或者LiveData#postValue方法来更新数据；
class LocationActivity : ComponentActivity() {
private val locationData = MutableLiveData<LocationImpl.Location>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_location)
lifecycle.addObserver(LocationObserver(object: LocationImpl.LocationListener {
override fun onLocationChanged(location: LocationImpl.Location) {
// post to main thread
locationData.postValue(location)
}
}))
locationData.observe(this) { location ->
updateLocation(location)
}
}
fun updateLocation(location: LocationImpl.Location) {
// update location
}
}
class LocationObserver(private val locationListener: LocationImpl.LocationListener) : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when (event) {
Lifecycle.Event.ON_START -> {
LocationImpl.startLocation(locationListener)
}
Lifecycle.Event.ON_STOP -> {
LocationImpl.stopLocation()
}
else -> {
// do nothing
}
}
}
}
借助LiveData组件可以避免使用接口来完成View层和Presenter层之间的通信，LiveData组件内部通过观察者模式收敛了这种通信关系，使得业务代码更加简洁明了。
此外，LiveData组件还支持其他高级功能，比如借助Transformations类可以实现在分发给观察者之前对数据进行转换、根据另一个LiveData的值来返回不同的LiveData实例等效果，借助MediatorLiveData可以合并多个LiveData实例，实现只要其中一个LiveData实例发生数据变化，即可通知MediatorLiveData实例的观察者。
3. 实现原理
LiveData组件的实现主要分两部分：注册观察者到LiveData组件上和通过LiveData组件通知观察者数据变化，下面围绕这两个部分分析下具体的源码实现。
3.1 注册观察者到LiveData
/**
* LiveData is a data holder class that can be observed within a given lifecycle.
* This means that an {@link Observer} can be added in a pair with a {@link LifecycleOwner}, and
* this observer will be notified about modifications of the wrapped data only if the paired
* LifecycleOwner is in active state. LifecycleOwner is considered as active, if its state is
* {@link Lifecycle.State#STARTED} or {@link Lifecycle.State#RESUMED}. An observer added via
* {@link #observeForever(Observer)} is considered as always active and thus will be always notified
* about modifications. For those observers, you should manually call
* {@link #removeObserver(Observer)}.
*/
public abstract class LiveData<T> {
private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers = new SafeIterableMap<>();
/**
* Adds the given observer to the observers list within the lifespan of the given
* owner. The events are dispatched on the main thread. If LiveData already has data
* set, it will be delivered to the observer.
* <p>
* The observer will only receive events if the owner is in {@link Lifecycle.State#STARTED}
* or {@link Lifecycle.State#RESUMED} state (active).
* <p>
* If the owner moves to the {@link Lifecycle.State#DESTROYED} state, the observer will
* automatically be removed.
* <p>
* When data changes while the {@code owner} is not active, it will not receive any updates.
* If it becomes active again, it will receive the last available data automatically.
* <p>
*/
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// LifecycleOwner已经销毁，那么没必要再添加观察者了。
return;
}
// 包装成感知生命周期的观察者
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 将观察者和包装后的观察者作为键值对保存到Map中
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
// 如果观察者已经被添加过并且添加到了另一个LifecycleOwner，那么抛异常
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
// 如果观察者已经被添加到同一个LifecycleOwner，那么直接返回
if (existing != null) {
return;
}
// 通过LifecycleOwner将包装后的观察者注册到Lifecycle里，用于感知生命周期
owner.getLifecycle().addObserver(wrapper);
}
// LifecycleBoundObserver实现了LifecycleEventObserver接口，因此可以被添加到Lifecycle用于感知生命周期变化
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
// 当生命周期发生变化之后自动移除Observer
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
}
从源码可以看出，LiveData#observe会将观察者observer包装一层得到LifecycleBoundObserver类型的对象wrapper，因为LifecycleBoundObserver实现了LifecycleEventObserver接口，所以通过向LifecycleOwner注册LifecycleBoundObserver对象来感知生命周期，同时LiveData组件内部会通过Map维护LiveData组件的Observer和注册到LifecycleOwner的LifecycleBoundObserver的键值对。
之后LifecycleBoundObserver对象就可以通过LifecycleBoundObserver#onStateChanged方法感知生命周期变化了，下面主要看下LifecycleBoundObserver#onStateChanged方法的代码实现。
public abstract class LiveData<T> {
@MainThread
public void removeObserver(@NonNull final Observer<? super T> observer) {
assertMainThread("removeObserver");
ObserverWrapper removed = mObservers.remove(observer);
if (removed == null) {
return;
}
// 调用LifecycleBoundObserver#detachObserver方法移除之前注册到Lifecycle的LifecycleBoundObserver实例
removed.detachObserver();
removed.activeStateChanged(false);
}
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
// 判断当前状态是否为DESTROYED，如果是DESTROYED，那么就调用LiveData#removeObserver移除观察者。
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
private abstract class ObserverWrapper {
final Observer<? super T> mObserver;
boolean mActive;
int mLastVersion = START_VERSION;
ObserverWrapper(Observer<? super T> observer) {
mObserver = observer;
}
abstract boolean shouldBeActive();
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive owner
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
// 如果处于活跃状态，那么调用dispatchingValue方法将最新数据通知给观察者
if (mActive) {
dispatchingValue(this);
}
}
}
}
可以看到，当生命周期状态发生变化时会先判断当前是否处于DESTROYED，如果是的话将会移除之前注册到LiveData的Observer和注册到LifecycleOwner的LifecycleBoundObserver，避免出现内存泄漏的问题。如果还没有处于DESTROYED，那么将会循环获取LifecycleOwner的当前状态，之所以是循环，应该是避免循环体内部的逻辑会导致状态发生变化，循环体内部会调用ObserverWrapper#activeStateChanged方法，如果LifecycleOwner处于活跃状态，那么调用LiveData#dispatchingValue方法将最新数据通知给观察者。
public abstract class LiveData<T> {
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
// 如果入参不为null，那么只通知initiator对应的mObserver
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else { // 如果入参为null，则遍历所有的观察者并通知对应的mObserver
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
// Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
//
// we still first check observer.active to keep it as the entrance for events. So even if
// the observer moved to an active state, if we've not received that event, we better not
// notify for a more predictable notification order.
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
}
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
private abstract class ObserverWrapper {
int mLastVersion = START_VERSION;
}
public LiveData(T value) {
mData = value;
mVersion = START_VERSION + 1;
}
public LiveData() {
mData = NOT_SET;
mVersion = START_VERSION;
}
}
从LiveData#dispatchingValue方法可以发现，通知观察者有两种情况，一种是入参initiator不为null，一种是入参initiator为null。如果是LifecycleOwner的生命周期变化时触发的LiveData#dispatchingValue，那么入参initiator不为null；如果是，那么入参initiator为null。不管哪种情况最终都会调用LiveData#considerNotify通知观察者，进一步会调用Observer#onChanged方法。但是调用Observer#onChanged的前提是LiveData内部数据的版本mVersion比ObserverWrapper内部变量mLastVersion大，而LiveData内部数据的版本mVersion的更新时机有两个：LiveData对象的构造函数和LiveData#setValue方法。
3.2 通知数据变化
在3.1节中分析到当LifecycleOwner的生命周期发生变化时会检查是否处于活跃状态，如果处于活跃状态会再次检查LiveData的数据版本号是否发生变化，如果发生数据更新那么版本号会递增，此时会通知观察者进行处理。此外，在分析LiveData#dispatchingValue方法时发现入参initiator为null的处理逻辑是遍历所有观察者并通知数据发生变化，这里我们看下什么地方会调用LiveData#dispatchingValue方法并且入参initiator为null。
在3.1节中只分析到LifecycleOwner的生命周期发生变化时会通知观察者，但是更新数据的逻辑并没有分析，数据更新的时候分发通知观察者，是不是就是LiveData#dispatchingValue方法调用并且入参initiator为null的情况，直接看下LiveData#setValue方法。
public abstract class LiveData<T> {
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
}
果然，当更新数据时会调用LiveData#dispatchingValue方法通知观察者进行处理，至此，通知观察者检查数据的时机全部分析出来了，一个是主动更新数据时，一个是LifecycleOwner的生命周期发生变化（变为活跃状态）时。而真正调用Observer#onChanged方法之前必须满足两个条件：
LifecycleOwner处于活跃状态；LiveData数据的版本号mVersion比ObserverWrapper内部记录的版本号mLastVersion大；（mLastVersion只有在Observer#onChanged方法被调用的情况下才会更新）
三、总结
LiveData组件是一个感知生命周期变化的数据容器类，使用LiveData组件可以实现对感兴趣的数据的观察，同时只会在LifecycleOwner生命周期处于活跃状态时通知观察者，并且会自动管理观察者的移除避免内存泄漏。通过LiveData组件可以实现数据驱动UI更新的目标，简化View层和Model层之间的依赖关系。
