Lifecycle 是 AAC 中幫助我們構(gòu)建生命周期感知組件的框架.
常見(jiàn)的情況
在客戶端開(kāi)發(fā)中, 我們的組件需要頁(yè)面的狀態(tài)做出不同的響應(yīng).
舉個(gè)例子, Activity 中有個(gè)播放器player, 為了更好的用戶體驗(yàn)我們通常需要 :
- 在 Activity#onPasuse() 時(shí)暫停播放
- 在 Activity#onResume() 時(shí)繼續(xù)播放
- 在 Activity#onDestory() 時(shí)銷毀播放器和監(jiān)聽(tīng)器
常見(jiàn)的模式是在 Activity/Fragment 的生命周期方法中實(shí)現(xiàn)依賴組件的操作。然而，這種模式會(huì)導(dǎo)致糟糕的代碼組織和錯(cuò)誤的擴(kuò)散. 通過(guò)使用生命周期感知組件，您可以將依賴組件的代碼移出生命周期方法，并移到組件本身。
使用Lifecycle
class DetailActivity :AppCompatActivity(){
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_detail)
getLifecycle().addObserver(object: DefaultLifecycleObserver {
override fun onResume(owner: LifecycleOwner) {
super.onResume(owner)
player.start()
}
override fun onPause(owner: LifecycleOwner) {
super.onPause(owner)
player.pause()
}
override fun onDestroy(owner: LifecycleOwner) {
super.onDestroy(owner)
player.release()
}
}
}
}
核心組件
Lifecycle 包括很多包: ViewModel, LiveData, ktx擴(kuò)展, RxJava轉(zhuǎn)LiveData擴(kuò)展...
本篇討論的只是
lifecycle-runtime:
- LifecycleOwner : 生命周期持有者, 被觀察的對(duì)象.
- LifecycleObserver : 生命周期觀察者.
- Lifecycle : 表明生命周期的接口.
1. LifecycleOwner
LifecycleOwner 只定義了一個(gè)方法 Lifecycle getLifecycle() 返回 Lifecycle 對(duì)象.
當(dāng)前的 ComponentActivity & Fragment 都實(shí)現(xiàn)了這個(gè)接口.
/**
* A class that has an Android lifecycle. These events can be used by custom components to
* handle lifecycle changes without implementing any code inside the Activity or the Fragment.
*
* @see Lifecycle
*/
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
1.1 LifecycleOwner分發(fā)事件
以 Activity 為例, ComponentActivity 實(shí)現(xiàn)了 LifecycleOwner 接口, 并返回了 Lifecycle 的實(shí)現(xiàn)類對(duì)象 LifecycleRegistry.
- 通過(guò)一個(gè)沒(méi)有界面的
ReportFragment來(lái)充當(dāng)生命周期的輔助類(這一點(diǎn)和Glide類似)
public class ComponentActivity extends Activity
implements LifecycleOwner{
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//創(chuàng)建 ReportFragment
ReportFragment.injectIfNeededIn(this);
}
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
- 在 ReportFragment 的生命周期回調(diào)中都調(diào)用了
dispatch(Lifecycle.Event.XXXX)方法.
public class ReportFragment extends Fragment {
public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
}
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onStop() {
super.onStop();
dispatch(Lifecycle.Event.ON_STOP);
}
@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
}
-
dispatch(event)調(diào)用((LifecycleRegistry) lifecycle).handleLifecycleEvent(event), 而 LifecycleRegistry 怎么處理 event 的接下來(lái)會(huì)分析.
public class ReportFragment extends Fragment {
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
//為舊版本support.v7.app.AppCompatActivity兼容的, 已經(jīng)標(biāo)記為deprecated
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
//androidx.fragment.app.FragmentActivity
if (activity instanceof LifecycleOwner) {
//Lifecycle對(duì)象由Activity實(shí)現(xiàn)LifecycleOwner接口返回
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
//調(diào)用Lifecycle # handleLifecycleEvent(event)方法來(lái)分發(fā)生命周期
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
}
2. LifecycleObserver
我們的組件實(shí)現(xiàn) LifecycleObserver 接口, 標(biāo)記著組件是生命周期的觀察者.
/**
* Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
* {@link OnLifecycleEvent} annotated methods.
* <p>
* @see Lifecycle Lifecycle - for samples and usage patterns.
*/
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {
}
但他是一個(gè)空接口, 參照 Lifecycle 的注釋, 在不同的JDK版本上有不同的實(shí)現(xiàn).
| JDK版本 | 實(shí)現(xiàn) |
|---|---|
| 1.8之前 |
@OnLifecycleEvent 方法注解 |
| 1.8 | DefaultLifecycleObserver |
兩種方式都是通過(guò) Lifecycing 的 getCallback(Object object) 創(chuàng)建.
2.1 注解實(shí)現(xiàn)
@OnLifecycleEvent 是運(yùn)行時(shí)注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
Lifecycle.Event value();
}
具體實(shí)現(xiàn)在 ClassesInfoCache 類中:
class ClassesInfoCache {
//判斷是否有注解
boolean hasLifecycleMethods(Class klass) {
if (mHasLifecycleMethods.containsKey(klass)) {
return mHasLifecycleMethods.get(klass);
}
Method[] methods = getDeclaredMethods(klass);
for (Method method : methods) {
//根據(jù) OnLifecycleEvent 注解
OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
if (annotation != null) {
//生成CallbackInfo對(duì)象, 保存到 mCallbackMap 中
createInfo(klass, methods);
return true;
}
}
mHasLifecycleMethods.put(klass, false);
return false;
}
private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
Class superclass = klass.getSuperclass();
Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
if (superclass != null) {
//getInfo() 又會(huì)遞歸調(diào)用createInfo(), 解析所有的 @OnLifecycleEvent 注解
CallbackInfo superInfo = getInfo(superclass);
if (superInfo != null) {
handlerToEvent.putAll(superInfo.mHandlerToEvent);
}
}
Class[] interfaces = klass.getInterfaces();
for (Class intrfc : interfaces) {
for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
intrfc).mHandlerToEvent.entrySet()) {
verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
}
}
// 解析 @OnLifecycleEvent 注解方法,保存到 info 中
Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
boolean hasLifecycleMethods = false;
for (Method method : methods) {
OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
if (annotation == null) {
continue;
}
hasLifecycleMethods = true;
Class<?>[] params = method.getParameterTypes();
int callType = CALL_TYPE_NO_ARG;
if (params.length > 0) {
callType = CALL_TYPE_PROVIDER;
if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
throw new IllegalArgumentException(
"invalid parameter type. Must be one and instanceof LifecycleOwner");
}
}
Lifecycle.Event event = annotation.value();
if (params.length > 1) {
callType = CALL_TYPE_PROVIDER_WITH_EVENT;
if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
throw new IllegalArgumentException(
"invalid parameter type. second arg must be an event");
}
if (event != Lifecycle.Event.ON_ANY) {
throw new IllegalArgumentException(
"Second arg is supported only for ON_ANY value");
}
}
if (params.length > 2) {
throw new IllegalArgumentException("cannot have more than 2 params");
}
MethodReference methodReference = new MethodReference(callType, method);
verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
}
CallbackInfo info = new CallbackInfo(handlerToEvent);
//以class名字作為key, 添加到mCallbackMap中
mCallbackMap.put(klass, info);
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;
}
使用注解時(shí), Lifecycying 的 getCallBack() 返回的是 ReflectiveGenericLifecycleObserver, 在 onStateChanged() 時(shí)反射調(diào)用 mInfo 中的方法.
class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
//反射調(diào)用對(duì)應(yīng)的 event回調(diào)
mInfo.invokeCallbacks(source, event, mWrapped);
}
}
2.2 DefaultLifecycleObserver
借助1.8的新特性 default method, 我們不必實(shí)現(xiàn)所有的接口方法.
public interface DefaultLifecycleObserver extends FullLifecycleObserver {
@Override
default void onCreate(@NonNull LifecycleOwner owner) {
}
@Override
default void onStart(@NonNull LifecycleOwner owner) {
}
.....
@Override
default void onDestroy(@NonNull LifecycleOwner owner) {
}
}
此時(shí) Lifecycing 返回的是 FullLifecycleObserverAdapter, onStateChanged() 時(shí)會(huì)調(diào)用 FullLifecycleObserver 中的回調(diào).
class FullLifecycleObserverAdapter implements GenericLifecycleObserver {
private final FullLifecycleObserver mObserver;
FullLifecycleObserverAdapter(FullLifecycleObserver observer) {
mObserver = observer;
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
switch (event) {
case ON_CREATE:
mObserver.onCreate(source);
break;
.......
case ON_DESTROY:
mObserver.onDestroy(source);
break;
case ON_ANY:
throw new IllegalArgumentException("ON_ANY must not been send by anybody");
}
}
}
3. Lifecycle
Lifecycle 保存了 LifecycleOwner 的生命周期信息, 來(lái)給 LifecycleObserver 觀察.
他使用了兩個(gè)枚舉來(lái)跟蹤 LifecycleOwner 生命周期狀態(tài):
3.1 Event
生命周期事件, 對(duì)應(yīng)著 Activity/Fragment 中的生命周期回調(diào).
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
3.2 State
提供了五種生命周期狀態(tài)和一個(gè)判斷生命周期的方法.
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
//判斷組件的狀態(tài)是否在給定的state之后
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
3.3 State和Event
如圖, State 是狀態(tài)的節(jié)點(diǎn), 而 Event 則是從一個(gè)State 到達(dá)另外一個(gè) State 的過(guò)程.
lifecycle_state_event.png
3.4 Lifecycle的實(shí)現(xiàn)類
除了枚舉, Lifecycle 還定義了三個(gè)抽象方法, 標(biāo)準(zhǔn)的狀態(tài)機(jī)模式
//添加觀察者
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer)
//移除觀察者
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
//獲取當(dāng)前的狀態(tài)
@MainThread
@NonNull
public abstract State getCurrentState();
在SDK中已經(jīng)提供了他的一個(gè)實(shí)現(xiàn)類 LifecycleRegistry, 在 ComponentActivity & Fragment 中的 getLifecycle() 返回的就是該實(shí)現(xiàn).
public class ComponentActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
public class Fragment implements LifecycleOwner {
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
4. LifecycleRegistry
LifecycleRegistry 實(shí)現(xiàn)了 Lifecycle 的三個(gè)抽象方法.
4.1. handleLifecycleEvent(event)
處理生命周期通過(guò) handleLifecycleEvent(event) 處理:
public class LifecycleRegistry extends Lifecycle {
private int mAddingObserverCounter = 0;
private boolean mHandlingEvent = false;
private boolean mNewEventOccurred = false;
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
// mHandlingEvent 在sync()前后標(biāo)記, 在sync()完成前為true
// mAddingObserverCounter在addObserver()中被遞增遞減, 在addObserver()完成前 != 0
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// 不需要sync()
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
// sync() 會(huì)把狀態(tài)的變化轉(zhuǎn)化為生命周期事件，然后轉(zhuǎn)發(fā)給 LifecycleObserver
sync();
mHandlingEvent = false;
}
}
4.1.1 sync()
sync() 負(fù)責(zé)處理Aticivty/Fragmet 生命周期變化時(shí), 同步 Observer 的狀態(tài), 從而觸發(fā) Observer 的狀態(tài)回調(diào).
LifecycleRegistry 使用 FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap 作為保存 Observer 和 State 映射關(guān)系的容器, 他保證 :
插入順序 Observer1 < Observer2 時(shí), Observer1.State1 >= Observer2.State2.
所以 isSynced() 判斷是否同步完成, 只需要判斷 mObserverMap 頭尾的 State 相等eldestObserverState == newestObserverState, 并且都等于最新的狀態(tài) mState
public class LifecycleRegistry extends Lifecycle {
//使用弱引用指向LifecycleOwner
private final WeakReference<LifecycleOwner> mLifecycleOwner;
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
/**
* Custom list that keeps observers and can handle removals / additions during traversal.
*
* Invariant: at any moment of time for observer1 & observer2:
* if addition_order(observer1) < addition_order(observer2), then
* state(observer1) >= state(observer2),
* mObserverMap中元素的state順序和插入的順序是相反的
*/
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
// happens only on the top of stack (never in reentrance),
// so it doesn't have to take in account parents
private void sync() {
//如果owner被回收了, 就不繼續(xù)分發(fā)
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
+ "new events from it.");
return;
}
//一直同步到isSynced()為true
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
//mObserverMap中元素的state和插入的順序是相反的, 參照注釋
//判斷是否同步完成, 只需要判斷頭尾元素都等于最新的state
private boolean isSynced() {
if (mObserverMap.size() == 0) {
return true;
}
State eldestObserverState = mObserverMap.eldest().getValue().mState;
State newestObserverState = mObserverMap.newest().getValue().mState;
return eldestObserverState == newestObserverState && mState == newestObserverState;
}
}
而while循環(huán)中的同步處理又分為兩種情況 backwardPass() 和 forwardPass()
4.1.2 backwardPass()
因?yàn)?mObserverMap 中 Observer 的 State 是遞減的, 所以如果第一個(gè) Observer 的 State 小于等于 LifecycleRegistry 的 mState, 那么 mObserverMap 中所有 Observer 的 State 都小于等于 mState.
如果第一個(gè) Observer 的 State 就大于 mState, 那么 mObserverMap 后面可能還有大于 mState 的 Observer. 因?yàn)?mObserverMap 中 Observer 的 State 是遞減的, 所以要從尾到頭開(kāi)始遍歷.
private void backwardPass(LifecycleOwner lifecycleOwner) {
// 使用mObserverMap的反向迭代器, 從尾向頭遍歷
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
//如果分發(fā)過(guò)程中有新的事件, 就停止分發(fā)
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
//如果observer.mState大于mState, 就向下調(diào)整
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
//向下調(diào)整的邏輯
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
向下調(diào)整的邏輯分解一下:
1.downEvent(observer.mState)
獲取State節(jié)點(diǎn)的下一個(gè)Event
private static Event downEvent(State state) {
switch (state) {
case INITIALIZED:
throw new IllegalArgumentException();
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
case DESTROYED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
2. pushParentState(getStateAfter(event)) & popParentState()
這里引入了一個(gè)新的對(duì)象 ArrayList<State> mParentStates 來(lái)保存目標(biāo) State, 這是為了應(yīng)對(duì)重入的場(chǎng)景:
// we have to keep it for cases:
// void onStart() {
// mRegistry.removeObserver(this);
// mRegistry.add(newObserver);
// }
// newObserver should be brought only to CREATED state during the execution of
// this onStart method. our invariant with mObserverMap doesn't help, because parent observer
// is no longer in the map.
private ArrayList<State> mParentStates = new ArrayList<>();
private void popParentState() {
mParentStates.remove(mParentStates.size() - 1);
}
private void pushParentState(State state) {
mParentStates.add(state);
}
重入的部分比較難理解, 參考注釋中的例子, 在 observer.onStart() 中先 mRegistry.removeObserver(this) 移除自己, 然后添加observer mRegistry.add(newObserver).
- observer的 State 經(jīng)過(guò)
forwardPass()從INITIALIZED變成CREATED, 調(diào)用 observer.onCreate() - Activity 經(jīng)過(guò) onStart() 時(shí)通過(guò)
handleLifecycleEvent()繼續(xù)調(diào)用sync(), observer 通過(guò)forwardPass()從CREATED變成STARTED, 分發(fā) observer.onStart().
注意此時(shí)分發(fā)未結(jié)束, 沒(méi)有調(diào)用popParentState(), 所以mParentStates中仍然是 CREATED, observer 分發(fā)前的狀態(tài). - 這時(shí)
mRegistry.removeObserver(this)移除掉observer, 這時(shí)mRegistry.add(newObserver)添加了newObserver. 此時(shí)需要計(jì)算 newObserver 需要同步到的targetState(在下面的addObserver(observer)會(huì)提到), 此時(shí)mObserverMap中已經(jīng)沒(méi)有 observer 的信息. 這時(shí)可以借助上一步保存的mParentStates保存的 CREATED 來(lái)幫助我們計(jì)算 newOsberver 的targetState. - 這時(shí) observer 的
forwardPass流程結(jié)束, 并且mObserverMap中有了新的元素 newObserver, 不滿足sync()中isSynced()的條件, 需要繼續(xù)把 newObserver 同步到當(dāng)前頁(yè)面的狀態(tài)STARTED.
3. observer.dispatchEvent(lifecycleOwner, event)
通過(guò) GenericLifecycleObserver 的 onStateChanged(owner, event) 來(lái)完成事件的分發(fā).
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) 中不管你使用注解+反射的方式, 還是Java8的default method方式, 都會(huì)使用適配器模式, 生成對(duì)應(yīng)的 GenericLifecycleObserver 實(shí)現(xiàn)類.
forwardPass()
邏輯與 backwardPass() 相反, 不多贅述.
4.2. add & remove Observer
向 mObserverMap 中添加和刪除 Observer.
需要注意的是 calculateTargetState() 中使用了暫存的 mParentStates 來(lái)處理 observer 重入的情況.上面已經(jīng)分析過(guò).
//觀察者的集合
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//初始化狀態(tài)
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//不能重復(fù)添加同一個(gè)Observer, 保證唯一性
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
//LifecycleOwner即Fragment/Activity
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
//如果owner為空, 說(shuō)明頁(yè)面被回收了, 直接return
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
// isReentrance表示是重入執(zhí)行，通過(guò)mAddingObserverCounter或mHandlingEvent判斷。
// mHandlingEvent是在前文的sync方法前后進(jìn)行標(biāo)記的，也就是“在分發(fā)事件”。
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
// 計(jì)算要同步到的目標(biāo)狀態(tài)，是LifecycleRegistry上一個(gè)添加的Observer的狀態(tài)、上一層被分發(fā)事件的Observer的狀態(tài)
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);
}
//非重入情況, 直接同步狀態(tài)
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
mObserverMap.remove(observer);
}
private State calculateTargetState(LifecycleObserver observer) {
Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
State siblingState = previous != null ? previous.getValue().mState : null;
State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
: null;
return min(min(mState, siblingState), parentState);
}
