kotlin如何使用协程作用域调用web服务并处理错误

Question

I develop an android app with kotlin.I use swagger to get all my Web Services. I want to call the web service and handle the error with try/catch if exist. After a while of research, about How to consume this WS, I found that I should use coroutine with Dispatchers, I use GlobalScope as the following :

         GlobalScope.launch(Dispatchers.Default) {
  val productsType = mobileApi.apiMobileProductTypeGetAllPost(params, 0, 50, "", "")
withContext(Dispatchers.Main) {
    viewProductType.loadAllTypeProduct(productsType)}

Here's the code of loadAllTypeProduct :

override fun loadAllTypeProduct(data: Array<ProductTypeData>) {
        recyclerViewProductTypeList.apply {
            recyclerViewProductTypeList.layoutManager = LinearLayoutManager(context, RecyclerView.HORIZONTAL, false)
            recyclerViewProductTypeList.adapter = ProductTypeItemAdapter(data, this@HomeFragment, context)
        }
    }

But,I found that I should use Coroutine Scope instead of Global Scope and the Global Scope is highly disouraged. So, I change my code from code above to the following one :

   val scope = CoroutineScope(Dispatchers.Main)
        basicViewInterface.showProgressBar()
        val task = scope.launch {
            try {
               withContext(Dispatchers.IO) {
                   val productsType=  mobileApi.apiMobileProductTypeGetAllPost(params, 0, 50, "", "")
                   viewProductType.loadAllTypeProduct(productsType)
                }
                basicViewInterface.hideProgressBar()
            } catch (e: Throwable) {
                e.printStackTrace()
            }
        }
        if (task.isCancelled){
            basicViewInterface.displayError("error")
        }

I want to call my WS and handle the exception with try/catch and dispaly the error in a Toast,How can I do that.

Answer 1

The point of the coroutine scope is that it's available at the place where you detect that the user has navigated away from the current activity, so that you may cancel it at one central place and have all the child coroutines cancelled. Your change, which just creates a local, throwaway scope, is just as bad as using GlobalScope . If your code is within an Activity or a Fragment, then make that class implement CoroutineScope by MainScope , you can see a more detailed example in the documentation of CoroutineScope .

As for handling exceptions, the code should look pretty much as you posted it, just pay attention to switching contexts. The coroutine scope should specify Main as the dispatcher and you should switch to IO only for the blocking network call, like this:

basicViewInterface.showProgressBar()
scope.launch {
    try {
        val productsType = withContext(Dispatchers.IO) {
            mobileApi.apiMobileProductTypeGetAllPost(params, 0, 50, "", "")
        }
        viewProductType.loadAllTypeProduct(productsType)
        basicViewInterface.hideProgressBar()
    } catch (e: Throwable) {
        basicViewInterface.displayError("error")
    }
}

It would be even better and cleaner if you pushed that withContext into the body of apiMobileProductTypeGetAllPost because it's a concern localized to it. From the outside it should be just another suspendable function you can call without worrying about such low-level details as whether the given implementation is blocking on non-blocking.

I noticed others mentioning the coroutine exception handler, but I don't recommend using it. It works only at the top level of the coroutine hierarchy and its purpose is to only catch those exceptions that were not appropriately handled within the business code, due to a programming error. It is the equivalent of Thread.uncaughtExceptionHandler in Java.

Answer 2

If you want to handle exceptions on your own then you'll need to use CoroutineExceptionHandler .

Documentation states that:

An optional element in the coroutine context to handle uncaught exceptions.

Normally, uncaught exceptions can only result from coroutines created using the launch builder. A coroutine that was created using async always catches all its exceptions and represents them in the resulting Deferred object.

How? Create object of this exception handler and then pass it to your coroutine as context like below:

// Create object of exception handler
val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
    // Here you can handle your exception
}

val scope = CoroutineScope(Dispatchers.Main)
basicViewInterface.showProgressBar()
// pass exception handler as context to launch method
val task = scope.launch(exceptionHandler) {
        withContext(Dispatchers.IO) {
            val productsType=  mobileApi.apiMobileProductTypeGetAllPost(params, 0, 50, "", "")
            viewProductType.loadAllTypeProduct(productsType)
        }
        basicViewInterface.hideProgressBar()
    }