Kotlin: Async tasks inside foreach loop - kotlin

Question

I want to call tasks asynchronously, so it can varied how long will each task take, but I want to wait for all of them to be finished in order to continue in next line under for loop. How can I achieve that? Because so far its not happening. Code below foreach should be called only if all of those tasks are finished. I'm looking for some "elegant" way to solve this, I dont wanna use some while loop and freeze entire thread.
Code:
val failedTasks = mutableListOf<ApiTask<T>>()
App.log("apiCallChained: startCall")
apiBlocks.forEachIndexed { i, apiBlock->
App.log("apiCallChained: callingTask: $i")
launch(Dispatchers.Main){
val (r, err) = withContext(Dispatchers.IO){
try {
apiBlock.apiBlock(this) to null
} catch (e: ApiCallError) {
null to e
}
}
when {
r != null -> {
App.log("apiCallChained: callingTask: $i - success")
apiBlock.onSuccess(r)
}
err != null -> {
App.log("apiCallChained: callingTask: $i - error")
failedTasks.add(apiBlock)
}
}
}
}
App.log("apiCallChained: endCall: ${failedTasks.size}")
if (failedTasks.isEmpty()) onSuccess.invoke() else onError.invoke(failedTasks)
Logs:
apiCallChained: startCall
apiCallChained: callingTask: 0
apiCallChained: callingTask: 1
apiCallChained: callingTask: 2
apiCallChained: callingTask: 3
apiCallChained: callingTask: 4
apiCallChained: endCall: 0
apiCallChained: callingTask: 2 - success
apiCallChained: callingTask: 3 - success
apiCallChained: callingTask: 4 - success
apiCallChained: callingTask: 0 - success
apiCallChained: callingTask: 1 - success

Answer 1

The only way two ways to do this without freezing the thread is with a callback or by directly running all of it in a coroutine to begin with.
So either:
scope.launch {
//replacement for your code above, see below...
// code to call after work finished...
}
or, assuming your CoroutineScope defaults to the main thread and you want to react on the main thread, you can call a callback from inside your coroutine. It looks like you already are doing something like this with your onSuccess and onError callbacks.
// This could be a ()->Unit callback passed into the function that runs this code:
val onWorkFinished = {
// code to call after work finished...
}
scope.launch {
//replacement for your code above, see below...
onWorkFinished()
}
So, the code we are replacing your above code with is in a coroutine. The typical way to do a bunch of parallel work and wait for all of it is by using a coroutineScope block. The block suspends until all children coroutines finish. You can replace your above code with:
val failedTasks = mutableListOf<ApiTask<T>>()
App.log("apiCallChained: startCall")
coroutineScope {
apiBlocks.forEachIndexed { i, apiBlock->
launch(Dispatchers.Main){
val (r, err) = withContext(Dispatchers.IO){
try {
apiBlock.apiBlock(this) to null
} catch (e: ApiCallError) {
null to e
}
}
when {
r != null -> {
App.log("apiCallChained: callingTask: $i - success")
apiBlock.onSuccess(r)
}
err != null -> {
App.log("apiCallChained: callingTask: $i - error")
failedTasks.add(apiBlock)
}
}
}
}
}
App.log("apiCallChained: endCall: ${failedTasks.size}")
if (failedTasks.isEmpty()) onSuccess.invoke() else onError.invoke(failedTasks)
Incidentally, you can simplify it as follows:
val failedTasks = mutableListOf<ApiTask<T>>()
App.log("apiCallChained: startCall")
coroutineScope {
apiBlocks.forEachIndexed { i, apiBlock->
launch(Dispatchers.Main){
try {
val result = withContext(Dispatchers.IO) { apiBlock.apiBlock(this) }
App.log("apiCallChained: callingTask: $i - success")
apiBlock.onSuccess(result)
} catch (e: ApiCallError) {
App.log("apiCallChained: callingTask: $i - error")
failedTasks.add(apiBlock)
}
}
}
}
App.log("apiCallChained: endCall: ${failedTasks.size}")
if (failedTasks.isEmpty()) onSuccess.invoke() else onError.invoke(failedTasks)