一文讀懂Lifecycle綁定Activity生命周期原理

LifeCycle怎麼綁定Activity/Fragment？
LifeCycle怎麼監聽Activity/Fragment生命周期？

今日黃曆:2022年9月13日星期二

座位朝向：面向東北方寫程式，BUG 最少。今日宜飲：奶茶,果味汽水女神親近指數：2.4

宜：今天白天上線是安全的。

忌：1.撸管小撸怡情，大撸傷身，強撸灰飛煙滅。2.命名變量"ad"。3.開會。

如果喜歡，請點選關注或點選收藏，篇幅較長，請耐心閱讀。

定義：

LifeCycle 是一個類，用于存儲有關元件（如 Activity 或 Fragment）的生命周期狀态的資訊，并允許其他對象觀察此狀态。

綁定生命周期

LifeCycle沒有使用之前，我們監聽Activity或Fragment生命周期一般都是下面這種形式：

先定義一個監聽類：

class MyLifeCycleListener {
    
    fun onStart() {

    }
    fun onStop() {

    }
}

然後在Activity中使用這個類：

class MainActivity : AppCompatActivity() {
    private  lateinit var myLifeCycleListener:MyLifeCycleListener
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        myLifeCycleListener = MyLifeCycleListener()
    }

    override fun onStart() {
        myLifeCycleListener.onStart()
        super.onStart()
    }

    override fun onStop() {
        myLifeCycleListener.onStart()
        super.onStop()
    }
}

最後在onStart和onStop方法調用對應的方法。

雖然上面看起來沒問題，但在真實的應用中，會有太多管理界面和其他元件的調用，以響應生命周期的目前狀态。在LifeCycle出來之後，我們再也不用手動在Activity或Fragment中去添加類似的代碼。使用觀察者設計模式綁定生命周期，觀察生命周期狀态。

常用一般有三種寫法。

第一種，實作LifecycleObserver接口：

class MyLifeCycleObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {

    }
}

第二種，實作DefaultLifecycleObserver接口

class MyDefaultLifeCycleObserver:DefaultLifecycleObserver {

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
    }
    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
    }

    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
    }

    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
    }

}

第三種，實作LifecycleEventObserver接口

class MyLifecycleEventObserver:LifecycleEventObserver{
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when(event){
            Lifecycle.Event.ON_START->{
                
            }
            Lifecycle.Event.ON_STOP->{
                
            }
        }
    }

}

三種方式，在Activity和Fragment中綁定的方式一樣。

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(MyLifeCycleObserver())
        lifecycle.addObserver(MyDefaultLifeCycleObserver())
        lifecycle.addObserver(MyLifecycleEventObserver())
    }

綁定元件

在上面的示例中，我們調用了lifecycle.addObsever将觀察者與Activity綁定一起，為什麼要這麼做，是如何綁定的？我們接着往下看。

首先我們看一下lifecycle是什麼？

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
@NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

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

我們通過分析MainActivity的父類ComponentActivity發現，lifecycle是調用了getLifecycle() 這個方法傳回的一個lifeCycle。而這個getLifecycle() 是接口LifecycleOwner中定義的方法，我們看到ComponentActivity實作了LifecycleOwner接口。我們再看一下Lifecycle。

public abstract class Lifecycle {

   
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

   
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    ........................
}

可以看出Lifecycle這個抽象類中的方法addObserver方法的參數正好是LifecycleObserver。而三種使用方式都是繼承自LifecycleObserver接口，是以Activity作為LifecycleOwner接口的實作者，可以直接調用addObserver添加監聽者。至此我們可以知道LifeCycle是怎麼綁定Activity/Fragment的了。

監聽生命周期

Lifecycle使用兩種主要枚舉跟蹤其關聯元件的生命周期狀态：

事件枚舉 ON_CREATE，ON_START，ON_RESUME，ON_PAUSE，ON_STOP，ON_DESTROY，ON_ANY

