I am not sure, is this code effective?

@Composable
fun Test() {
    var checked by remember { mutableStateOf(isMyServiceRunning()) }
    if (checked) {
        startMyService()
    } else {
        stopMyService()
    }
    Switch(checked = checked, onCheckedChange = { checked = it})
    // ... A lot of others composable functions
}

As far as I understand, one switch will cause recomposition of entire

Test()

function, won't it?

be very careful about how you process state changes. This is one of those things about compose that is going to present a learning curve for the new comers. Many people will incline to introduce a state observer like this without realizing the potential side effects. This composable function might rerun for various reasons. You may add another state in the future without realizing that it will also run the whole function when it mutates. When that happens,

if (checked) {
        startMyService()
    } else {
        stopMyService()
    }

this piece of code will be a headache because even though

checked

state doesn't change, function still runs. Instead, I would recommend you to accept a lambda into this composable which can be triggered from

onCheckedChange

.

When

checked

changes, the

Test

function will recompose. This means it will get reinvoked, but your intuition for how expensive that will be might not be great. In the example you’ve chosen for instance, the

startMyService

stopMyService

and

Switch

calls are all skippable, since their parameters don’t change. As a result, the recomposition of

Test

will be quite efficient

@Halil Ozercan MyService should rely on

checked

variable and not on switch state. In this example only Switch changes

checked

, but I can add another Composable functions in future.