前言

Jetpack 是一個(gè)由多個(gè)庫(kù)組成的套件，可幫助開(kāi)發(fā)者遵循最佳做法，減少樣板代碼诈泼。如果項(xiàng)目采用 MVVM 架構(gòu)，那么 Jetpack 里面的架構(gòu)相關(guān)的組件就是為MVVM 量身定制的煤禽，而且現(xiàn)在面試Jetpack也是必問(wèn)項(xiàng)铐达，但是很多開(kāi)發(fā)者對(duì)Jetpack中的一些核心組件都只停留在會(huì)用的階段，對(duì)其原理及源碼卻是一知半解甚至根本沒(méi)了解過(guò)檬果，因此整理了一個(gè)系列來(lái)幫助有需要的小伙伴理解Jetpack設(shè)計(jì)思想和原理瓮孙。

正文

什么是Lifecycle唐断？Lifecycle解決了開(kāi)發(fā)中的什么問(wèn)題？

我們先來(lái)一段Lifecycle出現(xiàn)之前的Activity生命周期監(jiān)聽(tīng)代碼:

1杭抠、先定義一個(gè)接口：

package com.kuer.ke_livedata;

public interface LifecycleInterface {
    void onCreate();

    void onResume();

    void onStart();

    void onStop();

    void onDestroy();
    //...
}

2脸甘、定義實(shí)現(xiàn)類

package com.kuer.ke_livedata;

import android.util.Log;

public class LifecycleImpl implements LifecycleInterface {
    @Override
    public void onCreate() {
        Log.e("LifecycleImpl------>","onCreate");
    }

    @Override
    public void onResume() {
        Log.e("LifecycleImpl------>","onResume");
    }

    @Override
    public void onStart() {
        Log.e("LifecycleImpl------>","onStart");
    }

    @Override
    public void onStop() {
        Log.e("LifecycleImpl------>","onStop");
    }

    @Override
    public void onDestroy() {
        Log.e("LifecycleImpl------>","onDestroy");
    }
    
    //...
}

3、生命周期監(jiān)聽(tīng)（綁定）

package com.kuer.ke_livedata;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;


public class MainActivity extends AppCompatActivity {
    LifecycleImpl lifecycle;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        lifecycle = new LifecycleImpl();
        lifecycle.onCreate();
    }


    @Override
    protected void onResume() {
        super.onResume();
        lifecycle.onResume();
    }

    @Override
    protected void onStart() {
        super.onStart();
        lifecycle.onStart();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        lifecycle.onDestroy();
    }

    @Override
    protected void onStop() {
        super.onStop();
        lifecycle.onStop();
    }
}

從以上代碼可以看出偏灿，在以前監(jiān)聽(tīng)Activity的生命周期變化是一件很麻煩的事情丹诀，而且如果邏輯復(fù)雜的話會(huì)顯得代碼特別的臃腫，耦合非常嚴(yán)重翁垂。

我們?cè)賮?lái)一段基于Lifecycle的Activity生命周期監(jiān)聽(tīng)代碼:

1铆遭、定義一個(gè)實(shí)現(xiàn)類實(shí)現(xiàn)LifecycleOwner接口（GenericLifecycleObserver是LifecycleOwner的子類，因?yàn)長(zhǎng)ifecycleOwner是空的沮峡，所以一般都是實(shí)現(xiàn)GenericLifecycleObserver）

package com.kuer.ke_livedata;

import android.annotation.SuppressLint;
import android.util.Log;

import androidx.lifecycle.GenericLifecycleObserver;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;

@SuppressLint("RestrictedApi")
public class Feel implements GenericLifecycleObserver {

    //每當(dāng)組件的生命周期發(fā)生改變的時(shí)候都會(huì)進(jìn)行回調(diào)
    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        Log.e("Feel----------->",event.name());
    }
}

2疚脐、將這個(gè)接口作為觀察者通過(guò)Lifecycle與Activity綁定起來(lái)

package com.kuer.ke_livedata;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MainActivity.this.getLifecycle().addObserver(new Feel());
    }
}

簡(jiǎn)單的代碼就能通過(guò)Feel對(duì)象監(jiān)聽(tīng)MainActivity的生命周期變化，而且所有的處理邏輯不需要寫在MainActivity中邢疙。Lifecycle中有多種觀察者寫法棍弄，這里就不一一例舉了。