從架構和 Lifecycle 類分派的生命周期事件。這些事件映射到 activity 和 fragment 中的回調事件。

狀态枚舉 DESTROYED，INITIALIZED，CREATED，STARTED，RESUMED

由 Lifecycle 對象跟蹤的元件的目前狀态。

其事件與狀态之間的關系如下圖所示:

從圖中我們可以看出事件和狀态之間的關系，當事件為前進事件ON_CREATE時，狀态變成CREATE狀态，當事件為回退事件ON_STOP時，對應的狀态從STARTED變成CREATE。接下來我們進入源碼。

首先我們從MainActivity的父類ComponentActivity的onCreate方法開始分析。

protected void onCreate(@Nullable Bundle savedInstanceState) {
        // Restore the Saved State first so that it is available to
        // OnContextAvailableListener instances
        mSavedStateRegistryController.performRestore(savedInstanceState);
        mContextAwareHelper.dispatchOnContextAvailable(this);
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this); //初始化 ReportFragment
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

我們看到在ComponentActivity的onCreate方法中初始化了一個ReportFragment。這個ReportFragment有什麼、作用？我們接着往下看。

public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            LifecycleCallbacks.registerIn(activity);
        }
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            //将這個fragment注冊到ComponentActivity中
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG)
                .commit();
            manager.executePendingTransactions();
        }
    }

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

ReportFragment的生命周期方法中調用了dispatch方法。

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

dispatch将生命周期事件傳給handleLifecycleEvent處理。

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        //通過生命周期事件擷取，目标狀态，調用moveTostate方法進行狀态更新
        moveToState(event.getTargetState());
    }

private void moveToState(State next) {
        if (mState == next) { //如果目前lifeCycle的狀态與下一個狀态相同則不處理
            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;
    }

moveToState方法中首先判斷lifecycle目前狀态來決定是否進行狀态同步。

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;
            //如果目前狀态小于觀察者狀态，則需要将觀察者狀态向後同步
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                //如果目前狀态大于觀察者狀态，則需要将觀察者狀态向前同步
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                //通過狀态回退事件
                Event event = Event.downFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event down from " + observer.mState);
                }
                pushParentState(event.getTargetState());
                //分發事件
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

@Nullable
        public static Event downFrom(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }

結合前面我們講的事件Event和狀态States的關系，我們很容易能了解downFrom方法，當狀态為STARTED，回退一下對應的事件正好是ON_STOP，Android源碼通過這樣狀态機的方式管理着狀态與事件之間的關系。至于forwardPass這個方法，我們留給讀者自己動手分析。至此Lifecycle的核心原理，我們就講完了。LifeCycle怎麼監聽Activity/Fragment生命周期，這個問題相信大家就能回答的上來，Lifecycle的難點在于事件與狀态之間的關系的了解。大家根據文章多讀幾遍，動手畫一遍流程圖，相信大家很快都能明白。

喜歡本篇文章的同學，可以點選關注或點選收藏，您的支援是作者創作的動力。

一文讀懂Lifecycle綁定Activity生命周期原理

繼續閱讀

c語言學習打卡第一天

盤點那些你不知道的戶外面料冷知識。·第一，GORE-TEXActive。GORE-TEX可分為三種不同的類型，分别是GO

Vue學習記錄--執行個體的生命周期

LeetCode-Linked List Cycle II

React學習筆記（五）：生命周期

局部内部類

掙值如何計算？

【Android重點知識突破系列1】——Activity

你所不知道的Activity方法

ThecycleoflifeisonlytemporaryYouaredyingButyouwillbebornagai

Activity的生命周期及加載模式1.Activity的生命周期2.Activity的加載模式

Android四大元件之Activity(七大生命周期)

Android四大元件之一：Activity總結（上）

Android四大元件之Activity Life Cycle

【React】1020- React useEffect 使用指南

PMBOK學習筆記－項目生命周期特征