前言
在上一篇文章中我们学习了LiveData的基本用法, 我们知道LiveData是一个可观察的数据持有者,他是具有组件生命周期感知的,那么它是如何观察组件生命周期变化的呢?
LiveData和RxJava的不同的是,LiveData并不是通知所有观察者,它只会通知处于Active状态的观察者; 如果一个观察者处于DESTROYED状态,它将不会收到通知,这一点又是如何做到的?还有另外一点,Transformations的map方法其内部进行了什么操作?等等问题,会在这篇文章中给大家进行讲解
1.LiveData如何观察组件生命周期变化
通过调用LiveData的observe方法来注册观察者,LiveData的observe方法如下所示。
@MainThread public void observe(@NonNull LifecycleOwner owner, @NonNull Observer 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存储到SafeIterableMapmObservers中; putIfAbsent方法和put方法有区别,如果传入key对应的value已经存在,就返回存在的value,不进行替换。如果不存在,就添加key和value,返回null。 如果等于null,在注释4处会将LifecycleBoundObserver添加到Lifecycle中完成注册,这样当我们调用LiveData的observe方法时,实际上是LiveData内部完成了Lifecycle的观察者的添加,这样LiveData自然也就有了观察组件生命周期变化的能力。
2.LiveData的observe方法回调
LifecycleBoundObservers是LiveData的内部类,代码如下所示
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver { @NonNull final LifecycleOwner mOwner; LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer 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 mObserver; boolean mActive; int mLastVersion = START_VERSION; ObserverWrapper(Observer 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> iterator = mObservers.iteratorWithAdditions(); iterator.hasNext(); ) { considerNotify(iterator.next().getValue()); if (mDispatchInvalidated) { break; } } } } while (mDispatchInvalidated); //标记不处于分发状态 mDispatchingValue = false; }
mDispatchingValue用于标记当前是否处于分发状态中; 如果处于该状态,则在注释1处标记当前分发无效,直接return;一路调用过来,ObserverWrapper是不为null的,ObserverWrapper为null的情况第3小节会讲到,无论是那种情况,都会调用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方法的回调
3.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方法,这个方法在第2小节介绍过,也就是dispatchingValue方法的参数ObserverWrapper为null的情况
从这里我们可以知道,无论是LiveData的observe方法还是LiveData的postValue/setValue方法都会调用dispatchingValue方法
4.Transformations.map方法分析
除了以上讲的常用的方法之外,还可能会使用到Transformations.map和Transformations.switchMap方法,这里以Transformations.map为例; 这个方法用来在LiveData对象分发给观察者之前对其中存储的值进行更改, 代码如下所示
@MainThread public static LiveData map( @NonNull LiveData source, @NonNull final Function mapFunction) { final MediatorLiveData result = new MediatorLiveData();//1 result.addSource(source, new Observer() { @Override public void onChanged(@Nullable X x) { result.setValue(mapFunction.apply(x)); } }); return result; }
Transformations.map方法运行在主线程,注释1处创建了MediatorLiveData,紧接着调用了它的addSource方法:
*/ @MainThread public void addSource(@NonNull LiveData source, @NonNull Observer onChanged) { Source 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 implements Observer { final LiveData mLiveData; final Observer mObserver; int mVersion = START_VERSION; Source(LiveData liveData, final Observer 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方法,这个和第2小节所讲的内容有什么区别呢?我们再往下看
@MainThread public void observeForever(@NonNull Observer 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 observer) { super(observer); } @Override boolean shouldBeActive() { return true; } }
AlwaysActiveObserver是LiveData的内部类; 它继承自ObserverWrapper,AlwaysActiveObserver是LiveData的内部类和ObserverWrapper的区别就是,它是永远处于Active状态的
5.LiveData关联类
其中MutableLiveData继承自LiveData,LifecycleOwner和Observer和LiveData有关联的关系,ObserverWrapper是Observer的包装类,因此它们有着关联的关系
有需要文中完整代码的同学: 《现在私信发送 “底层源码” 即可免费获取》
现在私信发送 “笔记” 还可以获取《更多 Android 源码解析+学习大纲+核心笔记》
最后我想说:
对于程序员来说,要学习的知识内容、技术有太多太多,要想不被环境淘汰就只有不断提升自己,从来都是我们去适应环境,而不是环境来适应我们
技术是无止境的,你需要对自己提交的每一行代码、使用的每一个工具负责,不断挖掘其底层原理,才能使自己的技术升华到更高的层面
Android 架构师之路还很漫长,与君共勉