Offer 驾到，掘友接招！我正在参与2022春招打卡活动，点击查看活动详情。
简介
LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
\
LiveData：绑定我们数据值的对象，我们可以通过setValue()和postValue()来更新值，并告诉观察者当前值已经变化；而绑定观察者则是通过Observe()方法来执行；Observer：它比较简单，就是一个观察者，用来感知LiveData值变化；ObserverWrapper：它是LiveData的内部类，用来包装Observer并且有一个很重要的点，就是感知Activity、Fragment的生命周期，在合适的时候remove观察者，它的默认子类提供了两种LifecycleBoundObserver和AlwaysActiveObserver，在接下来的源码分析阶段具体说下两种的区别。
LiveData源码分析
public abstract class LiveData<T> {
// 默认版本为-1
static final int START_VERSION = -1;
// 观察者集合
private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
new SafeIterableMap<>();
private volatile Object mData;
// 当前版本
private int mVersion;
private boolean mDispatchingValue;
private boolean mDispatchInvalidated;
// 用来更新postValue()传过来的值
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue);
}
};
@SuppressWarnings("unchecked")
private void considerNotify(ObserverWrapper observer) {
// 非活跃状态直接return
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和Observer的版本
// mVersion是在setValue()时增加，正常情况mLastVersion一直比mVersion小
if (observer.mLastVersion >= mVersion) {
return;
}
// 更新mLastVersion
observer.mLastVersion = mVersion;
// 调用Observer.onChange()方法
observer.mObserver.onChanged((T) mData);
}
// 分发值
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
// setValue()过来的initiator为空
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;
}
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
// 如果Activity、Fragment状态是Destroy，直接return
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 包装Observer
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 查看map是否已存在，不存在添加到map，如果存在直接return
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;
}
// 将wrapper和Lifecycle绑定，用来感知生命周期变化
owner.getLifecycle().addObserver(wrapper);
}
// 此方法和observe()不同的在于不考虑生命周期
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread("observeForever");
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
// 移到主线程更新值，最终还是低啊用setValue()方法
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
@MainThread
protected void setValue(T value) {
// 必须在主线程
assertMainThread("setValue");
// mVersion增加
mVersion++;
mData = value;
// 分发值变化
dispatchingValue(null);
}
}
- 第一步添加观察者
observe(lifecycleOwner,Observer)，LifecycleOwner是为了能够感知当前Owner生命周期变化，Observer是为了能够感知LiveData值变化； - 第二步更新LiveData值，主线程可使用
setValue(T)，子线程可使用postValue(T)，在源码中我也作了注释，两种方式最终走到的还是setValue(T)，紧接着后面会去分发这个更新的值，通过considerNotify(ObserverWrapper)逐一的调用每个Observer.onChange()方法。
ObserverWrapper
ObserverWrapper主要就是负责是否能够满足分发LiveData值变化。
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();
// 是否attach到LifecycleOwner
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
void detachObserver() {
}
// LifecycleOwner活跃的状态是否改变，如果改变了需要重新分发下数据
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);
}
}
}
ObserverWarpper主要还是和LifecycleOwner相互关联，用来判断在什么状态之下才能去更新数据，在什么状态下需要移除观察者，比如LifecycleBoundObserver它只有在STARTED和RESUMED状态下才会去主动更新数据，其它状态暂时不会更新数据的，而在DESTROYED的状态下会去主动removeObserver（）。
