Android中用Kotlin Coroutine(协程)和Retrofit进行网络请求和取消请求

CoroutineScope(Dispatchers.Main + Job())

interface MvpView

interface MvpPresenter<V: MvpView> {

    @UiThread
    fun attachView(view: V)

    @UiThread
    fun detachView()
}

open class BasePresenter<V: MvpView> : MvpPresenter<V> {
    lateinit var view: V
    val presenterScope: CoroutineScope by lazy {
        CoroutineScope(Dispatchers.Main + Job())
    }

    override fun attachView(view: V) {
        this.view = view
    }

    override fun detachView() {
        presenterScope.cancel()
    }
}

interface ApiService {
    @GET("data/iOS/2/1")
    fun getIOSGank(): Call<GankResult>

    @GET("data/Android/2/1")
    fun getAndroidGank(): Call<GankResult>
}

class ApiSource {
    companion object {
        @JvmField
        val instance = Retrofit.Builder()
            .baseUrl("http://gank.io/api/")
            .addConverterFactory(GsonConverterFactory.create())
            .build().create(ApiService::class.java)
    }
}

ApiSource.instance.getAndroidGank().enqueue(object : Callback<T> {
    override fun onFailure(call: Call<T>, t: Throwable) {
        
    }

    override fun onResponse(call: Call<T>, response: Response<T>) {
        
    }
})

//扩展Retrofit.Call类，为其扩展一个await方法，并标识为挂起函数
suspend fun <T> Call<T>.await(): T {
    return suspendCoroutine {
        enqueue(object : Callback<T> {
            override fun onFailure(call: Call<T>, t: Throwable) {
                //请求失败，抛出异常，手动结束当前协程
                it.resumeWithException(t)
            }

            override fun onResponse(call: Call<T>, response: Response<T>) {
                if(response.isSuccessful) {
                   //请求成功，将请求结果拿到并手动恢复所在协程
                   it.resume(response.body()!!)
                } else{
                   //请求状态异常，抛出异常，手动结束当前协程
                   it.resumeWithException(Throwable(response.toString()))
                }
            }
        })
    }
}

//使用CoroutineScope.launch创建一个协程，此协程在主线程中执行
presenterScope.launch {
    val time = System.currentTimeMillis()
    view.showLoadingView()
    try {
        val ganks = queryGanks()
        view.showLoadingSuccessView(ganks)
    } catch (e: Throwable) {
        view.showLoadingErrorView()
    } finally {
        Log.d(TAG, "耗时：${System.currentTimeMillis() - time}")
    }
}

suspend fun queryGanks(): List<Gank> {
    //此方法执行线程和调用者保持一致，因此也是在主线程中执行
    return try {
        //先查询Android列表，同时当前协程执行流程挂起在此处
        val androidResult = ApiSource.instance.getAndroidGank().await()
        
        //Android列表查询完成之后恢复当前协程，接着查询IOS列表，同时将当前协程执行流程挂起在此处
        val iosResult = ApiSource.instance.getIOSGank().await()

        //Android列表和IOS列表都查询结束后，恢复协程，将两者结果合并，查询结束
        val result = mutableListOf<Gank>().apply {
            addAll(iosResult.results)
            addAll(androidResult.results)
        }
        result
    } catch (e: Throwable) {
        //处理协程中的异常，否则程序会崩掉
        e.printStackTrace()
        throw e
    }
}

suspend fun queryGanks(): List<Gank> {
    /**
     * 此方法执行线程和调用者保持一致，因此也在主线程中执行
     * 因为网络请求本身是异步请求，同时async必须在协程上下文中执行，所以此方法实现中采用withContext切换执行线程到主线程，获取协程上下文对象
     */
    return withContext(Dispatchers.Main) {
        try {
            //在当前协程中创建一个新的协程发起Android列表请求，但是不会挂起当前协程
            val androidDeferred = async {
                val androidResult = ApiSource.instance.getAndroidGank().await()
                androidResult
            }

            //发起Android列表请求后，立刻又在当前协程中创建了另外一个子协程发起ios列表请求，也不会挂起当前协程
            val iosDeferred = async {
                val iosResult = ApiSource.instance.getIOSGank().await()
                iosResult
            }

            val androidResult = androidDeferred.await().results
            val iosResult = iosDeferred.await().results

            //两个列表请求并行执行，等待两个请求结束之后，将请求结果进行合并
            //此时当前方法的执行时间实际上两个请求中耗时时间最长的那个，而不是两个请求所耗时间的总和，因此此写法优于上面一种写法
            val result = mutableListOf<Gank>().apply {
                addAll(iosResult)
                addAll(androidResult)
            }
            result
        } catch (e: Throwable) {
            e.printStackTrace()
            throw e
        }
    }
}

val instance = Retrofit.Builder()
        .baseUrl("http://gank.io/api/")
        .addCallAdapterFactory(CoroutineCallAdapterFactory())
        .addConverterFactory(GsonConverterFactory.create())
        .build().create(CallAdapterApiService::class.java)
        
suspend fun queryGanks(): List<Gank> {
    return withContext(Dispatchers.Main) {
        try {
            val androidDeferred = ApiSource.callAdapterInstance.getAndroidGank()

            val iosDeferred = ApiSource.callAdapterInstance.getIOSGank()

            val androidResult = androidDeferred.await().results

            val iosResult = iosDeferred.await().results

            val result = mutableListOf<Gank>().apply {
                addAll(iosResult)
                addAll(androidResult)
            }
            result
        } catch (e: Throwable) {
            e.printStackTrace()
            throw e
        }
    }
}