Android lifecycle 使用詳解

版權聲明：本文為博主原創文章，遵循 CC 4.0
by-sa 版權協議，轉載請附上原文出處鏈接和本聲明。

本文鏈接：https://blog.csdn.net/gdutxiaoxu/article/details/86660746

說在前面

本次推出 Android Architecture Components 系列文章，目前寫好了四篇，主要是關於 lifecycle，livedata
的使用和源碼分析，其余的 Navigation， Paging library，Room，WorkMannager
等春節結束之后會更新，歡迎關注我的公眾號，有更新的話會第一時間會在公眾號上面通知。

Android lifecycle
使用詳解

Android LiveData
使用詳解

Android lifecyle
源碼解剖

Android livedata
源碼解剖

github sample 地址：
ArchiteComponentsSample

Android 技術人，一位不羈的碼農。

---

簡介

Architecture Components

lifecycle 是 2107 年 google 大會推出來的，它屬於 architecture compoment 里面的一個組件，它可以干什么用呢？
簡單得來說，它可以用來檢查 Activity 的生命周期，而不必強依賴 Activity。

---

為什么要引進 lifecycle

舉一下我們最常用的 MVP 例子，沒引進 lifecycle 之前，我們需要在 Activity 或者 Fragment 銷毀的時候，即 onDestroy
的時候手動調用 onDestroy 方法，這里會帶來一些問題，每一次在 Activity 或者 Fragment 銷毀的燒開后都要調用
presenter.destory() 方法，這樣的代碼枯燥，毫無意義。

class MyPresenter{
    public MyPresenter() {
    }

    void create() {
        //do something
    }

    void destroy() {
        //do something
    }
}

class MyActivity extends AppCompatActivity {
    private MyPresenter presenter;

    public void onCreate(...) {
        presenter= new MyPresenter ();
        presenter.create();
    }

    public void onDestroy() {
        super.onDestroy();
        presenter.destory();
    }
}

當然我們也可以定義一些 IBasePresenter 的接口，在 BaseActivity 的時候調用 IBasePresenter 的 onDestroy
方法，這樣也確實能做到。只不過稍微繁瑣一點。

那如果是別的類的呢，比如 MediaCompoment，在 Activity 的時候，我們需要銷毀一些資源，按照傳統的方法，我們還是需要在 Activity
onDestroy 的時候手動調用 onDestroy 方法。那有沒有更好的方法呢?當然是有的，lifecycle
就可以解決這個問題。接下來，我們先來看一下 Lifycycle 的基本使用。

---

Lifycycle 的基本使用

1. 引入相關的依賴包

Lifecycle 已經是穩定版，它包含在 support library 26.1.0
及之后的依賴包中，如果我們的項目基於這些依賴包，那么不需要額外的引用。

// ViewModel and LiveData
implementation "android.arch.lifecycle:extensions:1.1.0"
// alternatively, just ViewModel
implementation "android.arch.lifecycle:viewmodel:1.1.0"
// alternatively, just LiveData
implementation "android.arch.lifecycle:livedata:1.1.0"

support library在26.1.0 之前，lifecycle 並沒有集成進去，需要我們引入另外的包。

implementation "android.arch.lifecycle:extensions:1.0.0-alpha4"

2. 使用

這里同樣分為幾種情況

1. support library 26.1.0 之后，且繼承 FragmentActivity，那么我們直接調用 getLifecycle().addObserver 方法即可，當 Activity 的生命周期變化的時候，將會回調 onStateChanged 的方法，狀態分別是一一對應的

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

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

            @Override
            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
                Log.d(TAG, "onStateChanged: event =" + event);
            }
        });
    }
	
}

2. support library 26.1.0 之后，不是繼承 FragmentActivity，只是簡單地繼承 Actiivty

public class SimpleLifecycleActivity extends Activity implements LifecycleOwner {

