LiveData是Google发布的一个架构组件，它是一个数据持有类，并且数据可以被观察。区别于普通的被观察者，LiveData最大的特点是具备生命周期感知能力，即它仅更新处于活动生命周期状态的应用程序组件观察者(例如Activity/Fragment)。因此，LiveData可以很好的解决内存泄漏问题，以及常见的view空指针异常。
一、LiveData如何感知生命周期
在Android架构组件之Lifecycle源码解析一文中，我们了解到Lifecycle-Aware组件的核心就是生命周期感知，要明白LiveData为什么能感知生命周期，就要以Lifecycle-Aware组件的原理为基础。由于26.1.0及更高版本Support支持库中的Activity和Fragment已经实现了LifecycleOwner接口，因此Activity/Fragment就是LifecycleOwner，而且它们内部都会有一个LifecycleRegistry来存放生命周期State、Event等。通过Lifecycle-Aware源码分析，我们可以知道在初始化Lifecycle组件时会为每个Activity/Fragment添加一个ReportFragment(无UI界面的Fragment)，当Activity执行相应生命周期方法的时候，也会同步的执行ReportFragment的生命周期方法。因此，Lifecycle组件的核心就是通过无UI界面的Fragment来实现生命周期的监听，它会在执行其生命周期方法的时候更新LifecycleRegistry里的生命周期State、Event,，并且通过handleLifecycleEvent()方法来通知对应的观察者。
基于Lifecycle组件生命周期感知原理，那么只要让LiveData注册对Activity/Fragment的生命周期的监听，那么LiveData自然也就拥有了生命周期感知能力。具体看一下LiveData的源码实现：
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
... ...
owner.getLifecycle().addObserver(wrapper);
}
由源码可知，如果当前的LifecycleOwner处于DESTROYED状态，则忽略。否则，将传入的观察者做一个封装，然后添加到Activity/Fragment的LifecycleRegistry中去，当Activity/Fragment的什么周期发生变化时，就会通知这个封装的观察者，即LiveData拥有了生命周期感知能力。
二、LiveData注册观察者
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
owner.getLifecycle().addObserver(wrapper);
}
由源码可知，observe()注册观察者方法运行在主线程。同时，observe()方法会将传入的观察者对象封装成一个LifecycleBoundObserver对象，之后再将这个wrapper对象添加到Activity/Fragment的LifecycleRegistry中去。因此，对于Activity/Fragment而言，这个wrapper对象是观察者，Activity/Fragment生命周期的变化都会通知到wrapper。
那么，紧接着我们一起来看一下LifecycleBoundObserver的源码，而且配合上LifecycleRegistry静态内部类ObserverWithState的源码看效果更佳：
// LifecycleRegistry # ObserverWithState
static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
// LiveData # LifecycleBoundObserver
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@NonNull final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
由源码可知，当Activity/Fragment生命周期发生变化时，最终会去回调观察者的onStateChanged()方法。因此，我们先看一下LifecycleBoundObserver的onStateChanged()方法。很明显，如果Activity/Fragment的当前状态是DESTROYED，那么就将这个观察者移除，也就意味着解除了与Activity/Fragment的关联，这就是LiveData可以避免内存泄漏的原因。接着，会调用activeStateChanged()方法。
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;
LiveData.this.mActiveCount += mActive ? 1 : -1;
if (wasInactive && mActive) {
onActive();
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();
}
if (mActive) {
dispatchingValue(this);
}
}
可以看到，当LifecycleOwner的状态处于STARTED或RESUMED时，传入newActive的值为true，即LifecycleBoundObserver会被标记为激活状态，生命周期变化将会通知处于激活状态的观察者。
三、LiveData通知观察者
在上面的分析中，我们可以知道当Activity/Fragment生命周期变化时，如果Activity/Fragment处于活动状态，则会将生命周期变化通知观察者。
其次，我们也可以通过改变LiveData里面的数据内容，然后再将数据的变化通知观察者。具体主要体现在setValue()和postValue()这两个方法上。
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
由源码可知，setValue()方法只能运行在主线程上，而postValue()方法可以运行在任意线程上，但是Observer的OnChange回调最终会执行在主线程上。
我们注意到，不管是哪种通知观察者的方式，都会调用到dispatchingValue()这个方法，下面就具体来看一下：
private void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
由源码可知，mDispatchingValue和mDispatchInvalidated只在dispatchingValue方法中使用，显然这两个变量是为了防止重复分发相同的内容。接下来，我们注意到，无论传入的initiator是否为空，都会走到considerNotify()这个方法：
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;
//noinspection unchecked
observer.mObserver.onChanged((T) mData);
}
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
由源码可知，如果Activity/Fragment处于非活动状态，则忽略。也就是说，如果当前界面是不可见的，那么就不会去通知观察者，因此可以解决常见的view空指针异常问题。如果当前界面处于活动状态，则会去回调注册进来的观察者的onChanged()方法，之后进行相应的逻辑操作。
