Lifecycle組件的原理解析

Lifecycle組件，做爲LiveDada和ViewModel的支撐的同時，也爲咱們提供了一種新的監控生命週期的方法，因此咱們頗有必要了解一下其實現方式。 #1.從getLifecycle()開始 經過Lifecycle的使用流程發現，咱們實現的LifecycleObserver的最終都要在Lifecycle#addObserver中註冊。那麼Lifecycle到底是什麼呢。 查閱源碼咱們發現，該類是一個抽象類，聲明瞭三個重要的方法：

• addObserver(@NonNull LifecycleObserver observer)
• removeObserver(@NonNull LifecycleObserver observer)
• getCurrentState() 經過前兩個方法，咱們能夠添加/刪除回調，而經過getCurrentState()則能夠獲取一個State類型的實例，來知曉當前Activity/Fragment生命週期，State類聲明以下：

public enum State {
        /** * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch * any more events. For instance, for an {@link android.app.Activity}, this state is reached * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call. */
        DESTROYED,

        /** * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is * the state when it is constructed but has not received * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet. */
        INITIALIZED,

        /** * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached in two cases: * <ul> * <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call; * <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call. * </ul> */
        CREATED,

        /** * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached in two cases: * <ul> * <li>after {@link android.app.Activity#onStart() onStart} call; * <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call. * </ul> */
        STARTED,

        /** * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached after {@link android.app.Activity#onResume() onResume} is called. */
        RESUMED;

        /** * Compares if this State is greater or equal to the given {@code state}. * * @param state State to compare with * @return true if this State is greater or equal to the given {@code state} */
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
複製代碼

註釋很好的解釋了每種狀態的意義。那麼這個Lifecycle又是什麼時候在Activity/Fragment中賦值的呢？

• Activity Activity的getLifecycle()方法以下：

public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
複製代碼

mLifecycleRegistry是LifecycleRegistry類型的，而LifecycleRegistry是Lifecycle的子類，其在Activity被構造時便已經生成：

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
複製代碼

能夠看到，這裏把Activity做爲參數傳給了LifecycleRegistry，其構造函數以下：

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }
複製代碼

而ComponentActivity實現瞭如下接口：

• LifecycleOwner
• ViewModelStoreOwner
• SavedStateRegistryOwner LifecycleOwner接口僅僅聲明瞭getLifecycle()這一個方法。咱們先把目光放在LifecycleRegistry#addObserver()上:

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;
        }
        // 這裏使用弱引用的方式防止Activity泄露
        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--;
    }
複製代碼

該方法經過mObserverMap.putIfAbsent(observer, statefulObserver)將監聽器填入到mObserverMap，該變量實際就是一個鏈表map，key爲LifecycleObserver。實際上最終的生命週期回調都是在ObserverWithState#dispatchEvent(LifecycleOwner, Event)完成的，該類的存在，主要是爲了處理臨時添加監聽器致使的狀態不一致的問題。那麼Lifecycle到底是如何感知聲明週期的呢，答案在ComponentActivity#onCreate()中：

protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        // 關鍵代碼
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
複製代碼

咱們繼續看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();
        }
    }
複製代碼

該方法的做用就是若是當前Activity不存在ReportFragment便添加一個。manager.executePendingTransactions()這一行很關鍵，表示這一操做並不會添加到FragmentManager的消息隊列中，而是當即執行，以此指望該Fragment可以第一被添加到Activity中。相信不少讀者此時已經猜出答案了：Lifecycle正是經過一個無界面的Fragment來感知Activity的生命週期的。但這是以前版本的實現方式，在最新AndroidX 2.2.0版本中，採用了在相關生命週期中直接調用的方式來實現，以State.CREATED爲例，該狀態在ComponentActivity#onSaveInstanceState()被回調：

protected void onSaveInstanceState(@NonNull Bundle outState) {
        Lifecycle lifecycle = getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            // 關鍵代碼
            ((LifecycleRegistry) lifecycle).markState(Lifecycle.State.CREATED);
        }
        super.onSaveInstanceState(outState);
        mSavedStateRegistryController.performSave(outState);
    }
複製代碼

