Android_Banner.jpg
簡(jiǎn)介
- 上一遍文章中介紹了如何使用Lifecycle來(lái)感知Acitivity的生命周期的鲜屏。
- 讓我們來(lái)簡(jiǎn)單的回顧一下
- 首先新建一個(gè)MyObsever 繼承至 LifecycleObsever（如果是使用Java8 可以使用DefaultLifecycleObserver，可以不用寫(xiě)注解，直接重寫(xiě)對(duì)應(yīng)的方法就可以了）
- 在Activity（androidx下的 ComponentActivity）中通過(guò) getLifecycle().addObserver(MyObserver()) 這行代碼，將我們的觀察者添加到Lifecycle中（確切說(shuō)是LifcycleRegister中）
- 通過(guò)如上的操作就能感知到Activity的生命周期了
- 其實(shí)對(duì)于我們程序員來(lái)說(shuō)浦箱，日常最多的就是使用框架虹曙，使用API滑凉，來(lái)完成需求，針對(duì)我們項(xiàng)目中使用的開(kāi)源或者官方提供封裝好的框架贫橙，我們很有必要去了解一下它的原理贪婉，起碼在和別人吹牛的時(shí)候，可以有東西吹啊卢肃，覺(jué)得你這個(gè)人不禁需求完成的不錯(cuò)疲迂，而且還有一顆強(qiáng)烈學(xué)習(xí)的心
- 針對(duì)Lifecycle的原理，我們可以從這行代碼入手 getLifecycle().addObserver(MyObserver())莫湘，可以分解成如下
- getLifecycle() ---> 獲取到Lifecycle類(lèi)型的對(duì)象
- 將我們自定義好的觀察者添加進(jìn)去 addObserver()
Lifecycle解決什么問(wèn)題尤蒿？
- 生命周期的統(tǒng)一管理，“一處修改幅垮，處處生效的作用”
- 讓第三方組件可以在自己內(nèi)部隨時(shí)拿到生命周期的狀態(tài)腰池，以便自己能夠隨時(shí)可以開(kāi)啟或者暫停
- 讓第三方組件在調(diào)試時(shí) 能夠 更方便和安全地追蹤到 事故所在的生命周期源。
原理分析
getLifecycle()
-
點(diǎn)開(kāi)我們的getLifecycle()方法我們可以看到忙芒，我們來(lái)到了ComponentActivity中
@NonNull @Override public Lifecycle getLifecycle() { return mLifecycleRegistry; }- 該方法返回的是一個(gè)LifyCycleRegistry對(duì)象
- LifecycleRegister是繼承至Lifecycle的
看下我們這個(gè)ComponentActivity（挑重要有關(guān)的說(shuō)了）
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
- 它繼承至androidx.core.app.ComponentActivity
- 并且實(shí)現(xiàn)了LifecycleOwner（生命周期擁有者）
- 其實(shí)我們的getLifecycle()方法就是實(shí)現(xiàn)LifcycycleOwner接口內(nèi)的方法
addObserver()方法
調(diào)用的addObserver()是屬于LifyCycleRegistry中的示弓，我們先來(lái)看下LifyCycleRegistry這個(gè)類(lèi)
生命周期登記，它是Lifecycle的子類(lèi)呵萨，起到添加觀察者奏属、響應(yīng)生命周期事件、分發(fā)生命周期事件的作用
-
部分核心源碼
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>(); private State mState; private final WeakReference<LifecycleOwner> mLifecycleOwner; // 順便看下 Lifecycle的源碼 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(); @SuppressWarnings("WeakerAccess") public enum Event { ON_CREATE, ON_START, ON_RESUME, ON_PAUSE, ON_STOP, ON_DESTROY, ON_ANY } @SuppressWarnings("WeakerAccess") public enum State { DESTROYED, INITIALIZED, CREATED, STARTED, RESUMED; public boolean isAtLeast(@NonNull State state) { return compareTo(state) >= 0; } } }- FastSafeIterableMap是一個(gè)Map甘桑，用來(lái)保存觀察者和它對(duì)應(yīng)的狀態(tài)
- mState對(duì)應(yīng)著當(dāng)前的狀態(tài)（Lifecycle）
- LicecycleOwner表示生命周期的擁有者拍皮，我們的ComponentActivity實(shí)現(xiàn)了該接口
- 可以看到Lifecycle中有兩個(gè)枚舉類(lèi)，分別是事件和狀態(tài)跑杭，還有添加和移除觀察者的方法和趕會(huì)當(dāng)前Lifecycle對(duì)應(yīng)的狀態(tài)
-
LifyCycleRegistry # addObserver()
@Override public void (@NonNull LifecycleObserver observer) { //當(dāng)前的狀態(tài)是DESTROY的話铆帽，添加的Observer的初始狀態(tài)就是DESTROY否則就是INITIALIZED State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED; //創(chuàng)建一個(gè)ObserverWithState，它是LifecycleRegister類(lèi)中的一個(gè)靜態(tài)內(nèi)部類(lèi)德谅，將添加的Observer與狀態(tài)關(guān)聯(lián)到一起爹橱，（說(shuō)白就是用它來(lái)維持Observer與State的對(duì)應(yīng)關(guān)系） ObserverWithState statefulObserver = new ObserverWithState(observer, initialState); // 以observer作為key，ObserverWithState作為value存儲(chǔ)到Map中 //如果當(dāng)前Observer對(duì)應(yīng)的value不存在窄做，就將observer與對(duì)應(yīng)的value存儲(chǔ)到map //否則的話就將Observer對(duì)應(yīng)的value獲取到并且返回當(dāng)前的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; State targetState = calculateTargetState(observer); mAddingObserverCounter++; //注釋1 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--; }- 該方法是添加LifecycleObserver觀察者愧驱，并且可以將之前生命狀態(tài)分發(fā)給當(dāng)前添加的Observer的，例如我們?cè)贏ctivtity的onResume之后添加這個(gè)Observer椭盏，那么該Observer依然能收到ON_CREATE事件
- 注釋一：如果Observable的初始狀態(tài)是INITIALIZED组砚，當(dāng)前的狀態(tài)是RESUMED，那么需要將INITIALIZED到RESUMED之間的所有事件都分發(fā)給Observer
- 到這里我們回過(guò)頭來(lái)看下 ComponentActivity
-
ComponentActivity # onCreate()
@Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); mSavedStateRegistryController.performRestore(savedInstanceState); //注釋1 ReportFragment.injectIfNeededIn(this); if (mContentLayoutId != 0) { setContentView(mContentLayoutId); } }- 注釋1:我們調(diào)用了ReportFragment # injectIfNeededIn(this)
-
ReportFragment # injectIfNeededIn()
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(); } }- 這里我們添加了一個(gè)Fragment到Activity中
- 并且這個(gè)Fragment是一個(gè)沒(méi)有界面
- 其實(shí)添加這個(gè)Fragment就是用來(lái)感知Activity的生命周期的
-
ReportFragment的生命周期方法
@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; }- 通過(guò)觀察發(fā)現(xiàn)掏颊，都調(diào)用了dispatch()方法
-
ReportFragment # dispatch()方法
private void dispatch(Lifecycle.Event event) { Activity activity = getActivity(); 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); } } }- 這里可以看出 有兩個(gè)Owner 分別是LifecycleOwner和LifecycleRegistryOwner區(qū)別是：
- LifecycleOwner # getLifecycle() ----> Lifecycle
- LifecycleRegistryOwner # getLifecycle() ---> LifecycleRegister()
- 而我們的LifecycleRegistryOwner是繼承至LifecycleOwner的
- 最終調(diào)用的都是 LifecycleRegistry #handleLifecycleEvent()的方法
- 這里可以看出 有兩個(gè)Owner 分別是LifecycleOwner和LifecycleRegistryOwner區(qū)別是：
-
LifecycleRegistry # handleLifecycleEvent()
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) { State next = getStateAfter(event); moveToState(next); } /** * *根據(jù)事件返回我們當(dāng)前的狀態(tài) * 這個(gè)事件就是從ReportFragment中傳遞過(guò)來(lái)的 */ 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); } /** * 改變狀態(tài) * */ 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; } -
LifecycleRegistry # 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. //注釋1 if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) { backwardPass(lifecycleOwner); } Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest(); //注釋2 if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) { forwardPass(lifecycleOwner); } } mNewEventOccurred = false; }- 注釋1:如果當(dāng)前的狀態(tài)值小于 Observer狀態(tài)值糟红，需要將Observer的狀態(tài)值減小到和當(dāng)前狀態(tài)值相等。
- 注釋2:如果當(dāng)前當(dāng)前的狀態(tài)值大于Observer的狀態(tài)值乌叶，需要將Observer的狀態(tài)值增大到和當(dāng)前狀態(tài)值相等盆偿。
-
LifecycleRegistry # backwardPass
private void backwardPass(LifecycleOwner lifecycleOwner) { Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator = mObserverMap.descendingIterator(); while (descendingIterator.hasNext() && !mNewEventOccurred) { Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next(); ObserverWithState observer = entry.getValue(); while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) { Event event = downEvent(observer.mState); pushParentState(getStateAfter(event)); observer.dispatchEvent(lifecycleOwner, event); popParentState(); } } }- 對(duì)應(yīng)著sync中注釋1的代碼
-
LifecycleRegistry # forwardPass
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); observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState)); popParentState(); } } }- 對(duì)應(yīng)著sync注釋2的代碼
-
在上述的兩段代碼中。（forwardPass和backwarPass）在調(diào)整State時(shí)准浴，都調(diào)用了 observer # dispatchEvent()
- Observer ---> ObserverWithState
-
LifecycleRegistry # ObserverWithState # dispatchEvent()
void dispatchEvent(LifecycleOwner owner, Event event) { State newState = getStateAfter(event); mState = min(mState, newState); mLifecycleObserver.onStateChanged(owner, event); mState = newState; }- 在此方法中我們調(diào)用了 LifecycleEventObserver的onStateChange方法
- 那么這個(gè)LifecycleEventObserver時(shí)怎么來(lái)的呢事扭？
- 在上文中 我們?cè)贚ifecycleRegistry # addObserver()方法中我們構(gòu)建了一個(gè)ObserverWithState(),我們看下ObserverWithState()的構(gòu)造方法
-
ObserverWithState()
ObserverWithState(LifecycleObserver observer, State initialState) { mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer); mState = initialState; }- 可以看到我們的mLifecycleObserver對(duì)象時(shí)通過(guò) Lifecycling.lifecycleEventObserver(observer);獲取到的
-
Lifecycling # lifecycleEventObserver()
@NonNull static LifecycleEventObserver lifecycleEventObserver(Object object) { // 我們傳入的object是我們自定義的MyObservable // 這里面 LifecycleEventObserver extends LifecycleObserver // FullLifecycleObserver extends LifecycleObserver // 對(duì)于instanceof關(guān)鍵字 左面是類(lèi)的引用，右面是一個(gè)接口或者一個(gè)類(lèi) 的類(lèi)型 // 返回true的情況乐横，左邊的引用類(lèi)型是右邊類(lèi)型的求橄，或者是是其子類(lèi)，或者是實(shí)現(xiàn)類(lèi)的類(lèi)型 // 針對(duì)這里的情況晰奖，好像都不是 // isLifecycleEventObserver == false // isFullLifecycleObserver == false 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); }- 針對(duì)上述的分析谈撒，我們可以知道，lifecycleEventObserver()方法真正我們需要的是如下代碼
final Class<?> klass = object.getClass(); // 獲取到的type=1 int type = getObserverConstructorType(klass); // GENERATED_CALLBACK == 2 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);- 經(jīng)過(guò)上述分析匾南，可以看出返回的是 ReflectiveGenericLifecycleObserver()
-
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); } } @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); } } } } 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); } }- 根據(jù)調(diào)用事件線走下去啃匿，調(diào)用了ReflectiveGenericLifecycleObserver的onStateChanged()
- 繼而從invokeCallbacks() ---> invokeMethodsForEvent() ---> invokeCallback()
- 當(dāng)生命周期發(fā)生改變的時(shí)候，最終通過(guò)反射（ReflectiveGenericLifecycleObserver存儲(chǔ)了我們?cè)?Observer 里注解的方法）調(diào)用了我們?cè)谟^察者中利用注解聲明的方法蛆楞。
總結(jié)
- Lifecycle將Activity的生命周期函數(shù)對(duì)應(yīng)成Event溯乒，生命周期改變，會(huì)將Event傳遞給LifecycleRegistry豹爹，LifecycleRegistry中會(huì)修正State的值裆悄，并且觸發(fā)事件的分發(fā)，通過(guò)反射通知到LifecycleObsever中接受事件的方法臂聋。
- 基于觀察者模式光稼，將第三方組件以觀察者的形式在生命周期擁有者中通過(guò)addObserver()方法添加到List/Map中或南，當(dāng)生命周期的擁有者發(fā)生生命周期變化的時(shí)候，通過(guò)生命事件分發(fā)者（LifecycleRegister）遍歷集合中的觀察者艾君，執(zhí)行對(duì)應(yīng)的生命周期方法采够。