概念總結(jié)： Lifecycle其實(shí)就是一個(gè)生命周期中轉(zhuǎn)站疟游，當(dāng)組件的生命周期發(fā)生改變時(shí)呼畸，會(huì)通知該組件所持有的Lifecycle（Lifecycle中采取了觀察者模式，可以添加觀察者）颁虐，Lifecycle又會(huì)通知所有的觀察者蛮原，觀察者就可以做出相對(duì)應(yīng)的邏輯處理。在整個(gè)過(guò)程中另绩，觀察者與MainActivity的耦合很低儒陨，而且不會(huì)給MainActivity造成多余的負(fù)擔(dān)，達(dá)到了一個(gè)很好的解耦和瘦身的效果笋籽。

Lifecycle源碼分析

以下是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;
        //對(duì)比的方法 比如:State.RESUMED.isAtLeast(State.CREATED)蹦漠，
        //對(duì)比State.RESUMED的序數(shù)值是否大于State.CREATED的序數(shù)值（序數(shù)值不懂百度）
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

通過(guò)源碼我們可以看出，Lifecycle是一個(gè)抽象類车海，其內(nèi)部不僅包括了添加和移除觀察者的方法笛园，還包括了Event和State枚舉，這兩個(gè)枚舉中Event指向組件生命周期對(duì)應(yīng)的事件侍芝，這些事件會(huì)映射到 Activity和Fragment中的事件分發(fā)研铆，而State是用來(lái)配合Event來(lái)保存組件的生命周期執(zhí)行軌跡的（這個(gè)概念會(huì)在下面的狀態(tài)機(jī)中詳細(xì)講解）。

既然Lifecycle是一個(gè)抽象類州叠，那么肯定會(huì)提供有具體的實(shí)現(xiàn)棵红，它的實(shí)現(xiàn)類就是LifecycleRegistry，以下是LifecycleRegistry的源碼：

public class LifecycleRegistry extends Lifecycle {

    private static final String LOG_TAG = "LifecycleRegistry";

    //所有觀察者的容器
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
   
   //當(dāng)前狀態(tài)
    private State mState;

    private final WeakReference<LifecycleOwner> mLifecycleOwner;

    private int mAddingObserverCounter = 0;

