Android 生命週期組件 Lifecycle 使用詳解

前言

2018 年的 Google I/O 大會上，Google 發佈了 Android Jetpack，並稱其爲下一代的 Android 組件，旨在幫助開發者加快應用開發速度。準確來說，Jetpack 是一系列 Android 軟件組件的集合，它包括基礎組件、架構組件、行爲組件、界面組件。其中的 Android Architecture Components 指的就是這裏的 「架構組件」。

Android Architecture Components 是 Google 推薦的一個構建 APP 的應用架構，它包含了一些列架構相關組件。而本篇文章咱們要介紹的 Lifecycle 就是其中的一個與生命週期相關的庫，同時，Lifecycle 也跟 LiveData 和 ViewModel 兩個庫緊密聯繫，想要搞懂後二者，就必須先搞懂它。

具體各組件之間的關係，以及各自在 Jetpack 中的地位，能夠參見下面兩幅來源於官網的圖片。

Lifecycle 的做用

Lifecycle 是具備生命週期感知能力的組件，也就是說，咱們能在 Activity 或者 Fragment 的生命週期發生變化的時候獲得通知。咱們每每會在 Activity 的各類生命中週期方法裏執行特定的方法，好比，進行廣播的註冊和解綁、Eventbus 的註冊和解綁等:

public class TestActivity extends AppCompatActivity {

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

    @Override
    protected void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    protected void onDestroy() {
        EventBus.getDefault().unregister(this);
        super.onDestroy();
    }
}

若是咱們把不少這種須要跟生命週期相關的邏輯代碼都直接放在 Activity 的生命週期方法中，Activity 將會變得難以維護。經過 Lifecycle，咱們就能經過把這些邏輯抽離出來，進而避免這種問題。由於本質上咱們須要的只是 Activity 或者 Fragment 的生命週期發生改變的時候能通知到咱們，以便咱們在對應生命週期中執行對應的方法。

Lifecycle 的基本使用

2.0、 導入 Lifecycle 依賴

Lifecycle 被包含在 support library 26.1.0 及以後的依賴包中，若是咱們的項目依賴的支持庫版本在 26.1.0及以上，那麼不須要額外導入 Lifecycle 庫，本篇例子中使用的支持庫是 28.0.0 ：

implementation 'com.android.support:appcompat-v7:28.0.0'

若是支持庫版本小於 26.1.0 ，就須要單獨導入 Lifecycle 庫 ：

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

固然，若是項目已經遷移到了 AndroidX，可使用下面的方式引入 ：

implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"

仍是建議你們嘗試儘快把項目遷移爲 AndroidX，由於不少更新，會最早在 AndroidX 中發佈，逐漸擺脫傳統的support包。好比這裏要講的 Lifecycle 在 AndroidX 中已經升級到了 2.x 版本，而支持庫中仍是 1.x 版本。

鑑於支持庫通常都在 26.1.0 以上，而且尚有大部分用戶未遷移到AndroidX，在本篇文章中，咱們使用 support library 28.0.0 中默認包含的 Lifecycle 庫。咱們在項目的 app 目錄下的 build.gradle 文件中添加如下依賴：

implementation 'com.android.support:appcompat-v7:28.0.0'

以 support library 版本在 26.1.0 及以上爲前提，這裏咱們分兩種狀況來說。一種是咱們建立的Activity 繼承自 AppCompatActivity(以Activity 爲例，Fragment相似)，另外一種是建立的 Activity 繼承自普通的 Activity，而非 AppCompatActivity。

這裏要先說一點， Lifecycle 的實現機制是觀察者模式，意識到這點，再講它的使用過程及原理就比較容易理解了。

總體流程：

1. 構建一個 Lifecycle 對象（經過一個實現了 LifecycleOwner 接口的對象的 getLifecycle()方法返回），這個對象就是一個被觀察者，具備生命週期感知能力
2. 構建一個 LifecycleObserver 對象，它對指定的 Lifecycle 對象進行監聽
3. 經過將 Lifecycle 對象的 addObserver(...) 方法，將 Lifecycle 對象和 LifecycleObserver 對象進行綁定

2.一、 方式一：繼承自 AppCompatActivity

首先，咱們建立一個 MyObserver.java 類，讓它實現 LifecycleObserver 接口( LifecycleObserver 接口是一個空接口，主要是給註解處理器使用)，以下：

public class MyObserver implements LifecycleObserver {

    private static final String TAG = "MyObserver";

