A modern programming language that makes developers happier.

kotlinlang

Sem título.kt

Hello, how do i make this idea work :
api.stream is reading a websocket, the idea is to update a variable every time it receives a websocket message.

You can use a lambda:
```suspend fun updateState(api: Api, onRecieve: (String) -&gt; Unit) {
    val notify =  Channel&lt;String&gt;()
    api.stream(notify)
    while(true) {
        onRecieve(notify.receive())
    }
}  

@SuppressLint("CoroutineCreationDuringComposition")
@Composable
fun SomeComposable(api: Api, locationViewModel: LocationViewModel = viewModel()) {
    var state by remember { mutableStateOf("") }
    val composableScope = rememberCoroutineScope()
    composableScope.launch {
        updateState(api, onRecieve = { state = it })
    }
}```

This makes the api.stream goes on some loop and connect multiple times instead of one time and just reading

<https://developer.android.com/jetpack/compose/side-effects#launchedeffect>

I guess you can use your api as the key since it will relaunch when your api changes

Also, shouldn't the `updateState` be in your view model?

Any idea why it prints "" then the real state value ?

Because the initial value of your state is an empty string

Any way to the variable only holds the newer value ?

Sem_titulo.kt

I'm using the view model to store some coordinates that changes when the user click on a map

You can make the state null initially or ~maybe use a flow~

You can make another view model for your api stuff if you don't want it in the location view model

So a viewModel is better than a simple remember in this case?

From what I'm seeing, yes. It's always better to keep the UI separate

Should probably be `fun updateState(api: Api): Flow&lt;String&gt;` that returns a `channelFlow { .... }` . Then you can use `collectAsState()` .

What would be a snippet of this ? i never used a channelFlow before

```fun updateState(api: Api): Flow&lt;String&gt; {
    return channelFlow&lt;String&gt; {
        api.stream(this)
        awaitClose { /* do closing things if needed */ }
    }
}```


```

@SuppressLint("CoroutineCreationDuringComposition")
@Composable
fun SomeComposable(api: Api, locationViewModel: LocationViewModel = viewModel()) {
    val state by remember(api) { updateState(api) }.collectAsState("")
    // do stuff with state
}```


I saw here that it is a experimental api, is this safe to use ?

It was stabilised in the latest release so don't worry about it.