LiveData
LiveData是一種具有生命周期感知能力的可觀察數據持有類。
LiveData可以保證屏幕上的顯示內容和數據一直保持同步。
- LiveData了解UI界面的狀態，如果activity不在屏幕上顯示，LiveData不會觸發沒必要的界面更新，如果activity已經被銷毀，會自動清空與Observer的連接，意外的調用就不會發生。
- LiveData是一個LifecycleOwner，他可以直接感知activity或Fragment的生命周期。
1.定義LiveData
在項目中，LiveData一般是存放在ViewModel中，以保證app配置變更時，數據不會丟失。
2.使用流程
使用流程其實很簡單，就是自定義實現一個Observer觀察者，然后在Activity或者Fragment中獲取到ViewModel，通過ViewModel獲取到對應的LiveData，然后給LiveData添加觀察者監聽，用來監聽LiveData中的數據變化，在Observer的onChanged中使用監聽回調數據。
在使用LiveData的時候需要注意，LiveData有兩個設置數據的方法，一個是setValue，一個是postValue，setValue只能是在主線程使用，而postValue只能在子線程中使用。
3.核心原理
（1）LiveData.observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer)
LiveData添加觀察者監聽，可以看到LiveData的observe方法，使用了@MainThread注釋，表明該觀察者監聽添加的方法，只能是在主線程中使用，如果不是在主線程中使用，則會拋出異常。
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
// 判斷是否是在主線程中使用
assertMainThread("observe");
// 如果Activity或者Fragment的狀態已經是onDestroy，那么就不可以添加觀察者監聽
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 將LifecycleOwner和Observer實現對象封裝成LifecycleBoundObserver
// 而LifecycleBoundObserver是ObserverWrapper的子類，
// 并且實現了LifecycleEventObserver接口
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 往LiveData中的mObservers集合添加對應的wrapper對象
// 這樣做的目的，就是為了用來在LiveData更新的時候進行通知觀察者
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);
}
// LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
// Lifecycling.java
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
if (type == GENERATED_CALLBACK) {
List<Constructor<? extends GeneratedAdapter>> constructors =
sClassToAdapters.get(klass);
if (constructors.size() == 1) {
GeneratedAdapter generatedAdapter = createGeneratedAdapter(
constructors.get(0), object);
return new SingleGeneratedAdapterObserver(generatedAdapter);
}
GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
for (int i = 0; i < constructors.size(); i++) {
adapters[i] = createGeneratedAdapter(constructors.get(i), object);
}
return new CompositeGeneratedAdaptersObserver(adapters);
}
return new ReflectiveGenericLifecycleObserver(object);
}
在LiveData添加觀察者的時候，因為LifecycleBoundObserver實際上也是實現了LifecycleEventObserver接口的，所以在Lifecycling.lifecycleEventObserver對觀察者對象做封裝的時候，也是直接返回傳入的觀察者對象，不做任何的處理
（2）LiveData.LifecycleBoundObserver類
LifecycleBoundObserver中封裝了LifecycleOwner對象和Observer對象，并且實現了LifecycleEventObserver接口，根據Lifecycle的原理，其實我們可以知道，LifecycleRegistry.addObserver方法，添加的就是LifecycleEventObserver實現了對象。
所以在Activity使用LiveData，添加觀察者，其實其內部最終還是給Activity的LifecycleRegistry添加觀察者，然后根據Activity的生命周期的變化對LiveData進行通知。
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
// 封裝LifecycleOwner實現類對象
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() {
// 這個其實就是判斷Activity當前狀態是否大于等于STARTED，比如RESUMED
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
// 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();
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);
}
}
}
（3）setValue和postValue
@MainThread
protected void setValue(T value) {
// 判斷當前線程是否是主線程，如果不是主線程，就拋出異常
assertMainThread("setValue");
mVersion++;
mData = value;
// 通知觀察者
dispatchingValue(null);
}
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
// 分發執行任務
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
setValue的通知更新
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(); ) {
// 通知觀察者，參數是ObserverWrapper類型的對象
// 其實就是LifecycleBoundObserver對象
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
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是ObserverWrapper對象，其實現類是LifecycleBoundObserver
// LifecycleBoundObserver內部封裝了mObserver觀察者
// 在這里調用觀察者的onChanged()傳入新的數據，就是通知觀察者進行更新
observer.mObserver.onChanged((T) mData);
}
postValue的通知更新
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);
}
};
從這里可以看到，其實postValue在分發的任務中，其內部實現的依然是setValue()方法，只不過是從子線程切換到了主線程進行執行。做了一次線程的切換。
在postValue方法中，其內部調用的是ArchTaskExecutor的postToMainThread方法。
// ArchTaskExecutor.java
private ArchTaskExecutor() {
mDefaultTaskExecutor = new DefaultTaskExecutor();
mDelegate = mDefaultTaskExecutor;
}
@Override
public void postToMainThread(Runnable runnable) {
mDelegate.postToMainThread(runnable);
}
在這里可以看到mDelegate其實就是DefaultTaskExecutor對象
所以mDelegate.postToMainThread(runnable)其實就是調用了DefaultTaskExecutor.postToMainThread方法。
// DefaultTaskExecutor.java
@Override
public void postToMainThread(Runnable runnable) {
if (mMainHandler == null) {
synchronized (mLock) {
if (mMainHandler == null) {
mMainHandler = createAsync(Looper.getMainLooper());
}
}
}
//noinspection ConstantConditions
mMainHandler.post(runnable);
}
在這里可以看到，mMainHandler其實就是通過主線程的Looper實例創建的Handler對象，所以這里Handler發送消息執行任務，就是在主線程中執行該任務。
（4）dispatchingValue消息分發
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;
}
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;
//noinspection unchecked
observer.mObserver.onChanged((T) mData);
}
LiveData在分發消息的時候，會調用dispatchingValue方法循環分發，當消息分發完成之后，其實并不會退出do-while循環，還會在調用considerNotify方法的內部調用observer.activeStateChanged(false);繼續執行第二次dispatchingValue方法，也就是說遞歸執行，在第二次執行的時候，mDispatchingValue = true，就會執行將mDispatchInvalidated = true，那么就會完成dispatchingValue方法的第二次執行，被直接return，那么considerNotify()方法的執行也就完成，此時就會執行considerNotify之后的if條件，因為在dispatchingValue第二次執行的時候將mDispatchInvalidated設置為了true，就直接break跳出了循環，結束了消息的分發。
但是這樣的情況，一般是在存在觀察者處于ON_STOP或者已經是ON_DESTROY狀態的時候。
如果觀察者都是處于onResume，那么這個時候會因為mDispatchInvalidated=false而退出了循環，結束分發。
4.粘性事件
但是如果是先setValue，然后再設置Observer的話。
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> 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);
}
因為此時設置Observer的時候，當生命周期發生變化的時候，又會調用回調onStateChanged方法，進而調用activeStateChanged方法
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);
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
// 這里傳入的應該是true
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
// 而第一次的時候，mActive默認是false
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();
}
// 變成了true的時候，又會調用一次分發
if (mActive) {
dispatchingValue(this);
}
}
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;
}
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);
}
因為在添加Observer之前，已經針對該LiveData設置了一個value，此時添加了觀察者，那么又因為生命周期發生了變化，那么該觀察者在調用dispatchingValue(this);傳入的就不是null，則在do-while循環的if判斷中，就會執行if條件，進而調用considerNotify()方法給傳入的ObserverWrapper實現類分發消息，那么就會把之前設置的消息分發給了該觀察者。
這樣的情況就是LiveData的粘性事件。即后注冊的觀察者接收到了之前LiveData設置的value消息。
那么問題又一次來了，什么時候會觸發調用LifecycleBoundObserver的onStateChanged方法呢？
通過LiveData的observe方法進行分析，我們可以知道給LiveData添加觀察者的時候，其實就是通過給實現了LifecycleOwner接口的Activity的getLifecycle()方法獲取到的LifecycleRegistry對象添加觀察者，而LifecycleRegistry中的addObserver方法，就會先滿足while條件，然后執行了ObserverWithState.dispatchEvent方法，此時就會調用到了LifecycleBoundObserver.onStateChanged方法
這里為什么會滿足while條件呢？calculateTargetState會獲取當前Activity生命周期狀態的前一個和后一個狀態，然后取更小的那個狀態，在addObserver的時候，calculateTargetState這里如果activity是onStart的狀態，那么calculateTargetState取出的就是CREATED狀態，如果activity是onResume的狀態，那么這里取出的就是STARTED，不管怎么樣都會大于INITIALIZED狀態，那么就會滿足while條件，此時第二個activity是在onCreate生命周期調用observe方法注冊Observer
// LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
其實這里個人感覺，應該是在addObserver之后，因為第二個Activity(也就是添加addObserver的)發生了生命周期變化，從onCreate變成了onStart，從onStart變成onResume，此時就會調用moveToState，然后就會調用forwardPass()，然后就會分發消息，因為之前已經postValue或者setValue了，那么在這個LiveData里的mData就不會為null，有消息了，就可以優先分發一次。
滿足while條件后，就會調用statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));，這里最終就會調用LifecycleBoundObserver的
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
這里shouldBeActive()，在Activity的最后的生命周期是onResume的時候，就會滿足true，那么此時activeStateChanged()傳入的參數就是true，而初始的時候，mActive為false
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);
}
}
此時mActive就會重新賦值為true，那么就會調用dispatchingValue()方法，此時dispatchingValue()的參數傳入this，那么就不會為false。
一般常用的粘性事件解決方案，其實就是hook修改mLastVersion的值，讓這個值變成與mVersion的值一致，但是如果是在onResume或者onStart的生命周期去添加注冊觀察者，那么常見的粘性事件解決方案中，因為會調用super.observe()，那么就會因為在LifecycleRegistry.addObserver方法中，滿足while條件，從而又會進行LifecycleBoundObserver的onStateChanged方法的回調，這樣又會出現粘性事件。這樣的情況的解決方案，其實可以hook修改mVersion的值，在注冊觀察者之前，改成-1