    private static final String TAG = "SimpleLifecycleActivity";
    private LifecycleRegistry mLifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple_lifecycle);
        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        getLifecycle().addObserver(new GenericLifecycleObserver() {

            @Override
            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
                Log.d(TAG, "onStateChanged: event =" + event);
            }
        });
    }

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

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

}

3. support library 26.1.0 之前

（現在的 support library 基本都在 26.1.0 之后了，這個可以忽略）

第一步：實現 LifecycleOwner 接口，並返回響應的 Lifecycle

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

第二步：在 Activity 生命周期變化的時候，調用 mLifecycleRegistry.handleLifecycleEvent
方法，分發相應的生命周期。

第三步：調用 Lifecycle 的 addObserver 方法添加相應的 Observer。

代碼如下

public class MainActivity extends AppCompatActivity implements LifecycleOwner {

    private LifecycleRegistry mRegistry;

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mRegistry = new LifecycleRegistry(this);
        mRegistry.markState(Lifecycle.State.CREATED);
        getLifecycle().addObserver(new GenericLifecycleObserver() {
            @Override
            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
                Log.d(TAG, "onStateChanged:event =" + event);
            }

            @Override
            public Object getReceiver() {
                return null;
            }
        });

    }

    @Override
    protected void onStart() {
        super.onStart();
        mRegistry.markState(Lifecycle.State.STARTED);
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    @Override
    protected void onResume() {
        super.onResume();
        mRegistry.markState(Lifecycle.State.RESUMED);
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }

    @Override
    protected void onPause() {
        super.onPause();
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mRegistry.markState(Lifecycle.State.DESTROYED);
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
    }

    @Override
    public Lifecycle getLifecycle() {
        return mRegistry;
    }
}

---

總結

我們回過頭來看一下我們上面提出的問題？

MediaCompoment 在 Activity ondestroy 的時候，我們需要銷毀一些資源，用傳統的方法，我們需要在 Activity
onDestroy 的時候手動調用 onDestroy 方法。這樣會存在一個問題，調用者必須知道比較清楚得知道 MediaCompoment
的設計，否則可能會忘記調用 onDestroy 的方法。

那有沒有一種方法， 當 Activity 生命周期變化的時候，MediaCompoment 自身能夠檢測到 Activity 的
生命周期變化，從而做相應的處理。

答案當然是有的，使用 lifycycle。

public class MediaCompoment {
    private static final String TAG = "MediaCompoment";

    private final LifecycleOwner mLifecycleOwner;

    public MediaCompoment(LifecycleOwner lifecycleOwner) {
        mLifecycleOwner = lifecycleOwner;
        mLifecycleOwner.getLifecycle().addObserver(new GenericLifecycleObserver() {
            @Override
            public void onStateChanged(LifecycleOwner source, final Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_CREATE) {
                    onCreate();
                } else if (event == Lifecycle.Event.ON_START) {
                    onStart();
                } else if (event == Lifecycle.Event.ON_RESUME) {
                    onResume();
                } else if (event == Lifecycle.Event.ON_PAUSE) {
                    onPause();
                } else if (event == Lifecycle.Event.ON_STOP) {
                    onStop();
                } else if (event == Lifecycle.Event.ON_DESTROY) {
                    onDestroy();
                }
            }
        });
    }

    public void onCreate() {
        Log.d(TAG, "onCreate:");
    }

    public void onStart() {
        Log.d(TAG, "onStart:");
    }

    public void onResume() {
        Log.d(TAG, "onResume:");
    }

    public void onPause() {
        Log.d(TAG, "onPause:");
    }

    public void onStop() {
        Log.d(TAG, "onStop:");
    }

    public void onDestroy() {
        Log.d(TAG, "onDestroy:");
    }
}

小結：

1. lifycycle 其實是用觀察者模式實現的，當 Activity 生命周期變化的時候，通知相應的 Observers 即觀察者。
2. 使用 lifecycle，我們可以將釋放資源的動作內聚在自身，減少與調用者之間的耦合。

下一篇博客：Android LiveData
使用詳解

---