LiveData 是 Jetpack 推出的基于观察者的消息订阅/分发的可观察数据组件，具有宿主（Activity、Fragment）生命周期感知能力，这种感知能力可确保 LiveData 仅分发消息给处于活跃状态的观察者，即只有处于活跃状态的观察者才能收到消息
而 LiveData 的事件分发机制，会根据监听者的活跃状态来判断是否分发数据源变化事件，这样的话，我们就能避免当前页面在后台时，响应了事件，做出一些无用的逻辑浪费性能
LiveData 的简单使用LiveData 的使用十分方便，只需要简单的三步：
1、创建 LiveData 对象，LiveData 是抽象类，所以需要创建它的子类 MutableLiveData；
2、设置观察者 observe，第一个参数是 LifecycleOwner 对象，第二个是观察者监听，当数据改变的时候会在 onChanged 方法内做出响应；
3、设置数据，通过 postValue 或者 setValue 方法来更新数据；
LiveData 生命周期LiveData 如何观察组件生命周期变化通过调用 LiveData 的 observe 方法来注册观察者，LiveData 的 observe 方法如下所示
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
//如果被观察者的当前的状态是DESTROYED，就return
if (owner.getLifecycle().getCurrentState() == DESTROYED) {//1
return;
}
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);//2
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);//3
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);//4
}
注释1处的 owner 实际上就是注册时传进来组件，比如 Activity，获取组件当前的状态，如果状态为 DESTROYED，那么直接 return，这说明 DESTROYED 状态的组件是不允许注册的
注释2处新建了一个 LifecycleBoundObserver 包装类，将 owner 和 observer 传了进去
注释3处将 observer 和 LifecycleBoundObserver 存储到 SafeIterableMap<Observer<? super T>, ObserverWrapper>mObservers 中
- putIfAbsent 方法和 put 方法有区别
如果传入 key 对应的 value 已经存在，就返回存在的 value，不进行替换。如果不存在，就添加 key 和 value，返回 null
如果等于 null，在注释4处会将 LifecycleBoundObserver 添加到 Lifecycle 中完成注册，这样当我们调用 LiveData 的 observe 方法时，实际上是 LiveData 内部完成了 Lifecycle的观察者的添加
- 这样 LiveData 自然也就有了观察组件生命周期变化的能力
LifecycleBoundObservers是LiveData的内部类，代码如下所示
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@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(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);//1
return;
}
activeStateChanged(shouldBeActive());//2
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
LifecycleBoundObserver继承了ObserverWrapper类，重写了shouldBeActive方法，用于判断当前传入的组件的状态是否是Active的，Active状态包括STARTED和RESUMED状态
LifecycleBoundObserver实现了GenericLifecycleObserver接口，当组件状态发生变化时，会调用onStateChanged方法，当组件处于DESTROYED状态时，会调用注释1处的removeObserver方法，来移除observer
这样就解决了，为什么一个观察者（组件）处于DESTROYED状态时，它将不会收到通知
接着会调用注释2处的activeStateChange方法，代码如下所示
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();
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
void detachObserver() {
}
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
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);//1
}
}
}
activeStateChanged方法定义在抽象类ObserverWrapper中，它是Observer的包装类，activeStateChanged方法会根据Active状态和处于Active状态的组件的数量，来对onActive方法和onInactive方法回调，这两个方法用于拓展LiveData对象
注释1处，如果是Active状态，会调用dispatchingValue方法，并将自身传进去
private void dispatchingValue(@Nullable ObserverWrapper initiator) {
//正在处于分发状态中
if (mDispatchingValue) {
//分发无效
mDispatchInvalidated = true;//1
return;
}
mDispatchingValue = true;
do {
//分发有效
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
//标记不处于分发状态
mDispatchingValue = false;
}
mDispatchingValue用于标记当前是否处于分发状态中，如果处于该状态，则在注释1处标记当前分发无效，直接return
一路调用过来，ObserverWrapper是不为null的，ObserverWrapper为null无论是那种情况，都会调用considerNotify方法，代码如下所示
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {//1
return;
}
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);//2
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//noinspection unchecked
observer.mObserver.onChanged((T) mData);//3
}
considerNotify方法中做了多次的判断
- 注释1处，如果ObserverWrapper的mActive值不为true，就直接return
- 注释2处，如果当前observer对应组件的状态不是Active，就会再次调用activeStateChanged方法，并传入false，其方法内部会再次判断是否执行onActive方法和onInactive方法回调
如果判断条件都满足会调用Observer的onChanged方法，这个方法正是使用LiveData的observe方法的回调
postValue/setValue 方法分析当调用MutableLiveData的observe方法后，还需要通过postValue/setValue方法来更新数据
private final Runnable mPostValueRunnable = new Runnable() {
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
//noinspection unchecked
setValue((T) newValue);//1
}
};
...
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);//2
}
@MainThread //3
protected void setValue(T value) {
assertMainThread("setValue");
mVersion ;
mData = value;
dispatchingValue(null);
}
- postValue/setValue方法都定义在LiveData中
根据注释1和注释2处，可以发现postValue方法实际上就是将setValue方法切换到主线程调用。注释3处说明setValue方法是运行在主线程中的，其内部调用了dispatchingValue方法
ObserverWrapper为null的情况；从这里我们可以知道，无论是LiveData的observe方法还是LiveData的postValue/setValue方法都会调用dispatchingValue方法
Transformations.map 方法分析除了以上讲的常用的方法之外，还可能会使用到Transformations.map和Transformations.switchMap方法，这里以Transformations.map为例；这个方法用来在LiveData对象分发给观察者之前对其中存储的值进行更改， 代码如下所示
@MainThread
public static <X, Y> LiveData<Y> map(
@NonNull LiveData<X> source,
@NonNull final Function<X, Y> mapFunction) {
final MediatorLiveData<Y> result = new MediatorLiveData<>();//1
result.addSource(source, new Observer<X>() {
@Override
public void onChanged(@Nullable X x) {
result.setValue(mapFunction.apply(x));
}
});
return result;
}
Transformations.map方法运行在主线程，注释1处创建了MediatorLiveData，紧接着调用了它的addSource方法：
*/
@MainThread
public <S> void addSource(@NonNull LiveData<S> source, @NonNull Observer<? super S> onChanged) {
Source<S> e = new Source<>(source, onChanged);//1
Source<?> existing = mSources.putIfAbsent(source, e);
if (existing != null && existing.mObserver != onChanged) {
throw new IllegalArgumentException(
"This source was already added with the different observer");
}
if (existing != null) {
return;
}
if (hasActiveObservers()) {
e.plug();//2
}
}
注释1处将传进来的LiveData和onChanged封装到Source类中，注释2处调用了Source的plug方法：
private static class Source<V> implements Observer<V> {
final LiveData<V> mLiveData;
final Observer<? super V> mObserver;
int mVersion = START_VERSION;
Source(LiveData<V> liveData, final Observer<? super V> observer) {
mLiveData = liveData;
mObserver = observer;
}
void plug() {
mLiveData.observeForever(this);//1
}
void unplug() {
mLiveData.removeObserver(this);
}
@Override
public void onChanged(@Nullable V v) {
if (mVersion != mLiveData.getVersion()) {
mVersion = mLiveData.getVersion();
mObserver.onChanged(v);//2
}
}
}
注释2处可以看到，Transformations.map方法传入的Observer的回调在这里进行处理
注释1处，Source的plug方法会调用LiveData的observeForever方法
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread("observeForever");
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);//1
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);
}
注释1处用AlwaysActiveObserver来对Observer进行包装，紧接着调用AlwaysActiveObserver的activeStateChanged方法，其内部实际调用的是 ObserverWrapper 的 activeStateChanged 方法
来看 AlwaysActiveObserver 类是如何定义的
private class AlwaysActiveObserver extends ObserverWrapper {
AlwaysActiveObserver(Observer<? super T> observer) {
super(observer);
}
@Override
boolean shouldBeActive() {
return true;
}
}
AlwaysActiveObserver 是 LiveData 的内部类，它继承自 ObserverWrapper，LiveData 内部类和 ObserverWrapper 的区别就是，它是永远处于Active状态的
LiveData 关联类其中 MutableLiveData 继承自 LiveData， LifecycleOwner 和 Observer 和 LiveData 有关联的关系，ObserverWrapper 是 Observer 的包装类，因此它们有着关联的关系
总结本文 全面介绍了 LiveData 的生命周期是如何变化的 希望大家在开发时尽量避免出现 因生命周期变化而出现的问题
为了是大家能够更好的学习 Android Jetpack ， 在这里特别提供一份 Android Jetpack 高级开发学习笔记， 里面包含了这些年学习 Android 开发所遇到的难题及其解决方案； 有需要这份 Android Jetpack 高级开发学习笔记 的朋友： 可以私信 发送 “笔记” 即可 免费获取； 希望大家阅读过后，能够 查漏补缺；早日成为高级开发者
完整版 Android Jetpack 高级开发学习笔记获取方式：私信 发送 “笔记” 即可 免费获取
对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们
技术是无止境的，你需要对自己提交的每一行代码、使用的每一个工具负责，不断挖掘其底层原理，才能使自己的技术升华到更高的层面
加油！各位 Android 开发者们
![No pain No Gain [Official Music Video] ZIKK](http://img.17u1u.com/uploads/small/tos-cn-i-qvj2lq49k0/eb6752982c864091ad12bbc0902e5562.jpg)
