A simple way to work with Kotlin Coroutines in Android

Photo by Nareeta Martin on Unsplash

Do you feel curious about Kotlin’s coroutines? Have you heard about this before? Do you want to start working with them within your Android project? Well, I’m gonna try to write a simple example in order to clarify the general concept and how to apply it correctly.

Look at the code below:

class MoviesViewModel : ViewModel(), CoroutineScope {
      private val job = Job()
      private lateinit var moviesLiveData: LiveData<List<Movies>> = MutableLiveData()
override val coroutineContext: CoroutineContext
            get() = job + Dispatchers.Main
fun getAllMovies() {
          launch(Dispatchers.Main) {
                 val movies: List<Movie> = async(Dispatchers.IO) {
                     moviesRepository.queryMovies() 
                 }.await()
                 moviesLiveData.value = movies
          }
      }
}

In the code we have a ViewModel class, from an Android app, in which we implemented a coroutine to fetch a list of movies from an API. Look at the getAllMovies method, we create the coroutine with launch(Dispatchers.Main). Launch means that we are creating a coroutine that doesn’t have a return value, and Dispatchers.Main means that all the flow will be executed and observed from the Main thread. Internally, another coroutine is created using async, which is being executed in another thread (Dispatchers.IO) to fetch the data. Unlike launch, async coroutines return a value using the await() method. And this is all what we need to do to create a coroutine.

In summary, use launch to create a coroutine with no returning value just like the example above or to insert data into a local database. On the contrary, use async to create a coroutine with a return value, using await(), for example when fetching data from an API or a local database. All details regarding Dispatchers, launch and async can be found in this article from Sean McQuillan.

The Scope

In order to coroutines can run properly, the class in which we are using them has to implement CoroutineScope, which keeps track of the coroutine. In the example above the scope is the ViewModel. Then we need to override coroutineContext property. This will demand that the default dispatcher as well as the job must be configured. Our default dispatcher is the Main, and the Job lets us to cancel pending coroutines on any given moment. So, after creating the ViewModel, to keep the scope to this class, then the job must be is created.

We can have Global or more limited Scopes, and if you want to understand the different paths and uses, all the details regarding them can be found in this Antonio Leiva’s article.

.. We Are Done

… and this is all we need to understand and do to implement coroutines on Android.

Remember to include the dependencies in app’s build.gradle file:

ext {
  coroutinesVersion = "1.1.1"
}
dependencies {
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutinesVersion"
}

Let me know if this is clear. I know that all the theory behind coroutines is huge, but I’m trying to explain it in the most simple way so everyone can start using them within their projects.

Thank you very much to Cristian for helping me with the general revision.