Lifecycle 是 Android Jetpack 工具包中的一個(gè)工具庫(kù)，Jetpack 中的工具可以分為四個(gè)部分：架構(gòu)（Architecture）府寒、基礎(chǔ)（Foundation）魁衙、行為（Behavior）、界面（UI）株搔。

Jetpack 四大組成部分

其中剖淀，架構(gòu)部分是 Jetpack 工具包的精華所在，大家耳熟能詳?shù)?DataBinding纤房、LiveData纵隔、ViewModel等都是屬于 Architecture 架構(gòu)部分。Lifecycle 的地位就可想而知了炮姨。

1捌刮、背景

眾所周知，Activity 是有自己的生命周期的舒岸，從 onCreate 創(chuàng)建一直到 onDestroy 銷毀绅作，我們會(huì)在 Activity 的各個(gè)生命周期中做相應(yīng)的處理，完成業(yè)務(wù)邏輯的開(kāi)發(fā)工作蛾派。 比如俄认，某些功能組件需要在 Activity 或者 Fragment 的某些生命周期函數(shù)中做一些初始化，資源回收等等操作洪乍。久而久之，Activity 中的代碼體積就會(huì)變得臃腫役拴，功能組件也與 Activity 耦合在一起了。

為了解決這個(gè)問(wèn)題姜性，google 就開(kāi)發(fā)出了 Lifecycle 這個(gè)工具部念。

官方文檔上有個(gè)例子妓湘，假如 Activity 中有一個(gè)定位的功能組件，如果沒(méi)有使用 Lifecycle唬党，大致的實(shí)現(xiàn)是這樣的：

    // 1、開(kāi)發(fā)自己的功能組件屯烦，實(shí)現(xiàn)相關(guān)功能
    class MyLocationListener {
        public MyLocationListener(Context context, Callback callback) {
            // ...
        }

        void start() {
            // 連接系統(tǒng)定位服務(wù)
        }

        void stop() {
            // 斷開(kāi)系統(tǒng)定位服務(wù)
        }
    }

    // 2、在 Activity 中調(diào)用自己開(kāi)發(fā)的功能組件缸匪，并在 Activity 生命周期中進(jìn)行相應(yīng)操作
    class MyActivity extends AppCompatActivity {
        private MyLocationListener myLocationListener;

        @Override
        public void onCreate(...) {
            // 初始化自己開(kāi)發(fā)的功能組件
            myLocationListener = new MyLocationListener(this, (location) -> {
                // 更新 UI
            });
        }

        @Override
        public void onStart() {
            super.onStart();
            myLocationListener.start();
            // 管理其他需要響應(yīng) activity 生命周期的組件
        }

        @Override
        public void onStop() {
            super.onStop();
            myLocationListener.stop();
            // 管理其他需要響應(yīng) activity 生命周期的組件
        }
    }

2、Lifecycle 的使用

引入 Lifecycle 之后，我們就可以在定位組件的內(nèi)部監(jiān)聽(tīng)到 Activity 的生命周期的變化辩诞，從而執(zhí)行相應(yīng)的操作译暂。不需要在 Activity 的各個(gè)生命周期方法中調(diào)用自身的業(yè)務(wù)邏輯方法，從而實(shí)現(xiàn)功能組件與 Activity 的相互隔離與解耦伯顶，降低 Activity 中的代碼量灶体。

大體的思想就是一個(gè)觀察者模式赃春，具有生命周期的 Activity、Fragment 等作為被觀察者狭吼；需要在不同的生命周期中執(zhí)行不同的業(yè)務(wù)邏輯的功能組件作為觀察者，當(dāng)觀察者監(jiān)聽(tīng)到生命周期發(fā)生變化時(shí)疲吸，執(zhí)行相應(yīng)的業(yè)務(wù)邏輯摘悴。具有生命周期的 Activity、Fragment 等口四，在下文中我們用 生命周期持有者（LifecycleOwner）來(lái)稱呼蔓彩；我們自己開(kāi)發(fā)的需要依賴于生命周期的功能組件，在下文中用 生命周期觀察者（LifecycleObserver）進(jìn)行稱呼探膊。

