Hi all, I was trying to use `callbackFlow { }` but the code inside the block never gets called, am I...

# coroutines

[Sergio C.]

Hi all, I was trying to use callbackFlow { } but the code inside the block never gets called, am I doing something wrong?

[Joffrey]

If you share how you declare and use your callbackFlow, we should be able to answer this 😉

[ephemient]

flow() and channelFlow() are cold flows, they only run when collected

[Sergio C.]

already rewritten everything but I had a ViewModel with

fun getSensors(): LiveData<ReadResult> {
    return sensorsRepository.getSensorsFLow().asLiveData()
}

in the repository

private var data: Flow<ReadResult> = MutableSharedFlow()
init {
    CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>).launch {
        val dataStore: DataStore<AppPreferences> = app.appPreferencesStore
        dataStore.data.catch {
            updateObservers(AppPreferences.getDefaultInstance())
        }.collectLatest {
            updateObservers(it)
        }
    }
}
private fun updateObservers(appPreferences: AppPreferences) {
    stopSensors()
    when (appPreferences.selectedDevice) {
        AppPreferences.Device.SUNI -> initSuniReader()
        AppPreferences.Device.TZ702 -> initTZReader()
        AppPreferences.Device.NEXPEK7 -> initNexpekReader()
        else -> flowOf(ReadResul())
    }
}
private fun initNexpek(): Flow<ReadResult> {
    return callbackFlow<ReadResult> {
        init sensor and wait for callback
        trySend(the result)
     }
 }

[Sergio C.]

Sensor was not initiated

[Sergio C.]

Now I have

private var data: MutableSharedFlow<ReadResult> = MutableSharedFlow()

and everyone sends data to it with tryEmit

[Joffrey]

You probably forgot the awaitClose() call at the end of the callbackFlow block

[Joffrey]

But note that callbackFlow is meant for multi-shot callbacks. If you want to encapsulate a single-shot callback you should make a suspend function returning a single value instead of a flow, and you can build that function using suspendCancellableCoroutine. I'm not sure which one is your case though

[Sergio C.]

just add awaitClose() inside the lock?

[Sergio C.]

I can have multiple return events from the sensor

[Sergio C.]

I will try this later

[Sergio C.]

thanks for the tips

[Joffrey]

In general if you want to encapsulate a multi-shot callback into a Flow, you also want to unregister the callback / stop the emitter when the flow is cancelled or completed. This is what you would do inside the awaitClose { } block. Check the documentation of callbackFlow

[Sergio C.]

ok

[Sergio C.]

I need more practice with Flows.

[Sergio C.]

also using tryEmit from different places to the same MutableSharedFlow seems like a valid approach, what do you think?

[ephemient]

updating a MutableStateFlow from different places would be the closest equivalent to LiveData (without being tied to the UI thread)

[ephemient]

having mutation from multiple places does not sound like a good design, though

[Sergio C.]

ok. any other approach I could take?

[gildor]

Cold flow is usually better approach. It really depends on your case