Kotlin 协程 (7/7篇) - 在Android中的使用

一、使用场景

1.1 LiveData 还是 StateFlow

1.2 Suspend 还是 Flow

1.3 哪种数据流 

二、相互转换

2.1 改造回调API

2.1.1 Callback → Suspend（suspendCancellableCoroutine） 

对于已有的调用了回调的函数可以改造成挂起函数，onSuccess()中调用resume()返回数据，onFailure()中调用resumeWithException()返回异常。suspendCoroutine适用于改造SAM回调。

//1.回调接口
interface NetCallback<T> {
    fun onSuccess(t: T)
    fun onError(excpption: Exception)
}
 
//2.在Model中封装回调API（联网获取数据）
fun getData(callback: NetCallback<String>) {
    Thread {
        Thread.sleep(1000) //模拟联网操作
        callback.onSuccess("数据")
        callback.onError(Exception("错误"))
    }.run()
}
 
//3.以前在ViewModel中封装功能
fun show() {
    getData(object : NetCallback {
        override fun onSuccess(t: String) {...}
        override fun onError(excpption: Exception) {...}
    })
}
 
//4.现在在ViewModel中封装功能
suspend fun showWithSuspend():String = suspendCancellableCoroutine { cancellableContinuation ->
    getData(object : NetCallback {
        override fun onSuccess(t: String) { cancellableContinuation.resume(t)}
        override fun onError(excpption: Exception) {cancellableContinuation.resumeWithException(excpption)}
    })
}

2.1.2 Callback → Flow（callbackFlow）

底层使用的sendChannel，默认容量64满了会挂起直到消费出空位，为了避免生产被挂起可以配置为CONFLATED或者UNLIMITED。

fun showWithFlow(): Flow<Int> = callbackFlow {
    //1.创建Flow并发送值（实现Callback接口）
    val callback = object: NetCallback {
        override fun onNextValue(value: Int) {
            try {
                offer(num)
            } catch(t: Throwable) {...}
        }
        override fun onError(ecxeption: Throwable) {
            cancel(CancellationException("API发生错误", exception))
        }
        override fun onCompleted() = close()
    }
    //2.注册回调（传参使用，并对API进行配置操作）
    getData(callback)
    //3.取消协程并注销回调（用来释放API资源）
    awaitClose {...}
}

2.2 数据转换到LiveData

2.2.1 Suspend → LiveData（liveData{ }）

class MyViewModel : ViewModel() {
    //直接调用挂起函数赋值
    val num1: LiveData<Int> = liveData { emit(getData()) }
    //还可以指定线程，单独写耗时操作
    val num2: LiveData<Int> = liveData(Dispatchers.IO) {
        emit(5)
        delay(1000)
        emit(3)
    }
    //从另一个LivaData获取更新结果
    val aa = MutableLiveData(10)
    val bb = liveData{ emitSource(aa) }
    suspend fun getData(): Int = withContext(Dispatchers.IO) { 3 }
}

2.2.2 Flow → LiveData（asLiveData）

class MyViewModel : ViewModel() {
    val num1: LiveData<Int> = liveData { DataSource().getDataFlow.collect { emit(it) } }
    val num2: LiveData<Int> = DataSource().getDataFlow.asLiveData()    //简写
}
 
class DataSource {
    val getDataFlow: Flow<Int> = flow { repeat(3) { emit(it) } }
}

2.3 流之间转换

2.3.1  Channel → Flow

fun main(): Unit = runBlocking {
    val channel = Channel<Int>()
    val receiveAsFlow = channel.receiveAsFlow()
    val consumeAsFlow = channel.consumeAsFlow()
    launch { receiveAsFlow.collect { print("$it,") } }
    repeat(3) { channel.send(it) }
    channel.close()
}

2.3.2 Flow → Channel

fun main(): Unit = runBlocking {
    val receiveChannel = (1..3).asFlow().produceIn(this)
    repeat(3) { print("$i,") }
}

2.3.3 Flow → SharedFlow

2.3.4 Flow → StateFlow

三、View生命周期

通常需要在UI层收集数据流以便显示更新，当UI进入后台不可见时，数据流也会持续发送不停止（除非手动取消协程）。如使用了基于Channel收集的：CoroutineScope.launch、Flow.launchIn、LifecycleCoroutineScope.launchWhenX，或使用了带缓存操作符的Flow：buffer、conflate、flowIn、shareIn。

3.1 Flow.flowWithLifecyle( )

当只有一个Flow需要收集时使用该操作符，内部基于Lifecyle.repeatOnLifecyle()实现。生命周期低于目标状态会取消上游，不影响下游，需要注意调用顺序。

3.2  Lifecyle.repeatOnLifecyle( )

1. 在生命周期到达目标状态时，挂起调用它的协程。
2. 会在离开目标状态时取消子协程，再次进入目标状态会重开子协程，即围绕目标状态的进出多次重新执行代码。
3. 进入Destroy状态才会恢复调用它的协程。

lifecycleScope.launch {
    //会挂起之前的代码
    lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
        //重复的工作
    }
    //当进入onDestroy()状态协程会恢复执行后面的代码
}

3.3 LifecycleScope.launchWhenX( )

会在进入X状态前等待、进入后执行、离开后挂起。如果内部订阅了数据流，挂起只是停止消费数据，没有取消协程，无法阻止被订阅的数据流继续活跃生产数据，由于会造成资源浪费已被废弃，使用上面的 3.2 替代。

3.4 配置生产者