In this post, we will learn exception handling in coroutines. Later on, we will know how to handle exceptions in a sequential program.

In coroutine, exception behavior depends on coroutines builder. So we already know that we have to two coroutines builders. We have launch and async. launch generates a job and async will generate a deferred that will give us a value. So based on that the behavior changes slightly.

Exception behaviour with launch

So for launch, As you know launch creates a job hierarchy. So exceptions will propagate instantly through the parent-child hierarchy and will immediately cause jobs to fail. So there is no delay and no way to catch it automatically. So what we need to do, we need to use try-catch inside the launch or we have a structure called an exception handler. So the summary of this is below

• Propagates through the parent-child hierarchy
• The exception will be thrown immediately and jobs will fail
• use try-catch or an exception handler

In sort, launch automatically generates the exception and causes all the jobs to fail in the exception hierarchy. In coroutines, you won’t see the exceptions straight away. you will see the exception when you try to actually use the job or coroutines in the main thread. So if you call join on the job you will automatically join into main thread and then you will see the exception.

Behaviour with async

The async is slightly different. So async means we don’t have a hierarchy we just have the outcome. So the exception is deferred, and it will not be shown until the result is consumed. So if we call wait then we will see the exception. If we never call wait we will never see the exception. So what we need to do in this case is use the try-catch when we are calling await call. In sort we can say

• Exceptions are deferred until the result is consumed
• If the result is not consumed, the exception is never thrown
• try-catch in the coroutine or in the await() call

So the difference is the launch propagated the exception through the job hierarchy immediately and kill the jobs. The async will only show the exception when you call await().

Exception handling in launch

Now we have a way to handle exceptions in launch. In coroutines we have a class named is CoroutineExceptionHandler

class MainActivity : AppCompatActivity() {
    companion object {
        private const val TAG = "MainActivity"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        runBlocking {
            val myHandler = CoroutineExceptionHandler {coroutineContext, throwable ->
                Log.e(TAG,"Exception handled: ${throwable.localizedMessage}")
            }

            val job = GlobalScope.launch(myHandler) {
                Log.e(TAG,"Throwing exception from job")
                throw IndexOutOfBoundsException("exception in coroutine")
            }
            job.join()

            val deferred = GlobalScope.async {
                Log.e(TAG,"Throwing exception from async")
                throw ArithmeticException("exception from async")
            }

            try {
                deferred.await()
            } catch (e: java.lang.ArithmeticException) {
                Log.e(TAG,"Caught ArithmeticException ${e.localizedMessage}")
            }
        }
    }
}

Output

 E/MainActivity: Throwing exception from job
 E/MainActivity: Exception handled: exception in coroutine
 E/MainActivity: Throwing exception from async
 E/MainActivity: Caught ArithmeticException exception from async

Conclusion

In this post, we learned how to handle exceptions in coroutines. I have used this exception handling concept in the retrofit example. I hope it’s helpful for you, Help me by sharing this post with all your friends who learning android app development.

• Android retrofit with coroutines Kotlin
• Handle all types of Retrofit2 errors properly with RxJava2
• Kotlin Coroutines Job Example
• Coroutine async and await example
• Coroutines basics | Coroutines for beginners

Estimated reading time: 3 minutes

In this coroutines withContext example and we’ll see how we can change context easily in Coroutines. We’ll learn different ways to switch coroutine contexts also. In android aspects will see how to can switch the context main thread to another threads. So let’s started.

Uses of withContext

A function that is very commonly used in coroutines is withContext. Basically, withContext is allowed us to easily change context. It means It easily switches between dispatchers.

Suppose in an android application we have some heavy processing that we need to do. So we will do that in the Default Dispatchers then when the outcome completed then we want to switch to the Main Dispatchers in order to publish to display outcome on the UI. So we need a way to easily switch between context and the best way to do that is the withContext function. Because it’s very very lightweight.

Example of withContext

So let take a example see the below code

package com.asyncawaitexamplecoroutine

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {
    companion object {
        private const val TAG = "MainActivity"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        runBlocking {
            launch(Dispatchers.Default) {
                Log.d(TAG,"First context: $coroutineContext")
                // default context
                withContext(Dispatchers.IO) {
                    Log.d(TAG,"Second context: $coroutineContext")
                    // IO context
                }
                Log.d(TAG,"Third context: $coroutineContext")
                // back to default context
            }
        }
    }
}

In this code, first I’m going to launch a coroutine in the default dispatcher. and I’m gonna log coroutineContext. So simply I logging out the context that we have. Then I’m gonna switch dispatchers to IO dispatcher. So using withContext(Dispatchers.IO) I’m gonna log the second context here. So once that is finished, so I’m gonna go back to my first context. So let log the coroutineContext again.

So I’m starting a coroutine in default context then I’m switching to IO and then I’m coming back to original. So let’s go head and run the code and see the output that we get from the LOGCAT.

Output

 D/MainActivity: First context: [StandaloneCoroutine{Active}@45522db, Dispatchers.Default]
 D/MainActivity: Second context: [DispatchedCoroutine{Active}@940c178, Dispatchers.IO]
 D/MainActivity: Third context: [StandaloneCoroutine{Active}@45522db, Dispatchers.Default]

