produceState

Functions summary

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

Return an observable snapshot State that produces values over time without a defined data source.
Cmn
State<T>
@Composable
<T : Any?> produceState(initialValue: T, key1: Any?, producer: suspend ProduceStateScope<T>.() -> Unit)

Return an observable snapshot State that produces values over time from key1.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    vararg keys: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

Return an observable snapshot State that produces values over time from keys.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

Return an observable snapshot State that produces values over time from key1 and key2.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    key3: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

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

Functions

produceState

Cmn 
@Composable
fun <T : Any?> 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:

import androidx.compose.foundation.layout.Column
import androidx.compose.runtime.produceState

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}")
            }
        }
}
 
import androidx.compose.runtime.produceState

val currentPerson by
    produceState<Person?>(null, viewModel) {
        val disposable = viewModel.registerPersonObserver { person -> value = person }

        awaitDispose { disposable.dispose() }
    }

produceState

Cmn 
@Composable
fun <T : Any?> 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:

import androidx.compose.foundation.layout.Column
import androidx.compose.runtime.produceState

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}")
            }
        }
}
 
import androidx.compose.runtime.produceState

val currentPerson by
    produceState<Person?>(null, viewModel) {
        val disposable = viewModel.registerPersonObserver { person -> value = person }

        awaitDispose { disposable.dispose() }
    }

produceState

Cmn 
@Composable
fun <T : Any?> 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:

import androidx.compose.foundation.layout.Column
import androidx.compose.runtime.produceState

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}")
            }
        }
}
 
import androidx.compose.runtime.produceState

val currentPerson by
    produceState<Person?>(null, viewModel) {
        val disposable = viewModel.registerPersonObserver { person -> value = person }

        awaitDispose { disposable.dispose() }
    }

produceState

Cmn 
@Composable
fun <T : Any?> 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:

import androidx.compose.foundation.layout.Column
import androidx.compose.runtime.produceState

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}")
            }
        }
}
 
import androidx.compose.runtime.produceState

val currentPerson by
    produceState<Person?>(null, viewModel) {
        val disposable = viewModel.registerPersonObserver { person -> value = person }

        awaitDispose { disposable.dispose() }
    }

produceState

Cmn 
@Composable
fun <T : Any?> 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.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:

import androidx.compose.foundation.layout.Column
import androidx.compose.runtime.produceState

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}")
            }
        }
}
 
import androidx.compose.runtime.produceState

val currentPerson by
    produceState<Person?>(null, viewModel) {
        val disposable = viewModel.registerPersonObserver { person -> value = person }

        awaitDispose { disposable.dispose() }
    }