Side Effects in Compose: LaunchedEffect, SideEffect, and DisposableEffect

@Composable
fun NotesScreen(state: NotesUiState, onMessageShown: () -> Unit) {
    val snackbarHostState = remember { SnackbarHostState() }

    state.userMessage?.let { message ->
        LaunchedEffect(message) {                 // restarts only for a new message
            snackbarHostState.showSnackbar(message)
            onMessageShown()
        }
    }
    Scaffold(snackbarHost = { SnackbarHost(snackbarHostState) }) { padding -> /* ... */ }
}

val listState = rememberLazyListState()
val scope = rememberCoroutineScope()

FloatingActionButton(onClick = {
    scope.launch { listState.animateScrollToItem(0) }   // launched by an event, not by composition
}) { Icon(Icons.Default.KeyboardArrowUp, contentDescription = "Scroll to top") }

@Composable
fun TrackScreenTime(screenName: String, onTimeSpent: (String, Long) -> Unit) {
    val lifecycleOwner = LocalLifecycleOwner.current
    val currentOnTimeSpent by rememberUpdatedState(onTimeSpent)   // always call the latest lambda

    DisposableEffect(lifecycleOwner, screenName) {
        var resumedAt = 0L
        val observer = LifecycleEventObserver { _, event ->
            when (event) {
                Lifecycle.Event.ON_RESUME -> resumedAt = SystemClock.elapsedRealtime()
                Lifecycle.Event.ON_PAUSE -> currentOnTimeSpent(screenName, SystemClock.elapsedRealtime() - resumedAt)
                else -> Unit
            }
        }
        lifecycleOwner.lifecycle.addObserver(observer)
        onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }   // always paired
    }
}

@Composable
fun SplashTimeout(onTimeout: () -> Unit) {
    val latestOnTimeout by rememberUpdatedState(onTimeout)
    LaunchedEffect(Unit) {                 // don't restart the timer when the lambda changes...
        delay(2_000)
        latestOnTimeout()                  // ...but still call the newest one
    }
}

SideEffect { analytics.setUserProperty("theme", if (isDark) "dark" else "light") }

@Composable
fun rememberBatteryLevel(context: Context): State<Int?> = produceState<Int?>(initialValue = null, context) {
    val receiver = object : BroadcastReceiver() {
        override fun onReceive(c: Context, i: Intent) { value = i.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) }
    }
    ContextCompat.registerReceiver(context, receiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED), ContextCompat.RECEIVER_NOT_EXPORTED)
    awaitDispose { context.unregisterReceiver(receiver) }
}