    // 使用註解  @OnLifecycleEvent 來代表該方法須要監聽指定的生命週期事件
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
//        ...
        Log.d(TAG, "connectListener:  --------   onResume" );
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
//        ...
        Log.d(TAG, "disconnectListener: -------   onPause");
    }
}

能夠看到，咱們經過在方法上使用@OnLifecycleEvent 註解使得該方法具備了生命週期感知能力。括號裏面的參數，代表須要監聽的是什麼生命週期事件。Lifecycle 主要就是經過 Event 和 State 這兩個枚舉類來跟蹤所關聯組件的生命週期狀態。具體的 Event 和 State 之間的轉換關係，能夠參照下圖：

接下來，讓咱們的 Activity 繼承自 AppCompatActivity，而後在 onCreate(...) 方法中經過getLifecycle().addObserver(new MyObserver())完成 Lifecycle 和LifecycleObserver 的綁定。

public class MainActivity extends AppCompatActivity {

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

        // 就只須要這一行代碼，簡潔吧
        getLifecycle().addObserver(new MyObserver());
    }
}

而後咱們就能夠運行下程序，跑起來以後按 Home 鍵或者按返回鍵進行操做。能看到，隨着生命週期的變化，MyObserver() 中定義的方法在控制檯中也被正確地打印了出來。

是否是以爲特別簡單。

但之因此絕不費力，是由於有人替你「負重前行」。在 support library 26.1.0 及之後的支持庫中，AppCompatActivity 的祖先類 SupportActivity已經默認實現了 LifecycleOwner 接口，經過其 getLifecycle() 方法能夠直接返回一個 Lifecycle 對象。以後咱們就能夠經過該對象的 addObserver(...) 方法將 Lifecycle 跟指定的 LifecycleObserver 進行綁定。

2.二、 方式二：繼承自普通的 Activity

首先，咱們仍然須要像上面的方式，來建立一個MyObserver 對象。

此次咱們建立一個繼承自普通的 Activity 的 Activity ，那天然沒法直接使用 getLifecycle() 方法來獲取 Lifecycle 。沒法直接使用，那咱們可否模仿 AppCompatActivity的實現，來本身建立 Lifecycle 對象呢？固然能夠。這時候，咱們就須要本身實現LifecycleOwner接口，並在具體的生命週期下經過 LifecycleRegistry 的 markState(...)方法來主動進行事件的分發。請看下面改造過的 MainActivity.java 代碼 ：

public class MainActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry;

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

        mLifecycleRegistry = new LifecycleRegistry(this);
        getLifecycle().addObserver(new MyObserver());
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    protected void onResume() {
        super.onResume();
        mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
    }

    @Override
    protected void onPause() {
        super.onPause();
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

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

而後運行代碼，發現結果和上面的徹底同樣。

能夠看到，MainActivity實現了LifecycleOwner接口（實現該接口的對象，便是 Lifecycle 的持有者），並在其 getLifecycle( ) 方法中返回了一個 LifecycleRegistry對象，而 LifecycleRegistry 是 Lifecycle 的實現類，能處理多個 Observer，咱們自定義 LifecycleOwner的時候就能夠直接使用它。其餘使用方式，則徹底相同。

爲了讓使用更加方便靈活，Lifecycle 還提供了查詢當前組件所處的生命週期狀態的方法：

lifecycle.getCurrentState().isAtLeast(STARTED)

總結

1. 實現了 LifecycleObserver 接口的類能夠和實現了 LifecycleOwner 接口的類無縫工做，由於 LifecycleOwner 能夠提供一個 Lifecycle 對象，而 LifecycleObserver 就正須要對這個 Lifecycle 對象進行監聽呢。
2. LifecycleOwner 是從特定的類（好比 Activity 或者 Fragment 等）中抽象出來的Lifecycle 的持有者。
3. LifecycleRegistry 是 Lifecycle 的實現類，用於註冊和反註冊那些須要監聽當前組件生命週期的 LifecycleObserver

注意

從 1.0.0-rc1 版本的 Lifecycle 包開始，當 Activity 的 onSaveInstanceState() 方法調用結束以後，Lifecycle 將馬上被標記爲 CREATED 和 ON_STOP ，而不是等 onStop() 方法調用結束。這點和 API level 26 或者更低版本上 Activity 的生命週期的調用順序並不匹配，須要稍加註意。有具體需求的能夠進一步查閱相關文檔。

更多最新消息，歡迎關注個人公衆號獲取：