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([email protected]())
}
}
複製程式碼
由於它使用了 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([email protected]())
}
}
複製程式碼
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) {
[email protected]()
}
} 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 ，因此任意建立的協程都可以使用它來繫結生命週期。