一、LifeCycle 簡介

LifeCycle 是一個可以感知宿主生命週期變化的元件。常見的宿主包括 Activity/Fragment、Service 和 Application。LifeCycle 會持有宿主的生命週期狀態的資訊，當宿主生命週期發生變化時，會通知監聽宿主的觀察者。

LifeCycle 的出現主要是為了解決： 系統元件的生命週期與普通元件之間的耦合性。

• 系統元件指：Activity/Fragment、Service 和 Application。
• 普通元件指：將程式碼按照功能或者作用封裝成的元件。

哪些情況下，系統元件的生命週期會和普通元件的生命週期耦合在一起呢？

舉個例子：

在 58 部落業務中有影片播放的業務需求。我們需要在 Activity 中對影片播放元件進行初始化，在 onPause() 方法中停止影片的播放，在 onDestroy() 方法中對影片播放元件以及一些資源進行回收。這樣的做法非常繁瑣，會讓頁面與元件之間的耦合度變高。

對於這類問題，完全可以使用 LifeCycle 來解決。 它不僅降低了模組之間的耦合度，還降低了記憶體洩露發生的可能性。

二、LifeCycle 的使用

Jetpack 為我們提供了兩個介面：

被觀察者： LifecycleOwner

觀察者： LifecycleObserver

被監聽的系統元件需要去實現 LifecycleOwner 介面，觀察者需要實現 LifecycleObserver 介面。

（一）使用場景1：使用 LifeCycle 解耦頁面與元件

（1）解耦 Activity

第一步：新增依賴

implementation 'androidx.appcompat:appcompat:1.2.0'

在 AndroidX 裡面 ComponentActivity 已經預設實現了 LifecycleOwner 介面。如果專案沒有遷移到 AndroidX，還是用的 Support 庫，新版本的 SDK 也透過 SupportActivity 實現了 LifecycleOwner 介面。

在 LifecycleOwner 介面中，只有一個 getLifecycle 方法。

第二步：實現觀察者

如果是想監聽某個 Activity 的生命週期，需要我們做的就是自定義元件，實現 LifecycleObserver 介面即可，該介面沒有介面方法，不需要任何具體的實現。

比如以剛剛的影片播放為例：

1. 建立一個 MyVideoPlayListener 類，實現 LifecycleObserver 介面，與影片播放相關的邏輯全在這個類裡面完成。對於元件裡面需要在 Activity 生命週期變化時得到通知的方法，用 @OnLifecycleEvent(Lifecycle.Event.ON_XXX) 註解進行標記，這樣當 Activity 生命週期發生變化時，被標記過的方法便會被自動呼叫。

public class MyVideoPlayListener implements LifecycleObserver {

    private static String TAG = "MyVideoPlayListener";



    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)

    private void initVideo(){

        Log.d(TAG,"initVideo");

    }



    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

    private void startPlay(){

        Log.d(TAG,"startPlay");

    }



    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

    private void pausePlay(){

        Log.d(TAG,"pausePlay");

    }}

2.在 MainActivity 中對 MyVideoPlayListener 進行引用即可。

public class MainActivity extends AppCompatActivity {



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);



        MyVideoPlayListener listener = new MyVideoPlayListener();

        getLifecycle().addObserver(listener);

    }}

（2）解耦 Fragment

在新版的 SDK 中，Fragment 同樣也預設實現了 LifecycleOwner 介面，因此，以上的例子同樣適合於 Fragment。

（二）使用場景2：使用 LifecycleService 解耦 Service 與元件

（1）LifecycleService 基本介紹

Android 中擁有生命週期的元件除了 Activity/Fragment ，還有一個非常重要的元件就是 Service。LifecycleService 就是用來監聽和解耦 Service 元件的。

public class LifecycleService extends Service implements LifecycleOwner {



    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);



    ......



    @Override

    @NonNull

    public Lifecycle getLifecycle() {

        return mDispatcher.getLifecycle();

    }}

（2）具體使用方法

第一步：新增相關依賴

implementation "androidx.lifecycle:lifecycle-service:2.2.0"

第二步：建立 MyServiceObserver 類，實現 LifecycleObserver 介面。使用 @OnLifecycleEvent 標記希望在 Server 生命週期發生變化時得到同步呼叫的方法。

public class MyServiceObserver implements LifecycleObserver {

    private static String TAG = "MyServiceObserver";



    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)

    private void initVideo(){

        Log.d(TAG,"initVideo");

    }



    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)

    private void pausePlay(){

        Log.d(TAG,"stopPlay");

    }}

第三步：建立一個 MyService 的類，繼承 LifecycleService。由於 LifecycleService 是 Service 的直接子類，所以使用起來與普通的 Service 沒有差別。

public class MyService extends LifecycleService {

    private MyServiceObserver myServiceObserver;



    public MyService(){

        myServiceObserver = new MyServiceObserver();

        getLifecycle().addObserver(myServiceObserver);

    }}

（三）使用場景3：使用 ProcessLifecycleOwner 監聽應用程式的生命週期

具有生命週期的元件除了 Activity、Fragment 和 Service 外，還有 Application。ProcessLifecycleOwner 就是用來監聽整個應用程式的生命週期情況。

