Lifecycle生命周期感知型組件，用來執行、操作、響應另一個組件（如 Activity 和 Fragment）的生命周期狀態的變化。
本文Lifecycle版本為2.2.0：
implementation 'androidx.lifecycler:lifecycle-common:2.2.0' //22.2.23 更新 2.5 ，2.2是用的比較多的版本
你真的了解Lifecycle了嗎？
Lifecycle使用非常非常簡單。默認你已經使用過Lifecycle。但如果我問你以下幾個問題。你能回答出來幾個？
-
Lifecycle的創建方式有幾種？- 有什么不同？推薦使用哪種？為什么？
-
Event事件和State狀態是什么關系-
onStop()生命周期，處于什么State狀態
-
-
Lifecycle是如何進行生命周期同步- 如果在
onResume()注冊觀察者會收到那幾個種回調？為什么？
- 如果在
-
Activity/Fragment實現Lifecycle能力的方式一樣嗎？- 為什么要這么設計？有什么好處？
- Application能感知Activity生命周期嗎?（如何使用Lifecycle監聽前后臺的能力）
-
Lifecycle從源碼角度，簡述Lifecycle的注冊，派發，感知的過程 - 什么
嵌套事件？發生的時機？Lifecycle是如何解決的？
如果我是面試官，遇到簡歷上寫掌握Jetpack組件，我一定是會問Lifecycle這幾個問題。因為它首先是Jetpack另外兩個超級核心組件ViewModel,LiveData，實現能力的基石。同時它的使用頻率也非常高，看似簡單，容易被忽略，但卻很多東西值得學習。
這十幾個問題，從用法到源碼，從表面到延伸。如果全懂，說明你真正掌握了Lifecycle的80%，沒錯~！僅僅是8成。因為下面的源碼分析，還會有更多延伸的問題.
Lifecycle基本使用
作為生命周期感知組件、它的作用就是監聽宿主Activity/Fragment，然后派發給觀察者。這句看似簡單的概括，卻倒出3個重要的角色：
宿主，觀察者，用來派發的調度器
[圖片上傳失敗...(image-614e69-1649222135014)]
使用Lifecycle的方法很簡單：
- 先創建Observer，可以直接繼承父類：
LifecycleObserver
public class LocationObserver implements LifecycleObserver {
private static final String TAG = "LocationObserver";
//1. 自定義的LifecycleObserver觀察者，用注解聲明每個方法觀察的宿主的狀態
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreate(@NotNull LifecycleOwner owner) {
Timber.e("onCreate_ON_CREATE");
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void onStart(@NotNull LifecycleOwner owner) {
Timber.e("onStart_ON_START");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume(@NotNull LifecycleOwner owner) {
Timber.e("onResume_ON_RESUME");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause(@NotNull LifecycleOwner owner) {
Timber.e("onPause_ON_PAUSE");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void onStop(@NotNull LifecycleOwner owner) {
Timber.e("onStop_ON_STOP");
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestroy(@NotNull LifecycleOwner owner) {
Timber.e("onDestroy_ON_DESTROY");
}
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
void onAny(LifecycleOwner owner) {
Timber.e("onAny_ON_ANY-->%s", owner.getLifecycle().getCurrentState());
}
}
自己定義生命周期方法，并在每個方法上面標記對應生命周期的注解。同時還能獲得LifecycleOwner也就是宿主Activity
- 繼承：
LifecycleEventObserver，復寫onStateChanged方法：
public class EventObserver implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
switch (event) {
case ON_CREATE:
Timber.d("ON_CREATE");
break;
case ON_START:
Timber.d("ON_START");
break;
case ON_RESUME:
Timber.d("ON_RESUME");
break;
case ON_PAUSE:
Timber.d("ON_PAUSE");
break;
case ON_STOP:
Timber.d("ON_STOP");
break;
case ON_DESTROY:
Timber.d("ON_DESTROY");
break;
default:
break;
}
}
}
- 繼承：
FullLifecycleObserver，直接復寫對應的生命周期回調：
public class FullLocationObserver implements DefaultLifecycleObserver {
@Override
public void onCreate(@NonNull LifecycleOwner owner) {
Timber.e("onCreate");
}
@Override
public void onStart(@NonNull LifecycleOwner owner) {
Timber.e("onStart");
}
@Override
public void onResume(@NonNull LifecycleOwner owner) {
Timber.e("onResume");
}
@Override
public void onPause(@NonNull LifecycleOwner owner) {
Timber.e("onPause");
}
@Override
public void onStop(@NonNull LifecycleOwner owner) {
Timber.e("onStop");
}
@Override
public void onDestroy(@NonNull LifecycleOwner owner) {
Timber.e("onDestroy");
}
}
此時你會發現，你無法直接繼承FullLifecycleObserver這時你要添加一個依賴：
implementation 'androidx.lifecycler:lifecycle-common:2.2.0'
替換上面引入的依賴(默認會集成上面的)
implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"
繼承：DefaultLifecycleObserver，它是FullLifecycleObserver的子類，因為在Java8以后，支持interface接口類型，可以有自己的默認實現。
然后在Activity#OnCreate()中調用如下方法：
lifecycle.addObserver(LocationObserver())
接著，你就可以使用Lifecycle的能力了。
從源碼了解過程
如果是MVP，你可以讓你的Presenter去實現Observer，在處理邏輯時獲得感知的能力。但如果我們把注冊的代碼lifecycle.addObserver(LocationObserver())放入onResume()方法中，會發生什么？你會發現Observer除了可以收到onResume事件，竟然還可以收到onCreate,onStart。也就說宿主的狀態，會同步給觀察者。這是怎么做到的？
感知監聽
getLifecycle點進去，會進入到ComponentActivity核心代碼：
public class ComponentActivity extends Activity implements LifecycleOwner{
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
protected void onCreate(Bundle bundle) {
super.onCreate(savedInstanceState);
//往Activity上添加一個fragment,用以報告生命周期的變化
//目的是為了兼顧不是繼承自AppCompactActivity的場景.
ReportFragment.injectIfNeededIn(this);
}
-
LifecycleRegistry是Lifecycle的子類，通過new LifecycleRegistry(this);把宿主Owner,也就是當前Activity作為構造參數傳遞進去 -
Activity并不是直接派發生命周期，而是利用ReportFragment.injectIfNeededIn(this)，
public class ReportFragment extends Fragment{
public static void injectIfNeededIn(Activity activity) {
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
@Override
public void onStart() {
super.onStart();
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
}
private void dispatch(Lifecycle.Event event) {
//調用宿主的Lifecycle
Lifecycle lifecycle = activity.getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
ReportFragment.injectIfNeededIn(this)的作用是在Activity之上，創建一個不可見的Fragment的。當Fragment的生命周期發生變化，會通過dispatch()，接著調用((LifecycleRegistry) lifecycle).handleLifecycleEvent(event)來分發事件。這樣做的目的是為了，當頁面不是繼承ComponentActivity,而是直接繼承Activity，那么它就沒有了感知的能力。此時需要自己實現LifecycleOwner,復寫getLifecycle(),然后將自己傳入進new LifecycleRegistry(this),就可以成為宿主，讓其他Observer來監聽。ReportFragment.injectIfNeededIn(this)另一個使用的地方LifecycleDispatcher：
class LifecycleDispatcher {
private static AtomicBoolean sInitialized = new AtomicBoolean(false);
static void init(Context context) {
if (sInitialized.getAndSet(true)) {
return;
}
((Application) context.getApplicationContext())
.registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}
@SuppressWarnings("WeakerAccess")
@VisibleForTesting
static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
ReportFragment.injectIfNeededIn(activity);
}
@Override
public void onActivityStopped(Activity activity) {
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
}
private LifecycleDispatcher() {
直接為Activity注入ReportFragment,使得每個頁面都能成為宿主，讓觀察者感知,當然，你里面要自己實現LifecycleOwner,復寫getLifecycle(),然后將自己傳入進new LifecycleRegistry(this)。==這部分與Lifecycle關系不大，只是作為知識擴展==
[圖片上傳失敗...(image-376d45-1649222135014)]
總結：
- 監聽過程就是，
Activity/Fragment繼承LifecycleOwner,并在子類CommponentActivity中創建Lifecycle的子類LifecycleRegistry。在復寫getLifecycle()的方法中將子類LifecycleRegistry返回。 - 在
onCreate()中注入ReportFragment，在生命周期回調后，通過getLifecycle()的方法得到LifecycleRegistry對象中的handleLifecycleEvent(event)方法給每個觀察者派發生命周期事件。
為什么以Activity為例子，而不是像其他文章，以Fragement為例子，是因為你去看眼源碼就會發現ReportFragment類中的dispatch()過程和Fragement如出一轍：
public class Fragment implements xxx, LifecycleOwner {
//...
void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState); //1.先執行生命周期方法
//...省略代碼
//2.生命周期事件分發
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
onStart();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
onResume();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
//3.注意，調用順序變了
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
//...
onPause();
}
void performStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
//...
onStop();
}
void performDestroy() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
//...
onDestroy();
}
}
參照Android 架構組件（一）——Lifecycle, @ShymanZhu文中的時序圖：
[圖片上傳失敗...(image-6393d7-1649222135014)]
同時，你會發現Fragment中performCreate()、performStart()、performResume()會先調用自身的onXXX()方法，然后再調用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中會先LifecycleRegistry的handleLifecycleEvent()方法 ，然后調用自身的onXXX()方法。摘抄自-Lifecycle:生命周期組件詳解&原理分析
同步
上面是監聽過程，getLifecycle().addObserver(LocationObserver())注冊代碼的前半部分。現在我們獲得感知宿主的能力，并將事件event轉發給LifecycleRegistry,他是整個流程的核心。現在來看后半部分，如何注冊Observer后可以在任何時機(onDestory除外),感知完整生命周期。
不過在此之前，我們要先搞懂什么是狀態State和事件Event
public abstract class Lifecycle {
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract State getCurrentState();
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
/**
* <li>after {@link android.app.Activity#onStart() onStart} call;
* <li><b>right before</b> {@link android.app..Activity#onPause( onPause} call.
* </ul>
*/
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
在Lifecycle類中除了add，remove外，還有兩個枚舉類，Event事件對應的就是Activty的onCreate,onStart()事件，而狀態卻只有5種。以STARTED狀態為例：這個狀態發生在Activity#onStart()之后，Activity#onPause()之前。什么意思呢？請看下面這張圖：
[圖片上傳失敗...(image-7f8905-1649222135014)]
這張圖我們一定見過，但這次我們橫著對半切一刀,上面表示生命周期的前進,下面表示生命周期的后退，一定要記住，這對我們后的理解源碼非常重要，接著我們在解釋下：
Activity剛剛創建的時候它一定是INITIALIZED狀態，執行onCreate()方法后，進入到CREATED狀態，
執行onStart()方法后，進入到STARTED狀態，執行onResume()方法后，進入到RESUMED狀態，這個過程就表示生命周期的前進。
當我們跳轉下一個
Activity后，執行onPase()方法后，又重新回到STARTED狀態，執行onStop()方法后，進入到CREATED狀態，最后執行onDestory()方法后，進入到DESTROYED狀態。這個過程表示生命周期的后退
參照Android 架構組件（一）——Lifecycle, @ShymanZhu文中的關系圖：
[圖片上傳失敗...(image-2de08c-1649222135014)]
這個圖片僅作參考，
ObserverWithState類中的關系有所變換，mLifeCycleObserver->LifeCycleEventObserver
LifecycleRegistryshi生命周期注冊，記錄，派發事件的地方，理解狀態和事件的關系，對我們搞清楚LifecycleRegistry非常有幫助，下面以在onResume()中調用lifecycle.addObserver(LocationObserver())為例：
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
public void addObserver(@NonNull LifecycleObserver observer) {
//1
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//2
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//3
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;
//4
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
//5
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--;
}
//并不是繼承自`Observer`
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;
}
}
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);
}
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
//發生生命周期的前進，RESUMED處于前進階段的末尾，無法前進了。因為之后要發生生命周期后退
//所以拋出異常
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
//根據事件，判斷所處的狀態
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}
-
mState表示宿主的狀態或是Observer應該處于正確的狀態,如果不是DESTROYED,那么就賦值為INITIALIZED狀態，什么意思？就是當你添加一個Observer的時機是在onDestory()那么直接設置為DESTROYED,之后便不會給這個觀察者派發事件，否則即便你是在onReume()注冊，都是INITIALIZED,為什么要這樣做，而不是直接派發RESUMED。這就是LifecycleRegistry的高明之處，因為他下面要做事件同步.如果直接派發RESUMED，觀察者且不是丟失了ON_CREATE,ON_START事件？這與Lifecycycle設計的初衷肯定是不相符的 - 將
observer和initialState,封裝進ObserverWithState,從類名可以看出，他是持有觀察者和它當前狀態的包裝類,。 - 觀察者
Observer為key，ObserverWithState為Value封裝進Map，mObserverMap這個存儲集合它的作用沒啥可說的，但它的數據結構很特別，可以理解為是一個鏈表結構的Map，記錄了鏈頭Start，和鏈未End，同時每個Value元素，還記錄了當前值的Next和Previous。 -
calculateTargetState翻譯為：計算目標狀態，也就是計算傳入的Observer應該是什么狀態。而它里面計算的邏輯很有意思。展開說涉及到嵌套事件下面再講，簡單來說就是根據集合中的前一個Observer狀態和宿主的狀態與當前Observer應該處于正確的狀態mState作min()比較。從這里我們可以得出：一個Activity/Fragment可以有多個觀察者，每個觀察者的狀態全部一致 - 循環判斷，如果觀察者狀態小于目標狀態，表示
發生生命周期的前進。調用upEvent(State state)計算前進事件。初始化是INITIALIZED狀態，發生前進事件，根據前面的圖，應該發生ON_CREATE事件。這有點不好理解。就是小于的情況下。肯定發生生命周期的前進，所以INITIALIZED狀態下，下一個事件必然是ON_CREATE事件。然后調用ObserverWithState #dispatchEvent(),通過getStateAfter(event)來根據事件，判斷所處的狀態。ON_CREATE事件一定是CREATED狀態。接著保存起來newState，調用注冊進來的觀察者的回調方法mLifecycleObserver.onStateChanged(owner, event)把事件分發出去,然后更新mStatemState = newState.
下次循環mState=CREATED還是小于目標狀態，upEvent():CREATED-->ON_START,getStateAfter(event)：ON_START-->STARTED,保存狀態newState,回調監聽onStateChanged,保存狀態：mState = newState,直到mState = RESUMED
[圖片上傳失敗...(image-845e20-1649222135014)]
經過循環之后。新注冊的Observer和宿主同步到相同的生命周期。
派發
當宿主生命周期發生變化，會調用mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);來向觀察者派發，直接看分析然后再結合源碼
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);//1
}
private void moveToState(State next) {
mState = next;
sync();//2
}
private void sync() {
while (!isSynced()) {//3
//當宿主狀態小于 最早添加進來的觀察者，為什么是最早，首先集合中的觀察者是按順序添加的，State應該是一致的，小于最早觀察者，一定小于后面最后觀察者
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);//4
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
//當宿主狀態大于最新的道理相同
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);//5
}
}
}
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;
}
private void backwardPass(LifecycleOwner lifecycleOwner) {
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = downEvent(observer.mState);
observer.dispatchEvent(lifecycleOwner, event);
}
}
private void forwardPass(LifecycleOwner lifecycleOwner) {
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
}
}
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);
}
- 根據傳入的事件
event，判斷宿主的狀態 - 進行復制
mState = next,然后調用sync()開始同步所有觀察者 -
isSynced()是否已經同步過了，取出Map中首尾元素，兩者相等同時尾部元素，也就是最后添加，最新的元素和宿主狀態mState相同，就說明同步過了不用同步。再次印證：一個Activity/Fragment可以有多個觀察者，每個觀察者的狀態全部一致，但注意sync()中是取的非while (!isSynced())所以不一致時進入接下來的循環 -
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0),宿主狀態小于觀察者的狀態，這是什么情況？如果你看懂前面的表，這里就不難理解，舉個例子:觀察者為RESUMED狀態，此時宿主發生onPase()生命周期，那么宿主會進入STARTED狀態。進入生命周期后退過程.所以會調用backwardPass(lifecycleOwner)向后傳遞。 -
(observer.mState.compareTo(mState) > 0上面判斷是宿主小于觀察者，backwardPass判斷觀察者大于宿主，完全是一個意思，接著會調用downEvent,根據狀態回退RESUMED-->ON_PAUSE -
observer.dispatchEvent(lifecycleOwner, event)更新狀態，分發觀察者事件，更新mState -
mState.compareTo(newest.getValue().mState) > 0事件前進forwardPass(lifecycleOwner);與之前同步過程完全相同
[圖片上傳失敗...(image-4e36d3-1649222135014)]
統一Observer
思考一個問題：ObserverWithState#dispatch是給觀察者分發事件的位置，但他調用的是onStateChange()，但我們回調方式的實現，是完全不同的，他是如何做到統一的呢？
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;
}
}
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer)答案就是適配器模式，看就在這里：
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {//Object 就是傳入的observer
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);
}
- Object 就是傳入的
observer,如果是如果同時實現LifecycleEventObserver,FullLifecycleObserver,創建FullLifecycleObserverAdapter - 如果是
isFullLifecycleObserver,創建FullLifecycleObserverAdapter - 如果是
isLifecycleEventObserver,直接返回
而FullLifecycleObserverAdapter ，FullLifecycleObserverAdapter，所有適配器Adapter都是繼承自LifecycleEventObserver
這樣就可以收攏統一后調用
而直接繼承LifecycleObserver又是怎么判斷的呢？：
int type = getObserverConstructorType(klass);
最終調用
/**
* Create a name for an adapter class.
*/
public static String getAdapterName(String className) {
return className.replace(".", "_") + "_LifecycleAdapter";
}
當引入androidx.lifecycle:lifecycle-compiler:2.2.0會利用APT，運行時注解處理器生成工具類并拼接類名：MyObserver_LifecycleAdapter,然后調取注解標記的觀察者，否者會用ReflectiveGenericLifecycleObserver,反射執行。
嵌套事件
這部分不好理解，目前個人的理解就是，先弄清楚：什么時候回出現嵌套事件，兩種情況：
- 在新添加觀察者時，同步還未完成，此時
宿主又發生了生命周期變化，那么此時就會導致不同步的問題 - 在派發
生命周期給觀察者時，又有新的觀察者添加進來，那么新的觀察者可能和其他觀察者狀態不同步的問題。
嵌套事件，說白了就是同步沖突。因為所有觀察者和宿主的狀態是完全相同的，一旦生命周期派發，或是新的觀察者添加進來時，如果生命周期或觀察者集合元素發生變化，就可能會導致不同步。這錯亂不是來自多線程。因為細心的你會發現。LifeCycleRegistry的大部分方法都標注@MainThread注解。也就說，沖突并非是多線程，而是上面兩種情況。
那么LifeCycleRegistry又是如何如何處理的呢？答案是利用多個標記位表示狀態，同時將新添加的觀察者，或是正在變化的觀察者壓入棧。正確同步后后再出棧,也就是mParentStates這個mParentStates類型的集合。所以一旦出現觀察者狀態不一致導致無法正常出棧。這個棧mParentStates內的元素就不是空。就需要來重新處理或者判斷。核心思想大概是這樣樣子。就是多個標記位和棧管理，來確保狀態的同步和一致。
以上是個人理解。對嵌套事件感興趣，想深入理解，可以看這篇：LifeCycle對于嵌套事件的處理
總結：
LifeCycle組件簡單，深入卻有很復雜，理解后又會發現很有意思。但大部分文章卻無法做到既深入，又能體現卻他人的不同。更無法完全解答開頭的十幾個問題。不過現在你應該有了自己的答案。