2.1 引入依賴

如果是非 AndroidX 項(xiàng)目流济，則引入：

implementation "android.arch.lifecycle:extensions:1.1.1"

如果是 AndroidX 項(xiàng)目绳瘟，則引入：

implementation 'androidx.appcompat:appcompat:1.2.0'

如果只需要使用 Lifecycle，不需要其他的 ViewModel蘸泻、LiveData等等的話，則只需要引入 lifecycle-runtime 包即可抡诞。

2.2 實(shí)現(xiàn) Lifecycle 觀察者

這個(gè) Lifecycle 觀察者就是我們自己開(kāi)發(fā)的功能組件昼汗，加上 LifecycleObserver 接口就可以通過(guò)注解的方式來(lái)編碼各個(gè)生命周期需要執(zhí)行的業(yè)務(wù)邏輯。如代碼所示：

class MyLocationListener implements LifecycleObserver {
    MyLocationListener(Activity activity, OnLocationChangedListener onLocationChangedListener) {
        // 初始化
        initLocationManager();
    }

    // 當(dāng) Activity 執(zhí)行 onResume 方法時(shí)，自動(dòng)調(diào)用該方法
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void startGetLocation(){
        Log.i(TAG, "startGetLocation() is executed");
    }

    // 當(dāng) Activity 執(zhí)行 onPause 方法時(shí)璧疗，自動(dòng)調(diào)用該方法
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void stopGetLocation(){
        Log.i(TAG, "stopGetLocation() is executed");
    }

    private void initLocationManager(){
        Log.i(TAG, "initLocationManager() is executed");
    }

    // 當(dāng)位置發(fā)生變化時(shí)崩侠，通過(guò)該接口通知調(diào)用方
    public interface OnLocationChangedListener{
        void onChange(double latitude, double longitude);
    }
}

2.3 生命周期持有者添加觀察者

在 Android 中具有生命周期的一般是 Activity、Fragment系瓢，先通過(guò) getLifecycle 方法獲得 Lifecycle 生命周期對(duì)象夷陋，Lifecycle 對(duì)象使用 addObserver 方法給自己添加觀察者骗绕，即 MyLocationListener荆忍。這樣一來(lái)刹枉，當(dāng) Lifecycle 生命周期發(fā)生變化，MyLocationListener 就會(huì)收到通知芥吟，做相應(yīng)的操作钟鸵。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MyLocationListener myLocationListener = new MyLocationListener(this,
                new MyLocationListener.OnLocationChangedListener() {
            @Override
            public void onChange(double latitude, double longitude) {
                // 位置發(fā)生變化時(shí)，調(diào)用該方法
            }
        });

        // 將觀察者（MyLocationListener）與被觀察者（MainActivity）綁定
        getLifecycle().addObserver(myLocationListener);
    }
}

那么蒙袍，這種觀察者模式是怎樣建立起來(lái)的呢害幅？我們可以去看看 Jetpack 中 Lifecycle 相關(guān)源碼。

3邑遏、Lifecycle 源碼淺析

下面的源碼分析是基于 lifecycle-runtime:2.1.0、lifecycle-common:2.1.0 版本孽鸡。從 getLifecycle() 方法進(jìn)入彬碱，發(fā)現(xiàn)是來(lái)到了 ComponentActivity 中晚胡，ComponentActivity 就是 Activity 的基類估盘，代碼如下：

    // ComponentActivity.java 類
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

還可以看出，其實(shí) ComponentActivity 只是實(shí)現(xiàn)了 LifecycleOwner 這個(gè)接口：

// LifecycleOwner.java 接口文件
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

// ComponentActivity 實(shí)現(xiàn)了 LifecycleOwner 接口
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
        ···
}

回過(guò)頭來(lái)再看看 ComponentActivity 中的 getLifecycle 方法箫踩，返回了一個(gè) Lifecycle 對(duì)象境钟，這個(gè)對(duì)象是在 ComponentActivity 中 new 出來(lái)的慨削，并將 Activity 實(shí)例傳參給了它：

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