    private boolean mHandlingEvent = false;
    private boolean mNewEventOccurred = false;

   
    private ArrayList<State> mParentStates = new ArrayList<>();

   
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        //當(dāng)LifecycleRegistry對(duì)象被創(chuàng)建的好 初始化狀態(tài)
        mState = INITIALIZED;
    }

    //改變狀態(tài)的方法1  
    @SuppressWarnings("WeakerAccess")
    @MainThread
    public void markState(@NonNull State state) {
        moveToState(state);
    }

    //改變狀態(tài)的方法2 
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

    private void moveToState(State next) {
        //新?tīng)顟B(tài)和當(dāng)前狀態(tài)一樣就返回
        if (mState == next) {
            return;
        }
        //更新當(dāng)前狀態(tài)
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        //同步
        sync();
        mHandlingEvent = 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;
    }

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

    //添加觀察者的方法
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //將觀察者和Lifecycle的狀態(tài)進(jìn)行包裝留量，方便觀察者回調(diào)
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //將包裝類放入map容器中
        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++;
        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--;
    }

    private void popParentState() {
        mParentStates.remove(mParentStates.size() - 1);
    }

    private void pushParentState(State state) {
        mParentStates.add(state);
    }

    @Override
    public void removeObserver(@NonNull LifecycleObserver observer) {

        mObserverMap.remove(observer);
    }

    /**
     * The number of observers.
     *
     * @return The number of observers.
     */
    @SuppressWarnings("WeakerAccess")
    public int getObserverCount() {
        return mObserverMap.size();
    }

    @NonNull
    @Override
    public State getCurrentState() {
        return mState;
    }

    //獲取狀態(tài) ,當(dāng)前組件的生命周期事件分發(fā)過(guò)來(lái)后
    //Lifecycle的狀態(tài)機(jī)要處于的狀態(tà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);
    }

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

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

    private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            //將數(shù)組的Entry拿出來(lái)窄赋，Entry中key就是觀察者哟冬，Value就是Lifecycle的狀態(tài)
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                //回調(diào)觀察者
                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));
                 //回調(diào)觀察者
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

    // 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) {
            Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
                    + "new events from it.");
            return;
        }
        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) {
                //在里面會(huì)回調(diào)所有觀察者
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                //在里面會(huì)回調(diào)所有觀察者
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

    static State min(@NonNull State state1, @Nullable State state2) {
        return state2 != null && state2.compareTo(state1) < 0 ? state2 : state1;
    }

    static class ObserverWithState {
        State mState;
        GenericLifecycleObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.getCallback(observer);
            mState = initialState;
        }

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

通過(guò)以上的代碼我們可以大概猜出組件生命周期發(fā)生改變的適合是如何通知Lifecycle的博投，如下圖： !

那么恢暖，我們通過(guò)源碼來(lái)看一看，組件的生命周期變化的時(shí)候是如何通知Lifecycle的岸售。

Lifecycle的實(shí)現(xiàn)類LifecycleRegistry是在Activity的父類ComponentActivity中被實(shí)例化的错敢，所以我們開(kāi)去ComponentActivity中看看翰灾，一下是ComponentActivity相關(guān)代碼：

@RestrictTo(LIBRARY_GROUP)
public class ComponentActivity extends Activity implements LifecycleOwner {
    private SimpleArrayMap<Class<? extends ExtraData>, ExtraData> mExtraDataMap =
            new SimpleArrayMap<>();

    //1、
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @RestrictTo(LIBRARY_GROUP)
    public void putExtraData(ExtraData extraData) {
        mExtraDataMap.put(extraData.getClass(), extraData);
    }

    @Override
    @SuppressWarnings("RestrictedApi")
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //2稚茅、
        ReportFragment.injectIfNeededIn(this);
    }

    @CallSuper
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        //3纸淮、
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }

    @RestrictTo(LIBRARY_GROUP)
    public <T extends ExtraData> T getExtraData(Class<T> extraDataClass) {
        return (T) mExtraDataMap.get(extraDataClass);
    }

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    @RestrictTo(LIBRARY_GROUP)
    public static class ExtraData {
    }
}

在注釋1處LifecycleRegistry被創(chuàng)建了，在注釋3處亚享，將LifecycleRegistry的State設(shè)置為CREATED咽块，注釋2處的將ComponentActivity注入到ReportFragment中。正常來(lái)說(shuō)欺税，從以上結(jié)構(gòu)來(lái)看侈沪，組件的生命周期事件應(yīng)該是在ComponentActivity中被分發(fā)給LifecycleRegistry的，但實(shí)際上晚凿，并不是亭罪，而是由ReportFragment來(lái)進(jìn)行分發(fā)的，所以接下來(lái)我們要進(jìn)入ReportFragment中看看：

@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";
    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();
        }
    }
    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }
   ...
    @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);
    }

    //...
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
         //判斷當(dāng)前組件是否實(shí)現(xiàn)了LifecycleRegistryOwner接口
         //LifecycleRegistryOwner是LifecycleOwner的子類
         //兩者區(qū)別的它們的getLifecycle()方法返回的類型不一樣
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }
        //判斷當(dāng)前組件是否實(shí)現(xiàn)了LifecycleOwner接口
        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
    //...
}

通過(guò)以上代碼我們可以看出歼秽，在ReportFragment的各個(gè)生命周期的方法中应役，會(huì)調(diào)用dispatch()方法，而dispatch方法中就會(huì)將組件相對(duì)應(yīng)的事件分發(fā)給Lifecycle燥筷，最終會(huì)在LifecycleRegistry進(jìn)行狀態(tài)更新以及通知所有的觀察者箩祥。

以上就是Lifecycle感知組件生命周期，并通知觀察者的流程肆氓。

Lifecycle中的狀態(tài)機(jī)概念

