自己看，如果不对，请指出！
package androidx.lifecycle;
import static androidx.lifecycle.Lifecycle.State.DESTROYED;
import static androidx.lifecycle.Lifecycle.State.STARTED;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.arch.core.executor.ArchTaskExecutor;
import androidx.arch.core.internal.SafeIterableMap;
import java.util.Iterator;
import java.util.Map;
public abstract class LiveData {
// 用于synchronized同步处理的数据对象
@SuppressWarnings("WeakerAccess") /* synthetic access */
final Object mDataLock = new Object();
// 当前持有数据的版本号，默认为-1
static final int START_VERSION = -1;
// 定义当mData没有数据时的默认数据
@SuppressWarnings("WeakerAccess") /* synthetic access */
static final Object NOT_SET = new Object();
// 用于存储全部的Observer对象的安全迭代Map
// SafeIterableMap一个能在遍历中删除元素的数据结构
private SafeIterableMap, ObserverWrapper> mObservers =
new SafeIterableMap<>();
// 记录有多少个Active状态的Observer
@SuppressWarnings("WeakerAccess") /* synthetic access */
int mActiveCount = 0;
// 用于处理Active\InActive状态
private boolean mChangingActiveState;
// 真实数据
private volatile Object mData;
// 当setData被调用, 在主线程进行pending数据和实际数据的交换
@SuppressWarnings("WeakerAccess") /* synthetic access */
volatile Object mPendingData = NOT_SET;
// 当前持有数据的版本号
private int mVersion;
// 记录在遍历通知各ObserverWrapper期间，数据是否发生变化
private boolean mDispatchingValue;
// 记录判断是否数据分发无效
@SuppressWarnings("FieldCanBeLocal")
private boolean mDispatchInvalidated;
// postValue()函数调用的Runnable
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
// 定义新的value
Object newValue;
// 同步处理
synchronized (mDataLock) {
// 新的value设置为mPendingData
newValue = mPendingData;
// mPendingData更新为默认数据
mPendingData = NOT_SET;
}
// 调用setValue()
setValue((T) newValue);
}
};
/**
* 有参数的构造函数
*
* @param value initial value
*/
public LiveData(T value) {
// 实际数据设置为参数传递的数据
mData = value;
// 当前持有的数据版本号从-1变为0
mVersion = START_VERSION + 1;
}
/**
* 无参构造函数
*/
public LiveData() {
// 实际数据设置为默认数据
mData = NOT_SET;
// 当前版本设置为-1
mVersion = START_VERSION;
}
// 实际更新数据的方法，判断是否需要将数据分发到指定的ObserverWrapper
@SuppressWarnings("unchecked")
private void considerNotify(ObserverWrapper observer) {
// 判断指定的observer是否是Active状态，不是则返回
if (!observer.mActive) {
return;
}
// 再次确认observer的最新状态，因为有可能生命周期实际上已经变化了，但是Active状态还没改变
if (!observer.shouldBeActive()) {
// 如果当前的observer不是Active状态，处于InActive状态，则不进行数据分发，并返回
observer.activeStateChanged(false);
return;
}
// 判断observer所持有的的版本是不是最新版本，如果是最新版本，则返回
if (observer.mLastVersion >= mVersion) {
return;
}
// 否则observer的版本就是当前最新版本
observer.mLastVersion = mVersion;
// observer通知新数据更新
observer.mObserver.onChanged((T) mData);
}
// 将数据通知给observer
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
// 如果在遍历OberverWrapper期间，如果数据发生改变，则会重新遍历通知
if (mDispatchingValue) {
// 如果数据发生变化，则分发无效
mDispatchInvalidated = true;
return;
}
// 设置数据发生变化标识为true
mDispatchingValue = true;
do {
// 分发无效标记设为false
mDispatchInvalidated = false;
// 如果传入的initiator不是空的，就只通知特定的ObserWrapper即可，如果是空的，就通知所有的
if (initiator != null) {
// 进行实际数据分发
considerNotify(initiator);
// initiator对象置空
initiator = null;
} else {
// 遍历所有的ObserverWrapper对象
for (Iterator, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
// 进行实际数据分发
considerNotify(iterator.next().getValue());
// 如果期间数据发生了变化，则中断for循环数据分发处理
if (mDispatchInvalidated) {
break;
}
}
}
// 如果数据无效标识为true，则do...while进行重新遍历，通知ObserWrapper进行数据分发
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
// 注册Observer
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
// 判断是否是主线程，不是则抛出异常
assertMainThread("observe");
// 判断当前的生命周期持有者是销毁状态，则返回
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 创建LifecycleBoundObserver对象
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 判断传入的Map中是否已经存在observer，如果存在则返回对象，否则添加并返回空
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
// 如果已经存在于map中，并且owner不同，则抛出异常
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
// 如果存在于map中，则返回
if (existing != null) {
return;
}
// 如果existing为空，map中不存在，则追加，从而实现对LifecycleOwner生命周期的感知
owner.getLifecycle().addObserver(wrapper);
}
// 永久观察，不在乎生命周期，只要数据发生变化，就会通知Observer
@MainThread
public void observeForever(@NonNull Observer observer) {
// 判断是否是主线程，不是则抛出异常
assertMainThread("observeForever");
// 创建AlwaysActiveObserver对象
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
// 判断传入的Map中是否已经存在observer，如果存在则返回对象，否则添加并返回空
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
// 判断map中存在Observer的类型，如果类型是LifecycleBoundObserver，不是AlwaysActiveObserver，则抛出异常
if (existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
// 如果map中存在则返回
if (existing != null) {
return;
}
// 直接分发数据
wrapper.activeStateChanged(true);
}
// 移除现有的Observer
@MainThread
public void removeObserver(@NonNull final Observer observer) {
// 判断是否是主线程
assertMainThread("removeObserver");
// 移除observer对象
ObserverWrapper removed = mObservers.remove(observer);
// 如果map中不存在则返回
if (removed == null) {
return;
}
// 通知生命周期持有者移除
removed.detachObserver();
// 不在分发数据
removed.activeStateChanged(false);
}
// 移除指定生命周期持有者对应的Observer
@SuppressWarnings("WeakerAccess")
@MainThread
public void removeObservers(@NonNull final LifecycleOwner owner) {
// 判断是否是主线程
assertMainThread("removeObservers");
// 遍历
for (Map.Entry, ObserverWrapper> entry : mObservers) {
// 判断是否owner一致
if (entry.getValue().isAttachedTo(owner)) {
// 移除
removeObserver(entry.getKey());
}
}
}
/**
* 子线程处理，最终还是通过setValue函数使用主线程进行分发数据
*
* liveData.postValue("a");
* liveData.setValue("b");
* "b"会被setValue函数首先设置，随后会在主线程被"a"覆盖
*
* 如果在主线程执行post之前，多次调用该函数，那么只有最后一个值会被分发
*/
protected void postValue(T value) {
// 创建标识
boolean postTask;
// 同步处理
synchronized (mDataLock) {
// mPendingData是否是默认值
postTask = mPendingData == NOT_SET;
// 将mPendingData设置为传入的value
mPendingData = value;
}
// 如果mPendingData不是默认值，则返回
if (!postTask) {
return;
}
// 主线程执行mPostValueRunnable
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
/**
* 设置数据，并且直接分发
* 必须主线程调用
*/
@MainThread
protected void setValue(T value) {
// 判断是否在主线程
assertMainThread("setValue");
// 当前持有数据版本高号加1
mVersion++;
// 实际数据设置为传递的参数
mData = value;
// 分发数据，并且参数传递为null，通知所有Observer
dispatchingValue(null);
}
/**
* 获取当前数据.
* 如果在子线程调用，有可能获取的并不是最新的数据
*/
@SuppressWarnings("unchecked")
@Nullable
public T getValue() {
// 创建临时变量，用于返回
Object data = mData;
// 当数据不是默认值的情况返回，否则返回空
if (data != NOT_SET) {
return (T) data;
}
return null;
}
// 获取当前数据版本
int getVersion() {
return mVersion;
}
/**
* 当观察者数量从0变为1时调用.
*/
protected void onActive() {
}
/**
* 当观察者数量从1变为0时调用.
* 并不意味这当前没有Observer了，只是观察者可能不处于STARTED或者RESUMED状态,例如Activity在后台
* 可以使用hasObservers检查当前是否还有observer
*/
protected void onInactive() {
}
/**
* 判断当前是否还有Observer
*/
@SuppressWarnings("WeakerAccess")
public boolean hasObservers() {
return mObservers.size() > 0;
}
/**
* 判断当前是否还有处于Active状态的Observer
*/
@SuppressWarnings("WeakerAccess")
public boolean hasActiveObservers() {
return mActiveCount > 0;
}
// 更新Active状态Observer的数量
@MainThread
void changeActiveCounter(int change) {
// 将之前的数量保存到局部变量中
int previousActiveCount = mActiveCount;
// 当前数量追加
mActiveCount += change;
// 当前是否处于Active状态，是Active状态则返回
if (mChangingActiveState) {
return;
}
// 否则设置为true
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 {
// 将状态设置为false
mChangingActiveState = false;
}
}
// 将LifecycleObserver和ObserverWrapper进行关联，当生命周期发生改变，通知ObserverWrapper进行更新
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
// 生命周期持有者对象
@NonNull
final LifecycleOwner mOwner;
// 构造函数
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer observer) {
super(observer);
// 生命周期持有者赋值
mOwner = owner;
}
// 判断是否处于Active状态
// DESTROYED,
// INITIALIZED,
// CREATED,
// STARTED,
// RESUMED;
// STARTED和RESUMED算是Active
@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) {
// 如果是destoryed则移除观察者，并返回
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;
}
// 移除Observer
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
// 抽象类ObserWrapper，用于LifecycleBoundObserver和AlwaysActiveObserver
private abstract class ObserverWrapper {
// 观察者对象
final Observer mObserver;
// 状态
boolean mActive;
// 版本号
int mLastVersion = START_VERSION;
// 构造函数
ObserverWrapper(Observer observer) {
mObserver = observer;
}
// 抽象函数，判断生命周期持有者当前状态，给到LifecycleBoundObserver和AlwaysActiveObserver
abstract boolean shouldBeActive();
// LifecycleBoundObserver用于判断生命周期持有者
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
// LifecycleBoundObserver用于移除Observer
void detachObserver() {
}
// 状态改变
void activeStateChanged(boolean newActive) {
// 如果状态一致则返回
if (newActive == mActive) {
return;
}
// 立即设置活动状态，这样我们就不会向非活动所有者发送任何内容
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
if (mActive) {
// 活动状态，分发数据
dispatchingValue(this);
}
}
}
// 无视生命周期的观察者
private class AlwaysActiveObserver extends ObserverWrapper {
// 构造函数
AlwaysActiveObserver(Observer observer) {
super(observer);
}
// 无视生命周期，直接返回true
@Override
boolean shouldBeActive() {
return true;
}
}
// 线程判断
static void assertMainThread(String methodName) {
if (!ArchTaskExecutor.getInstance().isMainThread()) {
throw new IllegalStateException("Cannot invoke " + methodName + " on a background"
+ " thread");
}
}
}