LifecycleRegistry 類是一個(gè) Lifecycle 的實(shí)現(xiàn)類，Lifecycle 本身只是一個(gè)抽象類，里面定義了一些生命周期中的狀態(tài) State 以及切換生命周期的一些事件 Event宙橱，還有一些抽象方法：

public abstract class Lifecycle {
    ...
    // 添加生命周期觀察者 抽象方法
    @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();
    // 定義的事件值，對(duì)應(yīng) Activity 的各個(gè)生命周期發(fā)生事件
    @SuppressWarnings("WeakerAccess")
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY    // 可以響應(yīng)任何一個(gè)事件
    }
    // 生命周期狀態(tài)值
    @SuppressWarnings("WeakerAccess")
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        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;
        }
    }
}

再來(lái)看看 LifecycleRegistry 類具體實(shí)現(xiàn)了 Lifecycle 中的哪些方法。

3.1 LifecycleRegistry 類具體實(shí)現(xiàn)

首先地梨，它內(nèi)部是用一個(gè)類似 Map 的數(shù)據(jù)結(jié)構(gòu)來(lái)存儲(chǔ)添加的生命周期觀察者的：

private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();

Key 是將要存儲(chǔ)的觀察者洁闰，Value 是將這個(gè)觀察者賦予一個(gè) State 狀態(tài)扑眉，然后存到 Value 中，看它們的命名也可以理解。這個(gè)數(shù)據(jù)結(jié)構(gòu)是為了管理所有的觀察者洋访，方便添加和移除捌显。

先看看添加觀察者的 addObserver 方法在 LifecycleRegistry 類的具體實(shí)現(xiàn) ：

    // LifecycleRegistry.java 類
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        // 根據(jù) LifecycleOwner 的生命周期狀態(tài) mState 初始化一個(gè) 狀態(tài)賦給 將添加的觀察者
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;    // 不為空 說(shuō)明 observer 之前已添加過(guò)，則返回不再處理
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        // 獲取的是 LifecycleOwner 的一個(gè)弱引用，如果 為空則說(shuō)明被回收了年枕，就不往下執(zhí)行了
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        // 是否重入 判斷品洛，如果正在添加的觀察者不為0 或 正在處理 Event 事件桥状，則發(fā)生了重入
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);    // 計(jì)算出目標(biāo)狀態(tài)
        mAddingObserverCounter++;
        // while 循環(huán)里處理的事情就是，避免 該 observer 因?yàn)樘砑拥耐聿樾希沟靡恍┥芷诹鬓D(zhuǎn)分發(fā)事件
        // 沒(méi)有被分發(fā)給 該 observer扰藕。有點(diǎn)像 粘性廣播 的意思
        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();    // 同步所有觀察者狀態(tài)实胸，后面會(huì)細(xì)說(shuō)
        }
        mAddingObserverCounter--;
    }

代碼注釋的比較清楚了。這里補(bǔ)充說(shuō)明下 calculateTargetState 方法是如何計(jì)算出新添加的 LifecycleObserver 的目標(biāo)狀態(tài) State 的门躯，可以看一下它的代碼：

    private State calculateTargetState(LifecycleObserver observer) {
        // 首先獲取 前一個(gè)添加的觀察者 previous
        Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
        // previous 不為空時(shí)山孔，獲得 previous 的狀態(tài)值賦給 siblingState
        State siblingState = previous != null ? previous.getValue().mState : null;
        // mParentStates 列表不為空時(shí)懂讯，將最近添加的 state 值賦給 parentState
        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
                : null;
        return min(min(mState, siblingState), parentState);
    }

它是取 mState、parentState台颠、siblingState 中的最小值作為自己的 targetState褐望。然后需要將自己的狀態(tài)一步步切換到 targetState，如何進(jìn)行的串前，后面會(huì)細(xì)說(shuō)瘫里。

再來(lái)看看 LifecycleRegistry 類的實(shí)例化。 new 一個(gè) LifecycleRegistry 類時(shí)谨读，會(huì)將 LifecycleOwner 的弱引用傳進(jìn)去，并將 state 初始化為 INITIALIZED统舀。

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