具體使用方法：

第一步：新增依賴項

implementation "androidx.lifecycle:lifecycle-process:2.2.0"

第二步：定義一個 ApplicationObserver，實現 LifecycleObserver 介面。

public class ApplicationObserver implements LifecycleObserver {

    private String TAG = this.getClass().getName();



    /**

     * 在應用程式的整個生命週期中只會被呼叫一次

     */

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)

    public void onCreate() {

        Log.d(TAG,"Lifecycle.Event.ON_CREATE");

    }



    @OnLifecycleEvent(Lifecycle.Event.ON_START)

    public void onStart() {

        Log.d(TAG,"Lifecycle.Event.ON_START");

    }



    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

    public void onResume() {

        Log.d(TAG,"Lifecycle.Event.ON_RESUME");

    }



    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

    public void onPause() {

        Log.d(TAG,"Lifecycle.Event.ON_PAUSE");

    }



    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)

    public void onStop() {

        Log.d(TAG,"Lifecycle.Event.ON_STOP");

    }



    /**

     * 永遠不會被呼叫，系統不會分發呼叫 ON_DESTROY 事件

     */

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)

    public void onDestroy() {

        Log.d(TAG,"Lifecycle.Event.ON_DESTROY");

    }}

第三步：在 Application 中關聯 ApplicationObserver。

public class App extends Application {

    @Override

    public void onCreate() {

        super.onCreate();

        ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());

    }}

注意事項：

1. ProcessLifecycleOwner 是針對整個應用程式的監聽，與 Activity 的數量無關。
2. Lifecycle.Event.ON_CREATE 只會被呼叫一次，而 Lifecycle.Event.ON_DESTROY 永遠不會被呼叫。
3. Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的呼叫會有一定的延後，因為系統需要為“螢幕旋轉，由於配置發生變化而導致的 Activity 重新建立” 的情況預留一些時間。

三、Lifecycle 的另外兩種寫法

Lifecycle 有三種實現方法：

1. LifecycleObserver 配合註解
2. FullLifecyclerObserver 擁有宿主所有生命週期事件
3. LifecycleEventObserver宿主生命週期事件封裝成 Lifecycle.Event

在上一節使用介紹中，我們用的是第一種方式：LifecycleObserver 配合註解。

這種方式使用比較簡單，但是注意最好新增 lifecycle-compiler 這個註解處理器，否者在執行時會使用反射的形式回撥到對應的方法上：

annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.2.0"

加上這個註解處理器後，用  @OnLifecycleEvent 標記的方法就不能再宣告成  private ，否者會報如下的錯誤：

method marked with OnLifecycleEvent annotation can not be private

下面介紹一下另外兩種實現方式：

（一）FullLifecyclerObserver 擁有宿主所有生命週期事件

//該介面中定義好了生命週期方法，我們只需要實現 FullLifecycleObserver 介面，重寫對應的//生命週期方法即可。不過目前 FullLifecycleObserver 這個介面未開放給開發者使用。interface FullLifecycleObserver extends LifecycleObserver {



    void onCreate(LifecycleOwner owner);



    void onStart(LifecycleOwner owner);



    void onResume(LifecycleOwner owner);



    void onPause(LifecycleOwner owner);



    void onStop(LifecycleOwner owner);



    void onDestroy(LifecycleOwner owner);}

（二）LifecycleEventObserver 宿主生命週期事件封裝成 Lifecycle.Event

//透過實現 LifecycleEventObserver 介面，重寫 onStateChanged 方法，在該方法內部//透過判斷 Lifecycle.Event 來實現具體的業務邏輯public class MyVideoPlayObserver implements LifecycleEventObserver {

    private static String TAG = "MyVideoPlayObserver";



    @Override

    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {

        switch (event){

            case ON_CREATE:

                Log.d(TAG,"initVideo");

                break;

            case ON_START:

                Log.d(TAG,"startPlay");

                break;

            case ON_RESUME:

                Log.d(TAG,"resumePlay");

                break;

            default:

                 break;

        }

    }}

四、總結

LifeCycle 元件存在的主要意義是幫助我們解耦，讓自己定義的元件也能夠感受到生命週期的變化。

五、補充

截止本文釋出時，lifecycle_version 最新版本是  2.2.0，如需獲取最新版本請檢視官網： developer.android.google.cn/jetpack/and…

注： lifecycle-extensions 中的 API 已棄用，需要使用到 Lifecycle 下的某個工具時，新增對應的依賴即可：

       dependencies {

        def lifecycle_version = "2.2.0"

        def arch_version = "2.1.0"



        // ViewModel

        implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"

        // LiveData

        implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"

        // Lifecycles only (without ViewModel or LiveData)

        implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"



        // Saved state module for ViewModel

        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"



        // Annotation processor

        annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"

        // alternately - if using Java8, use the following instead of lifecycle-compiler

        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"



        // optional - helpers for implementing LifecycleOwner in a Service

        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"



        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process

        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"



        // optional - ReactiveStreams support for LiveData

        implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"



        // optional - Test helpers for LiveData

        testImplementation "androidx.arch.core:core-testing:$arch_version"

    }

Android中高階進階資料碼雲地址：