Do we have our first context which is standalone coroutine whatever the name is system has given it. Then we are switching context. so we can that we have different Id(940c178) here.

That mainly I just want to show you the different ID that we get. Here is @45522db, @940c178, @45522db. So when we finish there we’re going back to same context that we have initially.

So basically it’s a very lightweight way to switch between context depending on type of functionality, type of processing that we need to do.

Conclusion

That all, in this blog we have learned coroutines withContext example in Kotlin android.  I hope it’s helpful for you. Keep reading 🙂

• Android retrofit with coroutines Kotlin
• Dispatchers in Kotlin Coroutines
• Coroutines basics | Coroutines for beginners
• Suspending functions in Coroutine
• Coroutine Scope in Kotlin | Coroutine Context

In this blog, I’ll show you uses of async and await function in coroutine. We’ll learn async and await coroutine functions with example. So let’s started.

Objective

The async is basically another way to start a Coroutine. Sometimes when you start a coroutine, you might need a value to be return from that coroutine back to the thread that launched it. So async just like launch, except it return a result.

Now the results, obviously since it’s returning in parallel, It can not return immediately. so think about an operation like network communication might have undetermined delay. But we still want to have that resolved that outcome at some point. So what async does, is return a result in the form of a deferred.

So deferred is basically promise that at the some point we will be able to get result but it’s not available right now. So it’s a future promise of a value.

async function

So this question is when we actually need the value, we have the await function. Important things is, this is a blocking call. It done on purpose obviously because at certain points we do need the value we can not proceed without it. So we have to wait for that value to be available.

So either the value is available straight away which is return immediately or If in value is not available it will pause the current thread until it is. So you can say If the value is available, it will return immediately or If the value is not available, it will pause the thread until it is, as simple as that. For achieving this functionality we have await function in coroutine.

How use await function

It a quite simple, so let say we have one suspended function that gives a random integer number. Now would have aync coroutine. So we have a GlobalScope.aysnc just like below. This will launch a coroutine that simply return call the suspended function.

suspend fun getRandom() = Random.nextInt(1000)

val valueDeferred = GlobalScope.async { getRandom() }
… // Do some processing here
val finalValue = valueDeferred.await( )

So it will give us a deferred. So this is the object of deferred then we do whatever processing we need in that program. Then we actually need the value we have to await() function. So this will pause the execution until the value is available for our main program. So we are simply waiting for a value to be available.

Example of async and await

Let’s take one example for better understanding. Let suppose you want to call a APIs right. For calling that API you might need some auth token. For example you might need API key and Access Token for calling API. It not a useful or a practical example but explain async concept, Its perfect.

So here I simply creating a runBlocking. and define 3 functions. these are below.

package com.asyncawaitexamplecoroutine

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.android.synthetic.main.activity_main.*
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlin.random.Random

class MainActivity : AppCompatActivity() {
    companion object {
        private const val TAG = "MainActivity"
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        runBlocking {
            val accessTokenDeferred = async { getAccessToken() }
            val apiKeyDeferred = async { getApiKey() }

            Log.i(TAG,"Doing some processing here")
            delay(500L)
            Log.i(TAG,"Waiting for values")

            val firstValue = accessTokenDeferred.await()
            val secondValue = apiKeyDeferred.await()

            textView.append("Access Token -> $firstValue \n")
            textView.append("API Key  -> $secondValue \n")
            textView.append(" User Details -> " + getUserDetails(firstValue,secondValue) )

        }
    }
    private suspend fun getAccessToken(): String {
        delay(1000L)
        val value = "ffe20d1e-bb7d-48c6-95a4-7d0f1fde26ab"
        Log.i(TAG,"Returning AccessToken $value")
        return value
    }

    private suspend fun getApiKey(): String {
        delay(2000L)
        val value = "ca6ee68b-73b8-41e1-8920-d20e349e36b6"
        Log.i(TAG,"Returning API key $value")
        return value
    }
    private suspend fun getUserDetails(accessToken:String, apiKey:String): String {
        delay(2000L)
        Log.i(TAG, " Access Token -> $accessToken API key ->$apiKey")
        val value = " Morris Kushwaha"
        Log.i(TAG,"Returning user details $value")
        return value
    }
}

It’s pretty straight forward, getAccessToken() and getApiKey() is aysnc in scope of run blocking. After that will call getUserDetails() function. In this function we simply logging access token and api and returning a value. So Important things is we are waiting a result from the first coroutine which will take 1 second.

Then second value is going to be deferred and it taking 2 second. After this simply calling userDetails function, that all. Let run this code and see this output

Output

I/MainActivity: Doing some processing here
I/MainActivity: Waiting for values
I/MainActivity: Returning AccessToken ffe20d1e-bb7d-48c6-95a4-7d0f1fde26ab
I/MainActivity: Returning API key ca6ee68b-73b8-41e1-8920-d20e349e36b6
I/MainActivity:  Access Token -> ffe20d1e-bb7d-48c6-95a4-7d0f1fde26ab API key ->ca6ee68b-73b8-41e1-8920-d20e349e36b6
I/MainActivity: Returning user details  Morris Kushwaha

