概述
在上一篇文章ViewModel的使用及源码分析中，我们介绍了 ViewModel的基本使用及原理分析。因为 ViewModel通常还需要结合组件间通信工具一起使用，所以上次文章也是讲了 ViewModel + LiveData结合使用的场景。这次会结合上篇文章的例子来分析 LiveData的一些原理。
1、使用
因为这次主要分析一下 LiveData的一些原理，所以就不再创建 Demo。为了方便分析，将上次部分代码贴上：
// 注释 1，注册观察者
mLiveData.observe(this, new Observer<String>() {
@Override
public void onChanged(String s) {
Toast.makeText(getApplicationContext(), "mag = " + s, Toast.LENGTH_SHORT).show();
}
});
// 注释 2，发射数据
mLiveData.postValue(result);
2、源码分析
现在就从上面注释 1和注释 2两个地方入手，来分析一下 LiveData的注册以及数据发射流程。
- 注册
先看观察者的注册过程，上面注释 1的 observe方法：
// LiveData.java
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// 注释 3，获取组件（Activity）生命周期
// 如果组件处于 DESTROYED（销毁状态），不允许注册
return;
}
LiveData.LifecycleBoundObserver wrapper = new LiveData.LifecycleBoundObserver(owner, observer);
// 注释 4，将组件和观察者包装后存入链表，如果该对象已经存在，则不覆盖 且existing 不为空
LiveData.ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
// 注释 5，如果观察者已经存在，则返回，不重复注册
if (existing != null) {
return;
}
// 注释 6，将观察者保存进 Lifecycle中完成注册
owner.getLifecycle().addObserver(wrapper);
}
//注释 7， putIfAbsent 方法
public V putIfAbsent(@NonNull K key, @NonNull V v) {
SafeIterableMap.Entry<K, V> entry = get(key);
if (entry != null) {
return entry.mValue;
}
put(key, v);
return null;
}
上面注释 3我们看到，LiveData在注册观察者之前，先去判断观察者组件生命周期的状态。如果观察者生命周期已处于 DESTROYED（已销毁）状态那么就直接返回，不予注册。然后在注释 4的地方会将经过包装的观察者对象以键值对的形式保存进 Map中。如果该对象已经存在，那么不做覆盖操作，且返回的 existing 不为 null。这时注册方法直接返回，不再重复注册。putIfAbsent存储方法逻辑见注释 7处。
如果包装后的观察者对象之前没有被保存注册过，那么就在上面注释 6的 Lifecycle里完成注册。现在再看看上面注释 4处 LiveData里的观察者包装类 LifecycleBoundObserver ：
// LiveData.java
class LifecycleBoundObserver extends LiveData.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) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
// 注释 8，当组件生命周期发生改变是回调该方法
// 组件生命周期状态为 DESTROYED时，将观察者移除
// 这样，当观察者组件处于已销毁状态时将不会收到数据
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
// 移除观察者
public void removeObserver(@NonNull final Observer<? super T> observer) {
assertMainThread("removeObserver");
LiveData.ObserverWrapper removed = mObservers.remove(observer);
if (removed == null) {
return;
}
removed.detachObserver();
removed.activeStateChanged(false);
}
上面注释 8处的 onStateChanged方法，当组件生命周期发生改变时回调该方法。经过判断当组件生命周期状态为 DESTROYED时，会将观察者移除。这样，当观察者组件处于已销毁状态时将不会收到数据。
根据上面注册过程的分析，对于 LiveData生命周期我们简单总结以下两点：
（1） 观察者处于被销毁状态时，LiveData不予注册
（2） LiveData具有组件的生命周期感知能力（通过 LifeCycle）。当组件被销毁时，LiveData会将观察者移除，以避免内存泄漏。
- 数据发送
接下来再回到上面注释 2处，从 LiveData.postValue(result)方法切入，看看 LiveData数据发送过程：
// LiveData.java
public void postValue(T value) {
super.postValue(value);
}
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
// 注释 9，将要发送的消息打包，切换到主线程中执行 setValue（）方法
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
// 注释 10，主线程中执行 setValue（）方法
setValue((T) newValue);
}
};
从上面注释处我们可以看到，postValue方法最终也是切换到主线程当中执行了 setValue方法。现在我们看看 setValue方法：
// LiveData.java
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
void dispatchingValue(@Nullable LiveData.ObserverWrapper initiator) {
......
for (Iterator<Map.Entry<Observer<? super T>, LiveData.ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
//注释 11， 遍历观察者
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
......
}
private void considerNotify(LiveData.ObserverWrapper observer) {
// 注释 12，观察者生命周期不处于 Active状态，不发送
// Active状态包括 STARTED 和 RESUMED ， 也就是对应我们组件生命周期的 onStart() 和 onResume()方法
if (!observer.mActive) {
return;
}
......
observer.mObserver.onChanged((T) mData);
}
上面我们可以看到，setValue会调用 dispatchingValue(null)方法来分发事件。dispatchingValue方法里会遍历所有观察者然后执行 considerNotify方法。那么 LiveData是不是会向所有观察者都发送数据呢？看上面注释 12.。发送数据之前，LiveData会对观察者当前的生命周期状态进行判断。只有当前为 Active状态的观察者才会收到数据，而 Active 状态包括 STARTED 和 RESUMED ， 也就是对应我们组件生命周期的 onStart() 和 onResume()方法。
这就是我们需要知道的结论，组件生命周期只有在 Start 或 Resume状态时才会收到 LiveData的数据。这样组件在接收数据显示时就不需要先判断自身当前的状态了。
