前言
Android Jetpack組件之Lifecycle源碼解析
基于androidx.lifecycle2.1.0組件包進行分析
一、如何使用 lifecycle
1.1、最簡單的在Activity里面監聽，當你的Activity的生命周期發生變化的時候會打印對應的日志
lifecycle.addObserver(object :LifecycleObserver{
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {
Log.d(TAG, "onCreate: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart() {
Log.d(TAG, "onStart: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() {
Log.d(TAG, "onResume: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause() {
Log.d(TAG, "onPause: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop() {
Log.d(TAG, "onStop: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
Log.d(TAG, "onDestroy: ")
}
})
結果如下：打開其他界面然后返回
2022-04-26 19:53:36.100 31510-31510/com.cnstrong.eccard D/HtmlVersionUpdate: onPause:
2022-04-26 19:53:36.416 31510-31510/com.cnstrong.eccard D/HtmlVersionUpdate: onStop:
2022-04-26 19:53:39.470 31510-31510/com.cnstrong.eccard D/HtmlVersionUpdate: onStart:
2022-04-26 19:53:39.472 31510-31510/com.cnstrong.eccard D/HtmlVersionUpdate: onResume:
為什么Activity里面lifecycle 注冊LifecycleObserver 后會監測到activity的生命周期：
猜測：內部將activity的生命周期進行分發，然后監測 LifecycleObserver 函數，找到內部的添加了不同注解的方法，通過反射進行調用
1.2、自定義一個生命周期觀察者
class ActivityLifecycleProxy : LifecycleOwner {
var mLifecycleRegistry = LifecycleRegistry(this)
override fun getLifecycle(): Lifecycle {
return mLifecycleRegistry
}
///處理生命周期事件
fun handleLifeEvent(event: String?) {
Log.e("test", "接收到的event事件：$event")
when (event) {
//通過自定義的“字符串”匹配，進行Lifecycle的生命周期調度
Constant.Life.ON_CREATE -> mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
Constant.Life.ON_START -> mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
Constant.Life.ON_RESUME -> mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
Constant.Life.ON_PAUSE -> mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
Constant.Life.ON_STOP -> mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
Constant.Life.ON_DESTROY -> {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
}
Constant.Life.ON_SAVE_INSTANCE -> mLifecycleRegistry.currentState =
Lifecycle.State.CREATED
}
}
}
class MyActivity:AppCompatActivity(){
val activityLifecycleProxy :ActivityLifecycleProxy()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.main_layout.xml)
//將activity的生命周期進行分發
activityLifecycleProxy.handleLifeEvent(Constant.Life.ON_CREATE)
activityLifecycleProxy.lifecycle.addObserver(object : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {
LogUtil.d(TAG, "onCreate: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() {
LogUtil.d(TAG, "onResume: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
LogUtil.d(TAG, "onDestroy: ")
}
})
}
override fun onResume() {
super.onResume()
activityLifecycleProxy.handleLifeEvent(Constant.Life.ON_RESUME)
}
}
這樣自定義的ActivityLifecycleProxy類也有了觀察MyActivity的生命周期的能力
1.3、通過自定義的ActivityLifecycleProxy 過程 分析Activity為什么也有這個能力
1.3.1、分析
lifecycle對象是屬于LifecycleOwner對象的如下：
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
那為什么Activity能夠拿到該對象，那肯定是當前的Activity實現的LifecycleOwner接口類
1.
BaseViewBindActivity<VB : ViewDataBinding> : AppCompatActivity()
2.
public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,
TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider
3.
public class FragmentActivity extends ComponentActivity implements
ActivityCompat.OnRequestPermissionsResultCallback,
ActivityCompat.RequestPermissionsRequestCodeValidator
4.
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner
看上面第四點發現ComponentActivity實現了 LifecycleOwner接口
看ComponentActivity類的getLifecycle()方法如下：
...
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
...
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
@CallSuper
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
Lifecycle lifecycle = getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
}
super.onSaveInstanceState(outState);
mSavedStateRegistryController.performSave(outState);
}
/**
Returns the Lifecycle of the provider.
Overriding this method is no longer supported and this method will be made final in a future version of ComponentActivity. If you do override this method, you must:
Return an instance of LifecycleRegistry
Lazily initialize your LifecycleRegistry object when this is first called. Note that this method will be called in the super classes' constructor, before any field initialization or object state creation is complete.
翻譯：
返回提供程序的生命周期。
不再支持重寫這個方法，這個方法將在未來的ComponentActivity版本中成為final。如果你重寫了這個方法，你必須:
返回一個lifecyclerregistry實例
當它第一次被調用時惰性地初始化你的lifecyclereregistry對象。注意，這個方法將在父類的構造函數中調用，在任何字段初始化或對象狀態創建完成之前。
**/
...
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
...
看到ComponentActivity實現了接口LifecycleOwner，并在getLifecycle()返回了LifecycleRegistry實例。前面提到LifecycleRegistry是Lifecycle具體實現。
然后在onSaveInstanceState()中設置mLifecycleRegistry的狀態為State.CREATED，然后怎么沒有了？其他生命周期方法內咋沒處理？what？和猜測的不一樣啊。 別急，在onCreate()中有這么一行：ReportFragment.injectIfNeededIn(this),這個就是關鍵所在。從方法名可以看出注入了一個Fragment，熟悉Glide的朋友肯定知道這個套路了。添加一個透明的Fragment，用它來感知宿主Activity的生命周期，然后進行轉發。
1.3.2、下面看：ReportFragment
**下面主要分為兩種：**他們走的都是dispatch(activity, ...）;方法
- api29以上-- activity.registerActivityLifecycleCallbacks( new LifecycleCallbacks()); 看下面的 LifecycleCallbacks類，進行生命周期分發
- api29以下---根據這個透明的fragment的生命周期進行分發
ReportFragment類中的 dispatch方法如下：
根據條件判斷我們走的是下面第2點 LifecycleRegistry類的handleLifecycleEvent(event)方法
@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
//2.我們的lifecycle走的是這個方法
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
ReportFragment整個類代碼如下：
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
public static void injectIfNeededIn(Activity activity) {
if (Build.VERSION.SDK_INT >= 29) {
// On API 29+, we can register for the correct Lifecycle callbacks directly
activity.registerActivityLifecycleCallbacks(
new LifecycleCallbacks());
}
// Prior to API 29 and to maintain compatibility with older versions of
// ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
// need to support activities that don't extend from FragmentActivity from support lib),
// use a framework fragment to get the correct timing of Lifecycle events
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();
}
}
@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
static ReportFragment get(Activity activity) {
return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
REPORT_FRAGMENT_TAG);
}
private ActivityInitializationListener mProcessListener;
private void dispatchCreate(ActivityInitializationListener listener) {
if (listener != null) {
listener.onCreate();
}
}
private void dispatchStart(ActivityInitializationListener listener) {
if (listener != null) {
listener.onStart();
}
}
private void dispatchResume(ActivityInitializationListener listener) {
if (listener != null) {
listener.onResume();
}
}
@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;
}
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
// Only dispatch events from ReportFragment on API levels prior
// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
// added in ReportFragment.injectIfNeededIn
dispatch(getActivity(), event);
}
}
void setProcessListener(ActivityInitializationListener processListener) {
mProcessListener = processListener;
}
interface ActivityInitializationListener {
void onCreate();
void onStart();
void onResume();
}
// this class isn't inlined only because we need to add a proguard rule for it. (b/142778206)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
@Override
public void onActivityCreated(@NonNull Activity activity,
@Nullable Bundle bundle) {
}
@Override
public void onActivityPostCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
}
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_START);
}
@Override
public void onActivityResumed(@NonNull Activity activity) {
}
@Override
public void onActivityPostResumed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_RESUME);
}
@Override
public void onActivityPrePaused(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_PAUSE);
}
@Override
public void onActivityPaused(@NonNull Activity activity) {
}
@Override
public void onActivityPreStopped(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_STOP);
}
@Override
public void onActivityStopped(@NonNull Activity activity) {
}
@Override
public void onActivitySaveInstanceState(@NonNull Activity activity,
@NonNull Bundle bundle) {
}
@Override
public void onActivityPreDestroyed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_DESTROY);
}
@Override
public void onActivityDestroyed(@NonNull Activity activity) {
}
}
}
二、分析LifecycleRegistry類的handleLifecycleEvent(event)方法
/**
Sets the current state and notifies the observers.
Note that if the currentState is the same state as the last call to this method, calling this method has no effect.
Params:
event – The event that was received
解釋：
設置當前狀態并通知觀察者。
注意，如果currentState的狀態與對該方法的最后一次調用相同，則調用該方法沒有效果。
參數:event -接收到的事件
**/
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
上面主要是進行生命周期的比較與分發
2.1、我們根據Lifecycle的addObserver方法來進行分析，LifecycleRegistry的addObserver方法如下：
override fun onCreate(savedInstanceState: Bundle?) {
val myLifecycleObserver = object :LifecycleObserver{
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {
Log.d(TAG, "onCreate: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
Log.d(TAG, "onDestroy: ")
}
}
lifecycle.addObserver(myLifecycleObserver)
}
override fun onStart() {
super.onStart()
}
@Override
public void addObserver(@NonNull LifecycleObserver observer) {//這里的 observer對象可以認為是上面我們監測的myLifecycleObserver
//1.剛開始mState的初始值在構造函數中設置為INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//2.ObserverWithState是對observer對象的一個包裝類，將狀態與事件類結合,在其構造方法內，又創建了一個LifecycleEventObserver類型的觀察者對象，它是一個接口，它繼承自LifecycleObserver，在這里返回的實現類是ReflectiveGenericLifecycleObserver。
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//3.將我們的觀察者作為key，包裝對象ObserverWithState作為value，將其保存到一個Map中，并且在Map中的value還被維護成了一個雙向鏈表。
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.注釋4
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
//注釋5：看完注釋4，我們知道首次注冊的時候targetState = INITIALIZED，statefulObserver.mState也 = INITIALIZED（這個要看注釋3的map的put過程）
//所以比較compareTo的返回值，前面大于后面大于0，相等=0，前面小于后面 小于0，所以首次注冊該方法不會調用
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);
}
//注釋6：isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
//剛開始mHandlingEvent的默認值為false，所以下面必定成立
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
解釋：
-
注釋1：//1.剛開始mState的初始值在構造函數中設置為INITIALIZED
public LifecycleRegistry(@NonNull LifecycleOwner provider) { mLifecycleOwner = new WeakReference<>(provider); mState = INITIALIZED; } -
注釋2：
ObserverWithState是對observer對象的一個包裝類，將狀態與事件類結合,在其構造方法內，又創建了一個LifecycleEventObserver類型的觀察者對象，它是一個接口，它繼承自LifecycleObserver，在這里返回的實現類是ReflectiveGenericLifecycleObserver。
static class ObserverWithState { State mState; LifecycleEventObserver mLifecycleObserver; ObserverWithState(LifecycleObserver observer, State initialState) { mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);//返回ReflectiveGenericLifecycleObserver對象 mState = initialState; } void dispatchEvent(LifecycleOwner owner, Event event) { State newState = getStateAfter(event); mState = min(mState, newState); mLifecycleObserver.onStateChanged(owner, event); mState = newState; } } -
注釋3： ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//主要是記錄上一次的State狀態，在isSynced()方法中進行比較，決定生命周期變更后是否需要發送監測回調將我們的觀察者作為key，包裝對象ObserverWithState作為value，將其保存到一個Map中，并且在Map中的value還被維護成了一個雙向鏈表。
@Override public V putIfAbsent(@NonNull K key, @NonNull V v) { Entry<K, V> current = get(key); if (current != null) { return current.mValue; } mHashMap.put(key, put(key, v));//再看put方法 return null; } protected Entry<K, V> put(@NonNull K key, @NonNull V v) { Entry<K, V> newEntry = new Entry<>(key, v); mSize++; if (mEnd == null) { mStart = newEntry; mEnd = mStart; return newEntry; } mEnd.mNext = newEntry; newEntry.mPrevious = mEnd; mEnd = newEntry; return newEntry; } -
注釋4：
計算我們的觀察者對象的
mState。這里的previous為包含我們的觀察者對象的Entry節點的前驅節點，它不為空且它的State為INITIALIZED。mParentStates的size為空，所以在return語句中內層min方法返回的是INITIALIZED，而外層min方法返回還是INITIALIZED。**注意：**下面的mState（這個就是ObserverWithState的State，與LifecycleRegistry的 mState，雖然類型一致但是值有個先后關系的過程，這就涉及到生命周期的同步分發流程，他就是通過mObserverMap與LifecycleRegistry的 mState進行區分）
private State calculateTargetState(LifecycleObserver observer) { //previous這個的值其實就是我們的myLifecycleObserver的對象，包裝的ObserverWithState對象，具體看它的值，看上面注釋3出 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); } -
注釋5：
看完注釋4，我們知道首次注冊的時候targetState = INITIALIZED，statefulObserver.mState也 = INITIALIZED（這個要看注釋3的map的put過程） 所以比較compareTo的返回值，前面大于后面結果值要大于0，相等=0，前面小于后面 小于0，所以首次注冊該方法不會調用
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);
}
-
注釋6：
//isReentrance = mAddingObserverCounter != 0 || mHandlingEvent; //剛開始mHandlingEvent的默認值為false，所以下面必定成立
... boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent; ... //注釋6：isReentrance = mAddingObserverCounter != 0 || mHandlingEvent; //剛開始mHandlingEvent的默認值為false，所以下面必定成立 if (!isReentrance) { // we do sync only on the top level. sync(); }
2.2、下面看sync方法
// happens only on the top of stack (never in reentrance),
// so it doesn't have to take in account parents
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
+ "garbage collected. It is too late to change lifecycle state.");
}
//首次addObserver（）的過程該方法不會執行
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;
}
先看看進入while循環的條件判斷方法isSynced（）方法。mObserverMap.eldest()為雙向鏈表的頭節點，它的mState為INITIALIZED；mObserverMap.newest()為雙向鏈表的尾節點，也就是我們的觀察地者對象，它的mState也是為INITIALIZED。而LifecycleRegistry的mSate初始值也是INITIALIZED，所以整個方法返回值為true,while循環體不會執行。
到這里，我們的Activity的addObserver方法分析完成。接下來就是執行前面提到的ReportFragment的生命周期分發的handleLifecycleEvent方法
進入sync方法中的 while (!isSynced()) 方法 ，會根據當前狀態和mObserverMap中的eldest和newest的狀態做對比 ，判斷當前狀態是向前還是向后，比如由STARTED到RESUMED是狀態向前，反過來就是狀態向后，這個不要和Activity的生命周期搞混。向前還是向后的代碼大同小異，這里以向后為例。
[圖片上傳失敗...(image-3a3c1f-1689062740616)]
2.3、上面分析流程切換由onCreate切換到onStart()方法
我們從前面的1.3知道，activity生命周期切換會觸發LifecycleRegistry 的 handleLifecycleEvent 方法
//1.
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
//2.onStart() 方法 發送的是 ON_START ，所以next = STARTED
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);
}
//3.前面走了oncreate方法mState =處于CREATED，因為不相等所以， mState被賦值為了STARTED
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}
由上面幾個注釋得出又到了sync()方法
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
+ "garbage collected. It is too late to change lifecycle state.");
}
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;
}
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;
}
isSynced()方法這次返回的是false，為什么呢mObserverMap.eldest().getValue().mState的值為CREATED 狀態，而 mState為STARTED
mObserverMap.eldest().getValue().mState其實你可以認為它是一個緩存緩存上一次的狀態，它會在， 符合條件的情況下backwardPass(lifecycleOwner);方法或者 forwardPass(lifecycleOwner)中進行記錄。
因為：mObserverMap.eldest().getValue().mState的值為CREATED 狀態，而 mState為STARTED 所以走的 forwardPass(lifecycleOwner);方法
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
//1.拿到上次的緩存 mObserverMap中的值observer.mState為CREATED 看upEvent(observer.mState)方法
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
//2.返回 ON_START，再看 observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
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;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
//3.ObserverWithState 類中的
void dispatchEvent(LifecycleOwner owner, Event event) {
//根據event ，第二點傳入的值，獲取狀態
State newState = getStateAfter(event);
//`得出最小的狀態進行記錄，后續activity的狀態變更后，拿到的狀態又要在 isSynced() 方法里面進行比對才決定是否需要同步`
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
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);
}
到這里狀態切換變更結束了，后面是狀態變更后如何通知對應的觀察者
三、分析ObserverWithState，就是addObserver(@NonNull LifecycleObserver observer)方法中的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);
//狀態變更，通過onStateChanged方法進行，通知
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
3.1、Lifecycling.lifecycleEventObserver(observer)方法的注冊
它在Lifecycling類中的 lifecycleEventObserver(Object object) 方法的object，就是我們在2.1中的例子LifecycleObserver的對象
所以經過一系列判斷知道走的是ReflectiveGenericLifecycleObserver(object)對象實例
@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);
}
3.2、ReflectiveGenericLifecycleObserver類
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
//走這里
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
}
、、1.
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
、、2.
CallbackInfo getInfo(Class<?> klass) {
CallbackInfo existing = mCallbackMap.get(klass);
if (existing != null) {
return existing;
}
、、3.
existing = createInfo(klass, null);
return existing;
}
3.、、
private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
Class<?> superclass = klass.getSuperclass();
Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
if (superclass != null) {
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);
}
}
Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
boolean hasLifecycleMethods = false;
、、獲取OnLifecycleEvent注解的方法，存儲起來
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類
CallbackInfo info = new CallbackInfo(handlerToEvent);
mCallbackMap.put(klass, info);
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;
}
3.3、 CallbackInfo 最后的分發類
static class CallbackInfo {
final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
//分發事件的存儲
CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
mHandlerToEvent = handlerToEvent;
mEventToHandlers = new HashMap<>();
for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {
Lifecycle.Event event = entry.getValue();
List<MethodReference> methodReferences = mEventToHandlers.get(event);
if (methodReferences == null) {
methodReferences = new ArrayList<>();
mEventToHandlers.put(event, methodReferences);
}
methodReferences.add(entry.getKey());
}
}
//，具體的反射，調用被 @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)注解標記的方法
@SuppressWarnings("ConstantConditions")
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
target);
}
private static void invokeMethodsForEvent(List<MethodReference> handlers,
LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
if (handlers != null) {
for (int i = handlers.size() - 1; i >= 0; i--) {
handlers.get(i).invokeCallback(source, event, mWrapped);
}
}
}
}
@SuppressWarnings("WeakerAccess")
static class MethodReference {
final int mCallType;
final Method mMethod;
MethodReference(int callType, Method method) {
mCallType = callType;
mMethod = method;
mMethod.setAccessible(true);
}
//，反射調用
void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
//noinspection TryWithIdenticalCatches
try {
switch (mCallType) {
case CALL_TYPE_NO_ARG:
mMethod.invoke(target);
break;
case CALL_TYPE_PROVIDER:
mMethod.invoke(target, source);
break;
case CALL_TYPE_PROVIDER_WITH_EVENT:
mMethod.invoke(target, source, event);
break;
}
} catch (InvocationTargetException e) {
throw new RuntimeException("Failed to call observer method", e.getCause());
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
MethodReference that = (MethodReference) o;
return mCallType == that.mCallType && mMethod.getName().equals(that.mMethod.getName());
}
@Override
public int hashCode() {
return 31 * mCallType + mMethod.getName().hashCode();
}
}
到了這里整個事件結束，當activity的生命周期進行變更，然后調用handleLifecycleEvent(@NonNull Lifecycle.Event event) -->ObserverWithState 類的mLifecycleObserver.onStateChanged(owner, event);-->ReflectiveGenericLifecycleObserver類的onStateChanged分發-->`MethodReference類的invokeCallback方法反射調用被注解標記的方法
最后
如果你進階的路上缺乏方向，
需要更多的Android 可以查看我的個人介紹！！！
