作用：监听数据变化，同时感知Activity或Fragment的生命周期
使用
创建一个LiveData的对象，并调用observe进行监听。然后调用setValue和postValue进行数据设置，触发回调。
public class MainActivity extends AppCompatActivity {
LiveData<String> data = new MutableLiveData<>();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main_activity);
//实现对data的监听，如果数据改变，会触发回调
data.observe(this, new Observer<String>() {
@Override
public void onChanged(String s) {
}
});
}
//data.setValue(value);
//data.postValue(value); 改变数据，触发回调
}
关键类
类图：
public abstract class LiveData<T> {
@SuppressWarnings("WeakerAccess")
final Object mDataLock = new Object();
static final int START_VERSION = -1;
@SuppressWarnings("WeakerAccess")
static final Object NOT_SET = new Object();
private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
new SafeIterableMap<>();
@SuppressWarnings("WeakerAccess")
int mActiveCount = 0;
private volatile Object mData;
@SuppressWarnings("WeakerAccess") /* synthetic access */
volatile Object mPendingData = NOT_SET;
private int mVersion;
private boolean mDispatchingValue;
@SuppressWarnings("FieldCanBeLocal")
private boolean mDispatchInvalidated;
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue);
}
};
public LiveData(T value) {
mData = value;
mVersion = START_VERSION + 1;
}
public LiveData() {
mData = NOT_SET;
mVersion = START_VERSION;
}
@SuppressWarnings("unchecked")
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
//是否应该分发
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
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");
//如果已经onDestroy，不注册观察者
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
return;
}
//将Observer封装成LifecycleBoundObserver，与LifecycleOwner绑定
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
//如果已经添加过，且LifecycleOwner不一样
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
//已添加过
if (existing != null) {
return;
}
owner.getLifecycle().addObserver(wrapper);
}
@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;
}
//一直分发数据，不关心Liefcycle的状态
wrapper.activeStateChanged(true);
}
@MainThread
public void removeObserver(@NonNull final Observer<? super T> observer) {
assertMainThread("removeObserver");
ObserverWrapper removed = mObservers.remove(observer);
if (removed == null) {
return;
}
removed.detachObserver();
//将状态置为不再分发新数据
removed.activeStateChanged(false);
}
@SuppressWarnings("WeakerAccess")
@MainThread
public void removeObservers(@NonNull final LifecycleOwner owner) {
assertMainThread("removeObservers");
for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) {
//移除跟LifecycleOwner绑定的观察者
if (entry.getValue().isAttachedTo(owner)) {
removeObserver(entry.getKey());
}
}
}
//异步将设置数据的任务放到主线程消息队列，如果同时调用多次，只有最后一次的数据会生效
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
//如果有任务在消息队列中，不再放到队列中，避免回调执行多次
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
//同步设置数据
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
@SuppressWarnings("unchecked")
@Nullable
public T getValue() {
Object data = mData;
if (data != NOT_SET) {
return (T) data;
}
return null;
}
int getVersion() {
return mVersion;
}
protected void onActive() {
}
protected void onInactive() {
}
@SuppressWarnings("WeakerAccess")
public boolean hasObservers() {
return mObservers.size() > 0;
}
@SuppressWarnings("WeakerAccess")
public boolean hasActiveObservers() {
return mActiveCount > 0;
}
}
ObserverWrapper：观察者的包装类，持有观察者，并跟状态有关
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();
//是否跟Lifecycle绑定
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
//移除观察者
void detachObserver() {
}
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
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);
}
}
}
LifecycleBoundObserver：继承自ObserverWrapper，跟Lifecycle绑定
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() {
//生命周期至少onStart之后才能进行分发
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
//如果已经onDestroy则移除观察者，并不进行分发
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
//判断LifecycleOwner是否一样
return mOwner == owner;
}
@Override
void detachObserver() {
//移除观察者
mOwner.getLifecycle().removeObserver(this);
}
}
