Coroutine与LifecycleOwner绑定自动跟随生命周期销毁

原文链接

前言

前面讲了Coroutine的实现原理。对协程有个初步的认识。
我们都知道协程是运行在CoroutineScope之下,而CoroutineScope下的协程也是有父子关系的。那么父协程取消的时候会取消所有子协程。
由此我们可以想到:CoroutineScope如果与Activity生命周期绑定,activity销毁了后CoroutineScope下的所有子协程就会随着activity一起消亡。这不正好符合我们的需求吗?activity结束后自动释放资源。

行动

常规写法

要与activity生命周期绑定。我们首先想到的是activity实现CoroutineScope,在onDestroy的时候调用job的cancel()来释放资源。这样虽好,但是要写一大堆代码阿,使用起来每次都得这么搞下,代码侵入性太强。
不过还是先看看代码把:

class MainActivity2 : MainActivity(), CoroutineScope {
    val job = SupervisorJob()
    override val coroutineContext: CoroutineContext
        get() = {Dispatchers.Main + job}

    override fun onDestroy() {
        super.onDestroy()
        job.cancel()
    }
}

优化写法

我们再看下经过我封装后的写法:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) = installCoroutineScope(savedInstanceState){
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        launch {
            repeat(100){
                toast("ass")
            }
        }
    }
}

啥?加一句installCoroutineScope(savedInstanceState)代码就行了?协程也能直接在oncreate里launch了?对你没看错就是这么简单,无需关心activity结束后会取消协程。那么这行代码里做了什么呢?

1. LifecycleOwner

现在的AndroidAPI也是足够强大,提供了LifecycleOwner接口,activity都是它的子类,能够将生命周期拖过回调的方式抛出来,这样就给了我们解耦的可能,使得生命周期我们可以另外的处理。

2. Kotlin扩展函数

得益于Kotlin的扩展函数,我们能够另外的声明LifecycleOwner的扩展方法。我们可以扩展launch来让LifecycleOwner直接调用。

这二者一结合!installCoroutineScope(savedInstanceState)就诞生了。

实现源码

具体就不详细说了,没几行,有什么问题欢迎留言,思想就是扩展installCoroutineScope,LifecycleOwner注册生命周期的回调,在回调中处理取消。

/**
 * @Author : xialonghua
 * @Date : Create in 2019/2/12
 * @Description : a new file
 */

private class InternalCoroutineScope : LifecycleObserver, CoroutineScope{

    val job = SupervisorJob()
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(activity: LifecycleOwner) {
        scopeMap[activity.toString()]?.job?.cancel()
        scopeMap.remove(activity.toString())
        activity.lifecycle.removeObserver(this)
    }
}

private val scopeMap = HashMap()

/**
 * 只需要在oncreate上添加即可
* 绑定activity与协程Scope,尽量减少修改。
* 注意:不要在onDestroy里启动协程
* 使用方法:
* ``` * override fun onCreate(savedInstanceState: Bundle?) = installCoroutineScope(savedInstanceState){ * super.onCreate(savedInstanceState) * setContentView(R.layout.activity_main) * } * ``` */ fun LifecycleOwner.installCoroutineScope(savedInstanceState: Bundle?, onCreate: (savedInstanceState: Bundle?) -> Unit){ if (scopeMap[this.toString()] != null){ return } val scope = InternalCoroutineScope() scopeMap[this.toString()] = scope lifecycle.addObserver(scope) onCreate(savedInstanceState) } private fun LifecycleOwner.getCoroutineScope(): CoroutineScope{ return scopeMap[this.toString()]!! } fun LifecycleOwner.launch( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit ): Job{ return getCoroutineScope().launch(context, start, block) } fun LifecycleOwner.launchOnIO( context: CoroutineContext = EmptyCoroutineContext + Dispatchers.IO, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit ): Job{ return launch(context, start, block) } fun LifecycleOwner.async( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T ): Deferred{ return getCoroutineScope().async(context, start, block) } fun LifecycleOwner.asyncOnIO( context: CoroutineContext = EmptyCoroutineContext + Dispatchers.IO, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T ): Deferred{ return async(context, start, block) }

你可能感兴趣的:(Coroutine与LifecycleOwner绑定自动跟随生命周期销毁)