ProvidableCompositionLocal
- Cmn
abstract class ProvidableCompositionLocal<T : Any?> : CompositionLocal
| kotlin.Any | ||
| ↳ | androidx.compose.runtime.CompositionLocal | |
| ↳ | androidx.compose.runtime.ProvidableCompositionLocal | |
A ProvidableCompositionLocal can be used in CompositionLocalProvider to provide values.
Summary
Public functions | ||
|---|---|---|
infix ProvidedValue<T> | provides(value: T)Associates a | Cmn |
infix ProvidedValue<T> | providesComputed(compute: CompositionLocalAccessorScope.() -> T)Associates a | Cmn |
infix ProvidedValue<T> | providesDefault(value: T)Associates a | Cmn |
Inherited properties | |||
|---|---|---|---|
|
Public functions
provides
infix fun provides(value: T): ProvidedValue<T>
Associates a CompositionLocal key to a value in a call to CompositionLocalProvider.
providesComputed
infix fun providesComputed(compute: CompositionLocalAccessorScope.() -> T): ProvidedValue<T>
Associates a CompositionLocal key to a lambda, compute, in a call to CompositionLocal. The compute lambda is invoked whenever the key is retrieved. The lambda is executed in the context of a CompositionLocalContext which allow retrieving the current values of other composition locals by calling CompositionLocalAccessorScope.currentValue, which is an extension function provided by the context for a CompositionLocal key.
The lambda passed to providesComputed will be invoked every time the CompositionLocal.current is evaluated for the composition local and computes its value based on the current value of the locals referenced in the lambda at the time CompositionLocal.current is evaluated. This allows providing values that can be derived from other locals. For example, if accent colors can be calculated from a single base color, the accent colors can be provided as computed composition locals. Providing a new base color would automatically update all the accent colors.
import androidx.compose.runtime.Composable import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.runtime.compositionLocalOf val LocalValue = compositionLocalOf { 10 } val LocalLargerValue = compositionLocalOf { 12 } @Composable fun App() { CompositionLocalProvider( LocalLargerValue providesComputed { LocalValue.currentValue + 10 } ) { SomeScreen() } }
import androidx.compose.runtime.Composable import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.runtime.compositionLocalOf import androidx.compose.runtime.compositionLocalWithComputedDefaultOf val LocalValue = compositionLocalOf { 10 } val LocalLargerValue = compositionLocalOf { 12 } val LocalComputedValue = compositionLocalWithComputedDefaultOf { LocalValue.currentValue + 4 } // In this example `LocalLargerValue` needs to be re-provided // whenever `LocalValue` is provided to keep its value larger // then `LocalValue`. However, `LocalComputedValue` does not // need to be re-provided to stay larger than `LocalValue` as // it is calculated based on the currently provided value for // `LocalValue`. Whenever `LocalValue` is provided the value // of `LocalComputedValue` is computed based on the currently // provided value for `LocalValue`. @Composable fun App() { // Value is 10, the default value for LocalValue val value = LocalValue.current // Value is 12, the default value val largerValue = LocalLargerValue.current // Value is computed to be 14 val computedValue = LocalComputedValue.current CompositionLocalProvider(LocalValue provides 20) { // Value is 20 provided above val nestedValue = LocalValue.current // Value is still 12 as an updated value was not re-provided val nestedLargerValue = LocalLargerValue.current // Values is computed to be 24; LocalValue.current + 4 val nestedComputedValue = LocalComputedValue.current CompositionLocalProvider(LocalLargerValue provides LocalValue.current + 2) { // Value is 22 provided above val newLargerValue = LocalLargerValue.current CompositionLocalProvider(LocalValue provides 50) { // Value is now 50 provided above val finalValue = LocalValue.current // Value is still 22 val finalLargerValue = LocalLargerValue.current // Value is now computed to be 54 val finalComputed = LocalComputedValue.current } } } }
providesDefault
infix fun providesDefault(value: T): ProvidedValue<T>
Associates a CompositionLocal key to a value in a call to CompositionLocalProvider if the key does not already have an associated value.