Kotlin Coroutines the right way in Android
Solution 1
After struggling with this question for days, I think the most simple and clear async-await pattern for Android activities using Kotlin is:
override fun onCreate(savedInstanceState: Bundle?) {
//...
loadDataAsync(); //"Fire-and-forget"
}
fun loadDataAsync() = async(UI) {
try {
//Turn on busy indicator.
val job = async(CommonPool) {
//We're on a background thread here.
//Execute blocking calls, such as retrofit call.execute().body() + caching.
}
job.await();
//We're back on the main thread here.
//Update UI controls such as RecyclerView adapter data.
}
catch (e: Exception) {
}
finally {
//Turn off busy indicator.
}
}
The only Gradle dependencies for coroutines are: kotlin-stdlib-jre7
, kotlinx-coroutines-android
.
Note: Use job.await()
instead of job.join()
because await()
rethrows exceptions, but join()
does not. If you use join()
you will need to check job.isCompletedExceptionally
after the job completes.
To start concurrent retrofit calls, you can do this:
val jobA = async(CommonPool) { /* Blocking call A */ };
val jobB = async(CommonPool) { /* Blocking call B */ };
jobA.await();
jobB.await();
Or:
val jobs = arrayListOf<Deferred<Unit>>();
jobs += async(CommonPool) { /* Blocking call A */ };
jobs += async(CommonPool) { /* Blocking call B */ };
jobs.forEach { it.await(); };
Solution 2
How to launch a coroutine
In the kotlinx.coroutines
library you can start new coroutine using either launch
or async
function.
Conceptually, async
is just like launch
. It starts a separate coroutine which is a light-weight thread that works concurrently with all the other coroutines.
The difference is that launch returns a Job
and does not carry any resulting value, while async
returns a Deferred
- a light-weight non-blocking future that represents a promise to provide a result later. You can use .await()
on a deferred value to get its eventual result, but Deferred
is also a Job
, so you can cancel it if needed.
Coroutine context
In Android we usually use two context:
-
uiContext
to dispatch execution onto the Android mainUI
thread (for the parent coroutine). -
bgContext
to dispatch execution in background thread (for the child coroutines).
Example
//dispatches execution onto the Android main UI thread
private val uiContext: CoroutineContext = UI
//represents a common pool of shared threads as the coroutine dispatcher
private val bgContext: CoroutineContext = CommonPool
In following example we are going to use CommonPool
for bgContext
which limit the number of threads running in parallel to the value of Runtime.getRuntime.availableProcessors()-1
. So if the coroutine task is scheduled, but all cores are occupied, it will be queued.
You may want to consider using newFixedThreadPoolContext
or your own implementation of cached thread pool.
launch + async (execute task)
private fun loadData() = launch(uiContext) {
view.showLoading() // ui thread
val task = async(bgContext) { dataProvider.loadData("Task") }
val result = task.await() // non ui thread, suspend until finished
view.showData(result) // ui thread
}
launch + async + async (execute two tasks sequentially)
Note: task1 and task2 are executed sequentially.
private fun loadData() = launch(uiContext) {
view.showLoading() // ui thread
// non ui thread, suspend until task is finished
val result1 = async(bgContext) { dataProvider.loadData("Task 1") }.await()
// non ui thread, suspend until task is finished
val result2 = async(bgContext) { dataProvider.loadData("Task 2") }.await()
val result = "$result1 $result2" // ui thread
view.showData(result) // ui thread
}
launch + async + async (execute two tasks parallel)
Note: task1 and task2 are executed in parallel.
private fun loadData() = launch(uiContext) {
view.showLoading() // ui thread
val task1 = async(bgContext) { dataProvider.loadData("Task 1") }
val task2 = async(bgContext) { dataProvider.loadData("Task 2") }
val result = "${task1.await()} ${task2.await()}" // non ui thread, suspend until finished
view.showData(result) // ui thread
}
How to cancel a coroutine
The function loadData
returns a Job
object which may be cancelled. When the parent coroutine is cancelled, all its children are recursively cancelled, too.
If the stopPresenting
function was called while dataProvider.loadData
was still in progress, the function view.showData
will never be called.
var job: Job? = null
fun startPresenting() {
job = loadData()
}
fun stopPresenting() {
job?.cancel()
}
private fun loadData() = launch(uiContext) {
view.showLoading() // ui thread
val task = async(bgContext) { dataProvider.loadData("Task") }
val result = task.await() // non ui thread, suspend until finished
view.showData(result) // ui thread
}
The complete answer is available in my article Android Coroutine Recipes
Solution 3
I think you can get rid of runOnUiThread { ... }
by using UI
context for Android applications instead of CommonPool
.
The UI
context is provided by the kotlinx-coroutines-android module.
Solution 4
We also have another option. if we use Anko library , then it looks like this
doAsync {
// Call all operation related to network or other ui blocking operations here.
uiThread {
// perform all ui related operation here
}
}
Add dependency for Anko in your app gradle like this.
implementation "org.jetbrains.anko:anko:0.10.5"
Solution 5
Like sdeff said, if you use the UI context, the code inside that coroutine will run on UI thread by default. And, if you need to run an instruction on another thread you can use run(CommonPool) {}
Furthermore, if you don't need to return nothing from the method, you can use the function launch(UI)
instead of async(UI)
(the former will return a Job
and the latter a Deferred<Unit>
).
An example could be:
fun loadListOfMediaInAsync() = launch(UI) {
try {
withContext(CommonPool) { //The coroutine is suspended until run() ends
adapter.listOfMediaItems.addAll(resources.getAllTracks())
}
adapter.notifyDataSetChanged()
} catch(e: Exception) {
e.printStackTrace()
} catch(o: OutOfMemoryError) {
o.printStackTrace()
} finally {
progress.dismiss()
}
}
If you need more help I recommend you to read the main guide of kotlinx.coroutines and, in addition, the guide of coroutines + UI
Sai
Six years of tech industry experience, an expert in Android application development and experience as a software solutions architect. Published 40+ app to PlayStore.
Updated on July 09, 2022Comments
-
Sai almost 2 years
I'm trying to update a list inside the adapter using async, I can see there is too much boilerplate.
Is it the right way to use Kotlin Coroutines?
can this be optimized more?
fun loadListOfMediaInAsync() = async(CommonPool) { try { //Long running task adapter.listOfMediaItems.addAll(resources.getAllTracks()) runOnUiThread { adapter.notifyDataSetChanged() progress.dismiss() } } catch (e: Exception) { e.printStackTrace() runOnUiThread {progress.dismiss()} } catch (o: OutOfMemoryError) { o.printStackTrace() runOnUiThread {progress.dismiss()} } }
-
BladeCoder over 6 yearsBe aware that this basically does the same thing as a non-static AsyncTask, with the same potential issues. You can "fire" it but not "forget" it because it interacts with your Activity at the end. I would recommend that you start the coroutine in onStart() and cancel it in onStop(), to avoid performing work when the Activity is not visible and prevent updating views after the Activity is destroyed. Another solution would be to move the coroutine to a Loader or to a ViewModel (from the Architecture components).
-
KTCO over 6 yearsThat is a very good point regarding potential life-cycle issues. I agree that all coroutines (jobs) should be added to a collection of some type, so proper clean-up can be done in onStop(). I also use this "fire-and-forget" approach in response to user actions (button clicks). Thank you for your comment and recommendations.
-
Admin over 6 yearsCan I get the progress of the async task somehow?
-
Felipe Belluco over 5 yearsI couldn't find the method withContext, where's is it from? My kotlin version is 1.2.71
-
mmBs over 5 yearsThis answer adds additional dependency - anko, which is currently in ver.
0.10.8
. I believe kotlinx.coroutines are more than enough to achieve this, what OP asked. Especially in version1.0.1
. -
user25 over 5 yearsYes, it's not good for Android apps. Try proandroiddev.com/android-coroutine-recipes-33467a4302e9
-
clementiano almost 5 yearsThis has been deprecated, can you help with the working one
-
Sumit Kumar over 4 yearsCan we use Anko Async in ViewModel. Or it can only be used in activity or fragment.
-
Kenneth Argo over 3 yearsSee: github.com/Kotlin/kotlinx.coroutines implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9"
-
android developer over 3 yearsHow can I cancel the task like on AsyncTask, with the ability to choose if it's cancelling the task nicely, or with thread-interruption:
https://developer.android.com/reference/android/os/AsyncTask#cancel(boolean)
, and how can I check inside that it was cancelled, to stop doing what it does?