带着几个问题去研究源码
- LiveData是如何感知生命周期的？
- LiveData如何更新数据
观察LiveData
[LiveData.java] observe()
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
assertMainThread("observe");
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);
}
这个方法主要做了几件事
- 判断是否在主线程添加观察者，如果不在主线程则抛出异常
- 根据LifecycleOwner,和实现的观察者observer，创建一个LifecycleBoundObserver实例对象，这是一个wrapper类，主要包装LifecycleOwner和observer
- 将observer添加到map中，observer为key，value为wrapper
- 通过LifecycleOwner获取LifecyclerRegistry并注册观察者wrapper
还有一个observeForever，表示观察者一直观察，shouldActive（）方法直接返回的true，而不是根据应用组件的生命周期是否是STARTED或RESUMED状态
内部类LifecycleBoundObserver
这个类从类名上来看，意思为生命周期约束观察者，也就是说受生命周期约束的观察者。该类实现了LifecycleEventObserver接口
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@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(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
回顾之前Lifecycle的源码分析，监听生命周期，就是通过向Lifecycle中添加LifecycleObserver，LifecycleEventObserver继承了LifecycleObserver。
LiveData感知生命周期是通过向Lifecycle注册观察者LifecycleObserver,当生命周期状态发生变化时回调onStateChanged方法
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
//如果当前状态为DESTROYED，则移除观察者
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
//根据当前状态是否是STARTED或RESUMED，执行活动状态发生改变
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
生命周期状态改变回调方法里，主要做了：
- 判断当前状态是否是销毁状态 DESTROYED，如果是销毁状态，则从Observers Map中移除observer
- 判断当前状态是否是活动状态，STARTED或RESUMED，并执行activeStateChanged方法，活动状态发生改变了
这里使用了while循环，主要当执行完后，如果生命周期又发生改变，者可以立即执行。
内部类ObserverWrapper
这个装饰类主要保存了Observer对象，以及记录状态
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
if (mActive) {
dispatchingValue(this);
}
}
- 如果不是新的活动，则不执行
- 保存新的活动状态，并更新活动的观察者计数器
- 如果是活动状态，则分发数据
改变活动计数器 changeActiveCounter
@MainThread
void changeActiveCounter(int change) {
int previousActiveCount = mActiveCount;
mActiveCount += change;
if (mChangingActiveState) {
return;
}
mChangingActiveState = true;
try {
while (previousActiveCount != mActiveCount) {
boolean needToCallActive = previousActiveCount == 0 && mActiveCount > 0;
boolean needToCallInactive = previousActiveCount > 0 && mActiveCount == 0;
previousActiveCount = mActiveCount;
if (needToCallActive) {
onActive();
} else if (needToCallInactive) {
onInactive();
}
}
} finally {
mChangingActiveState = false;
}
}
active 为true表示活动状态，否则为不活动，活动状态chang=1，不活动状态=-1
- mActiveCount 0->1 表示由不活动状态转变为活动状态，
- mActiveCount 1->0 表示由活动状态为不活动状态
- mActiveCount>0 则表示含有活动的观察者
dispatchingValue
最新的活动状态newActive为true，并且之前为不活动状态时，分发数据dispathingValue()
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
//表示通知某个观察者
if (initiator != null) {
considerNotify(initiator);
//这里不置为null也可以吧
initiator = null;
} else {
//当数据发送变化时走下面这个分支，即调用了setValue方法
for (Iterator, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
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;
}
//判断观察者的的版本号，如果版本号大于LiveData的版本号，说明已经通知过观察者了，直接返回
if (observer.mLastVersion >= mVersion) {
return;
}
//将当前LiveData的版本号赋值给observer
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
关于使用LiveData实现事件总线替代EventBus和RxBus的方案
参考美团技术团队：https://tech.meituan.com/2018/07/26/android-livedatabus.html
ObserverWrapper.mLastVersion 版本号的问题，当LiveData注册观察者ObserverWrapper的时候，ObserverWrapper默认是mLastVersion为-1，LiveData每更新一次数据后版本号会+1，当Observer 所感知含有生命周期的组件，生命周期发生变化的时候会回调onStateChanged->activeStateChanged->dispatchingValue->considerNotify,也就是说在订阅者订阅消息后有会立马收到消息，这个消息发生在订阅之前。
解决的方案：使用反射更改ObserverWrapper的mLastVersion为当前LiveData的mVersion
小结
以上的流程主要是向LifecycleRegistry注册观察者LifecycleObserver，当应用组件生命周期发送变化时获取生命周期回调事件，并通过判断生命周期是否处于活动状态（STARTED 或RESUMED）更新数据，如果生命周期状态为DESTORYED这移除观察者
更新数据postValue 和 getValue
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
提交数据，这个方法加了同步锁，也就是说可在其他子线程提交数据，通过ArchTaskExecutor提交一个Runnable到主线程，ArchTaskExecutor类里面其实封装了Handler和一个线程池，通过Handler切换到主线程
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue);
}
};
切换到主线程之后执行了setValue（）方法
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
setValue（）方法只能在主线程中执行，数据的版号加1，然后执行了dispatchingValue方法分发数据，和上面分析获取生命周期状态时为活动状态事执行了同样的方法，只是这里传递wrapper为null，需要通知所有的观察者，最后调用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;
observer.mObserver.onChanged((T) mData);
}
这个方法主要的功能就是，考虑是否要通知观察者有新的数据，如果观察者的状态为不活动状态则不通知，通过数据的版本来判断是否是新的数据，然后调用观察者的onChanged方法
总结
- 通过向LiveData 添加观察者observer，监听数据。注册Observer需要传递，LifecycleOwner对象，实现该对象的接口含有自己的生命周期
- 注册Observer 将LifecycleOwner和Observer包装到一个wrapper类中，该类是一个LifecycleObserver的实现类，通过LifecycleOwner获取LifecycleRegistry，并注册生命周期观察者LifecycleObserver
- 当应用组件的生命周期发生变化的时候，通知到这个wrapper类，这样LiveData就感知了应用组件的生命周期了，如果是状态是活动状态，有新的数据则通知观察者。如果生命周期状态为销毁状态DESTROYED，则从Observers Map中移除observer
- 更新数据通过postValue（T value）和setValue（T value），postValue是通过handler切换到主线程，执行setValue，setValue方法则根据应用组件的生命周期是否处于活动状态，如果是活动状态这通知观察者有数据更新