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 的協程已是正式版本，能夠考慮引入生產環境。

最後附上該庫的 github 地址：github.com/fengzhizi71…

---

Java與Android技術棧：每週更新推送原創技術文章，歡迎掃描下方的公衆號二維碼並關注，期待與您的共同成長和進步。