What's the best way for me to collect this stateFlow boolean just to log it? Option 1 ```@Composabl...

# compose

[Colton Idle]

What's the best way for me to collect this stateFlow boolean just to log it?

Option 1

@Composable
fun App() {
    LaunchedEffect(Unit) {
        applicationScope.launch {
            connection?.isConnected?.collectLatest {
                Logger.i { "connected? $it" }
            } } }

no logs

Option 2

@Composable
fun App() {
        applicationScope.launch {
            connection?.isConnected?.collectLatest {
                Logger.i { "connected? $it" }
            } } }

I get double logs

[jw]

Option 2 is just wrong. You'll get a new coroutine for each recomposition.

[jw]

Side effects should not be put directly in a composition

[jw]

Seems like something you might want to hoist outside of the composition entirely

[Seri]

Option 1 may not execute the log if your states are null (connection?.isConnected?.) on the first frame of composition

[Colton Idle]

I tried hoisting out of the App composable entirely and just having it in the top level of my App.kt file... but that also doesn't work. I guess I would need to do it in the init {} block of App.kt?

[Landry Norris]

Would it make sense to use connection?.isConnected as the key for LaunchedEffect? That would also allow you to update if the value changes.

[jw]

That only works if connection is observable by Compose

[Colton Idle]

so i did leave that out

var connection by mutableStateOf<Connection?>(null)

[jw]

well that only means that changes to the connection instance are observable, not changes to its isConnected value

[Colton Idle]

Okay. so this is kinda ugly... but only single instance of logs... so it works 🎉

@Composable
fun App() {
    LaunchedEffect(Unit) {
        snapshotFlow { connection }
            .collectLatest { conn ->
                conn?.isConnected?.collectLatest {
                    Logger.i { "connected? $it" }
                }
            }
    }

[Colton Idle]

to follow jakes advice though... I am a bit more curious on where I could do this work outside of the composable...

[Colton Idle]

And just to be clear... this IS fine to do in a composable right?

val connected = connection?.isConnected?.collectAsState()

[jw]

only if isConnected returns the same instance each time it's called

[jw]

if you create a new flow instance each time it's called, then you will constantly be collecting and canceling coroutines

[Colton Idle]

Hm. Not sure if I follow 100%

my setup is as such

var connection by mutableStateOf<Connection?>(null)

and then

class Connection {
    private val _isConnected = MutableStateFlow(false)
    val isConnected = _isConnected.asStateFlow()

[Colton Idle]

I guess since

private val _isConnected = MutableStateFlow(false)

is val then I should be good

[jw]

well no, it's because isConnected is a val without a get() that you're good.

[jw]

However, I would do val isConnected: StateFlow<Boolean> get() = _isConnected

[jw]

asStateFlow() is almost always pointless

[Colton Idle]

cool. making progress.

I do still want to move this outside of the Composable, But I'm in a CMP (android+ios) app and basically this is my first "entry point" that is shared. so im trying to do this initial logging in one place

[Colton Idle]

also actually...

However, I would do val isConnected: StateFlow<Boolean> get() = _isConnected

wouldn't that mean that now the consumer can edit this?

[jw]

no, StateFlow is not writable

[Colton Idle]

I updated


private val _isConnected = MutableStateFlow(false)
val isConnected = _isConnected.asStateFlow()

to

private val _isConnected = MutableStateFlow(false)
val isConnected: StateFlow<Boolean> get() = _isConnected

though

[Colton Idle]

oh jeez.

[Colton Idle]

I didn't put the specific type.

[Colton Idle]

okay. now that makes sense.