网络请求随生命周期自动终止-Lifecycle实践

Lifecycle的目的是用来监听Activity和Fragmet的生命周期的变化，在生命周期的拥有者和生命周期的观察者之间建立一种联系，当生命周期拥有者生命周期改变的时候，观察者会收到对应的通知，所以可以可方便的判断生命周期的状态。当然也可以不适用Lifecycle，而是直接在activity或Fragment的的生命周期的回调里面处理各种事情，使用Lifecycle的目的就是解耦。

Lifecycle中需要使用的类：
LifecycleObserver：Lifecycle观察者
LifecycleOwner： 被观察者，就是生命周期的拥有者Activity或Fragment

LifecycleOwner 默认的activity和Fragment已经实现，所以我们只需要实现LifecycleObserver，并让其建立联系即可。

比如：

class LifecycleSourceEvent : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun doResume(){

        Log.i("LifecycleSourceEvent", "doResume: ")
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun doPause(){
        Log.i("LifecycleSourceEvent", "doResume: ")
    }
}

在base activity中让它和activity建立关系即可：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_rxjava)
    lifecycle.addObserver(LifecycleSourceEvent())
}

activity的生命周期就可以被观察了，并产生响应的回调
可以回调的事件都已经包含了，只要添加相应的注解即可：

public enum Event {
    /**
     * Constant for onCreate event of the {@link LifecycleOwner}.
     */
    ON_CREATE,
    /**
     * Constant for onStart event of the {@link LifecycleOwner}.
     */
    ON_START,
    /**
     * Constant for onResume event of the {@link LifecycleOwner}.
     */
    ON_RESUME,
    /**
     * Constant for onPause event of the {@link LifecycleOwner}.
     */
    ON_PAUSE,
    /**
     * Constant for onStop event of the {@link LifecycleOwner}.
     */
    ON_STOP,
    /**
     * Constant for onDestroy event of the {@link LifecycleOwner}.
     */
    ON_DESTROY,
    /**
     * An {@link Event Event} constant that can be used to match all events.
     */
    ON_ANY
}

在我们平常做项目中，我们可能会遇到这种需求，请求网络数据，如果请求失败，可能会多试几下，但是当你直接按home键直接退出，或者黑屏了，理论上就不应该在重试了，这个时候有么有什么优雅的方式，停止网络请求呢，这个生命周期的回调加上rxjava或许可以做的很优雅。

Rxjava中的有一个PublishSubject
PublishSubject的Observer只会接收到PublishSubject被订阅之后发送的数据。

所以思路是每当生命周期进行回调的时候，就可以用PublishSubject发送数据，订阅PublishSubject的观察者就可以拿到生命周期的回调，然后利用Rxjava的操作符takeUtil进行终止网络请求的重试即可：
代码如下：

class LifecycleSourceEvent : LifecycleObserver {

    val lifeSourceEventObject = PublishSubject.create<Lifecycle.Event>()

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun doResume(){
        lifeSourceEventObject.onNext(Lifecycle.Event.ON_RESUME)
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun doPause(){
        lifeSourceEventObject.onNext(Lifecycle.Event.ON_PAUSE)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun doStop(){
        lifeSourceEventObject.onNext(Lifecycle.Event.ON_STOP)
    }

    fun getLifecycleObservable(): Observable<Lifecycle.Event> {
        return lifeSourceEventObject.hide()
    }
}

关于模拟网络请求的代码如下：模拟发送异常，隔一秒重新发松请求

fun  testTakeUtil(lifecycleObservable: Observable<Lifecycle.Event>, vararg events: Lifecycle.Event){

    var count: Int = 0
    Observable.create(ObservableOnSubscribe<String> { emitter ->
        count ++
        Log.i(TAG, "onCreate:  创造数字$count")
        emitter?.onNext("$count")
    }).flatMap {
        Log.i(TAG, "flatMap: $it")
        if(it.toInt() < 100){
            Observable.error(Exception())
        }else{
            Observable.just(it)
        }
    }.retryWhen {
        Log.i(TAG, "retryWhen: $it")
        it.flatMap {
                throwable ->
            if(throwable is Exception){
                Observable.timer(2, TimeUnit.SECONDS)
            }else{
                Observable.error(throwable)
            }
        }
    }.takeUntil(lifecycleObservable.filter {
        for (event in events){
            if(it == event){
                Log.i(TAG, "takeUntil:请求终止")
                return@filter true
                }
            }
        return@filter false
        })
        .subscribe({
            Log.i(TAG, "subscribe: $it")
        },
            {
                Log.i(TAG, "subscribe: $it")
            })
}

activity中调用如下：

class RxjavaActivity : AppCompatActivity() {
    private var lifecycleSource = LifecycleSourceEvent()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_rxjava)
        lifecycle.addObserver(lifecycleSource)
    }

    val test = RxjavaTest()
    fun onClickTakeUtil(view: View){
        test.testTakeUtil(lifecycleSource.getLifecycleObservable(), Lifecycle.Event.ON_PAUSE)
    }
}

黑屏之后，打印结果如下：

2021-07-01 11:40:01.780 4336-4551/com.example.helloworld I/RxjavaTest: onCreate:  创造数字3
2021-07-01 11:40:01.780 4336-4551/com.example.helloworld I/RxjavaTest: flatMap: 3
2021-07-01 11:40:03.782 4336-4618/com.example.helloworld I/RxjavaTest: onCreate:  创造数字4
2021-07-01 11:40:03.782 4336-4618/com.example.helloworld I/RxjavaTest: flatMap: 4
2021-07-01 11:40:04.008 4
336-4336/com.example.helloworld I/RxjavaTest: takeUntil:请求终止

RetryWhen用于首先是重试机制，takeUtil操作符当满足条件的时候，事件就不会被发送了，事件终止。