為什么會(huì)存在狀態(tài)機(jī)的概念呢滥比？*因?yàn)?code>Lifecycle中的觀察者可能會(huì)在Activity的任意一個(gè)生命周期中添加進(jìn)來(lái)，所以*為了避免后面添加的觀察者錯(cuò)失組件前面的生命周期做院，就用狀態(tài)機(jī)中的狀態(tài)配合組件的生命周期的事件來(lái)記錄Activity的生命周期軌跡。大家還記得Lifecycle中的兩個(gè)枚舉類嗎濒持，那就是狀態(tài)機(jī)用來(lái)記錄Activity的生命周期記錄軌跡的键耕。我們可以先來(lái)看一下這張圖(紫色字體為L(zhǎng)ifecycle.State枚舉類中的常量，黑色字為L(zhǎng)ifecycle.EVENT中的常量柑营，對(duì)應(yīng)的是組件的生命周期)**：

當(dāng)Activity等組件的生命周期發(fā)生改變的后屈雄，就會(huì)把相對(duì)應(yīng)的生命周期傳到Lifecycle中，Lifecycle會(huì)將組件的生命周期和State枚舉類中的枚舉常量對(duì)應(yīng)保存起來(lái)并與每個(gè)觀察者進(jìn)行綁定官套，具體對(duì)應(yīng)如上圖酒奶。在Lifecycle中蚁孔，為了更好的了解組件的生命周期軌跡，將組件的生命周期分為兩個(gè)概念惋嚎，第一個(gè)概念叫“生命周期的前進(jìn)”杠氢，指的是onCreate->onStart->onResume這個(gè)過(guò)程，第二個(gè)概念叫 “生命周期的倒退” 另伍，指的是onPause->onStop->onDestroy這個(gè)過(guò)程（注意鼻百，前進(jìn)和后退不需要三個(gè)方法都調(diào)用，兩個(gè)方法調(diào)用也可以)摆尝。接下來(lái)我們聊聊Lifecycle.State的作用：

 public enum State {
        
        DESTROYED,


        INITIALIZED,

 
        CREATED,

    
        STARTED,

    
        RESUMED;

        //比較枚舉常量的序數(shù)大小的方法
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

Lifecycle.State會(huì)保存在觀察者中去的温艇，其意義是，當(dāng)我們?cè)?code>onStart方法中注冊(cè)一個(gè)觀察者時(shí)堕汞，為了讓這個(gè)觀察者不錯(cuò)過(guò)之前執(zhí)行過(guò)了的onCreate生命周期勺爱，在添加觀察者的時(shí)候會(huì)通過(guò)一段代碼來(lái)彌補(bǔ)：

 @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        //觀察者剛注冊(cè)的時(shí)候，初始化的狀態(tài)INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //把觀察者和狀態(tài)封裝在一起讯检，這樣能更好的綁定
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        //如果觀察者的狀態(tài)和Lifecycle不同步琐鲁，就先同步，在同步的好就會(huì)進(jìn)行回調(diào)觀察者
        //如果我們是在onStart中注冊(cè)的觀察者视哑，肯定不同步（這里建議去自行斷點(diǎn)測(cè)試下）
        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);
        }
        //...
    }

在以上代碼中會(huì)對(duì)比觀察者和Lifecycle保存的組組件的生命周期是否同步绣否，如果不同步，就先進(jìn)行同步挡毅，同步的時(shí)候就會(huì)回調(diào)觀察者蒜撮。以下是代碼測(cè)試：

public class MainActivity extends AppCompatActivity {

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

    @Override
    protected void onResume() {
        super.onResume();
        MainActivity.this.getLifecycle().addObserver(new Feel());
    }
}
@SuppressLint("RestrictedApi")
public class Feel implements GenericLifecycleObserver {
    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        Log.e("Feel----------->","Activity:"+event.name()+"------Lifecycle.State:------->"+source.getLifecycle().getCurrentState());
    }
}

一下是輸出日志：

2022-08-04 16:01:23.745 26582-26582/com.kuer.ke_livedata E/Feel----------->: Activity:ON_CREATE------Lifecycle.State:------->STARTED
2022-08-04 16:01:23.745 26582-26582/com.kuer.ke_livedata E/Feel----------->: Activity:ON_START------Lifecycle.State:------->STARTED
2022-08-04 16:01:23.745 26582-26582/com.kuer.ke_livedata E/Feel----------->: Activity:ON_RESUME------Lifecycle.State:------->RESUMED

總結(jié)：通過(guò)以上代碼，就可以了解到Lifecycle的狀態(tài)機(jī)的作用了跪呈，其實(shí)就是用來(lái)同步組件和Lifecycle和觀察者的生命周期狀態(tài)的段磨。