produceState

@Composable
public fun <T> produceState(
    initialValue: T,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>

Return an observable snapshot State that produces values over time without a defined data source.

producer is launched when produceState enters the composition and is cancelled when produceState leaves the composition. producer should use ProduceStateScope.value to set new values on the returned State.

The returned State conflates values; no change will be observable if ProduceStateScope.value is used to set a value that is equal to its old value, and observers may only see the latest value if several values are set in rapid succession.

produceState may be used to observe either suspending or non-suspending sources of external data, for example:

@Composable
public fun <T> produceState(
    initialValue: T,
    key1: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>

Return an observable snapshot State that produces values over time from key1.

producer is launched when produceState enters the composition and is cancelled when produceState leaves the composition. If key1 changes, a running producer will be cancelled and re-launched for the new source. producer should use ProduceStateScope.value to set new values on the returned State.

The returned State conflates values; no change will be observable if ProduceStateScope.value is used to set a value that is equal to its old value, and observers may only see the latest value if several values are set in rapid succession.

produceState may be used to observe either suspending or non-suspending sources of external data, for example:

@Composable
public fun <T> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>

Return an observable snapshot State that produces values over time from key1 and key2.

producer is launched when produceState enters the composition and is cancelled when produceState leaves the composition. If key1 or key2 change, a running producer will be cancelled and re-launched for the new source. producer should use ProduceStateScope.value to set new values on the returned State.

The returned State conflates values; no change will be observable if ProduceStateScope.value is used to set a value that is equal to its old value, and observers may only see the latest value if several values are set in rapid succession.

produceState may be used to observe either suspending or non-suspending sources of external data, for example:

@Composable
public fun <T> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    key3: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>

Return an observable snapshot State that produces values over time from key1, key2 and key3.

producer is launched when produceState enters the composition and is cancelled when produceState leaves the composition. If key1, key2 or key3 change, a running producer will be cancelled and re-launched for the new source. producer should use ProduceStateScope.valueto set new values on the returnedState`.

The returned State conflates values; no change will be observable if ProduceStateScope.value is used to set a value that is equal to its old value, and observers may only see the latest value if several values are set in rapid succession.

produceState may be used to observe either suspending or non-suspending sources of external data, for example:

@Composable
public fun <T> produceState(
    initialValue: T,
    vararg keys: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>

Return an observable snapshot State that produces values over time from keys.

producer is launched when produceState enters the composition and is cancelled when produceState leaves the composition. If keys change, a running producer will be cancelled and re-launched for the new source. producer should use ProduceStateScope.value to set new values on the returned State.

The returned State conflates values; no change will be observable if ProduceStateScope.value is used to set a value that is equal to its old value, and observers may only see the latest value if several values are set in rapid succession.

produceState may be used to observe either suspending or non-suspending sources of external data, for example:

Code Examples

ProduceState

@Composable
fun ProduceState(viewModel: ProduceStateSampleViewModel) {
    val uiState by
        produceState<UiState<List<Person>>>(UiState.Loading, viewModel) {
            viewModel.people.map { UiState.Data(it) }.collect { value = it }
        }
    when (val state = uiState) {
        is UiState.Loading -> Text("Loading...")
        is UiState.Data ->
            Column {
                for (person in state.data) {
                    Text("Hello, ${person.name}")
                }
            }
    }
}

ProduceStateAwaitDispose

@Suppress("UNUSED_VARIABLE")
@Composable
fun ProduceStateAwaitDispose(viewModel: ProduceStateSampleViewModel) {
    val currentPerson by
        produceState<Person?>(null, viewModel) {
            val disposable = viewModel.registerPersonObserver { person -> value = person }
            awaitDispose { disposable.dispose() }
        }
}