So in logcat we get are Doing some processing here first after that Waiting for values. And getting AccessToken and after two second API key and finally Returning user details.

Conclusion

So basically async is a way for us to retrieve values from Coroutine. That all, so in this coroutine async and await example we’ll learned how we’ll make async call using Coroutine in android. I hope it’s helpful for you, Help me by sharing this post with all your friends who learning android app development.

FAQ

Coroutine related article

• Android retrofit with coroutines Kotlin
• Dispatchers in Kotlin Coroutines
• Coroutines basics | Coroutines for beginners
• Suspending functions in Coroutine
• Coroutine Scope in Kotlin | Coroutine Context

In this blog, let’s briefly discuss what Coroutines, This blog dedicated to beginners, they can learn the basic concept of coroutines, Once you understand these concepts of coroutines. You can become a master Coroutines.

Why we should use coroutines

Very first let understand why we should Coroutines an instance of thread. What is the very basic difference between thread and Coroutines? and why we want to use it instance on Thread. So let started

Thread are resource intensive

So the main problem with threads is it very resource-intensive. So it takes a lot of resources to start a thread, stop a thread, coordinate between threads, and so on. Meanwhile, Coroutines are lightweight threads Infect is very very lightweight threads.

Coroutines are lightweight threads

So we have a program where we start about millions of Coroutines and no problem in memory. If you try to start maybe a thousand threads your program will run out of memory will crash. But Coroutines are very very lightweight so you can start as many as you like with no overhead with no problem.

Ok so basically Coroutines to use pulls a thread pool is, let’s think about it as a bunch of thread that you can use whenever you like. So you have a small Coroutines which small unit of executions. Then you assign it to as thread. When the Coroutines is finishes the thread is put back in the thread pool ready to reuse by another Coroutines that need it.

Okay so they reuse threads they use lightweight functionality so you can start as many as you like with absolutely no impact on performance

Simplify async code, callback and synchronisation

Now these simplify greatly async code, So callback and synchronization are very very easy to use in Coroutines and actually they make parallel programming look very likes of sequential programming

So you can start a Coroutines code and immediately access variables and methods in your program without any overhead. And that is how easy it is to do callback from a Coroutines to your program and synchronization is also very useful, just you have 2 or 3 methods that you to synchronize between Coroutines without any overhead.

Wheres thread is very complicated and if you’ve ever worked with the thread you know what headache they can be especially when you start a lot of them need a synchronization between them.

Simple syntax

Coroutines have very very simple common syntax. So they have few concept that we will discuss in this blog, that fit together very nicely and Once you understand those concept they are very easy to use to start Coroutines and execute code in parallel. Now they can pause and resume at any time and a coroutines is not bound to a thread.

A thread simply place to execute the coroutines but the coroutines itself can be stoped at any time and restarted at any time.

So In that way they are very light weight and can be reused as many times as you like.

Coroutines basic concept

Now let go through a basic concept of Coroutines and here I’m going to list them and the upcoming article we’re going through them one by one and see the implementation with example. So let started

Scope

So the first idea is a scope. The scope is what creates and runs coroutines. It provides life cycle event so things like pausing a coroutine stopping, cancelling a coroutine, is handled by a scope.

Context

Now the context is a concept that is very tied to the scope. So the scope itself provides a context and The Context is simply the state of coroutine. Basically, It provides some variable some functionality that you can use in your coroutine. So that is a context the scope and context are very tightly tied together.

Suspending functions

Suspending function are basically functions that can be run in a coroutine or can be suspended as we call them. So basically they provide functionality that you use to run in parallel that you want o run in parallel.

Jobs

So next stuff we have jobs. Now a job is basically a handle on a coroutine and you can use a job to access the lifecycle methods of a coroutine. Okay so when you create a coroutine in a certain way which we will see in upcoming articles cancel the coroutine

You will create a job and job can we used to let say cancel the coroutine, If you choose later on next up we have a deferred which is basically a call team that returns a result.

Deferred

The next thing we have deferred is basically a call team that returns a result but sends a coroutine run in parallel. You can not return the result immediately. The result can only be only returned when the coroutine finishes its execution.

So that means we need deferred which is a future result of a coroutine and what you can do with a deferred, basically tell the program to wait for the outcome of that coroutine. when you are at a point where you need that result.

Dispatchers

Next, we dispatchers, which simply says that dispatchers manage a certain number of threads, and whenever a coroutine needs to run, it will assign it to a thread and run in time that particular thread.

So dispatcher we have just a few of them that are more or less suited for certain tasks that we will discuss in this post.

Error handling

Error handling kind of self-explanatory. It basically provides a way to handle any errors that might come up in a coroutine.

Conclusion

So that’s it these are major concepts of the coroutine. I the blog we’ll discuss these concepts in detail one by one. Once you understand the basics idea of coroutines. You can easily play around will all these concepts to give you the functionality that you require.

Estimated reading time: 5 minutes