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. This can be changed by providing a SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@Composable
public fun <T> produceState(
initialValue: T,
mutationPolicy: SnapshotMutationPolicy<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 given mutationPolicy is used to control how changes are reported and merged in the returned state. If not specified, the default behavior is structuralEqualityPolicy, which conflates values that are equal to each other. Note observers may only see the latest value if several values are set in rapid succession. This is especially true when reading the returned state in composition, as composition executes with the latest values from a snapshot rather than composing once with each intermediate value of a state.
The mutationPolicy is only used when initializing the underlying state object. If the mutationPolicy changes after creating the state, the state and the producer are unaffected and will continue collecting in the previously returned state with the original SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| mutationPolicy | A policy used to control how changes are handled in the returned state |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@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. This can be changed by providing a SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| key1 | A key that, when changed, will restart the producer lambda |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@Composable
public fun <T> produceState(
initialValue: T,
key1: Any?,
mutationPolicy: SnapshotMutationPolicy<T>,
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 given mutationPolicy is used to control how changes are reported and merged in the returned state. If not specified, the default behavior is structuralEqualityPolicy, which conflates values that are equal to each other. Note observers may only see the latest value if several values are set in rapid succession. This is especially true when reading the returned state in composition, as composition executes with the latest values from a snapshot rather than composing once with each intermediate value of a state.
Changes to the mutationPolicy and initialValue are ignored.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| key1 | A key that, when changed, will restart the producer lambda |
| mutationPolicy | A policy used to control how changes are handled in the returned state |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@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. This can be changed by providing a SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| key1 | A key that, when changed, will restart the producer lambda |
| key2 | A key that, when changed, will restart the producer lambda |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@Composable
public fun <T> produceState(
initialValue: T,
key1: Any?,
key2: Any?,
mutationPolicy: SnapshotMutationPolicy<T>,
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 given mutationPolicy is used to control how changes are reported and merged in the returned state. If not specified, the default behavior is structuralEqualityPolicy, which conflates values that are equal to each other. Note observers may only see the latest value if several values are set in rapid succession. This is especially true when reading the returned state in composition, as composition executes with the latest values from a snapshot rather than composing once with each intermediate value of a state.
The mutationPolicy is only used when initializing the underlying state object. If the mutationPolicy changes after creating the state, the state and the producer are unaffected and will continue collecting in the previously returned state with the original SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| key1 | A key that, when changed, will restart the producer lambda |
| key2 | A key that, when changed, will restart the producer lambda |
| mutationPolicy | A policy used to control how changes are handled in the returned state |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@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.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. This can be changed by providing a SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| key1 | A key that, when changed, will restart the producer lambda |
| key2 | A key that, when changed, will restart the producer lambda |
| key3 | A key that, when changed, will restart the producer lambda |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@Composable
public fun <T> produceState(
initialValue: T,
key1: Any?,
key2: Any?,
key3: Any?,
mutationPolicy: SnapshotMutationPolicy<T>,
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 given mutationPolicy is used to control how changes are reported and merged in the returned state. If not specified, the default behavior is structuralEqualityPolicy, which conflates values that are equal to each other. Note observers may only see the latest value if several values are set in rapid succession. This is especially true when reading the returned state in composition, as composition executes with the latest values from a snapshot rather than composing once with each intermediate value of a state.
The mutationPolicy is only used when initializing the underlying state object. If the mutationPolicy changes after creating the state, the state and the producer are unaffected and will continue collecting in the previously returned state with the original SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| key1 | A key that, when changed, will restart the producer lambda |
| key2 | A key that, when changed, will restart the producer lambda |
| key3 | A key that, when changed, will restart the producer lambda |
| mutationPolicy | A policy used to control how changes are handled in the returned state |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@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. This can be changed by providing a SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| keys | A list of keys that, when changed, will restart the producer lambda |
| producer | A suspending lambda that defines what values are emitted to the returned state |
produceState
@Composable
public fun <T> produceState(
initialValue: T,
vararg keys: Any?,
mutationPolicy: SnapshotMutationPolicy<T>,
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 given mutationPolicy is used to control how changes are reported and merged in the returned state. If not specified, the default behavior is structuralEqualityPolicy, which conflates values that are equal to each other. Note observers may only see the latest value if several values are set in rapid succession. This is especially true when reading the returned state in composition, as composition executes with the latest values from a snapshot rather than composing once with each intermediate value of a state.
The mutationPolicy is only used when initializing the underlying state object. If the mutationPolicy changes after creating the state, the state and the producer are unaffected and will continue collecting in the previously returned state with the original SnapshotMutationPolicy.
produceState may be used to observe either suspending or non-suspending sources of external data, for example:
Parameters
| initialValue | The value that the returned state will initially contain |
| keys | A list of keys that, when changed, will restart the producer lambda |
| mutationPolicy | A policy used to control how changes are handled in the returned state |
| producer | A suspending lambda that defines what values are emitted to the returned state |
