Lifecycle 使用和源碼原理解析

一、Lifecycle是什么?

JetPack.Lifecycle能夠監(jiān)聽Activity/Fragment生命周期行為的各種變化

下面是Lifecycle的重要細(xì)節(jié):

Lifecycle可以有效的避免內(nèi)存泄漏和解決android生命周期的常見難題 
Livecycle 是一個表示android生命周期及狀態(tài)的對象 
LivecycleOwner 用于連接有生命周期的對象，如activity,fragment 
LivecycleObserver 用于觀察查LifecycleOwner 
Lifecycle框架使用觀察者模式實現(xiàn)觀察者監(jiān)聽被觀察者的生命周期的變化

二、用法

1、添加依賴

（1）如果項目使用的是androidX

 dependencies {
    def lifecycle_version = "2.4.0"
    def arch_version = "2.1.0"

    // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // 只有Lifecycles (不帶 ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

    // Saved state module for ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

    // lifecycle注解處理器
    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    // 替換 - 如果使用Java8,就用這個替換上面的lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    //以下按需引入
    // 可選 - 幫助實現(xiàn)Service的LifecycleOwner
    implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
    // 可選 - ProcessLifecycleOwner給整個 app進(jìn)程 提供一個lifecycle
    implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
    // 可選 - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"
    // 可選 - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$arch_version"


// 這種依賴支持是 精簡版本
// implementation "androidx.lifecycle:lifecycle-runtime:2.0.0" 
// implementation "androidx.lifecycle:lifecycle-extensions:2.0.0" 
// implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0" 
// annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.0.0"*/
}

（2）如果項目使用的是非androidX，那就需使用lifecycle android.arch.lifecycle庫

 dependencies {
    def lifecycle_version = "1.1.1"

    // 包含ViewModel和LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // 僅僅包含ViewModel
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version"
    // 僅僅包含LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
    // 僅僅包含Lifecycles
    implementation "android.arch.lifecycle:runtime:$lifecycle_version"

    // For Kotlin use kapt instead of annotationProcessor
    // annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" 

    // 如果用Java8, 用于替代compiler
    // implementation "android.arch.lifecycle:common-java8:$lifecycle_version" // 這個不行
    // implementation 'androidx.lifecycle:lifecycle-common-java8:2.2.0'

    // 可選，ReactiveStreams對LiveData的支持
    implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"

    // 可選，LiveData的測試
    testImplementation "android.arch.core:core-testing:$lifecycle_version"

    // 除此之外，不要忘了在build.gradle添加 "androidx.lifecycle:common-java8:<version>"
    implementation "androidx.lifecycle:common-java8:1.1.1"

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

2、使用

（1）使用1： 繼承LifecycleObserver接口，自定義方法，方法上添加@OnLifecycleEvent注解

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    lifecycle.addObserver(MyLifecycleObserver())
}

// 監(jiān)聽activity的生命周期
class MyLifecycleObserver : LifecycleObserver {
    private val TAG = MyLifecycleObserver::class.java.simpleName

    // 方法名可以自由定義，需要添加@OnLifecycleEvent注解
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun myCreate() = Log.e(TAG, "myCreate: ")

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun myStart() = Log.e(TAG, "myStart: ")

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun myResume() = Log.e(TAG, "myResume: ")

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun myPause() = Log.e(TAG, "myPause: ")

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun myStop() = Log.e(TAG, "myStop: ")
}

（2）使用2： 繼承DefaultLifecycleObserver接口，實現(xiàn)對應(yīng)的方法。

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onCreate(owner: LifecycleOwner) {
                Log.d(TAG, "onCreate: ")
            }

            override fun onStart(owner: LifecycleOwner) {
                Log.d(TAG, "onStart: ")
            }

            override fun onResume(owner: LifecycleOwner) {
                Log.d(TAG, "onResume: ")
            }

            override fun onPause(owner: LifecycleOwner) {
                Log.d(TAG, "onPause: ")
            }

            override fun onStop(owner: LifecycleOwner) {
                Log.d(TAG, "onStop: ")
            }

            override fun onDestroy(owner: LifecycleOwner) {
                Log.d(TAG, "onDestroy: ")
            }
        })
    }

三、源碼解析

AppCompatActivity繼承自FragmentActivity，而FragmentActivity又繼承自ComponentActivity，ComponentActivity實現(xiàn)了LifecycleOwner接口。

ComponentActivity.create()
--> ReportFragment.injectIfNeededIn(this);
        // 創(chuàng)建了一個ReportFragment，與activity的生命保持一致。以此來監(jiān)聽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();
        }

