This annotation can be applied to Composable functions and provide metadata to the compiler that imply compose-specific contracts that the author of the function is guaranteeing the function complies with.

ComposeCompilerApi

common

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS])

annotation class ComposeCompilerApi

Composer

common

class Composer<N>(applier: Applier<N>, parentReference: CompositionReference)

Implementation of a composer for mutable tree.

Composition

common

interface Composition

A composition object is usually constructed for you, and returned from an API that is used to initially compose a UI.

CompositionData

common

interface CompositionData

A CompositionData is the data tracked by the composer during composition.

CompositionGroup

common

interface CompositionGroup : CompositionData

CompositionGroup is a group of data slots tracked independently by composition.

CompositionLifecycleObserver

common

interface CompositionLifecycleObserver

Objects implementing this interface are notified when they are initially used in a composition and when they are no longer being used.

CompositionReference

common

abstract class CompositionReference

A CompositionReference is an opaque type that is used to logically "link" two compositions together.

DisposableEffectDisposable

common

interface DisposableEffectDisposable

DisposableEffectScope

common

class DisposableEffectScope

Receiver scope for DisposableEffect that offers the onDispose clause that should be the last statement in any call to DisposableEffect.

EmbeddingContext

common

interface EmbeddingContext

ExperimentalComposeApi

common

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY])

annotation class ExperimentalComposeApi

FrameManager

common

object FrameManager

The frame manager manages how changes to state objects are observed.

Immutable

common

@Target(allowedTargets = [AnnotationTarget.CLASS])

@StableMarker()

annotation class Immutable

Immutable can be used to mark class as producing immutable instances.

InternalComposeApi

common

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY])

annotation class InternalComposeApi

KeyInfo

common

class KeyInfo

Information about groups and their keys.

MainThread

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.CONSTRUCTOR])

annotation class MainThread

MutableState

common

@Stable()

interface MutableState<T> : State<T>

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.

NoLiveLiterals

common

@Target(allowedTargets = [AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.CLASS, AnnotationTarget.FILE])

annotation class 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.

ProduceStateScope

common

interface ProduceStateScope<T> : MutableState<T> , CoroutineScope

Receiver scope for use with produceState.

ProvidableAmbient

common

@Stable()

abstract class ProvidableAmbient<T> : Ambient<T>

A ProvidableAmbient can be used in Providers to provide values.

ProvidedValue

common

class ProvidedValue<T>

An instance to hold a value provided by Providers and is created by the ProvidableAmbient.provides infixed operator.

Recomposer

common

class Recomposer(effectCoroutineContext: CoroutineContext) : CompositionReference

The scheduler for performing recomposition and applying updates to one or more Compositions.

ScopeUpdateScope

common

interface ScopeUpdateScope

Internal compose compiler plugin API that is used to update the function the composer will call to recompose a recomposition scope.

SkippableUpdater

common

class SkippableUpdater<T>

SnapshotMutationPolicy

common

interface SnapshotMutationPolicy<T>

A policy to control how the result of mutableStateOf report and merge changes to the state object.

Stable

common

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY])

@StableMarker()

annotation class Stable

Stable is used to communicate some guarantees to the compose compiler about how a certain type or function will behave.

StableMarker

common

@Target(allowedTargets = [AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS])

annotation class StableMarker

StableMarker marks an annotation as indicating a type is stable.

State

common

@Stable()

interface State<T>

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.

TestOnly

common

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER])

annotation class TestOnly

UnionType

common

@Target(allowedTargets = [AnnotationTarget.TYPE, AnnotationTarget.TYPE_PARAMETER])

annotation class UnionType(types: KClass<*>)

Updater

common

class Updater<T>

WeakHashMap

common

class WeakHashMap<K, V> : MutableMap<K, V>

Functions

ambientOf

common

fun <T> ambientOf(policy: SnapshotMutationPolicy<T> = @OptIn(ExperimentalComposeApi::class) structuralEqualityPolicy(), defaultFactory: () -> T? = null): ProvidableAmbient<T>

Create an ambient key that can be provided using Providers.

clearRoots

common

@TestOnly()

fun clearRoots()

collectAsState

common

@ExperimentalCoroutinesApi()

Package androidx.compose.runtime

Types

Functions

Properties