因?yàn)?LifecycleOwner 一般是 Activity瓮钥、Fragment呀酸，所以用弱引用持有它們可以防止內(nèi)存泄漏煌往。

從 Lifecycle 抽象類中定義的狀態(tài)枚舉類型和事件枚舉類型就可以看出，生命周期狀態(tài)的流轉(zhuǎn)衙耕，都是通過(guò)執(zhí)行這些事件 Event 串起來(lái)的初坠。比如說(shuō)半沽，ON_CREATE 事件發(fā)生后蜂挪，生命周期狀態(tài)就會(huì)從 INITIALIZED 流轉(zhuǎn)到 CREATED 狀態(tài)驳糯。生命周期狀態(tài)的流轉(zhuǎn)是通過(guò) handleLifecycleEvent 這個(gè)方法實(shí)現(xiàn)的。

// 處理生命周期轉(zhuǎn)換事件
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);    // 首先求出 執(zhí)行 event 事件之后的生命周期 狀態(tài)值 state
        moveToState(next);    // 然后將 state 設(shè)置為 新的生命周期狀態(tài)
}

在 getStateAfter 方法中肆良，求出在執(zhí)行了 event 事件之后陨帆，生命周期的狀態(tài)负蚊。具體的代碼很簡(jiǎn)單：

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

看代碼可能會(huì)覺(jué)得納悶，為啥 ON_STOP 事件之后進(jìn)入 CREATED 狀態(tài)？我理解的是官方考慮到 CREATED 和 停止?fàn)顟B(tài)（STOPPED）可以合并為同一個(gè)狀態(tài)，CREATED 狀態(tài)其實(shí)就是 STARTED 狀態(tài)前的一種狀態(tài)窟蓝，也就是 停止?fàn)顟B(tài)（STOPPED）。可以參考官方文檔的這張圖幫助理解：

圖1 構(gòu)成生命周期的狀態(tài)和事件

拿到下一個(gè)狀態(tài)值后傲绣，再調(diào)用 moveToState 方法將生命周期持有者的狀態(tài)切換到新的狀態(tài)值毅往。

private void moveToState(State next) {
        if (mState == next) {    // 如果已接切換完成，則跳過(guò)
            return;
        }
        mState = next;    // 狀態(tài)重置為新的值
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            // 如果上一次狀態(tài)切換還未完成(mHandlingEvent = true)，或者存在正在添加中的觀察者
            mNewEventOccurred = true;    // 出現(xiàn)新的狀態(tài)值
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;    // 正在處理狀態(tài)切換 標(biāo)記位
        sync();    // 將新的生命周期狀態(tài)同步給所有的觀察者
        mHandlingEvent = false;
    }

將自身的生命周期狀態(tài)更新后泊业，還得將新的狀態(tài)同步給所有的觀察者昼丑，這就是 sync 方法需要處理的呻逆。

    // 同步生命周期狀態(tài)方法
    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        // 由于之前為了防止內(nèi)存泄漏，將 LifecycleOwner 包裝成了一個(gè)弱引用菩帝，所以這里需要檢查一下是否被回收了
        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;
    }

    ...
    // 判斷是否已經(jīng)同步完成
    private boolean isSynced() {
        // 如果沒(méi)有生命周期觀察者了咖城，那肯定就不用同步了
        if (mObserverMap.size() == 0) {
            return true;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }

先來(lái)看看它是怎么判斷已經(jīng)同步完成的。在 isSynced 方法中呼奢，獲取所有觀察者中最先添加和最近添加的觀察者的生命周期狀態(tài)值宜雀，當(dāng)這兩者的狀態(tài)值都與當(dāng)前生命周期持有者的狀態(tài)值（mState）相同，就說(shuō)明同步完成了握础。

再來(lái)看看 sync 同步方法辐董，有一個(gè) while 循環(huán)，當(dāng)還未同步完成時(shí)禀综，會(huì)先判斷當(dāng)前狀態(tài)是否在最先添加的觀察者的狀態(tài)值的前面（mState < eldest().getValue().mState）简烘，如果是，則調(diào)用 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();
            }
        }
    }

