End flow/coroutines task before go further null issue

Issue

Fragment

   private fun makeApiRequest() {
        vm.getRandomPicture()
        var pictureElement = vm.setRandomPicture()

        GlobalScope.launch(Dispatchers.Main) {
            // what about internet
            if (pictureElement != null && pictureElement!!.fileSizeBytes!! < 400000) {

                Glide.with(requireContext()).load(pictureElement!!.url)
                    .into(layout.ivRandomPicture)
                layout.ivRandomPicture.visibility = View.VISIBLE
            } else {
                getRandomPicture()
            }
        }
    }

viewmodel

    fun getRandomPicture() {
        viewModelScope.launch {
            getRandomPictureItemUseCase.build(Unit).collect {
                pictureElement.value = it
                Log.d("inspirationquotes", "VIEWMODEL $pictureElement")
                Log.d("inspirationquotes", "VIEWMODEL VALUE ${pictureElement.value}")
            }
        }
    }

    fun setRandomPicture(): InspirationQuotesDetailsResponse? {
            return pictureElement.value
    }

Flow UseCase

class GetRandomPictureItemUseCase @Inject constructor(private val api: InspirationQuotesApi): BaseFlowUseCase<Unit, InspirationQuotesDetailsResponse>() {
    override fun create(params: Unit): Flow<InspirationQuotesDetailsResponse> {
        return flow{
            emit(api.getRandomPicture())
        }
    }
}

My flow task from viewmodel doesn't goes on time. I do not know how to achieve smooth downloading data from Api and provide it further. I was reading I could use runBlocking, but it is not recommended in production as well. What do you use in your professional applications to achieve nice app?

Now the effect is that that image doesn't load or I have null error beacause of my Log.d before GlobalScope in Fragment (it is not in code right now).

One more thing is definding null object I do not like it, what do you think?

    var pictureElement = MutableStateFlow<InspirationQuotesDetailsResponse?>(null)

EDIT:

Viewmodel

 val randomPicture: Flow<InspirationQuotesDetailsResponse> = getRandomPictureItemUseCase.build(Unit)

fragment

private fun makeApiRequest() = lifecycleScope.launch {
            vm.randomPicture
                .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
                .collect { response ->
                    if (response.fileSizeBytes < 600000) {
                        Log.d("fragment", "itGetsValue")
                        Glide.with(requireContext()).load(response.url)
                            .into(layout.ivRandomPicture)
                        layout.ivRandomPicture.visibility = View.VISIBLE
                    } else {
                        onFloatingActionClick()
                    }
                }
    }

Edit2 problem on production, another topic: Link -> What is the substitute for runBlocking Coroutines in fragments and activities?

Solution

First of all, don't use GlobalScope to launch a coroutine, it is highly discouraged and prone to bugs. Use provided lifecycleScope in Fragment:

lifecycleScope.launch {...}

Use MutableSharedFlow instead of MutableStateFlow, MutableSharedFlow doesn't require initial value, and you can get rid of nullable generic type:

val pictureElement = MutableSharedFlow<InspirationQuotesDetailsResponse>()

But I guess we can get rid of it.

Method create() in GetRandomPictureItemUseCase returns a Flow that emits only one value, does it really need to be Flow, or it can be just a simple suspend function?

Assuming we stick to Flow in GetRandomPictureItemUseCase class, ViewModel can look something like the following:

val randomPicture: Flow<InspirationQuotesDetailsResponse> = getRandomPictureItemUseCase.build(Unit)

And in the Fragment:

private fun makeApiRequest() = lifecycleScope.launch {
    vm.randomPicture
      .flowWithLifecycle(lifecycle, State.STARTED)
      .collect { response ->
          // .. use response
      }
}

Dependency to use lifecycleScope:

implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.4.0'

Answered By - Sergey