1、首先我們需要了解到有五大狀態(tài)：DESTROYED（銷毀狀態(tài)）、INITIALIZED（初始狀態(tài)）、CREATED（創(chuàng)建狀態(tài)）、STARTED(啟動狀態(tài))、RESUMED（可見狀態(tài)）
以被觀察者（activity）的生命周期驅(qū)動觀察者（狀態(tài)）的變化，來達(dá)到觀察者中保存的狀態(tài)和被觀察者的生命周期保持一致。

2、接下來，我們代碼分析下流程。

// lifecycle是在ComponentActivity實現(xiàn)的。lifecycle = LifecycleRegistry()
lifecycle.addObserver(MyLifecycleObserver())@MainActivity
    // 初始化狀態(tài)，如果是非銷毀狀態(tài)，就初始化狀態(tài)為INITIALIZED
--> State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;@LifecycleRegistry
    // observer 作為參數(shù)傳入ObserverWithState
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // observer 繼續(xù)傳
    --> mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            // object 就是 observer。ReflectiveGenericLifecycleObserver這個類要記住，后面要用到。。。。。。。
        --> return new ReflectiveGenericLifecycleObserver(object);
                // mWrapped 就是 observer
            --> mWrapped = wrapped;
                // 獲取到observer的class。
            --> mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    sync();
    // 如果觀察者、被觀察者的狀態(tài)不一致，那就去同步狀態(tài)
    -->  while (!isSynced()) {
            mNewEventOccurred = false;
            // 被觀察者的狀態(tài)比觀察者中的狀態(tài)要小，說明是逆操作，往后走
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
                    // 再次校驗，如果觀察者中的狀態(tài)比被觀察者的要大，繼續(xù)執(zhí)行
                --> while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
                        // 事件回流。通過觀察者中的狀態(tài)，獲取到事件。下面再分析
                        Event event = Event.downFrom(observer.mState);
                        if (event == null) {
                            throw new IllegalStateException("no event down from " + observer.mState);
                        }
                        
                        pushParentState(event.getTargetState());
                        // 上面獲取到事件后，就去分發(fā)事件
                        observer.dispatchEvent(lifecycleOwner, event);
                            // mLifecycleObserver就是上面的ReflectiveGenericLifecycleObserver
                        --> mLifecycleObserver.onStateChanged(owner, event);
                            --> mInfo.invokeCallbacks(source, event, mWrapped);
                                --> invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
                                    invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event, target);
                                    --> handlers.get(i).invokeCallback(source, event, mWrapped);
                                            // 反射執(zhí)行對應(yīng)的方法
                                        --> mMethod.invoke(target);
                        popParentState();
                    }
            }
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            // 被觀察者的狀態(tài)比觀察者中的狀態(tài)要大，說明是正操作，往前走
            if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
                    // 再次校驗，如果觀察者中的狀態(tài)比被觀察者的要小，繼續(xù)執(zhí)行
                --> while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
                        pushParentState(observer.mState);
                        // 事件正流。通過觀察者中的狀態(tài)，獲取到事件。下面再分析
                        final Event event = Event.upFrom(observer.mState);
                        if (event == null) {
                            throw new IllegalStateException("no event up from " + observer.mState);
                        }
                        // 上面獲取到事件后，就去分發(fā)事件。后面的邏輯與上面一樣。
                        observer.dispatchEvent(lifecycleOwner, event);
                        popParentState();
                    }            
            }
        }

3、上面分析到，被觀察者的狀態(tài)發(fā)生變化，導(dǎo)致觀察者的狀態(tài)也發(fā)生響應(yīng)的變化。繼而觀察者再通過比較上一次和當(dāng)前的狀態(tài)，獲取出當(dāng)前應(yīng)該執(zhí)行的事件。
我們來畫個流程圖來分析。

綠色部分是狀態(tài)
紅色路徑是正操作
藍(lán)色路徑是反操作

狀態(tài)驅(qū)動事件流程圖

通過前進(jìn)狀態(tài)獲取到事件：

public static Event upFrom(@NonNull State state) {
    switch (state) {
        case INITIALIZED:
            return ON_CREATE;
        case CREATED:
            return ON_START;
        case STARTED:
            return ON_RESUME;
        default:
            return null;
    }
}

通過后退狀態(tài)獲取到事件：

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

4、上面分析了在設(shè)置監(jiān)聽時，去同步狀態(tài)的流程。其實當(dāng)framgment的生命周期發(fā)生變化的執(zhí)行，也是類似的。以onStart為例。

ReportFragment.onStart() {
--> dispatch(getActivity(), event);
    --> ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        --> moveToState(event.getTargetState());
                // 如果狀態(tài)一致，直接return，不執(zhí)行
            --> if (mState == next) {
                   return;
                }
                mState = next;
                
                mHandlingEvent = true;
                //這個代碼是不是又似曾相識，跟上面的一樣
                sync();
                mHandlingEvent = false;
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容