AAC 的 Lifecycle 结合 Kotlin Coroutines 进行使用

2022-05-11 192

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： AAC 的 Lifecycle 结合 Kotlin Coroutines 进行使用

一. Lifecycle

目前，AAC(Android Architecture Components简称) 已经是 Android Jetpack 的一部分。Lifecycle 是 AAC 其中的一个组件，Lifecycle 能够管理 Activity 和 Fragment 的生命周期。

Lifecycle 可以构建感知生命周期的组件 —— 这些组件根据 Activity、Fragment 的当前生命周期状态自动调整其行为。并且，LiveData 与 ViewModel 的 lifecycle 也依赖于 Lifecycle。

二. 创建 LifecycleObserver 的实现类

首先，创建一个 LifecycleObserver 接口的实现类 LifecycleCoroutineListener，在 Activity/Fragment 某个生命周期事件上（默认为Lifecycle.Event.ON_DESTROY），协程会调用取消的方法。

open class LifecycleCoroutineListener(private val job: Job,
                                 private val cancelEvent: Lifecycle.Event = Lifecycle.Event.ON_DESTROY) : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() = handleEvent(Lifecycle.Event.ON_PAUSE)
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop() = handleEvent(Lifecycle.Event.ON_STOP)
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy() = handleEvent(Lifecycle.Event.ON_DESTROY)
    private fun handleEvent(e: Lifecycle.Event) {
        if (e == cancelEvent && !job.isCancelled) {
            job.cancel()
        }
    }
}

三. 列举使用场景

3.1 使用协程并绑定生命周期

创建 GlobalScope 的扩展函数 asyncWithLifecycle，它使用async创建一个 deferred 对象，并使用 lifecycleOwner 的 lifecycle 去绑定 LifecycleCoroutineListener。

fun <T> GlobalScope.asyncWithLifecycle(lifecycleOwner: LifecycleOwner,
                                       context: CoroutineContext = EmptyCoroutineContext,
                                       start: CoroutineStart = CoroutineStart.DEFAULT,
                                       block: suspend CoroutineScope.() -> T): Deferred<T> {
    val deferred = GlobalScope.async(context, start) {
        block()
    }
    lifecycleOwner.lifecycle.addObserver(LifecycleCoroutineListener(deferred))
    return deferred
}

可以采用如下的方式进行使用，如果需要显示toast的话，必须使用 Dispatchers.Main 这样才能在主线程显示 toast：

GlobalScope.asyncWithLifecycle(this,Dispatchers.Main) {
            delay(1000)
            Toast.makeText(mContext,"hi, this must use 'Dispatchers.Main'",Toast.LENGTH_SHORT).show()
        }

使用 Dispatchers.Main 时，需要在 build.gradle 中添加

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1'

3.2 协程的block绑定生命周期

创建 GlobalScope 的扩展函数 bindWithLifecycle，它的协程 block 在调用时绑定生命周期。

fun <T> GlobalScope.bindWithLifecycle(lifecycleOwner: LifecycleOwner,
                                      block: CoroutineScope.() -> Deferred<T>): Deferred<T> {
    val deferred = block.invoke(this)
    lifecycleOwner.lifecycle.addObserver(LifecycleCoroutineListener(deferred))
    return deferred
}

可以采用如下的方式进行使用：

GlobalScope.bindWithLifecycle(this) {
            GlobalScope.async(Dispatchers.Main) {
                val deferred1 = async(Dispatchers.Default) {
                    delay(1000)
                    1
                }
                val deferred2 = async(Dispatchers.Default) {
                    delay(1500)
                    2
                }
                val result = deferred1.await() + deferred2.await()
                Toast.makeText(mContext,"the result is $result",Toast.LENGTH_SHORT).show()
            }
        }

3.3 then

创建 Deferred 的扩展函数 then，它会创建一个协程并运行在 UI 线程上：

infix fun <T> Deferred<T>.then(block: (T) -> Unit): Job {
    return GlobalScope.launch(context = Dispatchers.Main) {
        block(this@then.await())
    }
}

由于它使用了infix，并结合 asyncWithLifecycle 一起使用：

GlobalScope.asyncWithLifecycle(this,Dispatchers.IO) {
            delay(5000) // 模拟耗时的网络请求
            1
        } then {
            Toast.makeText(mContext,"the result is $it",Toast.LENGTH_SHORT).show()
        }

asyncWithLifecycle 使用了Dispatchers.IO来模拟一些耗时的网络请求。在实际开发中也可以这样使用，网络请求的结果使用then进行展示。

3.4 thenAsync

thenAsync 类似于 then，区别在于返回的对象不同。

infix fun <T, R> Deferred<T>.thenAsync(block: (T) -> R): Deferred<R> {
    return GlobalScope.async(context = Dispatchers.Main) {
        block(this@thenAsync.await())
    }
}

thenAsync 返回的是 Deferred 对象，因此可以使用如下的链式调用：

GlobalScope.asyncWithLifecycle(this, Dispatchers.IO) {
            delay(5000) // 模拟耗时的网络请求
            1
        } thenAsync {
            it + 2
        } then {
            Toast.makeText(mContext,"the result is $it", Toast.LENGTH_SHORT).show()
        }

3.5 awaitOrNull

创建 Deferred 的扩展函数 awaitOrNull，它参考了 Java 的 Future 的超时方法。如果遇到超时或者异常，则返回null。

suspend fun <T> Deferred<T>.awaitOrNull(timeout: Long = 0L): T? {
    return try {
        if (timeout > 0) {
            withTimeout(timeout) {
                this@awaitOrNull.await()
            }
        } else {
            this.await()
        }
    } catch (e: Exception) {
        Log.e("Deferred", e.message)
        null
    }
}

下面的例子中，deferred 会在 5秒才有返回值，但是deferred 使用了awaitOrNull()，它的超时时间是4秒，因此 result 的值为 null。

val deferred = GlobalScope.asyncWithLifecycle(this, Dispatchers.IO) {
            delay(5000) // 模拟耗时的网络请求
            1
        }
        GlobalScope.asyncWithLifecycle(this,Dispatchers.Main) {
            val result = deferred.awaitOrNull(4000)
            Toast.makeText(mContext,"the result is $result", Toast.LENGTH_SHORT).show()
        }

如果把超时时间设置大于5秒的话，result 会返回正确的值。

3.6 任意 job 绑定到生命周期

还记得最初的 LifecycleCoroutineListener 嘛？它使用了open，因此任意创建的协程都可以使用它来绑定生命周期。

四. 总结

本文讲解了协程在 Android 的一些使用场景。

然而，本文只是抛砖引玉，目前 Kotlin 的协程已经是正式版本，可以考虑引入生产环境。

AAC 的 Lifecycle 结合 Kotlin Coroutines 进行使用

一. Lifecycle

二. 创建 LifecycleObserver 的实现类

三. 列举使用场景

3.1 使用协程并绑定生命周期

3.2 协程的block绑定生命周期

3.3 then

3.4 thenAsync

3.5 awaitOrNull

3.6 任意 job 绑定到生命周期

四. 总结

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

AAC 的 Lifecycle 结合 Kotlin Coroutines 进行使用

一. Lifecycle

二. 创建 LifecycleObserver 的实现类

三. 列举使用场景

3.1 使用协程并绑定生命周期

3.2 协程的block绑定生命周期

3.3 then

3.4 thenAsync

3.5 awaitOrNull

3.6 任意 job 绑定到生命周期

四. 总结

热门文章

最新文章

相关电子书