How to return an int value stuck in a for loop but a callback in Kotlin?-CodePudding

I am trying to get the size of this firebase collection size of documents, and for some reason in Kotlin, I can't seem to get this to work. I have declared a variable to be zero in an int function and I put it inside a for loop where it increments to the size of the range. Then when I return the value, it is zero. Here is the code I have provided, please help me as to why it is returning zero.

This is just what is being passed to the function

var postSize = 0

That is the global variable, now for below

val db = FirebaseFirestore.getInstance()
val first = db.collection("Post").orderBy("timestamp")
getPostSize(first)

This is the function

private fun getPostSize(first: Query){
   first.get().addOnSuccessListener { documents -> 
      for(document in documents) {
       Log.d(TAG, "${document.id} => ${document.data}")
       getActualPostSize(postSize  )
   }
 }
return postSize
}

private fun getActualPostSize(sizeOfPost: Int): Int {
// The number does push to what I am expecting right here if I called a print statement
      return sizeOfPost // However here it just returns it to be zero again. Why @tenffour04? Why? 
}

It is my understanding, according to the other question that this was linked to, that I was suppose to do something like this.

CodePudding user response：

This question has answers that explain how to approach getting results from asynchronous APIs, like you're trying to do.

Here is a more detailed explanation using your specific example since you were having trouble adapting the answer from there.

Suppose this is your original code you were trying to make work:

// In your "calling code" (inside onCreate() or some click listener):
val db = FirebaseFirestore.getInstance()
val first = db.collection("Post").orderBy("timestamp")
val postSize = getPostSize(first)
// do something with postSize

// Elsewhere in your class:
private fun getPostSize(first: Query): Int {
    var postSize = 0
    first.get().addOnSuccessListener { documents -> 
       for(document in documents) {
           Log.d(TAG, "${document.id} => ${document.data}")
           postSize  
       }
    }
    return postSize
}

The reason this doesn't work is that the code inside your addOnSuccessListener is called some time in the future, after getPostSize() has already returned.

The reason asynchronous code is called in the future is because it takes a long time to do its action, but it's bad to wait for it on the calling thread because it will freeze your UI and make the whole phone unresponsive. So the time-consuming action is done in the background on another thread, which allows the calling code to continue doing what it's doing and finish immediately so it doesn't freeze the UI. When the time-consuming action is finally finished, only then is its callback/lambda code executed.

A simple retrieval from Firebase like this likely takes less than half a second, but this is still too much time to freeze the UI, because it would make the phone seem janky. Half a second in the future is still in the future compared to the code that is called underneath and outside the lambda.

For the sake of simplifying the below examples, let's simplify your original function to avoid using the for loop, since it was unnecessary:

private fun getPostSize(first: Query): Int {
    var postSize = 0
    first.get().addOnSuccessListener { documents -> 
       postSize = documents.count()
    }
    return postSize
}

The following are multiple distinct approaches for working with asynchronous code. You only have to pick one. You don't have to do all of them.

1. Make your function take a callback instead of returning a value.

Change you function into a higher order function. Since the function doesn't directly return the post size, it is a good convention to put "Async" in the function name. What this function does now is call the callback to pass it the value you wanted to retrieve. It will be called in the future when the listener has been called.

private fun getPostSizeAsync(first: Query, callback: (Int) -> Unit) {
    first.get().addOnSuccessListener { documents -> 
       val postSize = documents.count()
       callback(postSize)
    }
}

Then to use your function in your "calling code", you must use the retrieved value inside the callback, which can be defined using a lambda:

// In your "calling code" (inside onCreate() or some click listener):
val db = FirebaseFirestore.getInstance()
val first = db.collection("Post").orderBy("timestamp")
getPostSizeAsync(first) { postSize ->
    // do something with postSize inside the lambda here
}
// Don't try to do something with postSize after the lambda here. Code under
// here is called before the code inside the lambda because the lambda is called
// some time in the future.

2. Handle the response directly in the calling code.

You might have noticed in the above solution 1, you are really just creating an intermediate callback step, because you already have to deal with the callback lambda passed to addOnSuccessListener. You could eliminate the getPostSize function completely and just deal with callbacks at once place in your code. I wouldn't normally recommend this because it violates the DRY principle and the principle of avoiding dealing with multiple levels of abstraction in a single function. However, it may be better to start this way until you better grasp the concept of asynchronous code.

It would look like this:

// In your "calling code" (inside onCreate() or some click listener):
val db = FirebaseFirestore.getInstance()
val first = db.collection("Post").orderBy("timestamp")
first.get().addOnSuccessListener { documents -> 
   val postSize = documents.count()
   // do something with postSize inside the lambda here
}
// Don't try to do something with postSize after the lambda here. Code under
// here is called before the code inside the lambda because the lambda is called
// some time in the future.

3. Put the result in a LiveData. Observe the LiveData separately.

You can create a LiveData that will update its observers about results when it gets them. This may not be a good fit for certain situations, because it would get really complicated if you had to turn observers on and off for your particular logic flow. I think it is probably a bad solution for your code because you might have different queries you want to pass to this function, so it wouldn't really make sense to have it keep publishing its results to the same LiveData, because the observers wouldn't know which query the latest postSize is related to.

But here is how it could be done.

private val postSizeLiveData = MutableLiveData<Int>()

// Function name changed "get" to "fetch" to reflect it doesn't return
// anything but simply initiates a fetch operation:
private fun fetchPostSize(query: Query) {
    first.get().addOnSuccessListener { documents -> 
       postSize.value = documents.count()
    }
}

// In your "calling code" (inside onCreate() or some click listener):
val db = FirebaseFirestore.getInstance()
val first = db.collection("Post").orderBy("timestamp")
fetchPostSize(first)
postSizeLiveData.observer(this) { postSize ->
    // Do something with postSize inside this observer that will
    // be called some time in the future.
}
// Don't try to do something with postSize after the lambda here. Code under
// here is called before the code inside the lambda because the lambda is called
// some time in the future.

4. Use a suspend function and coroutine.

Coroutines allow you to write synchronous code without blocking the calling thread. After you learn to use coroutines, they lead to simpler code because there's less nesting of asynchronous callback lambdas. If you look at option 1, it will become very complicated if you need to call more than one asynchronous function in a row to get the results you want, for example if you needed to use postSize to decide what to retrieve from Firebase next. You would have to call another callback-based higher-order function inside the lambda of your first higher-order function call, nesting the future code inside other future code. (This is nicknamed "callback hell".) To write a synchronous coroutine, you launch a coroutine from lifecycleScope (or viewLifecycleOwner.lifecycleScope in a Fragment or viewModelScope in a ViewModel). You can convert your getter function into a suspend function to allow it to be used synchronously without a callback when called from a coroutine. Firebase provides an await() suspend function that can be used to wait for the result synchronously if you're in a coroutine. (Note that more properly, you should use try/catch when you call await() because it's possible Firebase fails to retrieve the documents. But I skipped that for simplicity since you weren't bothering to handle the possible failure with an error listener in your original code.)

private suspend fun getPostSize(first: Query): Int {
    return first.get().await().count()
}

// In your "calling code" (inside onCreate() or some click listener):
lifecycleScope.launch {
    val db = FirebaseFirestore.getInstance()
    val first = db.collection("Post").orderBy("timestamp")
    val postSize = getPostSize(first)
    // do something with postSize
}
// Code under here will run before the coroutine finishes so 
// typically, you launch coroutines and do all your work inside them.

Coroutines are the common way to do this in Kotlin, but they are a complex topic to learn for a newcomer. I recommend you start with one of the first two solutions until you are much more comfortable with Kotlin and higher order functions.