Android lifecycle 實戰及使用進階

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

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

前言

Android lifecycle
使用詳解

Android LiveData
使用詳解

Android lifecyle
源碼解剖

Android livedata
源碼解剖

Android lifecycle
實戰及使用進階

github sample 地址：
ArchiteComponentsSample

Android Architecture Components 的，前面我們已經講解了 lifecycle， LiveData
的使用及原理，今天，讓我們一起賴看看 lifecycle 在項目中的實戰。主要講解兩點

1. LifecycleHandler 的封裝
2. MVP 中引入 lifecycle，可以自行監聽 activity 生命周期變化

---

LifecycleHandle 的封裝

我們平時在使用 handler 的時候，在 activity onDestroy 的時候，需要手動取 removeMessage 或者
removeCallBack，不然的話，很容易發生內存泄漏。

@Override
protected void onDestroy() {
    super.onDestroy();
    mHandler.removeCallbacksAndMessages(null);
}

這對我們開發者來說，很明顯是一個重復的動作。我們一起通過 lifecycle 來減少這種重復性的動作，讓其內部自己釋放。

核心原理其實很簡單，內部監聽 activity 生命周期的變化，在 onDestroy 的時候移除 message 和 callback。

public class LifecycleHandler extends Handler implements FullLifecycleObserver {


    private LifecycleOwner mLifecycleOwner;

    public LifecycleHandler(LifecycleOwner lifecycleOwner) {
        mLifecycleOwner = lifecycleOwner;
        addObserver();
    }

    public LifecycleHandler(LifecycleOwner lifecycleOwner, Callback callback) {
        super(callback);
        mLifecycleOwner = lifecycleOwner;
        addObserver();
    }

    public LifecycleHandler(LifecycleOwner lifecycleOwner, Looper looper) {
        super(looper);
        mLifecycleOwner = lifecycleOwner;
        addObserver();
    }

    public LifecycleHandler(LifecycleOwner lifecycleOwner, Looper looper, Callback callback) {
        super(looper, callback);
        mLifecycleOwner = lifecycleOwner;
        addObserver();
    }

    private void addObserver() {
        if (mLifecycleOwner != null) {
            mLifecycleOwner.getLifecycle().addObserver(new FullLifecycleObserverAstrong textdapter(mLifecycleOwner, this));
        }
    }


    @Override
    public void onCreate(LifecycleOwner owner) {

    }

    @Override
    public void onStart(LifecycleOwner owner) {

    }

    @Override
    public void onResume(LifecycleOwner owner) {

    }

    @Override
    public void onPause(LifecycleOwner owner) {

    }

    @Override
    public void onStop(LifecycleOwner owner) {

    }

    @Override
    public void onDestroy(LifecycleOwner owner) {
        removeCallbacksAndMessages(null);
    }
}

我們來看一下這一行代碼

mLifecycleOwner.getLifecycle().addObserver(new FullLifecycleObserverAdapter(mLifecycleOwner, this));

FullLifecycleObserverAdapter 是什么呢？

FullLifecycleObserverAdapter

public class FullLifecycleObserverAdapter implements LifecycleObserver {

    private final FullLifecycleObserver mObserver;

    private static final String TAG = "FullLifecycleObserverAd";
    private final LifecycleOwner mLifecycleOwner;

    FullLifecycleObserverAdapter(LifecycleOwner lifecycleOwner, FullLifecycleObserver observer) {
        mLifecycleOwner = lifecycleOwner;
        mObserver = observer;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.i(TAG, "onCreate: ");
        mObserver.onCreate(mLifecycleOwner);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.i(TAG, "onStart: ");
        mObserver.onStart(mLifecycleOwner);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.i(TAG, "onResume: ");
        mObserver.onResume(mLifecycleOwner);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.i(TAG, "onPause: ");
        mObserver.onPause(mLifecycleOwner);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.i(TAG, "onStop: ");
        mObserver.onStop(mLifecycleOwner);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.i(TAG, "onDestroy: ");
        mObserver.onDestroy(mLifecycleOwner);
    }

}

FullLifecycleObserver

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

FullLifecycleObserver 是我們自己自定義的一個接口，繼承 LifecycleObserver，各個方法一一對應 activity
的生命周期。

FullLifecycleObserverAdapter 實現了 LifecycleObserver，使用了 @OnLifecycleEvent 注解，在
activity 生命周期變化的時候會回調相應的方法，我們再在里面回調 observer 的 onCreate， onStart
等方法，這有點類似代理模式。調用關系總結如下：

以后想觀察 lifecycle 生命周期變化的話，只需要 mLifecycleOwner.getLifecycle().addObserver(new FullLifecycleObserverAdapter(mLifecycleOwner, this)); 這一行代碼即可

有人可能會這樣問了，為什么要這樣設計呢

加 FullLifecycleObserver 這個接口，主要是為了跟 activity 的生命周期一一對應。

---

LifecyclePresenter 的封裝

public class LifecyclePresenter implements IPresenter, FullLifecycleObserver {

    private static final String TAG = "BasePresenter";

    private final LifecycleOwner mLifecycleOwner;

    public LifecyclePresenter(LifecycleOwner lifecycleOwner) {
        mLifecycleOwner = lifecycleOwner;
        mLifecycleOwner.getLifecycle().addObserver(new FullLifecycleObserverAdapter(lifecycleOwner, this));
    }

    @Override
    public void onCreate(LifecycleOwner owner) {
        Log.i(TAG, "onCreate: owner = " + owner);
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        Log.i(TAG, "onStart: owner = " + owner);
    }

    @Override
    public void onResume(LifecycleOwner owner) {
        Log.i(TAG, "onResume: owner = " + owner);
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        Log.i(TAG, "onPause: owner = " + owner);
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        Log.i(TAG, "onStop: owner = " + owner);
    }

    @Override
    public void onDestroy(LifecycleOwner owner) {
        Log.i(TAG, "onDestroy: owner = " + owner);
    }
}

---

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