How to execute multiple functions in order with Coroutine in Kotlin

I have six functions and in large, I will execute them in three steps.

First, variable userPointArray that will be used for it looks like below.

var userPointArray = ArrayList<UserPoint>()

data class UserPoint(
    var userId: String,
    var point: Int,
    var index: Int
)

My three steps will be below.

1. get userId data from firebase and put it to userPointArray
   -> one function
2. get four data from firebase and calculate point field -> four functions
3. update index based on point -> one function

Since I need to execute total 6 functions in three steps order, I will use Coroutine.

step 1 function

suspend fun userIdToArrayFun() = withContext(Dispatchers.IO) {
        userDB.get()
            .addOnSuccessListener { documents ->
                for (document in documents) {
                    var userId = document.data?.getValue("userId").toString()
                    var userEntry = UserPoint(
                        userId,
                        0,
                        0
                    )

                    userPointArray.add(userEntry)
                    dataToUserPointArray.userIdToArray.value = true
                }
            }
        true
    }

step 2 functions

: Four functions in this step are stepCountToArrayFun(), diaryArrayFun() ...

suspend fun calculatePointFun() = withContext(Dispatchers.IO) {
        try {
            listOf(
                launch { stepCountToArrayFun() },
                launch { diaryToArrayFun() },
                launch { commentToArrayFun() },
                launch { likeToArrayFun() }
            ).joinAll()
            false
        } catch (e: Throwable) {
            true
        }
    }

step3 Function

 fun indexArrayFun() = with(Dispatchers.IO) {
        userPointArray.sortWith(compareBy { it.point })

        var initialindex: Int = 1
        for (i in userPointArray.indices) {
            userPointArray[i].point = initialindex

            if (userPointArray[i + 1].point != userPointArray[i].point) {
                initialindex++
            }
        }
        true
    }

And lastly, I execute these order step 1 -> step2 -> step 3 as below:

var fullUserArrayPointFun = CoroutineScope(Dispatchers.Default).launch {
        
        if (userIdToArrayFun()) {
            calculatePointFun()
        }
        if(calculatePointFun()) {
            indexArrayFun()
        }
    }

Since I'm new in Coroutine, I just write code as searching, I guess my code is weird, especially my last code that executes these three step code in order.

Can you review each three step code and my last code?

I recommend reading through the documentation and blog posts on Medium by Roman Elizarov to get a firm grasp of the basic coroutine concepts before attempting to use them.

Here's a brief review of the code you posted:

Step 1 function

It doesn't make sense to use a suspend function to call an asynchronous function. Your suspend function is not going to wait for it. You can convert asynchronous functions into suspend functions by using suspendCancellableCoroutine, but it's unnecessary for Firebase, since it already provides a suspend function for you. You should use the await() suspend function instead of adding an asynchronous listener. It should look something like this, but I might be a little bit off because I don't use Firebase and I don't really know what you're doing in your for loop:

suspend fun userIdToArrayFun() {
    try {
        val documents = userDB.get().await()
        for (document in documents) {
            var userId = document.data?.getValue("userId").toString()
            var userEntry = UserPoint(
                userId,
                0,
                0
            )

            userPointArray.add(userEntry)
            dataToUserPointArray.userIdToArray.value = true
        }
    } catch (e: Exception) {
        // log error? Show error to user?
    }
}

Step 2 functions

If your four functions that you are calling are blocking functions, your current code is correct. If they are suspend functions or non-blocking, then there's no point in switching contexts, and can use coroutineScope { instead of withContext(Dispatchers.IO) { for code clarity.

If the four functions are intended to be suspend function that wait for results, then my comments on step 1 also apply to how you have implemented them.

Step 3 functions

Your use of with(Dispatchers.IO) is making IO the receiver of the lambda--it's the with scope function. I think you mixed it up with withContext.

If this code is not working with an enormous array, it's not really blocking, so you can just remove the with wrapper and leave it as is. But if it is enough data to take a certain amount of time, you can change it to a suspend function and use withContext(Dispatchers.Default) to offload the work from whatever thread is working on the coroutine. I suggest Default instead of IO since it's not IO-bound.

Last step

You shouldn't be creating a CoroutineScope() without storing it in a property so you can manage its lifecycle. If you truly don't have to manage its lifecycle, you can use GlobalScope, but it should be very rare for you not to care about a coroutine's lifecycle. It's using resources, and so when whatever UI it is related to becomes obsolete, you want to cancel the coroutines so the resources aren't wasted (memory leak and/or unnecessary CPU/network/disk use).

On Android, the vast majority of coroutines should be launched either from a lifecycleScope or viewModelScope because these CoroutineScopes are already available for you and already automatically cancel themselves when their associated UI is destroyed.

Also, you are calling your calculatePointFun() twice, which doesn't make sense. I would write your code like below. You don't need to assign your coroutine's Job to a variable, unless you have some circumstance under which you need to cancel it early.

You are using userIdToArrayFun() as if it returns a Boolean. Did you mean to make it return false when it fails and true for success?

val fullUserArrayPointJob = viewModelScope.launch {
    if (userIdToArrayFun()) {
        if(calculatePointFun()) {
            indexArrayFun()
        }
    }
}

// or

val fullUserArrayPointJob = viewModelScope.launch {
    if (!userIdToArrayFun()) {
        return@launch
    }
    if(calculatePointFun()) {
        indexArrayFun()
    }
}

</details>