Android Lifecycle結合RxJava&Retrofit實現安全的網絡回調

Lifecycle簡介

官方簡介如此：

Lifecycle-aware components perform actions in response to a change in the lifecycle status of another component, such as activities and fragments. These components help you produce better-organized, and often lighter-weight code, that is easier to maintain.

生命週期感知組件可以響應另一個組件生命週期的變化（例如Activity和Fragment的生命週期狀態更改）。 這些(實現了Lifecycle的)組件可幫助你構建組織性更好、更輕、更易於維護的代碼。

聽起來很強大吧，先來來看看使用效果吧。

Lifecycle網絡回調示例

常規RxJava&Retrofit網絡回調：

    @Deprecated
    private void getData(){
        new MyApi().getGankMeizhi(20)
                .subscribe(new OldObserver<GankMeizhi>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        //需記錄然後手動釋放該Disposable。
                    }

                    @Override
                    public void onNext(GankMeizhi gankMeizhi) {
                        //需判斷是否可以安全地執行UI刷新。
                        if (isFinishing()){
                            return;
                        }
                        if (!gankMeizhi.error) {
                            mMyAdapter.refreshData(gankMeizhi);
                        }
                    }
                });
    }

實現了Lifecycle的RxJava&Retrofit網絡安全回調：

    private void getDataSafe() {
        new MyApi().getGankMeizhi(20)
                .subscribe(new SafeObserver<GankMeizhi>(getLifecycle()) {
                    @Override
                    public void onNext(GankMeizhi gankMeizhi) {
                        //可以安全地執行UI操作。
                        if (!gankMeizhi.error) {
                            mMyAdapter.refreshData(gankMeizhi);
                        }
                    }
                });
    }

可以發現，結合Lifecycle，回調不僅簡潔，而且更爲安全。Lifecycle可以讓開發者更專注地實現功能而非小心翼翼地做生命週期判斷。

如何實現

首先，我們Lifecycle庫引入到項目。在app模塊build.gradle文件dependencies內添加以下代碼即可：

    // Java8 support for Lifecycles
    implementation 'android.arch.lifecycle:common-java8:1.1.1'

接着，我們爲自定義的RxObserver實現LifecycleObserver接口：

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.util.Log;

import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

/**
 * 一個生命週期安全的RxObserver。
 * Created on 2018/4/18.
 *
 * @author ice
 */
public abstract class SafeObserver<T> implements LifecycleObserver, Observer<T> {

    public static final String TAG = "SafeObserver";

    private Lifecycle mLifecycle;
    private Disposable mDisposable;


    /*不傳入Lifecycle，手動管理該Observer的生命週期*/
    public SafeObserver() {
        //unSafe
    }

    /*傳入Lifecycle，自動保證回調安全*/
    public SafeObserver(Lifecycle lifecycle) {
        //lifecycle safe.
        mLifecycle = lifecycle;
    }

    @Override
    public void onSubscribe(Disposable d) {
        mDisposable = d;
        if (mLifecycle != null)
            mLifecycle.addObserver(this); //加入到lifecycle觀察者。
    }

    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
        onEnd();
    }

    @Override
    public void onComplete() {
        onEnd();
    }

    protected void onEnd() {
        Log.i(TAG, "onEnd");
        onDisPose(); //RxObserver結束後自動釋放。
    }

    /*釋放Rx觀察者（在Lifecycle的ON_DESTROY事件發生時會自動調用該方法）*/
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDisPose() {
        Log.i(TAG, "dispose");
        if (mLifecycle != null)
            mLifecycle.removeObserver(this);//解除與lifecycle的綁定。
        if (mDisposable != null && !mDisposable.isDisposed())
            mDisposable.dispose();
    }
}

然後，我們需要爲Activity(或Fragment)實現LifecycleOwner接口(AppCompatActivity與v4Fragment已實現)。
我們需要在Activity(或Fragment)生命週期中處理Lifecycle事件（在Base類裏做一次即可，2018年8月補充：高版本的buildTools已經不需要手動處理）：

    //AppCompatActivity與v4Fragment自帶LifecycleRegistry，所以通過強轉獲取即可。
    protected LifecycleRegistry mLifecycleRegistry = (LifecycleRegistry) getLifecycle();

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //...
        handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

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

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

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

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

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

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        mLifecycleRegistry.handleLifecycleEvent(event);
    }

好了，大功告成！這樣一來，訂閱該lifecycle的觀察者(比如前面的SafeObserver)就能接收到該lifecycle對應Activity(或Fragment)生命週期的回調了。

相關資料

本文Demo: LifecyclePractice

使用了Lifecycle的一個輕圖文App: Now

Lifecycle官方文檔: Handling Lifecycles with Lifecycle-Aware Components