在 backwardPass 方法中夸研，首先初始化了一個(gè) 遞減迭代器邦蜜，即這個(gè)迭代器是從最近添加的觀察者開(kāi)始遍歷依鸥，一直遍歷到最初添加的觀察者（之所以這樣的遍歷順序是遞減迭代器，是因?yàn)樵皆谇懊嫣砑拥挠^察者悼沈，它的 state 越小贱迟，這里的遞減是指 state 是遞減的順序），要完成所有觀察者的狀態(tài)的更改絮供，這是第一層的 while 循環(huán)衣吠。如果這個(gè)時(shí)候又有新的 Event 事件發(fā)生，則中止同步過(guò)程壤靶，節(jié)省系統(tǒng)資源缚俏，因?yàn)檫@個(gè)時(shí)候可能會(huì)產(chǎn)生新的狀態(tài)值。

第二層循環(huán)開(kāi)始前贮乳，再次確認(rèn)觀察者狀態(tài)值比當(dāng)前狀態(tài)值要大忧换，且沒(méi)有新的 Event 出現(xiàn)，以及該觀察者沒(méi)有被移除向拆。然后調(diào)用 downEvent 方法根據(jù)觀察者現(xiàn)在的狀態(tài)亚茬，得到 Event 事件：

    // 降低 state 值的方法
    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);
    }

仔細(xì)看 downEvent 方法中的每個(gè)狀態(tài)對(duì)應(yīng)的返回事件，結(jié)合之前的狀態(tài)事件流程圖圖1浓恳，可以發(fā)現(xiàn) downEvent 方法處理的是 state 狀態(tài)后接下來(lái)發(fā)生的 event刹缝，對(duì)應(yīng)圖1 中從右向左的過(guò)程碗暗，不考慮向左的事件流程。這樣做就可以將觀察者的 state 逐漸減小梢夯，直至與當(dāng)前生命周期持有者的狀態(tài)值（mState）相同言疗。如圖2所示：

圖2 downEvent 方法減小 state 值示意圖

對(duì)應(yīng)地，還有個(gè) upEvent 方法颂砸，這個(gè)方法會(huì)不會(huì)就是處理圖1 中從左到右的過(guò)程呢洲守？查看代碼，果然如此：

    // 升高 state 值的方法
    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);
    }

例如 CREATED 狀態(tài)向右的 Event 就是 ON_START沾凄，而 RESUMED 沒(méi)有向右的事件梗醇，所以就向外拋出異常。

再來(lái)看 downEvent 方法之后撒蟀，調(diào)用了 pushParentState 方法叙谨，這個(gè)方法就是記錄了該觀察者下一個(gè)狀態(tài)，等到觀察者分發(fā)了 Event 事件之后保屯，再把這個(gè)狀態(tài)記錄刪除掉手负，也就是后面的 popParentState 方法。重點(diǎn)就是中間的這個(gè) dispatchEvent 分發(fā)事件的方法姑尺。這個(gè)方法是由該觀察者調(diào)用的竟终，將之前調(diào)用 downEvent 方法得到的 event 事件分發(fā)出去，具體的代碼如下：

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

這個(gè)方法是屬于觀察者內(nèi)部類切蟋，里面的 mState 并不是生命周期持有者的當(dāng)前狀態(tài)统捶，而是這個(gè)觀察者的當(dāng)前狀態(tài)，所以方法的最后把這個(gè)值更新為新的狀態(tài)值了柄粹。在更新之前還調(diào)用了 onStateChanged 方法喘鸟，這個(gè)方法是 LifecycleEventObserver 接口中的方法，而 LifecycleEventObserver 是繼承自 LifecycleObserver驻右，在 LifecycleEventObserver 的注釋中有這樣一句：

If a class implements this interface and in the same time uses {@link OnLifecycleEvent}, then annotations will be ignored.

