Lifecycle bound collectAsState

CollectAsStateWhile.kt

import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.Lifecycle.State.CREATED
import androidx.lifecycle.Lifecycle.State.STARTED
import androidx.lifecycle.flowWithLifecycle
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.StateFlow

@Composable
fun <R> StateFlow<R>.collectAsStateWhileCreated(): State<R> =
    collectAsStateWhile(minActiveState = CREATED)

@Composable
fun <R> StateFlow<R>.collectAsStateWhileStarted(): State<R> =
    collectAsStateWhile(minActiveState = STARTED)

@Composable
fun <R> StateFlow<R>.collectAsStateWhile(
    minActiveState: Lifecycle.State,
): State<R> = collectAsStateWhile(
    minActiveState = minActiveState,
    default = remember { value },
)

@Composable
fun <R> Flow<R>.collectAsStateWhileCreated(
    default: R,
): State<R> = collectAsStateWhile(
    minActiveState = CREATED,
    default = default,
)

@Composable
fun <R> Flow<R>.collectAsStateWhileStarted(
    default: R,
): State<R> = collectAsStateWhile(
    minActiveState = STARTED,
    default = default,
)

@Composable
fun <R> Flow<R>.collectAsStateWhile(
    minActiveState: Lifecycle.State,
    default: R,
): State<R> {
    @Suppress("NON_EXHAUSTIVE_WHEN")
    when (minActiveState) {
        Lifecycle.State.INITIALIZED,
        Lifecycle.State.DESTROYED -> {
            throw IllegalArgumentException("Only supports lifecycle states CREATED, STARTED and RESUMED")
        }
    }
    val lifecycleOwner = LocalLifecycleOwner.current
    return remember(default, lifecycleOwner) {
        flowWithLifecycle(
            lifecycle = lifecycleOwner.lifecycle,
            minActiveState = minActiveState,
        )
    }.collectAsState(initial = default)
}