Kotlin Coroutine on Android

Features of Coroutines

• Reduced memory leaks: It uses structured concurrency strategy for running operations in a given scope.
• Built-in cancellation support: Cancellation can be automatically propagated via the running coroutine hierarchy.
• Lightweight: Kotlin allows us to launch multiple coroutines on a single thread due to support for suspension, which doesn’t block the thread, that contains the running coroutine. Suspending cuts down the memory over blocking along with supporting several concurrent operations.
• Jetpack integration: A large number of Jetpack libraries include extensions that are compatible with full coroutines support. Some of these libraries also provide default coroutine scope that facilitates structured concurrency to a very high extend.

Coroutine Terminology

Kotlin provides an efficient bundle of APIs so that you may align your asynchronous code sequentially.

Consider this snippet of code as an example:

• val snowyBitmap = getFilteredBitmap()
• showBitmap(bitmap)

To fetch the bitmap from a specific API and apply the snow filter, we use the showBitmap() function and select the snowyBitmap from getFilteredBitmap().

Due to the high execution time, such sequential codes may also intervein between certain vital operations, therefore they should be placed in the distinct thread. This can be achieved by encapsulating such sequential codes in a Kotlin Coroutine.

For implementing Coroutines you need to have a proper understanding of the Coroutine terminology:

• Suspending functions: The set of functions, which can be suspended without blocking the execution of the current thread. Rather than only returning a specific value, they also maintain the record of the context in which the caller suspends it. With the help of the context, we may resume them if required.
• CoroutineBuilders: These functions have certain prerequisites; particularly a suspending lambda has to be passed as an argument to initiate a coroutine. Some widely used coroutine builders provided by Kotlin Coroutines are, async(), launch(), runBlocking.
• CoroutineScope: It is used to indicate and manipulate the lifecycle of Kotlin Coroutines. It can be used throughout the application or can be restricted to a specific. Android Activity or fragment. You need to manipulate the scope to trigger the coroutine.
• CoroutineDispatcher: It defines the thread pool so that you may launch your Kotlin Coroutines. It can be used to define various kinds of thread pools, namely, background thread pool, main thread pool, or several custom thread pools. You can also use this to toggle between threads or fetch results from them and pass them to other activities.

Prerequisites for Coroutine

With reference to the Kotlin Coroutines Github repository, prior to using coroutines in our source code, you need to import the kotlinx-coroutines-core and kotlinx-coroutines-android. Both of these libraries assist the Android main thread analogous to the library io.reactivex.rxjava2:rxandroid for RxJava and make sure to log the uncaught exceptions before the Android application crashes.

Moreover, if your project is RxJava based to make sure that you include kotlinx-coroutines-rx2 for implementing coroutines with RxJava also. This library assists in transferring RxJava to Coroutines. You need to import the following libraries in your Android project, in the app/build.gradle.

• implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2’
• implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2’
• implementation “org.jetbrains.kotlinx:kotlinx-coroutines-rx2:1.3.2”

Step Two: Include the latest Kotlin version in you build.gradle file

buildscript {
ext.kotlin_version = ‘1.3.50’
repositories {
jcenter()
…
}
…
}

Implementing Suspended Functions

If you intend to extract your workload into partitioned functions. (Let’s say that it takes a lap of thousand milliseconds and then,

returns the number).
fun workload(n: Int): Int
{
delay(1000)
return n
}

You will encounter a pop-up that displays a very familiar error, which says:

“Suspend functions are only allowed to be called from a coroutine or another suspend function.”

Now let’s try to understand what this indicates. The prime advantage of using coroutines is that they are allowed to suspend without blocking a thread. The compilers need to emit some specific codes for achieving this, so we need to add the keyword suspend explicitly in the code. We use the suspend modifier for it:

suspend fun workload(n: Int): Int {
delay(1000)
return n
}

Now if you call  workload() via a coroutine, the compiler is already aware that it might suspend and will release the resources accordingly:

GlobalScope.async {
workload(n)
}

The workload() function can be invoked within a coroutine (or any alternate suspending function), but it can’t be invoked from an exterior ecosystem, apart from the coroutine. It is obvious that delay() and await() functions that are used above declared themselves as suspend, and that’s why you need to encapsulate them with the runBlocking {}, launch {} or async {}.

Nowadays, coroutines have been deep-rooted in modern programming languages. They are easy to learn and implement and come with a wide set of advantages and utilities. We recommend the use of Kotlin coroutines in Android so that the end app becomes less prone to app crashes and sustainable.

Most of the apps based on AI technologies such as handwriting recognition, speech recognition, face detection use coroutines are these threads are very time-consuming, if they are directly linked to the user-interface they deteriorate the overall user-experience by blocking the main thread in execution.