能夠發現，CREATED這一狀態實在onCreate()調用以後，onSaveInstanceState()調用以前切換的，而LifecycleRegistry#markState內部則會經過sync()方法來讓每個Observer都追遇上當前的狀態。這裏之因此用追趕，是由於它並不會只通知當前狀態，而是從observer所處的狀態過渡到當前狀態，這期間通過的每一狀態都會產生回調，與Fragment生命週期頗爲類似:

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();
            }
        }
    }

    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();
            }
        }
    }
複製代碼

回調代碼以下[ObserverWithState#dispatchEvent()]：

void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
    }
複製代碼

這裏的mLifecycleObserver類型爲LifecycleEventObserver,它是在ObserverWithState構造函數中經過Lifecycling.lifecycleEventObserver(observer)生成的，其實是Lifecycling的實例。那麼咱們轉到Lifecycling.lifecycleEventObserver(),看看他作了什麼：

static LifecycleEventObserver lifecycleEventObserver(Object object) {
        // LifecycleEventObserver 僅擁有onStateChanged()方法的接口
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        // FullLifecycleObserver 擁有所有生命週期回調的接口
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        // 若是同時實現了這兩個接口
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            // FullLifecycleObserverAdapter是FullLifecycleObserver，LifecycleEventObserver
            // 的適配器，實現的是LifecycleEventObserver接口，用於在onStateChanged()轉發生命週期
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        // 若是僅實現了FullLifecycleObserver
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }
        // 若是僅實現了LifecycleEventObserver 直接返回該observer
        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }
        // 若是使用的是
        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
        // 若是是生成類型 @OnLifecycleEvent 註解
        if (type == GENERATED_CALLBACK) {
            // 獲取GeneratedAdapter的列表
            List<Constructor<? extends GeneratedAdapter>> constructors =
                    sClassToAdapters.get(klass);
            // 若是僅存在一個對應的adapter
            if (constructors.size() == 1) {
                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                        constructors.get(0), object);
                // 經過反射生成GeneratedAdapter並填入dadoter
                return new SingleGeneratedAdapterObserver(generatedAdapter);
            }
            // 若是父類及接口列表中有多個實現了LifecycleObserver，則對應的adapter都會收到通知
            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);
        }
        // 若是是反射類型，直接反射調用
        // 反射方法支持三種聲明：
        // 1.沒有參數
        // 2.僅有LifecycleOwner
        // 3.(LifecycleOwner,Lifecycle.Event)
        return new ReflectiveGenericLifecycleObserver(object);
    }
複製代碼

這裏是解析咱們自定義的LifecycleObserver的關鍵，主要作了如下工做，即識別Observer的類型並返回包裝類：

• LifecycleEventObserver或者FullLifecycleObserver的實現類，則直接返回對應適配器，這些適配器主要是爲了兼顧使用@OnLifecycleEvent的方式。
• 使用@OnLifecycleEvent的方式
  • 有生成類 xxx_LifecycleAdapter,則包裝生成類 CompositeGeneratedAdaptersObserver
  • 沒有生成類，使用反射方式包裝：ReflectiveGenericLifecycleObserver 由此看出最終都是經過包裝類，最終調用到咱們自定義的Observer，完成生命週期的回調。

Fragment的實現與Activity相似，咱們先看LifecycleRegistry的生成：

private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
        mSavedStateRegistryController = SavedStateRegistryController.create(this);
        if (Build.VERSION.SDK_INT >= 19) {
            mLifecycleRegistry.addObserver(new GenericLifecycleObserver() {
                @Override
                public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
                    if (event == Lifecycle.Event.ON_STOP) {
                        if (mView != null) {
                            mView.cancelPendingInputEvents();
                        }
                    }
                }
            });
        }
    }
複製代碼

該方法在FragmentManagerImpl#makeInactive中調用，用於初始化LifecycleRegistry。那麼又是如何感知Fragment的生命週期的呢？答案在Fragment的performXXX方法中，以onCreated爲例：

void performCreate(Bundle savedInstanceState) {
        mChildFragmentManager.noteStateNotSaved();
        mState = CREATED;
        mCalled = false;
        mSavedStateRegistryController.performRestore(savedInstanceState);
        onCreate(savedInstanceState);
        mIsCreated = true;
        if (!mCalled) {
            throw new SuperNotCalledException("Fragment " + this
                    + " did not call through to super.onCreate()");
        }
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
複製代碼

handleLifecycleEvent()一樣調用了makeState()來變動狀態。而Fragment的performXXX正是由FragmentManagerImpl調用的。至此便實現了Fragment聲明週期的感知。