一、LiveData 介绍
LiveData是 Google 推荐的 Android 架构组件之一，是一个基于观察者模式的数据容器，但与一般的被观察者不同的是，它是有生命周期感知功能，解决了Android开发者需要去手动处理生命周期的痛点。
它具备如下特点：
① 数据可以被观察者订阅。
② 能够感知组件(Fragment、Activity、Service)的生命周期。
③ 只有当组件处于活跃状态(STARTED或RESUMED)时才会通知观察者数据发生了变化。
官方对其优点说明概括如下：
① UI和实时数据保持一致
因为LiveData采用了观察者模式，LiveData是被观察者，所以当数据有变化时观察者（UI）就会获得通知，并进行更新。
② 避免内存泄漏
当被绑定的组件处于DEDTROYED状态时，观察者对象会自动清理自身的数据。
③ 当Activity停止时不会引起崩溃
当组件处于非激活状态时，它不会收到任何LiveData中数据变化的通知。
④ 不需要额外的处理来响应生命周期的变化
LiveData可以自动感知被绑定的UI组件的生命周期，只有当UI组件处于活跃状态时才会通知数据变化。
⑤ 始终保持最新的数据
当组件从不活跃状态变为活跃状态时总是可以收到最新的数据
⑥ 解决了Configuration change问题
当Activity或Fragment由于配置变化（如用户旋转了设备屏幕）而被重新创建时，能够立刻收到最新的数据。
⑦ 资源共享
我们可以实现一个单例模式的LiveData子类，并将系统服务封装在该类中。这样，任何需要这些系统服务的观察者就可以通过观察这个LiveData子类对象实现资源的共享。
二、LiveData的使用
LiveData组件相关的类和接口有：LiveData类、Observer接口、GenericLifecycleObserver接口和LifecycleOwner接口。
1. LiveData是个抽象类，MediatorLiveData继承自MutableLiveData，MutableLiveData则继承自LiveData。MediatorLiveData可以看成是多个LiveData的代理，MutableLiveData则是提供了可以修改LiveData中数据的对外公开方法。
2. LiveData有3个内部类ObserverWrapper、AlwaysActiveObserver和LifecycleBoundObserver，其中后两个类都是ObserverWrapper的子类。LifecycleBoundObserver实现了GenericLifecycleObserver接口，当LifecycleOwner的生命周期变化时就会通过该接口的onStateChanged()方法回调回来。
3. Observer接口就是观察者，它定义了LiveData数据变化的回调方法onChanged()。MediatorLiveData的内部类Source实现了该接口。
使用步骤如下：
1. 创建一个持有某种数据类型的LiveData对象。
2. 创建一个观察者对象，通常在UI Controller(如Activity或Fragment)中创建这个观察者。
3. 将观察者对象作为参数传入LiveData.observe()方法，连接观察者和LiveData。
2.1 创建LiveData对象
public class NameViewModel extends ViewModel { // Create a LiveData with a String private MutableLiveData<String> mCurrentName; public MutableLiveData<String> getCurrentName() { if (mCurrentName == null) { mCurrentName = new MutableLiveData<String>(); } return mCurrentName; } // Rest of the ViewModel... }
2.2 观察LiveData对象
通常情况下都是在组件的onCreate()方法中开始观察数据，原因有以下两点：
① 系统会多次调用onResume()方法
② 确保Activity或Fragment在处于活跃状态时立刻可以展示数据。
public class NameActivity extends AppCompatActivity { private NameViewModel mModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Other code to setup the activity... // Get the ViewModel. mModel = ViewModelProviders.of(this).get(NameViewModel.class); // Create the observer which updates the UI. final Observer<String> nameObserver = new Observer<String>() { @Override public void onChanged(@Nullable final String newName) { // Update the UI, in this case, a TextView. mNameTextView.setText(newName); } }; // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer. mModel.getCurrentName().observe(this, nameObserver); } }
2.3 更新LiveData对象
LiveData 没有提供可用的公共方法来更新其持有的数据，但是如果我们使用LiveData的子类MutableLiveData来存储数据，那么我们就可以使用它的公共方法setValue()和postValue()方法更新数据。
mButton.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { String anotherName = "John Doe"; mModel.getCurrentName().setValue(anotherName); } });
2.4 继承LiveData类
当然我们也可以通过继承LiveData定义自己的扩展类：
public class StockLiveData extends LiveData<BigDecimal> {
private StockManager mStockManager; private SimplePriceListener mListener = new SimplePriceListener() { @Override public void onPriceChanged(BigDecimal price) { setValue(price); } }; public StockLiveData(String symbol) { mStockManager = new StockManager(symbol); } @Override protected void onActive() { mStockManager.requestPriceUpdates(mListener); } @Override protected void onInactive() { mStockManager.removeUpdates(mListener); } } public class MyFragment extends Fragment { @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); LiveData<BigDecimal> myPriceListener = ...; myPriceListener.observe(this, price -> { // Update the UI. }); } }
自定义的StockLiveData实现了LiveData中的空方法onActive()和onInactive()。
三、LiveData 的原理
3.1 数据发生变化时LiveData如何通知 Observer？
LiveData提供了两种添加观察者的方法：observe()和observeForever()：
@MainThread public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) { if (owner.getLifecycle().getCurrentState() == DESTROYED) { // ignore return; } //将LifecycleOwner对象和Observer对象封装成LifecycleBoundObserver对象 LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer); // mObservers是一个SafeIterableMap类型的数据容器，通过它的putIfAbsent()方法可以判断Observer对象是否已经与一个LifecycleBoundObserver对象关联 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); } @MainThread public void observeForever(@NonNull Observer<T> observer) { AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer); ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper); if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) { throw new IllegalArgumentException("Cannot add the same observer with different lifecycles"); } if (existing != null) { return; } wrapper.activeStateChanged(true); }
如果通过observeForever()方法添加观察者，那么观察者会一直收到数据变化的回调通知；
如果通过observe()方法添加，那么观察者只会在LifecycleOwner处于STARTED和RESUMED即active状态才会收到。
其中observe()方法内部使用了LifecycleBoundObserver类，observeForever()方法内部则使用了AlwaysActiveObserver类，它们都是抽象类ObserverWrapper的具体实现类。
所以，我们先来看一下这个抽象类：
private abstract class ObserverWrapper { final Observer<T> mObserver; boolean mActive; int mLastVersion = START_VERSION; ...... void activeStateChanged(boolean newActive) { //新状态和之前状态相同则不做任何处理 if (newActive == mActive) { return; } // 将当前状态设置为传入的newActive mActive = newActive; //处于active状态的观察者数量是否为0 boolean wasInactive = LiveData.this.mActiveCount == 0; //如果当前状态为active状态，则处于active状态的观察者数量加1，否则减1 LiveData.this.mActiveCount += mActive ? 1 : -1; //处于active状态的观察者个数从0变为1，回调LiveData的onActive()方法 if (wasInactive && mActive) { onActive(); } //处于active状态的观察者数量从1变为0，回调LiveData的onInactive()方法 if (LiveData.this.mActiveCount == 0 && !mActive) { onInactive(); } if (mActive) { dispatchingValue(this); } } }
ObserverWrapper是Observer的封装类，在Observer的基础上增加了 mActive 和 mLastVersion 。其中mActive 用来标识观察者是否活跃，即它是否处于可用的生命周期内。
onActiveStateChanged()方法定义了观察者在活跃状态和非活跃状态之间转换时的处理逻辑，如果ObserverWrapper对象处于活跃状态，那么LiveData中的mActiveCount 计数会加一，否则会减一。紧接着，onActive()方法会在mActiveCount为1时触发，onInactive()方法则会在mActiveCount为0时触发。最后，如果ObserverWrapper对象处于活跃状态，还会调用 dispatchingValue()方法发送新的数据。
private void dispatchingValue(@Nullable ObserverWrapper initiator) { //如果mDispatchingValue为true，则将mDispatchInvalidated设为true并直接返回 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变量是为了防止重复分发。该方法会循环遍历mObservers 这个集合，并通过调用considerNotify()方法为每一个处于活跃状态且数据未更新的观察者发送数据。
private void considerNotify(ObserverWrapper observer) { if (!observer.mActive) { return; } if (!observer.shouldBeActive()) { observer.activeStateChanged(false); return; } if (observer.mLastVersion >= mVersion) { return; } observer.mLastVersion = mVersion; observer.mObserver.onChanged((T) mData); }
现在我们再来分析LifecycleBoundObserver类和AlwaysActiveObserver类。我们先看LifecycleBoundObserver：
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver { @NonNull final LifecycleOwner mOwner; LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) { super(observer); mOwner = owner; } //判断是否处于active状态 @Override boolean shouldBeActive() { return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED); } //当LifecycleOwner生命周期发生变化时会回调该方法 @Override public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) { //如果当前处于DESTROYED状态，则会自动移除观察者 if (mOwner.getLifecycle().getCurrentState() == DESTROYED) { removeObserver(mObserver); return; } //调用ObserverWrapper的activeStateChanged()方法，将当前是否处于active状态的判断结果作为参数传入 activeStateChanged(shouldBeActive()); } @Override boolean isAttachedTo(LifecycleOwner owner) { return mOwner == owner; } @Override void detachObserver() { mOwner.getLifecycle().removeObserver(this); } }
可以看出，LifecycleBoundObserver 把 ObserverWrapper 和 Lifecycle 结合在了一起。因此LiveData就可以获取到观察者的生命周期，当观察者的生命周期可用时，LiveData 会把数据发送给观察者，而当观察者生命周期不可用的时，即owner.getLifecycle().getCurrentState() == DESTROYED ，LiveData 就选择不发送并且自动解绑，防止内存泄漏。
AlwaysActiveObserver顾名思义观察者的生命周期一直可用，所以它和LifecycleOwner的生命周期无关，当数据改变时不管LifecycleOwner处于什么状态都会收到回调通知，除非手动将这个观察者移除。从AlwaysActiveObserver的源码也可以看出，它通过shouldBeActive()方法将自己的生命周期设为一直可用，LiveData的observeForever()方法内部使用的就是AlwaysActiveObserver。
private class AlwaysActiveObserver extends ObserverWrapper { AlwaysActiveObserver(Observer<T> observer) { super(observer); } @Override boolean shouldBeActive() { return true; } }
3.2 LiveData中的数据如何更新？
那么怎么改变LiveData中持有的数据呢？LiveData提供了两种方法——postValue()和setValue()：
@MainThread protected void setValue(T value) { //判断当前线程是否是主线程，不是主线程就抛出异常 assertMainThread("setValue"); //版本更新 mVersion++; //改变LiveData持有的数据 mData = value; //将新的数据分发给订阅该LiveData所有的观察者们 dispatchingValue(null); } protected void postValue(T value) { boolean postTask; synchronized (mDataLock) { postTask = mPendingData == NOT_SET; mPendingData = value; } if (!postTask) return; //在主线程中执行mPostValueRunnable中的内容 ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); } private final Runnable mPostValueRunnable = new Runnable() { @Override public void run() { Object newValue; synchronized (mDataLock) { newValue = mPendingData; mPendingData = NOT_SET; } setValue((T) newValue); } };
它们的区别是setValue()方法要在主线程中调用，而postValue()方法既可在主线程也可在子线程中调用。这是因为postValue()方法则通过ArchTaskExecutor将mPostValueRunnable运行在主线程，而在mPostValueRunnable中最终会调用setValue()方法来实现改变LiveData存储的数据。
但是我们发现LiveData并没有将这两个方法对外公开，好在我们可以通过LiveData的子类MutableLiveData实现数据的修改，其源码如下：
public class MutableLiveData<T> extends LiveData<T> { @Override public void postValue(T value) { super.postValue(value); } @Override public void setValue(T value) { super.setValue(value); } }
LiveData还有一个子类MediatorLiveData，它可以看成多个LiveData的代理。它定义了一个内部类Source，用于封装LiveData和Observer，这样如果多个LiveData被添加到MediatorLiveData中，那么任何一个LiveData数据发生变化时，MediatorLiveData的观察者都会收到通知。Source的源码如下：
private static class Source<V> implements Observer<V> { final LiveData<V> mLiveData; final Observer<V> mObserver; int mVersion = START_VERSION; Source(LiveData<V> liveData, final Observer<V> observer) { mLiveData = liveData; mObserver = observer; } void plug() { mLiveData.observeForever(this); } void unplug() { mLiveData.removeObserver(this); } @Override public void onChanged(@Nullable V v) { if (mVersion != mLiveData.getVersion()) { mVersion = mLiveData.getVersion(); mObserver.onChanged(v); } } }
通过一个简单的应用场景可以更加清楚地说明MediatorLiveData的作用。例如，一个Activity界面的UI数据依赖于网络数据源和数据库数据，因此会有两个LiveData。使用MediatorLiveData将两个LiveData合并后，Activity只需观察一个MediatorLiveData即可。无论何时，只要任何一个LiveData数据源发生变化，都会通知Activity的UI进行更新。