摘要：括號里面的參數，表明需要監聽的是什么生命周期事件。主要就是通過和這兩個枚舉類來跟蹤所關聯組件的生命周期狀態。這點和或者更低版本上的生命周期的調用順序并不匹配，需要稍加注意。

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

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

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

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 被包含在 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 的實現機制是觀察者模式，意識到這點，再講它的使用過程及原理就比較容易理解了。

整體流程：

構建一個 Lifecycle 對象（通過一個實現了 LifecycleOwner 接口的對象的 getLifecycle()方法返回），這個對象就是一個被觀察者，具有生命周期感知能力

構建一個 LifecycleObserver 對象，它對指定的 Lifecycle 對象進行監聽

通過將 Lifecycle 對象的 addObserver(...) 方法，將 Lifecycle 對象和 LifecycleObserver 對象進行綁定

首先，我們創建一個 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 進行綁定。

首先，我們仍然需要像上面的方式，來創建一個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)

實現了 LifecycleObserver 接口的類可以和實現了 LifecycleOwner 接口的類無縫工作，因為 LifecycleOwner 可以提供一個 Lifecycle 對象，而 LifecycleObserver 就正需要對這個 Lifecycle 對象進行監聽呢。

LifecycleOwner 是從特定的類（比如 Activity 或者 Fragment 等）中抽象出來的Lifecycle 的持有者。

LifecycleRegistry 是 Lifecycle 的實現類，用于注冊和反注冊那些需要監聽當前組件生命周期的 LifecycleObserver

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

更多最新消息，歡迎關注我的公眾號獲取：