1.在上一篇文章中介绍了LiveData的简单使用，可以查看LiveData简单使用_niuyongzhi的博客-CSDN博客
源码分析：
也可以分成两部分来看，一部分是注册observe源码，另一部分是setValue的源码。
先看Observe注册监听的方法。
1）先看liveData.observe()
MutableLiveData<Person> liveData = new MutableLiveData();
liveData.observe(this, new Observer<Person>() {
@Override
public void onChanged(Person person) {
ageTv.setText(String.valueOf(person.age));
nameTv.setText(person.name);
}
}); private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
new SafeIterableMap<>();
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
return;
}
//定义了一个Observer的包装类，用于数据变化时的回调。
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
//将wrapper存入一个HashMap中，
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
....
//向LifeCycle注册监听，这样wrapper就可以感知Activity声明周期变化。
owner.getLifecycle().addObserver(wrapper);
}看下这个LifecycleBoundObserver 类。
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@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);
}
//在收到Activity生命周期变化时，会回调这个方法。
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
//拿到当前的状态
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
//如果Activity的状态是销毁状态，则会从集合中移除注册的observer，防止内存泄露
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);
}
}看activeStateChanged()方法 更新状态。
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);
}
}2）在看setValue中做了啥
//看setValue的执行逻辑
protected void setValue(T value) {
//不是运行在主线程，抛异常
assertMainThread("setValue");
//版本控制，每调用一次setValue，version加1
mVersion++;
mData = value;
//数据分发，注意这里传的参数是null
dispatchingValue(null);
}看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 {
//由于上面传过来的参数是null，所以会执行这个循环遍历mObservers
//而mObservers就保存了向liveData添加的observer
for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}由于上面参数initiator传递过来的是null，所以会执行到for循环中的 considerNotify(iterator.next().getValue()); iterator.next().getValue()拿到的就是ObserverWrapper的实例。
再看considerNotify方法（）
private void considerNotify(ObserverWrapper observer) {
//如果观察在没有处于活跃状态，则不会受到更新的数据
if (!observer.mActive) {
return;
}
//这个判断是LifeCycleOwner的状态是否处于活跃状态
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
//如果Observer中的版本已经是最新的，则不会更新
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//调用observer中的回调方法。
//observer就是上面创建的LifecycleBoundObserver的实例
//mObserver就是添加的观察者
observer.mObserver.onChanged((T) mData);
} if (!observer.mActive) {
return;
}
这行代码，就控制了，不是活跃状态的观察者，不会去更新数据，保证处于前台的Activity中的LiveData，会刷新UI。
2.LiveData的粘性事件：
在第一个Activity中调用 liveData.setValue("main");已经注册的Observer能够收到消息。
当跳转到第二个Activity向第一个Activity中的LiveData添加Observer时，也会收到之前发送的消息。
这样的情况就是粘性事件。
正常的流程是 new LiveData----addObserver---setValue--收到消息
粘性事件的流程是 new LiveData---setValue-----addObserver--收到消息。
LiveData的粘性事件，并不是他的bug，而是出于某种业务需要才这样做到的，就是为了确保数据更新后，即使打开新的Activity也能够显示最新的数据。如果不期望这种效果，由于目前LiveData还没有提供这样的Api，所以得需要我们自己来实现。
LiveData出现粘性事件的源码分析。
由于第二个Activity也是实现了LifecycleOwner，也会调用ReportFragment的dispatch(Lifecycle.Event event)方法
private void dispatch(Lifecycle.Event event) {
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}看过LifeCycle源码分析的，对后面的执行流程应该很熟悉。
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;
}
}直接看到这里mLifecycleObserver是谁的实例？看Lifecycling.getCallback(observer);
在LifeCycle的回调中返回的是ReflectiveGenericLifecycleObserver的实例。
但是在LiveData中mLifecycleObserver是LifecycleBoundObserver的实例，实现了GenericLifecycleObserver接口。
在调用LiveData.Observer()创建了LifecycleBoundObserver的实例。
static GenericLifecycleObserver getCallback(Object object) {
if (object instanceof FullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
}
//LiveData中传进来的是LifecycleBoundObserver
//所以在这里就return了
if (object instanceof GenericLifecycleObserver) {
return (GenericLifecycleObserver) object;
}
.......
return new ReflectiveGenericLifecycleObserver(object);
}看LiveData.Observer()源码，创建了LifecycleBoundObserver对象，并作为观察者，添加到了LifeCycle中
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
owner.getLifecycle().addObserver(wrapper);
}在addObserver中，用ObserverWithState对LifecycleBoundObserver进行了一层封装。
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
}综上代码，可以知道 mLifecycleObserver.onStateChanged(owner, event);
调用的是LifecycleBoundObserver的onStateChanged方法。
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
//如果当前Activity是Destroy的，则回收Observer，防止发送内存泄露
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
} //删除的LiveData中该Activity(LifecycleOwner)添加的observer，
//在LiveData.Observer时会传入LifecycleOwner，
public void removeObserver(@NonNull final Observer<T> observer) {
assertMainThread("removeObserver");
ObserverWrapper removed = mObservers.remove(observer);
if (removed == null) {
return;
}
removed.detachObserver();
removed.activeStateChanged(false);
}activeStateChanged(shouldBeActive());
//shouldBeActive判断是Activity是否是线上状态。
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}//在第二个Activity启动后，这个newActive传过来的是true
void activeStateChanged(boolean newActive) {
//mActive默认是false，newActive是true
if (newActive == mActive) {
return;
}
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;
//记录avtiveCount，如果活跃加1否则减1
LiveData.this.mActiveCount += mActive ? 1 : -1;
if (wasInactive && mActive) {
onActive();
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();
}
if (mActive) {
dispatchingValue(this);
}
}//dispatchingValue把this传进来了，所以下面代码会执行if判断的第一个分支
private void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
//initiator不是null执行这里
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;
} private void considerNotify(ObserverWrapper observer) {
//observer.mActive 为true
if (!observer.mActive) {
return;
}
//observer.shouldBeActive()为true
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
//mVersion是LiveData的变量，会大于0
//observer.mLastVersion初始值是0，
//所以这个分支判断也不会进来
if (observer.mLastVersion >= mVersion) {
return;
}
//版本同步
observer.mLastVersion = mVersion;
//这行代码，就会调用observer的onChange方法
observer.mObserver.onChanged((T) mData);
}所以在第二个Activity中添加的observer就收到了第一个Activity发送的消息。
这就是LiveData粘性事件的源码执行原理。
如果想要消除这种粘性事件，通过上面的代码分析，我们可以修改添加的Observer的mLastVersion值，
使它在初始化时就和LiveData中的mVersion一致，就不会出现粘性事件。
3. liveData.observeForever(observer)
liveData.observeForever 是一个和Activity声明周期无关的消息订阅与发送的方法
public void observeForever(@NonNull Observer<T> observer) {
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null) {
return;
}
//这个参数是true
wrapper.activeStateChanged(true);
}
390
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