翻譯過(guò)來(lái)就是什黑，如果一個(gè)類實(shí)現(xiàn)了這個(gè)接口，同時(shí)也使用了{(lán)@link OnLifecycleEvent}（即使用 @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)）堪夭，那么后者的 annotation 注解的方法就不會(huì)被執(zhí)行愕把。也就是說(shuō)，各個(gè)生命周期中執(zhí)行的相應(yīng)操作森爽，都是在這里的 onStateChanged 方法中執(zhí)行的恨豁。接口方法具體的實(shí)現(xiàn)交給了開(kāi)發(fā)者，也就是被 @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) 等等標(biāo)記的方法拗秘。

到這里終于可以總結(jié)一下生命周期持有者 LifecycleOwner 是如何處理生命周期事件的了圣絮。LifecycleOwner 通過(guò)執(zhí)行 handleLifecycleEvent 方法，處理收到的生命周期事件 Event雕旨。首先扮匠，根據(jù) Event 得到下一個(gè)生命周期狀態(tài)捧请，將自身狀態(tài)更新；然后棒搜，將狀態(tài)的變動(dòng)同步給所有觀察它的觀察者疹蛉；觀察者們用自己的狀態(tài)與 LifecycleOwner 的狀態(tài)做比對(duì)，逐步算出要達(dá)到與 LifecycleOwner 狀態(tài)一致所需的 event 事件力麸，并逐步將這些 event 分發(fā)出去可款；這樣，觀察者內(nèi)部就可以接收到這些 event克蚂，并可以根據(jù)不同的 event 做不同的業(yè)務(wù)操作了闺鲸。

回頭再看一下 sync 方法，在 backwardPass 方法執(zhí)行完后埃叭，接下來(lái)會(huì)獲取最近添加的觀察者摸恍。當(dāng) LifecycleOwner 的當(dāng)前狀態(tài)比最近添加的觀察者的狀態(tài)值要大，那么就會(huì)調(diào)用 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();
            }
        }
    }

與 backwardPass 方法相反赤屋，forwardPass 方法是通過(guò)一個(gè)遞增迭代器立镶，從最初添加的觀察者開(kāi)始一直遍歷到最近添加的觀察者，依次更改所有觀察者的狀態(tài)类早。第一層 while 循環(huán)就是遍歷所有的觀察者媚媒；第二層 while 循環(huán)里就是將每個(gè)觀察者的狀態(tài)逐步地更新成與 LifecycleOwner 的狀態(tài) mState 一樣，并將 event 事件分發(fā)涩僻。

3.2 ReportFragment 類簡(jiǎn)述

前文終于弄清楚了生命周期狀態(tài)的更新與分發(fā)過(guò)程缭召。再來(lái)看一看是在哪里調(diào)用 handleLifecycleEvent 方法開(kāi)始處理生命周期事件的，如下圖所示令哟。

圖3 handleLifecycleEvent 調(diào)用方匯總

• Fragment 有自己的生命周期恼琼，所以它里面肯定會(huì)調(diào)用 handleLifecycleEvent 方法妨蛹。
• FragmentActivity 里面調(diào)用 handleLifecycleEvent 方法的對(duì)象屏富，并不是 Activity 的 Lifecycle 對(duì)象，而是 Fragment 的 Lifecycle 對(duì)象蛙卤，管理的是 Fragment 生命周期流轉(zhuǎn)狠半，從命名 mFragmentLifecycleRegistry 也可以看出來(lái)。
• FragmentViewLifecycleOwner 是單獨(dú)用來(lái)管理 Fragment 中 onCreateView 和 onDestroyView 的生命周期的管理類颤难。所以神年，我們也可以自己擴(kuò)展新的生命周期。
• ProcessLifecycleOwner 管理整個(gè) Application 的生命周期行嗤，需要另外引入 androidx.lifecycle:lifecycle-process 庫(kù)已日。借助這個(gè)庫(kù)，我們可以直接獲取到應(yīng)用前后臺(tái)切換的狀態(tài)栅屏，以及應(yīng)用的整個(gè)生命周期飘千。需要注意的是堂鲜，Lifecycle.Event.ON_CREATE 只會(huì)分發(fā)一次，Lifecycle.Event.ON_DESTROY 不會(huì)被分發(fā)护奈。
• ReportFragment 是 Activity 中真正管理各種生命周期分發(fā)的類缔莲。
• ServiceLifecycleDispatcher 管理 Service 生命周期分發(fā)的幫助類。如果需要在 Service 中使用 Lifecycle霉旗，需要自己的 Service 繼承自 LifecycleService痴奏，并且加入 androidx.lifecycle:lifecycle-service 依賴。

