androidx.compose.runtime

Kotlin |Java

Interfaces

Applier	An Applier is responsible for applying the tree-based operations that get emitted during a composition.
Composer	Composer is the interface that is targeted by the Compose Kotlin compiler plugin and used by code generation helpers.
Composition	A composition object is usually constructed for you, and returned from an API that is used to initially compose a UI.
ControlledComposition	A controlled composition is a Composition that can be directly controlled by the caller.
DisposableEffectResult
MonotonicFrameClock	Provides a time source for display frames and the ability to perform an action on the next frame.
MutableState	A mutable value holder where reads to the value property during the execution of a Composable function, the current RecomposeScope will be subscribed to changes of that value.
ProduceStateScope	Receiver scope for use with produceState.
RecomposerInfo	Read-only information about a Recomposer.
RecomposeScope	Represents a recomposable scope or section of the composition hierarchy.
RememberObserver	Objects implementing this interface are notified when they are initially used in a composition and when they are no longer being used.
ScopeUpdateScope	Internal compose compiler plugin API that is used to update the function the composer will call to recompose a recomposition scope.
SnapshotMutationPolicy	A policy to control how the result of mutableStateOf report and merge changes to the state object.
State	A value holder where reads to the value property during the execution of a Composable function, the current RecomposeScope will be subscribed to changes of that value.

Classes

AbstractApplier	An abstract Applier implementation.
AtomicReference
BroadcastFrameClock	A simple frame clock.
CompositionContext	A CompositionContext is an opaque type that is used to logically "link" two compositions together.
CompositionLocal	Compose passes data through the composition tree explicitly through means of parameters to composable functions.
DisposableEffectScope	Receiver scope for DisposableEffect that offers the onDispose clause that should be the last statement in any call to DisposableEffect.
PausableMonotonicFrameClock	A MonotonicFrameClock wrapper that can be paused and resumed.
ProvidableCompositionLocal	A ProvidableCompositionLocal can be used in CompositionLocalProvider to provide values.
ProvidedValue	An instance to hold a value provided by CompositionLocalProvider and is created by the ProvidableCompositionLocal.provides infixed operator.
Recomposer	The scheduler for performing recomposition and applying updates to one or more Compositions.
SkippableUpdater
Updater	A helper receiver scope class used by ComposeNode to help write code to initialized and update a node.

Annotations

CheckResult
Composable	Composable functions are the fundamental building blocks of an application built with Compose.
ComposeCompilerApi
DisallowComposableCalls	This will prevent composable calls from happening inside of the function that it applies to.
ExperimentalComposeApi
ExplicitGroupsComposable	This annotation can be applied to Composable functions so that no groups will be generated in the body of the function it annotates.
Immutable	Immutable can be used to mark class as producing immutable instances.
InternalComposeApi
NoLiveLiterals	This annotation is used to indicate to the Compose Compiler to not attempt to generate live literals inside the scope of the declaration it is applied to, even when the live literals code generation is turned on.
NonRestartableComposable	This annotation can be applied to Composable functions in order to prevent code from being generated which allow this function's execution to be skipped or restarted.
ReadOnlyComposable	This annotation can be applied to Composable functions so that no group will be generated around the body of the function it annotates.
Stable	Stable is used to communicate some guarantees to the compose compiler about how a certain type or function will behave.
StableMarker	StableMarker marks an annotation as indicating a type is stable.
TestOnly

Top-level functions summary

Unit	ComposeNode(noinline factory: () -> T, update: Updater<T>.() -> Unit) Emits a node into the composition of type T.
Unit	ComposeNode(noinline factory: () -> T, update: Updater<T>.() -> Unit, content: () -> Unit) Emits a node into the composition of type T.
Unit	ComposeNode(noinline factory: () -> T, update: Updater<T>.() ->