I am getting empty list while fetching data from FirebaseFirestore in Android(Kotlin and jetpack Compose)

i am constantly getting list of size 0 while fetching data from firebaseFirestore, which have data in it,
here is the code to take a look at...

Model...

data class Product(
    val productId: String,
    val title: String,
    val description: String,
    val price: Int,
    val image: Int?,
    val category: String,
    val isPopular: Boolean,
)

Repository implementation..

override suspend fun getProduct(): Any =  withContext(Dispatchers.IO) {
       return@withContext try{
            val documentReference = firestore
                .collection("Products")
                .document("")
            documentReference
                .get()
                .addOnSuccessListener { document ->
                    if (document != null) {
                        val product = document.toObject(Product::class.java)

                        Log.d("Successful", "Products received")
                    } else {
                        Log.d("ErrorGetting", document.toString())
                    }
                }
                .addOnFailureListener {
                    Log.d("ErrorGetting", it.toString())
                }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

ViewModel...

private val _getProductFlow = MutableStateFlow<List<Product>>(emptyList())
    val getProductFlow: StateFlow<List<Product>> = _getProductFlow

suspend fun getProduct() = viewModelScope.launch {
        val result = fireRepository.getProduct()
        _getProductLiveData.value = listOf(result as Product)
    }

Composable fun...

val pro = viewModel.getProductFlow.collectAsState().value

Card(
                modifier = Modifier.fillMaxWidth(),
                shape = RoundedCornerShape(15.dp),
                elevation = CardDefaults.cardElevation(
                    defaultElevation = 4.dp,
                    hoveredElevation = 8.dp
                )
            ) {
                pro.forEach {
                    Text(text = it.title, color = DarkTeal)
                }
            }

I debugged pro variable and it was 0 while i have 3 collections stored in the database. I have tried other ways too but the result is same

also here is the init block...

init {
        CoroutineScope(Dispatchers.IO).launch {
            getProduct()
        }
    }

It's because you're using listeners that will return some result in the future after your function has already returned, and you never actually return the document you retrieve. You assigned it to a variable and did nothing but log it.

In a suspend function, you need to use await() instead of using listeners. You also don't need Dispatchers.IO if you aren't calling blocking functions, which you are not doing.

The return value has to either be null, or you need to return something else to represent the error cases you have.

Change this function as shown:

override suspend fun getProduct(): Any? {
   return@withContext try{
        val document = firestore
            .collection("Products")
            .document("")
            .get()
            .await()
        if (document != null) {
            Log.d("Successful", "Products received")
        } else {
            Log.d("ErrorGetting", "Null document returned")
        }
        document?.toObject(Product::class.java)
    } catch (e: Exception) {
        Log.d("ErrorGetting", it.toString())
        null
    }
}

A couple other things you're doing wrong:

• getProduct() in your view model should not be a suspend function. That implies that it will only return after the product is retrieved, and that it will directly return the result. But it is just launching a coroutine. It should also not be named "get" because it doesn't return what it describes. It would be more appropriate to name it something like "launchFetchProduct".

• Never use CoroutineScope().launch. This creates a coroutine that will not be automatically cancelled when appropriate, leading to resource and memory leaks. Usually, you should be using a lifecycleScope or viewModelScope, or one that you have injected into a class. If you truly want to create a coroutine that should not be cancelled because it's not holding references or using resources that should be held indefinitely or until work is definitely complete, then GlobalScope is appropriate.

It's actually convoluted that you have this getProduct() function that only fills in a StateFlow. And you have to remember to call it from outside the class, but you somehow need to avoid calling it more than once to avoid wasting resources fetching it multiple times. You could avoid all this and the MutableStateFlow by using the flow builder and stateIn:

val getProductFlow: StateFlow<List<Product>> = flow {
       val result = fireRepository.getProduct() as? Product
       if (result == null) {
           Log.e(TAG, "Could not load product. Null or invalid response")
           return@flow
       }
       emit(listOf(result))
    }.stateIn(viewModelScope, emptyList())