ReportFragment厌秒，專門用來(lái)分發(fā)生命周期 Event 事件的 Fragment读拆，沒(méi)有可視化界面。最初見(jiàn)于 ComponentActivity 的 onCreate 方法中：

    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);    // ReportFragment 初始化
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

在 injectIfNeededIn 方法里初始化了這個(gè) Fragment鸵闪，用的還是 framework 里的 Fragment建椰，原因注釋里也說(shuō)的很清楚，因?yàn)榭紤]到有些 Activity 并不是繼承自 FragmentActivity岛马。在 ProcessLifecycleOwner 中也是用到這個(gè)方法初始化 ReportFragment棉姐，而 ProcessLifecycleOwner 是 Application 的生命周期持有者。

    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 生命周期方法中伞矩，都是調(diào)用 dispatch 方法分發(fā)Event 事件的。由于 ReportFragment 是掛靠在 ComponentActivity 上的夏志，所以 ComponentActivity 的生命周期與 ReportFragment 的生命周期是關(guān)聯(lián)在一起的乃坤。所以，ReportFragment 就可以準(zhǔn)確分發(fā) ComponentActivity 的生命周期事件沟蔑。在 dispatch 方法中湿诊，就是調(diào)用的上面所說(shuō)的 LifecycleRegistry 類的 handleLifecycleEvent 方法。

    ···
    @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);
    }
    ···
    // 分發(fā) Lifecycle.Event 的方法
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) { // LifecycleRegistryOwner 已廢棄瘦材，這一段可以不看
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                // 最終還是調(diào)用的 LifecycleRegistry 中的 handleLifecycleEvent 方法
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

除此之外厅须，ReportFragment 還負(fù)責(zé)了 Application 的生命周期的事件分發(fā)：

    // ReportFragment 中的部分代碼    注：僅節(jié)選了相關(guān)的代碼
    private ActivityInitializationListener mProcessListener;

    void setProcessListener(ActivityInitializationListener processListener) {
        mProcessListener = processListener;
    }

    interface ActivityInitializationListener {
        void onCreate();

        void onStart();

        void onResume();
    }

    // ProcessLifecycleOwner.java    Application 的生命周期持有者
    void attach(Context context) {
        mHandler = new Handler();
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        Application app = (Application) context.getApplicationContext();
        app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                ReportFragment.get(activity).setProcessListener(mInitializationListener);
            }

            @Override
            public void onActivityPaused(Activity activity) {
                activityPaused();
            }

            @Override
            public void onActivityStopped(Activity activity) {
                activityStopped();
            }
        });
    }

這里不再展開(kāi)了，只需要知道食棕，Application 的生命周期持有者 ProcessLifecycleOwner 也是使用 ReportFragment 進(jìn)行生命周期狀態(tài)分布就可以了朗和。

綜上，可以看出簿晓，ReportFragment 和 LifecycleRegistry 是 Lifecycle 最重要的兩個(gè)類眶拉。理解了它們，Lifecycle 的整體流程和思想就比較清楚了憔儿。其實(shí) Lifecycle 內(nèi)容遠(yuǎn)不止這些忆植，代碼也在不斷地迭代中，本文只是起到拋磚引玉作用，更多內(nèi)容可查看源碼~

還沒(méi)看夠朝刊？來(lái)我的公眾號(hào)看看吴侦。搜索： 修之竹

也歡迎知乎搜索 修之竹~

ps. 一個(gè)簡(jiǎn)單的 Demo：https://gitee.com/xiuzhizhu/LifeCycleDemo

參考文獻(xiàn)

1、Android Lifecycle 官方文檔
2坞古、https://juejin.cn/post/6893870636733890574#heading-13
3备韧、https://juejin.cn/post/6850418115931537416