androidx.compose.runtime

Kotlin |Java

Comuni/TuttiAndroid/JVM

In questa pagina troverai la documentazione relativa ai tipi, alle proprietà e alle funzioni disponibili nel pacchetto androidx.compose.runtime. Ad esempio:

• API di stato come State, remember, mutableStateOf e collectAsState.

• API per gli effetti collaterali, come LaunchedEffect e SideEffect.

• API correlate alle coroutine, come rememberCoroutineScope e snapshotFlow.

• API di CompositionLocal come compositionLocalOf.

• API correlate alla composizione, come Composition, Recomposer, ComposeNode e RecomposeScope.

• API Orologio come MonotonicFrameClock, withFrameMillis,

• Alcune annotazioni, come Composable e Stable.

Se invece stai cercando una guida, consulta le seguenti guide di Compose:

• Pensare in Compose.

• Gestione dello stato in Compose.

• Ciclo di vita dei componibili.

• Effetti collaterali in Compose.

Interfacce

Applier	Un applicatore è responsabile dell'applicazione delle operazioni basate su albero che vengono emesse durante una composizione.	CM
ComposeNodeLifecycleCallback	Osserva il ciclo di vita del nodo generato con ReusableComposeNode o ComposeNode all'interno di ReusableContentHost e ReusableContent.	CM
Composer	Composer è l'interfaccia scelta come target dal plug-in del compilatore Compose Kotlin e utilizzata dagli helper per la generazione di codice.	CM
Composition	In genere, un oggetto di composizione viene costruito automaticamente e restituito da un'API utilizzata per la composizione iniziale di un'interfaccia utente.	CM
CompositionLocalMap	Uno snapshot di sola lettura immutabile di CompositionLocals impostati in una posizione specifica nella gerarchia di composizione.	CM
CompositionServiceKey	Una chiave per individuare un servizio utilizzando l'interfaccia CompositionServices implementata facoltativamente mediante le implementazioni di Composition.	CM
CompositionServices	Consente di trovare servizi di composizione dal runtime.	CM
CompositionTracer	API di tracciamento interno.	CM
ControlledComposition	Una composizione controllata è un elemento Composition che può essere controllato direttamente dal chiamante.	CM
DisposableEffectResult		CM
DoubleState	Un titolare di valore in cui le letture alla proprietà doubleValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
FloatState	Un titolare di valore in cui le letture alla proprietà floatValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
IntState	Un titolare di valore in cui le letture alla proprietà intValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
LongState	Un titolare di valore in cui le letture alla proprietà longValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
MonotonicFrameClock	Fornisce un'origine del tempo per i frame di visualizzazione e la possibilità di eseguire un'azione sul frame successivo.	CM
MutableDoubleState	Un titolare di valore in cui le letture alla proprietà doubleValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
MutableFloatState	Un titolare di valore in cui le letture alla proprietà floatValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
MutableIntState	Un titolare di valore in cui le letture alla proprietà intValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
MutableLongState	Un titolare di valore in cui le letture alla proprietà longValue durante l'esecuzione di una funzione Composable fanno sì che l'attuale RecomposeScope sottoscriva le modifiche di quel valore.	CM
MutableState	Un contenitore di un valore modificabile che legge alla proprietà value durante l'esecuzione di una funzione Composable, il valore RecomposeScope corrente verrà sottoscritto alle modifiche di quel valore.	CM
ProduceStateScope	Ambito del destinatario per l'utilizzo con produceState.	CM
RecomposeScope	Rappresenta un ambito o una sezione ricomponibile della gerarchia di composizione.	CM
RecomposerInfo	Informazioni di sola lettura su un Recomposer.	CM
RememberObserver	Gli oggetti che implementano questa interfaccia vengono avvisati quando vengono utilizzati inizialmente in una composizione e quando non vengono più utilizzati.	CM
ReusableComposition	Un ReusableComposition è un Composition che può essere riutilizzato per diversi contenuti componibili.	CM
ScopeUpdateScope	API per il plug-in del compilatore interno di composizione utilizzata per aggiornare la funzione che il compositore chiama per ricomporre un ambito di ricomposizione.	CM
SnapshotMutationPolicy	Un criterio per controllare il modo in cui il risultato di mutableStateOf segnala e unisce le modifiche all'oggetto di stato.	CM
State	Un titolare di valore in cui legge la proprietà value durante l'esecuzione di una funzione Composable, il valore RecomposeScope corrente verrà sottoscritto alle modifiche di quel valore.	CM

Corsi

AbstractApplier	Un'implementazione Applier astratta.	CM
AtomicReference		CM
BroadcastFrameClock	Un semplice orologio a cornice.	CM
CompositionContext	Un CompositionContext è un tipo opaco che viene utilizzato per "collegare logicamente" due composizioni.	CM
CompositionLocal	Compose trasmette i dati attraverso l'albero della composizione in modo esplicito tramite parametri a funzioni componibili.	CM
CompositionLocalContext	Memorizza gli elementi CompositionLocal e i relativi valori.	CM
DisposableEffectScope	Ambito del destinatario per DisposableEffect che offre la clausola onDispose che dovrebbe essere l'ultima istruzione in qualsiasi chiamata a DisposableEffect.	CM
MovableContent	Un'API del plug-in di compilazione Compose.	CM
MovableContentState	Un'API del plug-in di compilazione Compose.	CM
MovableContentStateReference	Un'API del plug-in di compilazione Compose.	CM
PausableMonotonicFrameClock	Un wrapper MonotonicFrameClock che può essere paused e resumed.	CM
ProvidableCompositionLocal	È possibile utilizzare un ProvidableCompositionLocal in CompositionLocalProvider per fornire valori.	CM
ProvidedValue	Un'istanza per contenere un valore fornito da CompositionLocalProvider e creata dall'operatore infisso ProvidableCompositionLocal.provides.	CM
Recomposer	Lo scheduler per la ricomposizione e l'applicazione degli aggiornamenti a uno o più Composition.	CM
SkippableUpdater		CM
Updater	Una classe di ambito ricevitore helper utilizzata da ComposeNode per aiutare a scrivere il codice per inizializzare e aggiornare un nodo.	CM

Oggetti

MonotonicFrameClock.Key

CM

Annotazioni

CheckResult		CM Android
Composable	Le funzioni Composable sono i componenti di base fondamentali di un'applicazione creata con Compose.	CM
ComposableInferredTarget	Un'annotazione generata dal plug-in di compilazione di Composer.	CM
ComposableOpenTarget	L'Composable dichiara che non si aspetta un determinato applicatore.	CM
ComposableTarget	È stato dichiarato che la funzione Composable prevede un applicatore con il nome applier.	CM
ComposableTargetMarker	Questa annotazione viene utilizzata per contrassegnare un'annotazione come equivalente utilizzando ComposableTarget con il nome completo dell'annotazione contrassegnata come valore applier.	CM
ComposeCompilerApi		CM
DisallowComposableCalls	Ciò impedirà le chiamate componibili all'interno della funzione a cui si applica.	CM
ExperimentalComposeApi		CM
ExperimentalComposeRuntimeApi		CM
ExplicitGroupsComposable	Questa annotazione può essere applicata alle funzioni Composable in modo che non vengano generati gruppi nel corpo della funzione annotata.	CM
Immutable	Immutable può essere utilizzato per contrassegnare la classe come produzione di istanze immutabili.	CM
InternalComposeApi		CM
InternalComposeTracingApi		CM
NoLiveLiterals	Questa annotazione viene utilizzata per indicare al compilatore di Compose di non tentare di generare valori letterali attivi nell'ambito della dichiarazione a cui viene applicata, anche quando la generazione del codice dei valori letterali attivi è attivata.	CM
NonRestartableComposable	Questa annotazione può essere applicata alle funzioni Composable per impedire la generazione di codice che consente di saltare o riavviare l'esecuzione di questa funzione.	CM
ReadOnlyComposable	Questa annotazione può essere applicata alle funzioni Composable in modo che non venga generato nessun gruppo intorno al corpo della funzione annotata.	CM
Stable	La versione stabile viene utilizzata per comunicare alcune garanzie al compilatore di Composer sul comportamento di un determinato tipo o funzione.	CM
StableMarker	StableMarker contrassegna un'annotazione come indicante che un tipo è stabile.	CM
TestOnly		CM

Enum

Recomposer.State

Stati operativi validi di un Recomposer.

CM

Riepilogo funzioni di primo livello

inline Unit	@Composable <T : Any, E : Applier<*>> ComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit ) Emette un nodo nella composizione di tipo T.	CM
inline Unit	@Composable <T : Any?, E : Applier<*>> ComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     content: @Composable () -> Unit ) Emette un nodo nella composizione di tipo T.	CM
inline Unit	@Composable @ExplicitGroupsComposable <T : Any?, E : Applier<*>> ComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit,     content: @Composable () -> Unit ) Emette un nodo nella composizione di tipo T.	CM
Composition	Composition(applier: Applier<*>, parent: CompositionContext) Questo metodo è il modo per iniziare una composizione.	CM
Composition	@ExperimentalComposeApi Composition(     applier: Applier<*>,     parent: CompositionContext,     recomposeCoroutineContext: CoroutineContext ) Crea un Composition utilizzando applier per gestire la composizione, come elemento secondario di parent.	CM
Unit	@Composable CompositionLocalProvider(     context: CompositionLocalContext,     content: @Composable () -> Unit ) CompositionLocalProvider associa i valori a quelli di CompositionLocal, forniti da context.	CM
Unit	@Composable CompositionLocalProvider(     value: ProvidedValue<*>,     content: @Composable () -> Unit ) CompositionLocalProvider associa il valore alla chiave ProvidableCompositionLocal.	CM
Unit	@Composable CompositionLocalProvider(     vararg values: ProvidedValue<*>,     content: @Composable () -> Unit ) CompositionLocalProvider associa i valori a ProvidableCompositionLocal chiavi.	CM
ControlledComposition	@TestOnly ControlledComposition(applier: Applier<*>, parent: CompositionContext) Questo metodo è un modo per avviare una composizione.	CM
ControlledComposition	@TestOnly @ExperimentalComposeApi ControlledComposition(     applier: Applier<*>,     parent: CompositionContext,     recomposeCoroutineContext: CoroutineContext )	CM
Unit	@Composable @NonRestartableComposable DisposableEffect(effect: DisposableEffectScope.() -> DisposableEffectResult) Questa funzione è deprecata. DisposableEffect deve fornire uno o più parametri "key" che definiscano l'identità di DisposableEffect e che determini quando eliminare il suo effetto precedente e avviarne uno nuovo per la nuova chiave.	CM
Unit	@Composable @NonRestartableComposable DisposableEffect(key1: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult) Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di key1 e deve essere annullato o eliminato se key1 cambia o se DisposableEffect lascia la composizione.	CM
Unit	@Composable @NonRestartableComposable DisposableEffect(vararg keys: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult) Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di keys e deve essere annullato o eliminato se cambia il valore di keys o se DisposableEffect lascia la composizione.	CM
Unit	@Composable @NonRestartableComposable DisposableEffect(key1: Any?, key2: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult) Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di key1 o key2 e deve essere annullato o eliminato se key1 o key2 cambiano o se DisposableEffect lascia la composizione.	CM
Unit	@Composable @NonRestartableComposable DisposableEffect(     key1: Any?,     key2: Any?,     key3: Any?,     effect: DisposableEffectScope.() -> DisposableEffectResult ) Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di key1, key2 o key3 e deve essere annullato o eliminato se key1, key2 o key3 cambiano o se DisposableEffect lascia la composizione.	CM
Unit	@Composable LaunchedEffect(block: suspend CoroutineScope.() -> Unit) Questa funzione è deprecata. La funzione LaunchedEffect deve fornire uno o più parametri "key" che definiscano l'identità di LaunchedEffect e che determinino quando annullare la precedente coroutine degli effetti e lanciare un nuovo effetto per la nuova chiave.	CM
Unit	@Composable @NonRestartableComposable LaunchedEffect(key1: Any?, block: suspend CoroutineScope.() -> Unit) Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext.	CM
Unit	@Composable @NonRestartableComposable LaunchedEffect(vararg keys: Any?, block: suspend CoroutineScope.() -> Unit) Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext.	CM
Unit	@Composable @NonRestartableComposable LaunchedEffect(key1: Any?, key2: Any?, block: suspend CoroutineScope.() -> Unit) Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext.	CM
Unit	@Composable @NonRestartableComposable LaunchedEffect(key1: Any?, key2: Any?, key3: Any?, block: suspend CoroutineScope.() -> Unit) Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext.	CM
inline Unit	@Composable <T : Any, E : Applier<*>> ReusableComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit ) Emette un nodo riciclabile nella composizione di tipo T.	CM
inline Unit	@Composable <T : Any?, E : Applier<*>> ReusableComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     content: @Composable () -> Unit ) Emette un nodo riciclabile nella composizione di tipo T.	CM
inline Unit	@Composable @ExplicitGroupsComposable <T : Any?, E : Applier<*>> ReusableComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit,     content: @Composable () -> Unit ) Emette un nodo riciclabile nella composizione di tipo T.	CM
ReusableComposition	ReusableComposition(applier: Applier<*>, parent: CompositionContext) Questo metodo è il modo per avviare una composizione riutilizzabile.	CM
inline Unit	@Composable ReusableContent(key: Any?, content: @Composable () -> Unit) Una funzione di utilità per contrassegnare una composizione come supporto per il riciclo.	CM
inline Unit	@Composable @ExplicitGroupsComposable ReusableContentHost(     active: Boolean,     crossinline content: @Composable () -> Unit ) Una funzione di utilità facoltativa utilizzata durante l'hosting di ReusableContent.	CM
Unit	@Composable @NonRestartableComposable @ExplicitGroupsComposable SideEffect(effect: () -> Unit) Pianifica l'esecuzione di effect quando la composizione corrente viene completata correttamente e applica le modifiche.	CM
ProvidableCompositionLocal<T>	<T : Any?> compositionLocalOf(     policy: SnapshotMutationPolicy<T>,     defaultFactory: () -> T ) Crea una chiave CompositionLocal che possa essere fornita utilizzando CompositionLocalProvider.	CM
State<T>	@StateFactoryMarker <T : Any?> derivedStateOf(calculation: () -> T) Crea un oggetto State il cui State.value è il risultato di calculation.	CM
State<T>	@StateFactoryMarker <T : Any?> derivedStateOf(     policy: SnapshotMutationPolicy<T>,     calculation: () -> T ) Crea un oggetto State il cui State.value è il risultato di calculation.	CM
Boolean	@ComposeCompilerApi isTraceInProgress() API di tracciamento interno.	CM
inline T	@Composable <T : Any?> key(vararg keys: Any?, block: @Composable () -> T) key è un'utilità componibile utilizzata per "raggruppare" o "chiave" un blocco di esecuzione all'interno di una composizione.	CM
@Composable () -> Unit	movableContentOf(content: @Composable () -> Unit) Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable (P) -> Unit	<P : Any?> movableContentOf(content: @Composable (P) -> Unit) Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable (P1, P2) -> Unit	<P1 : Any?, P2 : Any?> movableContentOf(content: @Composable (P1, P2) -> Unit) Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable (P1, P2, P3) -> Unit	<P1 : Any?, P2 : Any?, P3 : Any?> movableContentOf(     content: @Composable (P1, P2, P3) -> Unit ) Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable (P1, P2, P3, P4) -> Unit	<P1 : Any?, P2 : Any?, P3 : Any?, P4 : Any?> movableContentOf(     content: @Composable (P1, P2, P3, P4) -> Unit ) Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable R.() -> Unit	<R : Any?> movableContentWithReceiverOf(content: @Composable R.() -> Unit) Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable R.(P) -> Unit	<R : Any?, P : Any?> movableContentWithReceiverOf(content: @Composable R.(P) -> Unit) Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable R.(P1, P2) -> Unit	<R : Any?, P1 : Any?, P2 : Any?> movableContentWithReceiverOf(     content: @Composable R.(P1, P2) -> Unit ) Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
@Composable R.(P1, P2, P3) -> Unit	<R : Any?, P1 : Any?, P2 : Any?, P3 : Any?> movableContentWithReceiverOf(     content: @Composable R.(P1, P2, P3) -> Unit ) Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.	CM
MutableDoubleState	@StateFactoryMarker mutableDoubleStateOf(value: Double) Restituisce un nuovo MutableDoubleState inizializzato con il passaggio in value	CM
MutableFloatState	@StateFactoryMarker mutableFloatStateOf(value: Float) Restituisce un nuovo MutableFloatState inizializzato con il passaggio in value	CM
MutableIntState	@StateFactoryMarker mutableIntStateOf(value: Int) Restituisce un nuovo MutableIntState inizializzato con il passaggio in value	CM
MutableLongState	@StateFactoryMarker mutableLongStateOf(value: Long) Restituisce un nuovo MutableLongState inizializzato con il passaggio in value	CM
SnapshotStateList<T>	@StateFactoryMarker <T : Any?> mutableStateListOf() Crea un'istanza di MutableList osservabile e che possa essere istantanea.	CM
SnapshotStateList<T>	@StateFactoryMarker <T : Any?> mutableStateListOf(vararg elements: T) Crea un'istanza di MutableList osservabile e che può essere istantanea.	CM
SnapshotStateMap<K, V>	@StateFactoryMarker <K : Any?, V : Any?> mutableStateMapOf() Crea un'istanza di MutableMap<k, v=""> osservabile e che può essere istantanea.</k,>	CM
SnapshotStateMap<K, V>	@StateFactoryMarker <K : Any?, V : Any?> mutableStateMapOf(vararg pairs: Pair<K, V>) Crea un'istanza di MutableMap<k, v=""> osservabile e che può essere istantanea.</k,>	CM
MutableState<T>	@StateFactoryMarker <T : Any?> mutableStateOf(value: T, policy: SnapshotMutationPolicy<T>) Restituisce un nuovo MutableState inizializzato con il passaggio in value	CM
SnapshotMutationPolicy<T>	<T : Any?> neverEqualPolicy() Un criterio non considera mai i valori di un MutableState come equivalenti.	CM
State<T>	@Composable <T : Any?> produceState(initialValue: T, producer: suspend ProduceStateScope<T>.() -> Unit) Restituire un elemento State osservabile snapshot che produce valori nel tempo senza un'origine dati definita.	CM
State<T>	@Composable <T : Any?> produceState(initialValue: T, key1: Any?, producer: suspend ProduceStateScope<T>.() -> Unit) Restituire un valore snapshot State osservabile che produce valori nel tempo da key1.	CM
State<T>	@Composable <T : Any?> produceState(     initialValue: T,     vararg keys: Any?,     producer: suspend ProduceStateScope<T>.() -> Unit ) Restituire un valore snapshot State osservabile che produce valori nel tempo da keys.	CM
State<T>	@Composable <T : Any?> produceState(     initialValue: T,     key1: Any?,     key2: Any?,     producer: suspend ProduceStateScope<T>.() -> Unit ) Restituire un valore snapshot State osservabile che produce valori nel tempo da key1 e key2.	CM
State<T>	@Composable <T : Any?> produceState(     initialValue: T,     key1: Any?,     key2: Any?,     key3: Any?,     producer: suspend ProduceStateScope<T>.() -> Unit ) Restituire un valore snapshot State osservabile che produce valori nel tempo da key1, key2 e key3.	CM
SnapshotMutationPolicy<T>	<T : Any?> referentialEqualityPolicy() Un criterio per trattare i valori di un elemento MutableState come equivalenti se sono uguali (===) in modo referenziale.	CM
inline T	@Composable <T : Any?> remember(crossinline calculation: @DisallowComposableCalls () -> T) Ricorda il valore prodotto da calculation.	CM
inline T	@Composable <T : Any?> remember(     key1: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) Ricorda il valore restituito da calculation se key1 è uguale alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.	CM
inline T	@Composable <T : Any?> remember(     vararg keys: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) Ricorda il valore restituito da calculation se tutti i valori di keys sono uguali alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.	CM
inline T	@Composable <T : Any?> remember(     key1: Any?,     key2: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) Ricorda il valore restituito da calculation se key1 e key2 sono uguali alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.	CM
inline T	@Composable <T : Any?> remember(     key1: Any?,     key2: Any?,     key3: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) Ricorda il valore restituito da calculation se key1, key2 e key3 sono uguali alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.	CM
CompositionContext	@Composable rememberCompositionContext() Un effetto per costruire un CompositionContext nel punto di composizione corrente.	CM
inline CoroutineScope	@Composable rememberCoroutineScope(     crossinline getContext: @DisallowComposableCalls () -> CoroutineContext ) Restituire un CoroutineScope legato a questo punto della composizione utilizzando il CoroutineContext facoltativo fornito da getContext.	CM
State<T>	@Composable <T : Any?> rememberUpdatedState(newValue: T) remember a mutableStateOf e aggiorna il relativo valore in newValue a ogni ricomposizione della chiamata rememberUpdatedState.	CM
Flow<T>	<T : Any?> snapshotFlow(block: () -> T) Crea un elemento Flow dallo stato Snapshot osservabile.	CM
Unit	@ComposeCompilerApi sourceInformation(composer: Composer, sourceInformation: String) Una funzione interna di Compose.	CM
Unit	@ComposeCompilerApi sourceInformationMarkerEnd(composer: Composer) Una funzione interna di Compose.	CM
Unit	@ComposeCompilerApi sourceInformationMarkerStart(     composer: Composer,     key: Int,     sourceInformation: String ) Una funzione interna di Compose.	CM
ProvidableCompositionLocal<T>	<T : Any?> staticCompositionLocalOf(defaultFactory: () -> T) Crea una chiave CompositionLocal che possa essere fornita utilizzando CompositionLocalProvider.	CM
SnapshotMutationPolicy<T>	<T : Any?> structuralEqualityPolicy() Un criterio per trattare i valori di un MutableState come equivalenti se sono strutturalmente (==) uguali.	CM
Unit	@ComposeCompilerApi traceEventEnd() API di tracciamento interno.	CM
Unit	@ComposeCompilerApi traceEventStart(key: Int, dirty1: Int, dirty2: Int, info: String) API di tracciamento interno.	CM
suspend R	<R : Any?> withFrameMillis(onFrame: (frameTimeMillis: Long) -> R) Esegue la sospensione finché non viene richiesto un nuovo frame, richiama immediatamente onFrame con la durata frame in millisecondi nel contesto di chiamata dell'invio dei frame, quindi riprende con il risultato da onFrame.	CM
suspend R	<R : Any?> withFrameNanos(onFrame: (frameTimeNanos: Long) -> R) Esegue la sospensione finché non viene richiesto un nuovo frame, richiama immediatamente onFrame con la durata frame in nanosecondi nel contesto di chiamata dell'invio del frame, quindi riprende con il risultato da onFrame.	CM
suspend R	<R : Any?> withRunningRecomposer(block: suspend CoroutineScope.(recomposer: Recomposer) -> R) Esegue block con un nuovo Recomposer attivo che applica modifiche all'CoroutineContext di chiamata.	CM

Riepilogo delle funzioni di estensione

DoubleState	State<Double>.asDoubleState() Converte un State<Double> (ossia un State di Double in scatola) in Double con supporto primitivo.	CM
FloatState	State<Float>.asFloatState() Converte un State<Float> (ossia un State di Float in scatola) in Float con supporto primitivo.	CM
IntState	State<Int>.asIntState() Converte un State<Int> (ossia un State di Int in scatola) in IntState con supporto primitivo.	CM
LongState	State<Long>.asLongState() Converte un State<Long> (ossia un State di Long in scatola) in LongState con supporto primitivo.	CM
inline T	@ComposeCompilerApi <T : Any?> Composer.cache(     invalid: Boolean,     block: @DisallowComposableCalls () -> T ) Un'API del plug-in di compilazione Compose.	CM
State<T>	@Composable <T : Any?> StateFlow<T>.collectAsState(context: CoroutineContext) Raccoglie valori da StateFlow e rappresenta il valore più recente tramite State.	CM
State<R>	@Composable <T : R, R : Any?> Flow<T>.collectAsState(initial: R, context: CoroutineContext) Raccoglie valori da Flow e rappresenta il valore più recente tramite State.	CM
inline operator Double	DoubleState.getValue(thisObj: Any?, property: KProperty<*>) Consente la delega di proprietà di val utilizzando by per DoubleState.	CM
inline operator Float	FloatState.getValue(thisObj: Any?, property: KProperty<*>) Consente la delega di proprietà di val utilizzando by per FloatState.	CM
inline operator Int	IntState.getValue(thisObj: Any?, property: KProperty<*>) Consente la delega di proprietà di val utilizzando by per IntState.	CM
inline operator Long	LongState.getValue(thisObj: Any?, property: KProperty<*>) Consente la delega di proprietà di val utilizzando by per LongState.	CM
inline operator T	<T : Any?> State<T>.getValue(thisObj: Any?, property: KProperty<*>) Consente la delega di proprietà di val utilizzando by per State.	CM
inline operator Unit	MutableDoubleState.setValue(     thisObj: Any?,     property: KProperty<*>,     value: Double ) Consente la delega di proprietà di var utilizzando by per MutableDoubleState.	CM
inline operator Unit	MutableFloatState.setValue(     thisObj: Any?,     property: KProperty<*>,     value: Float ) Consente la delega di proprietà di var utilizzando by per MutableFloatState.	CM
inline operator Unit	MutableIntState.setValue(thisObj: Any?, property: KProperty<*>, value: Int) Consente la delega di proprietà di var utilizzando by per MutableIntState.	CM
inline operator Unit	MutableLongState.setValue(     thisObj: Any?,     property: KProperty<*>,     value: Long ) Consente la delega di proprietà di var utilizzando by per MutableLongState.	CM
inline operator Unit	<T : Any?> MutableState<T>.setValue(     thisObj: Any?,     property: KProperty<*>,     value: T ) Consente la delega di proprietà di var utilizzando by per MutableState.	CM
SnapshotStateList<T>	<T : Any?> Collection<T>.toMutableStateList() Crea un'istanza di MutableList da una raccolta osservabile e che può essere istantanea.	CM
SnapshotStateMap<K, V>	<K : Any?, V : Any?> Iterable<Pair<K, V>>.toMutableStateMap() Crea un'istanza di MutableMap<k, v=""> da una raccolta di coppie osservabile e che può essere istantanea.</k,>	CM
suspend inline R	<R : Any?> MonotonicFrameClock.withFrameMillis(     crossinline onFrame: (frameTimeMillis: Long) -> R ) Esegue la sospensione finché non viene richiesto un nuovo frame, richiama immediatamente onFrame con la durata frame in millisecondi nel contesto di chiamata dell'invio dei frame, quindi riprende con il risultato da onFrame.	CM

Riepilogo delle proprietà di primo livello

MonotonicFrameClock	DefaultMonotonicFrameClock Questa proprietà è deprecata. Gli strumenti MonotonicFrameClocks non sono applicabili a livello globale su più piattaforme.	CM Android
Composer	currentComposer TODO(lmr): fornire la documentazione	CM
Int	currentCompositeKeyHash Si tratta di un valore hash utilizzato per coordinare la mappatura dello stato memorizzato esternamente alla composizione.	CM
CompositionLocalContext	currentCompositionLocalContext Restituisce l'attuale CompositionLocalContext che contiene tutti gli elementi di CompositionLocal nella composizione corrente e i relativi valori forniti da CompositionLocalProvider.	CM
RecomposeScope	currentRecomposeScope Restituisce un oggetto che può essere utilizzato per invalidare l'ambito corrente a questo punto della composizione.	CM

Riepilogo delle proprietà delle estensioni

MonotonicFrameClock	@ExperimentalComposeApi CoroutineContext.monotonicFrameClock Restituisce MonotonicFrameClock per questo CoroutineContext o restituisce IllegalStateException se non è presente.	CM
CoroutineContext	@ExperimentalComposeApi ControlledComposition.recomposeCoroutineContext Il CoroutineContext che dovrebbe essere utilizzato per eseguire ricomposizioni simultanee di ControlledComposition quando utilizzato in un ambiente che supporta la composizione simultanea.	CM

Funzioni di primo livello

ComposeNode

CM

@Composable
inline fun <T : Any, E : Applier<*>> ComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit
): Unit

Emette un nodo nella composizione di tipo T.

Questa funzione genera un'eccezione di runtime se E non è un sottotipo dell'applicatore di currentComposer.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
noinline factory: () -> T	Una funzione che creerà una nuova istanza di T. NON è garantito che questa funzione venga richiamata.
update: @DisallowComposableCalls Updater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. Questa operazione verrà eseguita ogni volta che viene eseguito l'emissione. Questa funzione viene chiamata in posizione e sarà incorporata.

Vedi anche
Updater
Applier
Composition

ComposeNode

CM

@Composable
inline fun <T : Any?, E : Applier<*>> ComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit,
    content: @Composable () -> Unit
): Unit

Emette un nodo nella composizione di tipo T. I nodi emessi all'interno di content diventeranno elementi secondari del nodo emesso.

Questa funzione genera un'eccezione di runtime se E non è un sottotipo dell'applicatore di currentComposer.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
noinline factory: () -> T	Una funzione che creerà una nuova istanza di T. NON è garantito che questa funzione venga richiamata.
update: @DisallowComposableCalls Updater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. Questa operazione verrà eseguita ogni volta che viene eseguito l'emissione. Questa funzione viene chiamata in posizione e sarà incorporata.
content: @Composable () -> Unit	i contenuti componibili che emettono i "elementi secondari" del nodo.

Vedi anche
Updater
Applier
Composition

ComposeNode

CM

@Composable
@ExplicitGroupsComposable
inline fun <T : Any?, E : Applier<*>> ComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit,
    noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit,
    content: @Composable () -> Unit
): Unit

Emette un nodo nella composizione di tipo T. I nodi emessi all'interno di content diventeranno elementi secondari del nodo emesso.

Questa funzione genera un'eccezione di runtime se E non è un sottotipo dell'applicatore di currentComposer.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
noinline factory: () -> T	Una funzione che creerà una nuova istanza di T. NON è garantito che questa funzione venga richiamata.
update: @DisallowComposableCalls Updater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. Questa operazione verrà eseguita ogni volta che viene eseguito l'emissione. Questa funzione viene chiamata in posizione e sarà incorporata.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. A differenza di update, questa funzione è componibile e verrà quindi ignorata, a meno che non venga invalidata da un altro meccanismo. Questo può essere utile per eseguire calcoli costosi per l'aggiornamento del nodo in cui è probabile che i calcoli abbiano gli stessi input nel tempo, in modo da poter saltare l'esecuzione della funzione.
content: @Composable () -> Unit	i contenuti componibili che emettono i "elementi secondari" del nodo.

Vedi anche
Updater
SkippableUpdater
Applier
Composition

Composizione

CM

Aggiunto in 1.0.0

fun Composition(applier: Applier<*>, parent: CompositionContext): Composition

Questo metodo è il modo per iniziare una composizione. parent può essere

• fornito per far sì che la composizione si comporti come una sottocomposizione dell'elemento principale. Se la composizione

• non dispone di un elemento padre, è necessario fornire un'istanza Recomposer.

È importante chiamare Composition.dispose quando la composizione non è più necessaria per rilasciare risorse.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
applier: Applier<*>	L'istanza Applier da utilizzare nella composizione.
parent: CompositionContext	L'elemento principale CompositionContext.

Vedi anche
Applier
Composition
Recomposer

Composizione

CM

Aggiunto in 1.0.0

@ExperimentalComposeApi
fun Composition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
): Composition

Crea un Composition utilizzando applier per gestire la composizione, come elemento secondario di parent.

Se utilizzato in una configurazione che supporta la ricomposizione simultanea, indica all'ambiente di utilizzare recomposeCoroutineContext per eseguire la ricomposizione. Le ricomposizioni saranno lanciate

ProviderLocale della composizione

CM

Aggiunto in 1.1.0

@Composable
fun CompositionLocalProvider(
    context: CompositionLocalContext,
    content: @Composable () -> Unit
): Unit

CompositionLocalProvider associa i valori a quelli di CompositionLocal, forniti da context. La lettura di CompositionLocal mediante CompositionLocal.current restituirà il valore fornito nei valori memorizzati all'interno di context per tutte le funzioni componibili chiamate direttamente o indirettamente nella funzione lambda content.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}

Vedi anche
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

ProviderLocale della composizione

CM

Aggiunto in 1.6.0-alpha07

@Composable
fun CompositionLocalProvider(
    value: ProvidedValue<*>,
    content: @Composable () -> Unit
): Unit

CompositionLocalProvider associa il valore alla chiave ProvidableCompositionLocal. La lettura di CompositionLocal mediante CompositionLocal.current restituirà il valore fornito nel parametro value di CompositionLocalProvider per tutte le funzioni componibili chiamate direttamente o indirettamente nella funzione lambda content.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}

Vedi anche
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

ProviderLocale della composizione

CM

@Composable
fun CompositionLocalProvider(
    vararg values: ProvidedValue<*>,
    content: @Composable () -> Unit
): Unit

CompositionLocalProvider associa i valori a ProvidableCompositionLocal chiavi. La lettura di CompositionLocal mediante CompositionLocal.current restituirà il valore fornito nel parametro values di CompositionLocalProvider per tutte le funzioni componibili chiamate direttamente o indirettamente nella funzione lambda content.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}

Vedi anche
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

Composizione controllata

CM

Aggiunto in 1.0.0

@TestOnly
fun ControlledComposition(applier: Applier<*>, parent: CompositionContext): ControlledComposition

Questo metodo è un modo per avviare una composizione. Facoltativamente, è possibile fornire un elemento parent per fare in modo che la composizione si comporti come una sottocomposizione dell'elemento principale oppure è possibile fornire un elemento Recomposer.

Una composizione controllata consente il controllo diretto della composizione invece di essere controllata dall'elemento Recomposer passato alla composizione principale.

È importante chiamare Composition.dispose. Questo compositore non è più necessario per rilasciare risorse.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
applier: Applier<*>	L'istanza Applier da utilizzare nella composizione.
parent: CompositionContext	L'elemento principale CompositionContext.

Vedi anche
Applier
Composition
Recomposer

Composizione controllata

CM

Aggiunto in 1.0.0

@TestOnly
@ExperimentalComposeApi
fun ControlledComposition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
): ControlledComposition

Effetto monouso

CM

@Composable
@NonRestartableComposable
fun DisposableEffect(effect: DisposableEffectScope.() -> DisposableEffectResult): Unit

Questa funzione è deprecata.
DisposableEffect deve fornire uno o più parametri "key" che definiscano l'identità di DisposableEffect e che determini quando eliminare il suo effetto precedente e avviare un nuovo effetto per la nuova chiave.

Un effetto collaterale della composizione che deve essere invertito o eliminato se DisposableEffect lascia la composizione.

Chiamare DisposableEffect senza almeno un parametro key è un errore.

Effetto monouso

CM

@Composable
@NonRestartableComposable
fun DisposableEffect(key1: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult): Unit

Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di key1 e deve essere annullato o eliminato se key1 cambia o se DisposableEffect lascia la composizione.

Una chiave di DisposableEffect è un valore che definisce l'identità di DisposableEffect. Se una chiave cambia, DisposableEffect deve dispose il suo effect attuale e reimpostato chiamando di nuovo effect. Esempi di chiavi includono:

• Oggetti osservabili a cui l'effetto si sottoscrive

• Parametri di richiesta univoci per un'operazione che deve essere annullata e riprovare se i parametri cambiano

DisposableEffect può essere usato per inizializzare o sottoscrivere una chiave e reinizializzare quando viene fornita una chiave diversa, eseguendo la pulizia della vecchia operazione prima di inizializzare quella nuova. Ad esempio:

import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun UserProfile(userRepository: UserRepository, userRequest: UserDataRequest) {
    var userDataState by remember { mutableStateOf<UserDataState>(UserDataState.Loading) }

    // If either the repository or request change, we must cancel our old data fetch
    // and begin a new data fetch. We will cancel the current data fetch if UserProfile
    // leaves the composition.
    DisposableEffect(userRepository, userRequest) {
        val requestDisposable = userRepository.fetchUserData(
            userRequest,
            onSuccess = { response ->
                userDataState = UserDataState.UserData(response)
            },
            onError = { throwable ->
                userDataState = UserDataState.Error(throwable.message)
            }
        )

        onDispose {
            requestDisposable.dispose()
        }
    }

    // ...
}

Un elemento DisposableEffect deve includere una clausola onDispose come istruzione finale nel blocco effect. Se la tua operazione non richiede lo smaltimento, potrebbe essere un SideEffect o un LaunchedEffect se avvia una coroutine che deve essere gestita dalla composizione.

È garantita una chiamata al numero dispose per ogni chiamata al numero effect. Sia effect che dispose verranno sempre eseguiti al supervisore applicato della composizione e gli applicatori non vengono mai eseguiti in simultanea, l'uno con l'altro, applicando modifiche all'albero della composizione o eseguendo callback eventi RememberObserver.

Effetto monouso

CM

@Composable
@NonRestartableComposable
fun DisposableEffect(vararg keys: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult): Unit

Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di keys e deve essere annullato o eliminato se cambia il valore di keys o se DisposableEffect lascia la composizione.

Una chiave di DisposableEffect è un valore che definisce l'identità di DisposableEffect. Se una chiave cambia, DisposableEffect deve dispose il suo effect attuale e reimpostato chiamando di nuovo effect. Esempi di chiavi includono:

• Oggetti osservabili a cui l'effetto si sottoscrive

• Parametri di richiesta univoci per un'operazione che deve essere annullata e riprovare se i parametri cambiano

DisposableEffect può essere usato per inizializzare o sottoscrivere una chiave e reinizializzare quando viene fornita una chiave diversa, eseguendo la pulizia della vecchia operazione prima di inizializzare quella nuova. Ad esempio:

import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun UserProfile(userRepository: UserRepository, userRequest: UserDataRequest) {
    var userDataState by remember { mutableStateOf<UserDataState>(UserDataState.Loading) }

    // If either the repository or request change, we must cancel our old data fetch
    // and begin a new data fetch. We will cancel the current data fetch if UserProfile
    // leaves the composition.
    DisposableEffect(userRepository, userRequest) {
        val requestDisposable = userRepository.fetchUserData(
            userRequest,
            onSuccess = { response ->
                userDataState = UserDataState.UserData(response)
            },
            onError = { throwable ->
                userDataState = UserDataState.Error(throwable.message)
            }
        )

        onDispose {
            requestDisposable.dispose()
        }
    }

    // ...
}

Un elemento DisposableEffect deve includere una clausola onDispose come istruzione finale nel blocco effect. Se la tua operazione non richiede lo smaltimento, potrebbe essere un SideEffect o un LaunchedEffect se avvia una coroutine che deve essere gestita dalla composizione.

È garantita una chiamata al numero dispose per ogni chiamata al numero effect. Sia effect che dispose verranno sempre eseguiti al supervisore applicato della composizione e gli applicatori non vengono mai eseguiti in simultanea, l'uno con l'altro, applicando modifiche all'albero della composizione o eseguendo callback eventi RememberObserver.

Effetto monouso

CM

@Composable
@NonRestartableComposable
fun DisposableEffect(key1: Any?, key2: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult): Unit

Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di key1 o key2 e deve essere annullato o eliminato se key1 o key2 cambiano o se DisposableEffect lascia la composizione.

Una chiave di DisposableEffect è un valore che definisce l'identità di DisposableEffect. Se una chiave cambia, DisposableEffect deve dispose il suo effect attuale e reimpostato chiamando di nuovo effect. Esempi di chiavi includono:

• Oggetti osservabili a cui l'effetto si sottoscrive

• Parametri di richiesta univoci per un'operazione che deve essere annullata e riprovare se i parametri cambiano

DisposableEffect può essere usato per inizializzare o sottoscrivere una chiave e reinizializzare quando viene fornita una chiave diversa, eseguendo la pulizia della vecchia operazione prima di inizializzare quella nuova. Ad esempio:

import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun UserProfile(userRepository: UserRepository, userRequest: UserDataRequest) {
    var userDataState by remember { mutableStateOf<UserDataState>(UserDataState.Loading) }

    // If either the repository or request change, we must cancel our old data fetch
    // and begin a new data fetch. We will cancel the current data fetch if UserProfile
    // leaves the composition.
    DisposableEffect(userRepository, userRequest) {
        val requestDisposable = userRepository.fetchUserData(
            userRequest,
            onSuccess = { response ->
                userDataState = UserDataState.UserData(response)
            },
            onError = { throwable ->
                userDataState = UserDataState.Error(throwable.message)
            }
        )

        onDispose {
            requestDisposable.dispose()
        }
    }

    // ...
}

Un elemento DisposableEffect deve includere una clausola onDispose come istruzione finale nel blocco effect. Se la tua operazione non richiede lo smaltimento, potrebbe essere un SideEffect o un LaunchedEffect se avvia una coroutine che deve essere gestita dalla composizione.

È garantita una chiamata al numero dispose per ogni chiamata al numero effect. Sia effect che dispose verranno sempre eseguiti al supervisore applicato della composizione e gli applicatori non vengono mai eseguiti in simultanea, l'uno con l'altro, applicando modifiche all'albero della composizione o eseguendo callback eventi RememberObserver.

Effetto monouso

CM

@Composable
@NonRestartableComposable
fun DisposableEffect(
    key1: Any?,
    key2: Any?,
    key3: Any?,
    effect: DisposableEffectScope.() -> DisposableEffectResult
): Unit

Un effetto collaterale della composizione che deve essere applicato a qualsiasi nuovo valore univoco di key1, key2 o key3 e deve essere annullato o eliminato se key1, key2 o key3 cambiano o se DisposableEffect lascia la composizione.

Una chiave di DisposableEffect è un valore che definisce l'identità di DisposableEffect. Se una chiave cambia, DisposableEffect deve dispose il suo effect attuale e reimpostato chiamando di nuovo effect. Esempi di chiavi includono:

• Oggetti osservabili a cui l'effetto si sottoscrive

• Parametri di richiesta univoci per un'operazione che deve essere annullata e riprovare se i parametri cambiano

DisposableEffect può essere usato per inizializzare o sottoscrivere una chiave e reinizializzare quando viene fornita una chiave diversa, eseguendo la pulizia della vecchia operazione prima di inizializzare quella nuova. Ad esempio:

import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun UserProfile(userRepository: UserRepository, userRequest: UserDataRequest) {
    var userDataState by remember { mutableStateOf<UserDataState>(UserDataState.Loading) }

    // If either the repository or request change, we must cancel our old data fetch
    // and begin a new data fetch. We will cancel the current data fetch if UserProfile
    // leaves the composition.
    DisposableEffect(userRepository, userRequest) {
        val requestDisposable = userRepository.fetchUserData(
            userRequest,
            onSuccess = { response ->
                userDataState = UserDataState.UserData(response)
            },
            onError = { throwable ->
                userDataState = UserDataState.Error(throwable.message)
            }
        )

        onDispose {
            requestDisposable.dispose()
        }
    }

    // ...
}

Un elemento DisposableEffect deve includere una clausola onDispose come istruzione finale nel blocco effect. Se la tua operazione non richiede lo smaltimento, potrebbe essere un SideEffect o un LaunchedEffect se avvia una coroutine che deve essere gestita dalla composizione.

È garantita una chiamata al numero dispose per ogni chiamata al numero effect. Sia effect che dispose verranno sempre eseguiti al supervisore applicato della composizione e gli applicatori non vengono mai eseguiti in simultanea, l'uno con l'altro, applicando modifiche all'albero della composizione o eseguendo callback eventi RememberObserver.

Effetto lanciato

CM

Aggiunto in 1.0.0

Deprecata in 1.0.0

@Composable
fun LaunchedEffect(block: suspend CoroutineScope.() -> Unit): Unit

Questa funzione è deprecata.
LaunchedEffect deve fornire uno o più parametri "key" che definiscono l'identità di LaunchedEffect e determinano quando annullare la precedente coroutine con effetto e lanciare un nuovo effetto per la nuova chiave.

Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext. La coroutine sarà cancelled quando LaunchedEffect esce dalla composizione.

Chiamare LaunchedEffect senza almeno un parametro key è un errore.

Effetto lanciato

CM

Aggiunto in 1.0.0

@Composable
@NonRestartableComposable
fun LaunchedEffect(key1: Any?, block: suspend CoroutineScope.() -> Unit): Unit

Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext. La coroutine sarà cancelled e riavviata quando LaunchedEffect verrà ricomposta con un key1 diverso. La coroutine sarà cancelled quando LaunchedEffect esce dalla composizione.

Questa funzione non deve essere utilizzata per (ri)avviare le attività in corso in risposta a eventi di callback tramite l'archiviazione dei dati di callback in MutableState passati a key1. Consulta invece rememberCoroutineScope per ottenere un CoroutineScope che può essere utilizzato per avviare i job in corso con ambito della composizione in risposta ai callback di eventi.

Effetto lanciato

CM

@Composable
@NonRestartableComposable
fun LaunchedEffect(vararg keys: Any?, block: suspend CoroutineScope.() -> Unit): Unit

Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext. La coroutine sarà cancelled e riavviata quando LaunchedEffect verrà ricomposta con qualsiasi keys diverso. La coroutine sarà cancelled quando LaunchedEffect esce dalla composizione.

Questa funzione non deve essere utilizzata per (ri)avviare le attività in corso in risposta a eventi di callback tramite l'archiviazione dei dati di callback in MutableState passati a key. Consulta invece rememberCoroutineScope per ottenere un CoroutineScope che può essere utilizzato per avviare i job in corso con ambito della composizione in risposta ai callback di eventi.

Effetto lanciato

CM

Aggiunto in 1.0.0

@Composable
@NonRestartableComposable
fun LaunchedEffect(key1: Any?, key2: Any?, block: suspend CoroutineScope.() -> Unit): Unit

Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext. La coroutine sarà cancelled e riavviata quando LaunchedEffect verrà ricomposta con un key1 o key2 diverso. La coroutine sarà cancelled quando LaunchedEffect esce dalla composizione.

Questa funzione non deve essere utilizzata per (ri)avviare le attività in corso in risposta a eventi di callback tramite l'archiviazione dei dati di callback in MutableState passati a key. Consulta invece rememberCoroutineScope per ottenere un CoroutineScope che può essere utilizzato per avviare i job in corso con ambito della composizione in risposta ai callback di eventi.

Effetto lanciato

CM

Aggiunto in 1.0.0

@Composable
@NonRestartableComposable
fun LaunchedEffect(key1: Any?, key2: Any?, key3: Any?, block: suspend CoroutineScope.() -> Unit): Unit

Quando LaunchedEffect entra nella composizione, lancerà block nel suo CoroutineContext. La coroutine sarà cancelled e riavviata quando LaunchedEffect verrà ricomposta con key1, key2 o key3 diverso. La coroutine sarà cancelled quando LaunchedEffect esce dalla composizione.

Questa funzione non deve essere utilizzata per (ri)avviare le attività in corso in risposta a eventi di callback tramite l'archiviazione dei dati di callback in MutableState passati a key. Consulta invece rememberCoroutineScope per ottenere un CoroutineScope che può essere utilizzato per avviare i job in corso con ambito della composizione in risposta ai callback di eventi.

ReusableComposeNode

CM

@Composable
inline fun <T : Any, E : Applier<*>> ReusableComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit
): Unit

Emette un nodo riciclabile nella composizione di tipo T.

Questa funzione genera un'eccezione di runtime se E non è un sottotipo dell'applicatore di currentComposer.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
noinline factory: () -> T	Una funzione che creerà una nuova istanza di T. NON è garantito che questa funzione venga richiamata.
update: @DisallowComposableCalls Updater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. Questa operazione verrà eseguita ogni volta che viene eseguito l'emissione. Questa funzione viene chiamata in posizione e sarà incorporata.

Vedi anche
Updater
Applier
Composition

ReusableComposeNode

CM

@Composable
inline fun <T : Any?, E : Applier<*>> ReusableComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit,
    content: @Composable () -> Unit
): Unit

Emette un nodo riciclabile nella composizione di tipo T. I nodi emessi all'interno di content diventeranno elementi secondari del nodo emesso.

Questa funzione genera un'eccezione di runtime se E non è un sottotipo dell'applicatore di currentComposer.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
noinline factory: () -> T	Una funzione che creerà una nuova istanza di T. NON è garantito che questa funzione venga richiamata.
update: @DisallowComposableCalls Updater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. Questa operazione verrà eseguita ogni volta che viene eseguito l'emissione. Questa funzione viene chiamata in posizione e sarà incorporata.
content: @Composable () -> Unit	i contenuti componibili che emettono i "elementi secondari" del nodo.

Vedi anche
Updater
Applier
Composition

ReusableComposeNode

CM

@Composable
@ExplicitGroupsComposable
inline fun <T : Any?, E : Applier<*>> ReusableComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit,
    noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit,
    content: @Composable () -> Unit
): Unit

Emette un nodo riciclabile nella composizione di tipo T. I nodi emessi all'interno di content diventeranno elementi secondari del nodo emesso.

Questa funzione genera un'eccezione di runtime se E non è un sottotipo dell'applicatore di currentComposer.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Parametri
noinline factory: () -> T	Una funzione che creerà una nuova istanza di T. NON è garantito che questa funzione venga richiamata.
update: @DisallowComposableCalls Updater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. Questa operazione verrà eseguita ogni volta che viene eseguito l'emissione. Questa funzione viene chiamata in posizione e sarà incorporata.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit	Una funzione per eseguire aggiornamenti sul nodo. A differenza di update, questa funzione è componibile e verrà quindi ignorata, a meno che non venga invalidata da un altro meccanismo. Questo può essere utile per eseguire calcoli costosi per l'aggiornamento del nodo in cui è probabile che i calcoli abbiano gli stessi input nel tempo, in modo da poter saltare l'esecuzione della funzione.
content: @Composable () -> Unit	i contenuti componibili che emettono i "elementi secondari" del nodo.

Vedi anche
Updater
SkippableUpdater
Applier
Composition

Composizione riutilizzabile

CM

Aggiunto in 1.6.0-alpha07

fun ReusableComposition(applier: Applier<*>, parent: CompositionContext): ReusableComposition

Questo metodo è il modo per avviare una composizione riutilizzabile. È possibile fornire parent per fare in modo che la composizione si comporti come una sottocomposizione dell'elemento principale. Se la composizione non ha un'istanza padre, è necessario fornire un'istanza Recomposer.

È importante chiamare Composition.dispose quando la composizione non è più necessaria per rilasciare risorse.

Parametri
applier: Applier<*>	L'istanza Applier da utilizzare nella composizione.
parent: CompositionContext	L'elemento principale CompositionContext.

Vedi anche
Applier
ReusableComposition
rememberCompositionContext

Contenuto riutilizzabile

CM

Aggiunto in 1.0.0

@Composable
inline fun ReusableContent(key: Any?, content: @Composable () -> Unit): Unit

Una funzione di utilità per contrassegnare una composizione come supporto per il riciclo. Se il valore di key cambia, la composizione viene sostituita da una nuova (come accadrebbe per key), ma i nodi riutilizzabili che vengono emessi da ReusableComposeNode vengono riutilizzati.

Parametri
key: Any?	il valore utilizzato per attivare il riciclo. Se ricomposto con un valore diverso, il compositore crea una nuova composizione, ma prova a riutilizzare i nodi riutilizzabili.
content: @Composable () -> Unit	i bambini componibili che sono riciclabili.

ReusableContentHost

CM

Aggiunto in 1.2.0

@Composable
@ExplicitGroupsComposable
inline fun ReusableContentHost(
    active: Boolean,
    crossinline content: @Composable () -> Unit
): Unit

Una funzione di utilità facoltativa utilizzata durante l'hosting di ReusableContent. Se active è false, i contenuti vengono trattati come se venissero eliminati rimuovendo dalla composizione tutti gli oggetti memorizzati, ma il nodo prodotto per la struttura non viene rimosso. Quando la composizione diventa successivamente attiva, i nodi possono essere riutilizzati all'interno del contenuto ReusableContent senza richiedere che lo stato ricordato della durata della composizione venga esteso arbitrariamente.

Parametri
active: Boolean	quando active è true, content è composto normalmente. Quando active è false, i contenuti vengono disattivati e tutto lo stato ricordato viene trattato come se il contenuto fosse stato eliminato, ma i nodi gestiti dall'elemento Applier della composizione non sono interessati. Un active diventa true tutti i nodi riutilizzabili della composizione attiva in precedenza sono idonei per il riutilizzo.
crossinline content: @Composable () -> Unit	i contenuti componibili gestiti da questo componente.

Effetto collaterale

CM

Aggiunto in 1.0.0

@Composable
@NonRestartableComposable
@ExplicitGroupsComposable
fun SideEffect(effect: () -> Unit): Unit

Pianifica l'esecuzione di effect quando la composizione corrente viene completata correttamente e applica le modifiche. SideEffect può essere utilizzato per applicare effetti collaterali agli oggetti gestiti dalla composizione che non sono supportati da snapshots, in modo da non lasciare questi oggetti in uno stato incoerente se l'operazione di composizione attuale non riesce.

effect verrà sempre eseguito sul supervisore di applicazione della composizione e gli applicatori non vengono mai eseguiti in simultanea, tra loro, applicando modifiche all'albero della composizione o eseguendo callback eventi RememberObserver. I SideEffect vengono sempre eseguiti dopo i callback eventi RememberObserver.

Un elemento SideEffect viene eseguito dopo ogni ricomposizione. Per avviare un'attività in corso che include potenzialmente molte ricomposizioni, vedi LaunchedEffect. Per gestire la sottoscrizione di un evento o il ciclo di vita di un altro oggetto, consulta DisposableEffect.

composizioneLocalOf

CM

Aggiunto in 1.0.0

fun <T : Any?> compositionLocalOf(
    policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy(),
    defaultFactory: () -> T
): ProvidableCompositionLocal<T>

Crea una chiave CompositionLocal che possa essere fornita utilizzando CompositionLocalProvider. La modifica del valore fornito durante la ricomposizione renderà non validi i contenuti di CompositionLocalProvider che leggono il valore utilizzando CompositionLocal.current.

compositionLocalOf crea un ProvidableCompositionLocal che può essere utilizzato in una chiamata al numero CompositionLocalProvider. Analogamente a MutableList rispetto a List, se la chiave viene resa pubblica come CompositionLocal anziché ProvidableCompositionLocal, può essere letta utilizzando CompositionLocal.current, ma non rifornita.

Parametri
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()	un criterio per determinare quando un elemento CompositionLocal viene considerato modificato. Per informazioni dettagliate, visita la pagina SnapshotMutationPolicy.
defaultFactory: () -> T	una fabbrica di valori per fornire un valore quando non viene fornito un valore. Questa fabbrica viene richiamata quando non viene fornito alcun valore tramite un CompositionLocalProvider del chiamante del componente utilizzando CompositionLocal.current. Se non è possibile fornire valori predefiniti ragionevoli, valuta la possibilità di generare un'eccezione.

Vedi anche
CompositionLocal
staticCompositionLocalOf
mutableStateOf

derivatoStateOf

CM

Aggiunto in 1.0.0

@StateFactoryMarker
fun <T : Any?> derivedStateOf(calculation: () -> T): State<T>

Crea un oggetto State il cui State.value è il risultato di calculation. Il risultato del calcolo verrà memorizzato nella cache in modo che la chiamata a State.value ripetutamente non provocherà l'esecuzione di calculation più volte, ma la lettura di State.value farà sì che tutti gli oggetti State che sono stati letti durante il calculation vengano letti nell'attuale Snapshot, il che significa che questo sottoscriverà correttamente gli oggetti dello stato derivato se il valore viene letto in un contesto osservato, come una funzione Composable. Gli stati derivati senza criterio di mutazione attivano gli aggiornamenti a ogni modifica delle dipendenze. Per evitare l'annullamento della validità dell'aggiornamento, fornisci un sovraccarico adeguato da SnapshotMutationPolicy a derivedStateOf.

import androidx.compose.material.Text
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable fun CountDisplay(count: State<Int>) {
    Text("Count: ${count.value}")
}

@Composable fun Example() {
    var a by remember { mutableStateOf(0) }
    var b by remember { mutableStateOf(0) }
    val sum = remember { derivedStateOf { a + b } }
    // Changing either a or b will cause CountDisplay to recompose but not trigger Example
    // to recompose.
    CountDisplay(sum)
}

Parametri
calculation: () -> T	il calcolo per creare il valore rappresentato da questo oggetto di stato.

derivatoStateOf

CM

Aggiunto in 1.3.0

@StateFactoryMarker
fun <T : Any?> derivedStateOf(
    policy: SnapshotMutationPolicy<T>,
    calculation: () -> T
): State<T>

Crea un oggetto State il cui State.value è il risultato di calculation. Il risultato del calcolo verrà memorizzato nella cache in modo che la chiamata a State.value ripetutamente non provocherà l'esecuzione di calculation più volte, ma la lettura di State.value farà sì che tutti gli oggetti State che sono stati letti durante il calculation vengano letti nell'attuale Snapshot, il che significa che questo sottoscriverà correttamente gli oggetti dello stato derivato se il valore viene letto in un contesto osservato, come una funzione Composable.

import androidx.compose.material.Text
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable fun CountDisplay(count: State<Int>) {
    Text("Count: ${count.value}")
}

@Composable fun Example() {
    var a by remember { mutableStateOf(0) }
    var b by remember { mutableStateOf(0) }
    val sum = remember { derivedStateOf { a + b } }
    // Changing either a or b will cause CountDisplay to recompose but not trigger Example
    // to recompose.
    CountDisplay(sum)
}

Parametri
policy: SnapshotMutationPolicy<T>	criterio di mutazione per controllare quando le modifiche all'aggiornamento dell'attivatore del risultato calculation.
calculation: () -> T	il calcolo per creare il valore rappresentato da questo oggetto di stato.

Traccia in corso

CM

Aggiunto in 1.2.0

@ComposeCompilerApi
fun isTraceInProgress(): Boolean

API di tracciamento interno.

Dovrebbe essere chiamato senza sincronizzazione dei thread con perdita di informazioni occasionale.

chiave

CM

@Composable
inline fun <T : Any?> key(vararg keys: Any?, block: @Composable () -> T): T

key è un'utilità componibile utilizzata per "raggruppare" o "chiave" un blocco di esecuzione all'interno di una composizione. A volte questa operazione è necessaria per la correttezza del flusso di controllo e ciò potrebbe causare l'esecuzione più di una volta di una determinata chiamata componibile durante la composizione.

Il valore di una chiave non deve necessariamente essere univoco a livello globale e deve essere univoco solo tra le chiamate di key in quel momento nella composizione.

Ad esempio, considera il seguente esempio:

import androidx.compose.runtime.key

for (user in users) {
    key(user.id) { UserPreview(user = user) }
}

for (user in users.filter { isAdmin }) {
    key(user.id) { Friend(friend = user) }
}

Anche se ci sono utenti con lo stesso ID composto sia nel loop superiore che in quello inferiore, poiché sono chiamate diverse a key, non è necessario creare chiavi composte.

Tuttavia, la chiave deve essere univoca per ogni elemento della raccolta, altrimenti gli elementi secondari e lo stato locale potrebbero essere riutilizzati in modi indesiderati.

Ad esempio, considera il seguente esempio:

import androidx.compose.runtime.key

for ((child, parent) in relationships) {
    key(parent.id) {
        User(user = child)
        User(user = parent)
    }
}

In questo esempio si presume che parent.id sia una chiave univoca per ogni elemento della raccolta, ma ciò è vero solo se è corretto supporre che un genitore avrà sempre un solo figlio, cosa che potrebbe non essere il caso. Invece, potrebbe essere più corretto eseguire le seguenti operazioni:

import androidx.compose.runtime.key

for ((child, parent) in relationships) {
    key(parent.id to child.id) {
        User(user = child)
        User(user = parent)
    }
}

Una chiave composta può essere creata passando più argomenti:

import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

for (element in elements) {
    val selected by key(element.id, parentId) { remember { mutableStateOf(false) } }
    ListItem(item = element, selected = selected)
}

Parametri
vararg keys: Any?	L'insieme di valori da utilizzare per creare una chiave composta. Questi valori verranno confrontati con i valori precedenti utilizzando equals e hashCode
block: @Composable () -> T	Gli elementi secondari componibili per questo gruppo.

movableContentOf

CM

Aggiunto in 1.2.0

fun movableContentOf(content: @Composable () -> Unit): @Composable () -> Unit

Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable () -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable () -> Unit	Una funzione lambda componibile di monitoraggio

movableContentOf

CM

Aggiunto in 1.2.0

fun <P : Any?> movableContentOf(content: @Composable (P) -> Unit): @Composable (P) -> Unit

Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable (P) -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable (P) -> Unit	Una funzione lambda componibile di monitoraggio

movableContentOf

CM

Aggiunto in 1.2.0

fun <P1 : Any?, P2 : Any?> movableContentOf(content: @Composable (P1, P2) -> Unit): @Composable (P1, P2) -> Unit

Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable (P1, P2) -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable (P1, P2) -> Unit	Una funzione lambda componibile di monitoraggio

movableContentOf

CM

Aggiunto in 1.2.0

fun <P1 : Any?, P2 : Any?, P3 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3) -> Unit
): @Composable (P1, P2, P3) -> Unit

Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable (P1, P2, P3) -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable (P1, P2, P3) -> Unit	Una funzione lambda componibile di monitoraggio

movableContentOf

CM

Aggiunto in 1.2.0

fun <P1 : Any?, P2 : Any?, P3 : Any?, P4 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3, P4) -> Unit
): @Composable (P1, P2, P3, P4) -> Unit

Converti una funzione lambda in un'operazione che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable (P1, P2, P3, P4) -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable (P1, P2, P3, P4) -> Unit	Una funzione lambda componibile di monitoraggio

movableContentWithRicevirOf

CM

Aggiunto in 1.2.0

fun <R : Any?> movableContentWithReceiverOf(content: @Composable R.() -> Unit): @Composable R.() -> Unit

Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable R.() -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable R.() -> Unit	Una funzione lambda componibile di monitoraggio

movableContentWithRicevirOf

CM

Aggiunto in 1.2.0

fun <R : Any?, P : Any?> movableContentWithReceiverOf(content: @Composable R.(P) -> Unit): @Composable R.(P) -> Unit

Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable R.(P) -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable R.(P) -> Unit	Una funzione lambda componibile di monitoraggio

movableContentWithRicevirOf

CM

Aggiunto in 1.2.0

fun <R : Any?, P1 : Any?, P2 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2) -> Unit
): @Composable R.(P1, P2) -> Unit

Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable R.(P1, P2) -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable R.(P1, P2) -> Unit	Una funzione lambda componibile di monitoraggio

movableContentWithRicevirOf

CM

Aggiunto in 1.2.0

fun <R : Any?, P1 : Any?, P2 : Any?, P3 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2, P3) -> Unit
): @Composable R.(P1, P2, P3) -> Unit

Converti una funzione lambda con un ricevitore in un dispositivo che sposta lo stato memorizzato e i nodi creati in una chiamata precedente nella nuova posizione in cui viene chiamata.

Le composizioni di tracciamento possono essere utilizzate per produrre un elemento componibile che sposta il proprio contenuto tra una riga e una colonna in base a un parametro, ad esempio

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Oppure possono essere utilizzati per garantire che lo stato della composizione tenga traccia di un modello mentre si muove nel layout, ad esempio:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

Parametri
content: @Composable R.(P1, P2, P3) -> Unit	La funzione lambda componibile da convertire in una funzione lambda di monitoraggio dello stato.

Valori restituiti
@Composable R.(P1, P2, P3) -> Unit	Una funzione lambda componibile di monitoraggio

mutableDoubleStateOf

CM

Aggiunto in 1.5.0

@StateFactoryMarker
fun mutableDoubleStateOf(value: Double): MutableDoubleState

Restituisce un nuovo MutableDoubleState inizializzato con il passaggio in value

La classe MutableDoubleState è un contenitore di valore singolo le cui operazioni di lettura e scrittura vengono osservate da Compose. Inoltre, le transazioni di scrittura vengono effettuate nell'ambito del sistema Snapshot. Sulla JVM, i valori vengono archiviati in memoria come tipo double primitivo, evitando l'autoboxing che si verifica quando si utilizza MutableState<Double>.

Parametri
value: Double	il valore iniziale di MutableDoubleState

Vedi anche
DoubleState
MutableDoubleState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf

mutableFloatStateOf

CM

@StateFactoryMarker
fun mutableFloatStateOf(value: Float): MutableFloatState

Restituisce un nuovo MutableFloatState inizializzato con il passaggio in value

La classe MutableFloatState è un contenitore di valore singolo le cui operazioni di lettura e scrittura vengono osservate da Compose. Inoltre, le transazioni di scrittura vengono effettuate nell'ambito del sistema Snapshot. Sulla JVM, i valori vengono archiviati in memoria come tipo float primitivo, evitando l'autoboxing che si verifica quando si utilizza MutableState<Float>.

Parametri
value: Float	il valore iniziale di MutableFloatState

Vedi anche
FloatState
MutableFloatState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableDoubleStateOf

Stato di mutableIntOf

CM

Aggiunto in 1.5.0

@StateFactoryMarker
fun mutableIntStateOf(value: Int): MutableIntState

Restituisce un nuovo MutableIntState inizializzato con il passaggio in value

La classe MutableIntState è un contenitore di valore singolo le cui operazioni di lettura e scrittura vengono osservate da Compose. Inoltre, le transazioni di scrittura vengono effettuate nell'ambito del sistema Snapshot. Sulla JVM, i valori vengono archiviati in memoria come tipo int primitivo, evitando l'autoboxing che si verifica quando si utilizza MutableState<Int>.

Parametri
value: Int	il valore iniziale di MutableIntState

Vedi anche
IntState
MutableIntState
mutableStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

Stato lungo

CM

Aggiunto in 1.5.0

@StateFactoryMarker
fun mutableLongStateOf(value: Long): MutableLongState

Restituisce un nuovo MutableLongState inizializzato con il passaggio in value

La classe MutableLongState è un contenitore di valore singolo le cui operazioni di lettura e scrittura vengono osservate da Compose. Inoltre, le transazioni di scrittura vengono effettuate nell'ambito del sistema Snapshot. Sulla JVM, i valori vengono archiviati in memoria come tipo long primitivo, evitando l'autoboxing che si verifica quando si utilizza MutableState<Long>.

Parametri
value: Long	il valore iniziale di MutableLongState

Vedi anche
LongState
MutableLongState
mutableStateOf
mutableIntStateOf
mutableFloatStateOf
mutableDoubleStateOf

mutableStateListOf

CM

Aggiunto in 1.0.0

@StateFactoryMarker
fun <T : Any?> mutableStateListOf(): SnapshotStateList<T>

Crea un'istanza di MutableList osservabile e che possa essere istantanea.

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun Names() {
    var name by remember { mutableStateOf("user") }
    val names = remember { mutableStateListOf<String>() }

    Column {
        Row {
            BasicTextField(
                value = name,
                onValueChange = { name = it }
            )
            Button(onClick = { names.add(name) }) {
                Text("Add")
            }
        }
        Text("Added names:")
        Column {
            for (addedName in names) {
                Text(addedName)
            }
        }
    }
}

Vedi anche
mutableStateOf
mutableListOf
MutableList
takeSnapshot

mutableStateListOf

CM

Aggiunto in 1.0.0

@StateFactoryMarker
fun <T : Any?> mutableStateListOf(vararg elements: T): SnapshotStateList<T>

Crea un'istanza di MutableList osservabile e che può essere istantanea.

Vedi anche
mutableStateOf
mutableListOf
MutableList
takeSnapshot

mutableStateMapOf

CM

Aggiunto in 1.0.0

@StateFactoryMarker
fun <K : Any?, V : Any?> mutableStateMapOf(): SnapshotStateMap<K, V>

Crea un'istanza di MutableMap<k, v=""> osservabile e che può essere istantanea.</k,>

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateMapOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun NamesAndAges() {
    var name by remember { mutableStateOf("name") }
    var saying by remember { mutableStateOf("saying") }
    val sayings = remember {
        mutableStateMapOf(
            "Caesar" to "Et tu, Brute?",
            "Hamlet" to "To be or not to be",
            "Richard III" to "My kingdom for a horse"
        )
    }

    Column {
        Row {
            BasicTextField(
                value = name,
                onValueChange = { name = it }
            )
            BasicTextField(
                value = saying,
                onValueChange = { saying = it }
            )
            Button(onClick = { sayings[name] = saying }) {
                Text("Add")
            }
            Button(onClick = { sayings.remove(name) }) {
                Text("Remove")
            }
        }
        Text("Sayings:")
        Column {
            for (entry in sayings) {
                Text("${entry.key} says '${entry.value}'")
            }
        }
    }
}

Vedi anche
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

mutableStateMapOf

CM

@StateFactoryMarker
fun <K : Any?, V : Any?> mutableStateMapOf(vararg pairs: Pair<K, V>): SnapshotStateMap<K, V>

Crea un'istanza di MutableMap<k, v=""> osservabile e che può essere istantanea.</k,>

Vedi anche
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

Statomodificabile

CM

Aggiunto in 1.0.0

@StateFactoryMarker
fun <T : Any?> mutableStateOf(
    value: T,
    policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()
): MutableState<T>

Restituisce un nuovo MutableState inizializzato con il passaggio in value

La classe MutableState è un contenitore di valore singolo le cui operazioni di lettura e scrittura vengono osservate da Compose. Inoltre, le transazioni di scrittura vengono effettuate nell'ambito del sistema Snapshot.

import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

val count = remember { mutableStateOf(0) }

Text(text = "You clicked ${count.value} times")
Button(onClick = { count.value++ }) {
    Text("Click me")
}

import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

val (count, setCount) = remember { mutableStateOf(0) }

Text(text = "You clicked $count times")
Button(onClick = { setCount(count + 1) }) {
    Text("Click me")
}

import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun observeUser(userId: Int): User? {
    val user = remember(userId) { mutableStateOf<User?>(null) }
    DisposableEffect(userId) {
        val subscription = UserAPI.subscribeToUser(userId) {
            user.value = it
        }
        onDispose {
            subscription.unsubscribe()
        }
    }
    return user.value
}

import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun LoginScreen() {
    var username by remember { mutableStateOf("user") }
    var password by remember { mutableStateOf("pass") }

    fun login() = Api.login(username, password)

    BasicTextField(
        value = username,
        onValueChange = { username = it }
    )
    BasicTextField(
        value = password,
        onValueChange = { password = it }
    )
    Button(onClick = { login() }) {
        Text("Login")
    }
}

Parametri
value: T	il valore iniziale di MutableState
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()	un criterio per controllare il modo in cui le modifiche vengono gestite negli snapshot modificabili.

Vedi anche
State
MutableState
SnapshotMutationPolicy
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

NormeMai pari

CM

Aggiunto in 1.0.0

fun <T : Any?> neverEqualPolicy(): SnapshotMutationPolicy<T>

Un criterio non considera mai i valori di un MutableState come equivalenti.

L'impostazione del criterio MutableState.value verrà sempre considerata una modifica. Quando applichi un'istruzione MutableSnapshot che modifica lo stato, sarà sempre in conflitto con altri snapshot che modificano lo stesso stato.

statodiproduzione

CM

Aggiunto in 1.0.0

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

Restituire un elemento State osservabile snapshot che produce valori nel tempo senza un'origine dati definita.

producer viene lanciato quando produceState entra nella composizione e viene annullato quando produceState abbandona la composizione. producer deve utilizzare ProduceStateScope.value per impostare nuovi valori sul State restituito.

Il valore State restituito combina i valori; non sarà osservabile nessuna modifica se viene utilizzato ProduceStateScope.value per impostare un valore equal sul valore precedente e gli osservatori potrebbero vedere il valore più recente solo se vengono impostati più valori in rapida successione.

produceState potrebbe essere utilizzato per osservare fonti di dati esterni sospese o non in sospensione, ad esempio:

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()
    }
}

statodiproduzione

CM

Aggiunto in 1.0.0

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

Restituire un valore snapshot State osservabile che produce valori nel tempo da key1.

producer viene lanciato quando produceState entra nella composizione e viene annullato quando produceState abbandona la composizione. Se il valore key1 cambia, un producer in esecuzione verrà annullato e riavviato per la nuova origine. producer deve utilizzare ProduceStateScope.value per impostare nuovi valori sul State restituito.

Il valore State restituito combina i valori; non sarà osservabile nessuna modifica se viene utilizzato ProduceStateScope.value per impostare un valore equal sul valore precedente e gli osservatori potrebbero vedere il valore più recente solo se vengono impostati più valori in rapida successione.

produceState potrebbe essere utilizzato per osservare fonti di dati esterni sospese o non in sospensione, ad esempio:

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()
    }
}

statodiproduzione

CM

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

Restituire un valore snapshot State osservabile che produce valori nel tempo da keys.

producer viene lanciato quando produceState entra nella composizione e viene annullato quando produceState abbandona la composizione. Se il criterio keys viene modificato, un producer in esecuzione verrà annullato e riavviato per la nuova origine. producer deve utilizzare ProduceStateScope.value per impostare nuovi valori sul State restituito.

Il valore State restituito combina i valori; non sarà osservabile nessuna modifica se viene utilizzato ProduceStateScope.value per impostare un valore equal sul valore precedente e gli osservatori potrebbero vedere il valore più recente solo se vengono impostati più valori in rapida successione.

produceState potrebbe essere utilizzato per osservare fonti di dati esterni sospese o non in sospensione, ad esempio:

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()
    }
}

statodiproduzione

CM

Aggiunto in 1.0.0

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

Restituire un valore snapshot State osservabile che produce valori nel tempo da key1 e key2.

producer viene lanciato quando produceState entra nella composizione e viene annullato quando produceState abbandona la composizione. Se key1 o key2 cambiano, un producer in esecuzione verrà annullato e riavviato per la nuova origine. producer deve utilizzare ProduceStateScope.value per impostare nuovi valori sul State restituito.

Il valore State restituito combina i valori; non sarà osservabile nessuna modifica se viene utilizzato ProduceStateScope.value per impostare un valore equal sul valore precedente e gli osservatori potrebbero vedere il valore più recente solo se vengono impostati più valori in rapida successione.

produceState potrebbe essere utilizzato per osservare fonti di dati esterni sospese o non in sospensione, ad esempio:

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()
    }
}

statodiproduzione

CM

Aggiunto in 1.0.0

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

Restituire un valore snapshot State osservabile che produce valori nel tempo da key1, key2 e key3.

producer viene lanciato quando produceState entra nella composizione e viene annullato quando produceState abbandona la composizione. Se key1, key2 o key3 cambiano, un producer in esecuzione verrà annullato e riavviato per la nuova origine. [Il producer deve utilizzare ProduceStateScope.value per impostare nuovi valori sul valore State restituito.

Il valore State restituito combina i valori; non sarà osservabile nessuna modifica se viene utilizzato ProduceStateScope.value per impostare un valore equal sul valore precedente e gli osservatori potrebbero vedere il valore più recente solo se vengono impostati più valori in rapida successione.

produceState potrebbe essere utilizzato per osservare fonti di dati esterni sospese o non in sospensione, ad esempio:

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()
    }
}

referentialEqualityPolicy

CM

Aggiunto in 1.0.0

fun <T : Any?> referentialEqualityPolicy(): SnapshotMutationPolicy<T>

Un criterio per trattare i valori di un elemento MutableState come equivalenti se sono uguali (===) in modo referenziale.

L'impostazione di MutableState.value sul valore corrente a livello di riferimento (===) non è considerata una modifica. Quando applichi un valore MutableSnapshot, se lo snapshot modifica il valore equivalente allo snapshot principale non viene considerato un conflitto.

ricordare

CM

Aggiunto in 1.0.0

@Composable
inline fun <T : Any?> remember(crossinline calculation: @DisallowComposableCalls () -> T): T

Ricorda il valore prodotto da calculation. calculation verrà valutato solo durante la composizione. La ricomposizione restituirà sempre il valore prodotto dalla composizione.

ricordare

CM

Aggiunto in 1.0.0

@Composable
inline fun <T : Any?> remember(
    key1: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
): T

Ricorda il valore restituito da calculation se key1 è uguale alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.

ricordare

CM

@Composable
inline fun <T : Any?> remember(
    vararg keys: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
): T

Ricorda il valore restituito da calculation se tutti i valori di keys sono uguali alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.

ricordare

CM

Aggiunto in 1.0.0

@Composable
inline fun <T : Any?> remember(
    key1: Any?,
    key2: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
): T

Ricorda il valore restituito da calculation se key1 e key2 sono uguali alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.

ricordare

CM

Aggiunto in 1.0.0

@Composable
inline fun <T : Any?> remember(
    key1: Any?,
    key2: Any?,
    key3: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
): T

Ricorda il valore restituito da calculation se key1, key2 e key3 sono uguali alla composizione precedente, altrimenti produci e ricorda un nuovo valore richiamando calculation.

ricordareComposizioneContesto

CM

Aggiunto in 1.0.0

@Composable
fun rememberCompositionContext(): CompositionContext

Un effetto per costruire un CompositionContext nel punto di composizione corrente. Questo può essere utilizzato per eseguire una composizione separata nel contesto di quella attuale, mantenendo CompositionLocal e propagando le invalidazioni. Quando questa chiamata esce dalla composizione, il contesto viene invalidato.

ricordaCoroutineScope

CM

@Composable
inline fun rememberCoroutineScope(
    crossinline getContext: @DisallowComposableCalls () -> CoroutineContext = { EmptyCoroutineContext }
): CoroutineScope

Restituire un CoroutineScope legato a questo punto della composizione utilizzando il CoroutineContext facoltativo fornito da getContext. getContext verrà chiamata una sola volta e la stessa istanza CoroutineScope verrà restituita nelle ricomposizioni.

Questo ambito sarà cancelled quando questa chiamata esce dalla composizione. Il CoroutineContext restituito da getContext potrebbe non contenere un Job poiché questo ambito è considerato un elemento secondario della composizione.

Il supervisore predefinito di questo ambito, se non ne viene fornito uno dal contesto restituito da getContext, sarà il supervisore applicatore del Recomposer della composizione.

Utilizza questo ambito per avviare job in risposta a eventi di callback come clic o altre interazioni degli utenti, in cui la risposta a quell'evento deve svolgersi nel tempo ed essere annullata se la gestione componibile di quel processo lascia la composizione. I job non dovrebbero mai essere lanciati in alcun ambito di coroutine come effetto collaterale della composizione stessa. Per i job in corso con ambito avviati dalla composizione, vedi LaunchedEffect.

Questa funzione non genera se le precondizioni non sono soddisfatte, poiché le funzioni componibili non supportano ancora completamente le eccezioni. Al contrario, il valore CoroutineScope.coroutineContext dell'ambito restituito conterrà un errore Job con l'eccezione associata e non sarà in grado di avviare job figlio.

ricordareAggiornato

CM

Aggiunto in 1.0.0

@Composable
fun <T : Any?> rememberUpdatedState(newValue: T): State<T>

remember a mutableStateOf e aggiorna il relativo valore in newValue a ogni ricomposizione della chiamata rememberUpdatedState.

rememberUpdatedState deve essere utilizzato quando i parametri o i valori calcolati durante la composizione fanno riferimento a una funzione lambda o di oggetti di lunga durata. La ricomposizione aggiornerà il valore State risultante senza ricreare la funzione lambda o l'oggetto di lunga durata, consentendo la persistenza dell'oggetto senza annullare e ripetere la sottoscrizione o il riavvio di un'operazione di lunga durata che potrebbe essere costosa o proibitiva da ricreare e riavviare. Questo potrebbe verificarsi quando si lavora con DisposableEffect o LaunchedEffect, ad esempio:

import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.rememberUpdatedState

@Composable
fun EventHandler(dispatcher: Dispatcher, onEvent: () -> Unit) {
    val currentOnEvent by rememberUpdatedState(onEvent)

    // Event handlers are ordered and a new onEvent should not cause us to re-register,
    // losing our position in the dispatcher.
    DisposableEffect(dispatcher) {
        val disposable = dispatcher.addListener {
            // currentOnEvent will always refer to the latest onEvent function that
            // the EventHandler was recomposed with
            currentOnEvent()
        }
        onDispose {
            disposable.dispose()
        }
    }
}

I LaunchedEffect spesso descrivono macchine a stato che non devono essere reimpostate e riavviate se un parametro o un callback di evento cambia, ma dovrebbero avere il valore corrente disponibile quando necessario. Ad esempio:

import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.rememberUpdatedState

@Composable
fun NotificationHost(state: NotificationState, onTimeout: (Notification) -> Unit) {
    val currentOnTimeout by rememberUpdatedState(onTimeout)

    state.currentNotification?.let { currentNotification ->
        LaunchedEffect(currentNotification) {
            // We should not restart this delay if onTimeout changes, but we want to call
            // the onTimeout we were last recomposed with when it completes.
            delay(NotificationTimeout)
            currentOnTimeout(currentNotification)
        }
    }

    // ...
}

Utilizzando rememberUpdatedState, una funzione componibile può aggiornare queste operazioni in corso.

Flusso snapshot

CM

Aggiunto in 1.0.0

fun <T : Any?> snapshotFlow(block: () -> T): Flow<T>

Crea un elemento Flow dallo stato Snapshot osservabile. (ad es. titolari di articoli restituiti da mutableStateOf).

snapshotFlow crea un oggetto Flow che esegue block quando viene raccolto ed emette il risultato, registrando qualsiasi stato dello snapshot a cui è stato eseguito l'accesso. Durante la raccolta, se viene applicato un nuovo Snapshot che modifica lo stato a cui accede block, il flusso eseguirà di nuovo block, registrando nuovamente lo stato dello snapshot a cui è stato eseguito l'accesso. Se il risultato di block non è equal to il risultato precedente, il flusso emetterà il nuovo risultato. Questo comportamento è simile a quello di Flow.distinctUntilChanged. La raccolta continuerà a tempo indeterminato, a meno che non venga esplicitamente annullata o limitata dall'uso di altri operatori Flow.

import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.snapshotFlow

// Define Snapshot state objects
var greeting by mutableStateOf("Hello")
var person by mutableStateOf("Adam")

// ...

// Create a flow that will emit whenever our person-specific greeting changes
val greetPersonFlow = snapshotFlow { "$greeting, $person" }

// ...

val collectionScope: CoroutineScope = TODO("Use your scope here")

// Collect the flow and offer greetings!
collectionScope.launch {
    greetPersonFlow.collect {
        println(greeting)
    }
}

// ...

// Change snapshot state; greetPersonFlow will emit a new greeting
Snapshot.withMutableSnapshot {
    greeting = "Ahoy"
    person = "Sean"
}

block viene eseguito in Snapshot di sola lettura e non può modificare i dati dello snapshot. Se block tenta di modificare i dati degli snapshot, la raccolta del flusso non andrà a buon fine con IllegalStateException.

block può essere eseguito più di una volta per insiemi uguali di input o solo una volta dopo molte modifiche rapide degli snapshot; dovrebbe essere idempotente e privo di effetti collaterali.

Quando lavori con lo stato Snapshot è utile tenere a mente la distinzione tra eventi e stato. snapshotFlow modella le modifiche agli snapshot come eventi, ma gli eventi non possono essere modellati in modo efficace come stato osservabile. Lo stato osservabile è una compressione con perdita degli eventi che lo hanno generato.

Un evento osservabile si verifica in un determinato momento e viene eliminato. Tutti gli osservatori registrati nel momento in cui si è verificato l'evento ricevono una notifica. Tutti i singoli eventi di uno stream vengono considerati pertinenti e possono basarsi l'uno sull'altro. Gli eventi uguali ripetuti hanno un significato, pertanto un osservatore registrato deve osservare tutti gli eventi senza ignorarli.

Lo stato osservabile genera eventi di modifica quando lo stato passa da un valore a un nuovo valore disuguale. Gli eventi di modifica dello stato vengono confusi; viene preso in considerazione solo lo stato più recente. Gli osservatori dei cambiamenti di stato devono quindi essere idempotenti; dato lo stesso valore di stato, l'osservatore dovrebbe produrre lo stesso risultato. Per un osservatore di stato è valido sia saltare gli stati intermedi sia eseguire più volte lo stesso stato e il risultato deve essere lo stesso.

informazionidiorigine

CM

Aggiunto in 1.0.0

@ComposeCompilerApi
fun sourceInformation(composer: Composer, sourceInformation: String): Unit

Una funzione interna di Compose. NON chiamare direttamente.

Registra le informazioni di origine che possono essere utilizzate per la creazione di strumenti per determinare la posizione di origine della funzione componibile corrispondente. Per impostazione predefinita, questa funzione è dichiarata senza effetti collaterali. Gli strumenti per la riduzione del codice (come R8 o ProGuard) possono rimuoverlo.

sourceInformationMarkerEnd

CM

Aggiunto in 1.0.0

@ComposeCompilerApi
fun sourceInformationMarkerEnd(composer: Composer): Unit

Una funzione interna di Compose. NON chiamare direttamente.

Registra la fine di un indicatore delle informazioni di origine che può essere utilizzato per gli strumenti per determinare la posizione di origine della funzione componibile corrispondente che altrimenti non richiedono informazioni di monitoraggio come le funzioni ReadOnlyComposable. Per impostazione predefinita, questa funzione è dichiarata senza effetti collaterali. Gli strumenti per la riduzione del codice (come R8 o ProGuard) possono rimuoverlo.

È importante che sourceInformationMarkerStart e sourceInformationMarkerEnd vengano rimossi insieme o che vengano conservati entrambi. La rimozione di un solo elemento causerà un comportamento di runtime errato.

sourceInformationMarkerStart

CM

Aggiunto in 1.0.0

@ComposeCompilerApi
fun sourceInformationMarkerStart(
    composer: Composer,
    key: Int,
    sourceInformation: String
): Unit

Una funzione interna di Compose. NON chiamare direttamente.

Registra l'inizio di un indicatore delle informazioni di origine che può essere utilizzato per gli strumenti per determinare la posizione di origine della funzione componibile corrispondente che altrimenti non richiedono informazioni di monitoraggio come le funzioni ReadOnlyComposable. Per impostazione predefinita, questa funzione è dichiarata senza effetti collaterali. Gli strumenti per la riduzione del codice (come R8 o ProGuard) possono rimuoverlo.

È importante che sourceInformationMarkerStart e sourceInformationMarkerEnd vengano rimossi insieme o che vengano conservati entrambi. La rimozione di un solo elemento causerà un comportamento di runtime errato.

staticComposizioneLocalOf

CM

Aggiunto in 1.0.0

fun <T : Any?> staticCompositionLocalOf(defaultFactory: () -> T): ProvidableCompositionLocal<T>

Crea una chiave CompositionLocal che possa essere fornita utilizzando CompositionLocalProvider.

A differenza di compositionLocalOf, le letture di un staticCompositionLocalOf non vengono monitorate dal compositore e la modifica del valore fornito nella chiamata CompositionLocalProvider causerà la ricomposizione dell'intero contenuto, anziché solo dei punti in cui nella composizione viene utilizzato il valore locale. Questa mancanza di monitoraggio, tuttavia, rende più efficiente un staticCompositionLocalOf quando è molto improbabile che il valore fornito cambi o non cambierà mai. Ad esempio, è improbabile che il contesto Android, i caricatori di caratteri o valori condivisi simili cambino per i componenti nei contenuti di un CompositionLocalProvider e dovresti prendere in considerazione l'utilizzo di un staticCompositionLocalOf. Un colore o un altro tema come il valore potrebbero cambiare o persino essere animati, pertanto devi utilizzare un compositionLocalOf.

staticCompositionLocalOf crea un ProvidableCompositionLocal che può essere utilizzato in una chiamata al numero CompositionLocalProvider. Analogamente a MutableList rispetto a List, se la chiave viene resa pubblica come CompositionLocal anziché ProvidableCompositionLocal, può essere letta utilizzando CompositionLocal.current, ma non rifornita.

Parametri
defaultFactory: () -> T	una fabbrica di valori per fornire un valore quando non viene fornito un valore. Questa fabbrica viene richiamata quando non viene fornito alcun valore tramite un CompositionLocalProvider del chiamante del componente utilizzando CompositionLocal.current. Se non è possibile fornire valori predefiniti ragionevoli, valuta la possibilità di generare un'eccezione.

Vedi anche
CompositionLocal
compositionLocalOf

structuralEqualityPolicy

CM

Aggiunto in 1.0.0

fun <T : Any?> structuralEqualityPolicy(): SnapshotMutationPolicy<T>

Un criterio per trattare i valori di un MutableState come equivalenti se sono strutturalmente (==) uguali.

L'impostazione di MutableState.value sul valore strutturale attuale (==) non è considerata una modifica. Quando applichi un valore MutableSnapshot, se lo snapshot modifica il valore equivalente allo snapshot principale non viene considerato un conflitto.

traceEventEnd

CM

Aggiunto in 1.2.0

@ComposeCompilerApi
fun traceEventEnd(): Unit

API di tracciamento interno.

Dovrebbe essere chiamato senza sincronizzazione dei thread con perdita di informazioni occasionale.

traceEventStart

CM

Aggiunto in 1.2.0

@ComposeCompilerApi
fun traceEventStart(key: Int, dirty1: Int, dirty2: Int, info: String): Unit

API di tracciamento interno.

Dovrebbe essere chiamato senza sincronizzazione dei thread con perdita di informazioni occasionale.

Parametri
dirty1: Int	metadati $dirty: ricomposizione forzata e parametri della funzione 1..10 se presenti
dirty2: Int	metadati $dirty2: ricomposizione forzata e parametri della funzione 11..20 se presenti

conFrameMillis

CM

suspend fun <R : Any?> withFrameMillis(onFrame: (frameTimeMillis: Long) -> R): R

Esegue la sospensione finché non viene richiesto un nuovo frame, richiama immediatamente onFrame con la durata frame in millisecondi nel contesto di chiamata dell'invio dei frame, quindi riprende con il risultato da onFrame.

frameTimeMillis deve essere utilizzato durante il calcolo dei delta della durata dell'animazione da un fotogramma all'altro, in quanto può essere normalizzato al tempo target per il frame, non necessariamente a un valore "ora" diretto.

La base di tempo del valore fornito da MonotonicFrameClock.withFrameMillis è definita per l'implementazione. I valori temporali specificati aumentano monotonicamente; una volta completata una chiamata a withFrameMillis, non deve essere fornito un valore inferiore per una chiamata successiva.

Questa funzione richiama MonotonicFrameClock.withFrameNanos utilizzando il MonotonicFrameClock di CoroutineContext della chiamata e genera un IllegalStateException se non è presente in CoroutineContext.

conFrameNanos

CM

suspend fun <R : Any?> withFrameNanos(onFrame: (frameTimeNanos: Long) -> R): R

Esegue la sospensione finché non viene richiesto un nuovo frame, richiama immediatamente onFrame con la durata frame in nanosecondi nel contesto di chiamata dell'invio del frame, quindi riprende con il risultato da onFrame.

frameTimeNanos deve essere utilizzato durante il calcolo dei delta della durata dell'animazione da un fotogramma all'altro, in quanto può essere normalizzato al tempo target per il frame, non necessariamente a un valore "ora" diretto.

La base di tempo del valore fornito da withFrameNanos è definita per l'implementazione. I valori di tempo forniti sono rigorosamente monotonicamente incrementati; una volta completata una chiamata a withFrameNanos, non deve restituire di nuovo lo stesso valore per una chiamata successiva.

Questa funzione richiama MonotonicFrameClock.withFrameNanos utilizzando il MonotonicFrameClock di CoroutineContext della chiamata e genera un IllegalStateException se non è presente in CoroutineContext.

withRunningRecomposer

CM

suspend fun <R : Any?> withRunningRecomposer(block: suspend CoroutineScope.(recomposer: Recomposer) -> R): R

Esegue block con un nuovo Recomposer attivo che applica modifiche all'CoroutineContext di chiamata. L'importo di Recomposer sarà closed dopo i resi di block. withRunningRecomposer verrà ripristinato quando Recomposer sarà Recomposer.State.ShutDown e tutti i job secondari lanciati da block avranno joined.

Funzioni di estensione

comeDoppioStato

CM

Aggiunto in 1.5.0

fun State<Double>.asDoubleState(): DoubleState

Converte un State<Double> (ossia un State di Double in scatola) in Double con supporto primitivo. Lo stato verrà automaticamente unboxed al tipo primitivo richiesto. Lo stato restituito è di sola lettura. Lo stato restituito rispecchierà i valori dello stato di base e applicherà gli aggiornamenti come definito dal destinatario.

Sulla JVM, questa conversione non evita il "autoboxing" che Double tenta di eseguire l'escape, ma ha invece lo scopo di consentire l'interoperabilità tra i componenti che utilizzano una rappresentazione di uno stato di tipo Double.

StatoAsFloat

CM

Aggiunto in 1.5.0

fun State<Float>.asFloatState(): FloatState

Converte un State<Float> (ossia un State di Float in scatola) in Float con supporto primitivo. Lo stato verrà automaticamente unboxed al tipo primitivo richiesto. Lo stato restituito è di sola lettura. Lo stato restituito rispecchierà i valori dello stato di base e applicherà gli aggiornamenti come definito dal destinatario.

Sulla JVM, questa conversione non evita il "autoboxing" che Float tenta di eseguire l'escape, ma ha invece lo scopo di consentire l'interoperabilità tra i componenti che utilizzano una rappresentazione di uno stato di tipo Float.

StatoInt

CM

Aggiunto in 1.5.0

fun State<Int>.asIntState(): IntState

Converte un State<Int> (ossia un State di Int in scatola) in IntState con supporto primitivo. Lo stato verrà automaticamente unboxed al tipo primitivo richiesto. Lo stato restituito è di sola lettura. Lo stato restituito rispecchierà i valori dello stato di base e applicherà gli aggiornamenti come definito dal destinatario.

Sulla JVM, questa conversione non evita il "autoboxing" che IntState tenta di eseguire l'escape, ma ha invece lo scopo di consentire l'interoperabilità tra i componenti che utilizzano una rappresentazione di uno stato di tipo Int.

StatoAsLungo

CM

Aggiunto in 1.5.0

fun State<Long>.asLongState(): LongState

Converte un State<Long> (ossia un State di Long in scatola) in LongState con supporto primitivo. Lo stato verrà automaticamente unboxed al tipo primitivo richiesto. Lo stato restituito è di sola lettura. Lo stato restituito rispecchierà i valori dello stato di base e applicherà gli aggiornamenti come definito dal destinatario.

Sulla JVM, questa conversione non evita il "autoboxing" che LongState tenta di eseguire l'escape, ma ha invece lo scopo di consentire l'interoperabilità tra i componenti che utilizzano una rappresentazione di uno stato di tipo Long.

cache

CM

Aggiunto in 1.0.0

@ComposeCompilerApi
inline fun <T : Any?> Composer.cache(
    invalid: Boolean,
    block: @DisallowComposableCalls () -> T
): T

Un'API del plug-in di compilazione Compose. NON chiamare direttamente.

Memorizzare nella cache un valore nei dati di composizione di una composizione. Viene usato per implementare remember e usato dal plug-in di compilazione per generare chiamate più efficienti a remember quando determina che queste ottimizzazioni sono sicure.

Stato raccolta

CM

@Composable
fun <T : Any?> StateFlow<T>.collectAsState(
    context: CoroutineContext = EmptyCoroutineContext
): State<T>

Raccoglie valori da StateFlow e rappresenta il valore più recente tramite State. StateFlow.value viene utilizzato come valore iniziale. Ogni volta che viene pubblicato un nuovo valore in StateFlow, viene aggiornato il valore State restituito, causando la ricomposizione di ogni utilizzo di State.value.

import androidx.compose.material.Text
import androidx.compose.runtime.collectAsState

val value: String by stateFlow.collectAsState()
Text("Value is $value")

Parametri
context: CoroutineContext = EmptyCoroutineContext	CoroutineContext da utilizzare per la raccolta.

Stato raccolta

CM

@Composable
fun <T : R, R : Any?> Flow<T>.collectAsState(
    initial: R,
    context: CoroutineContext = EmptyCoroutineContext
): State<R>

Raccoglie valori da Flow e rappresenta il valore più recente tramite State. Ogni volta che viene pubblicato un nuovo valore in Flow, viene aggiornato il valore State restituito, causando la ricomposizione di ogni utilizzo di State.value.

import androidx.compose.material.Text
import androidx.compose.runtime.collectAsState

val value: String by flow.collectAsState("initial")
Text("Value is $value")

Parametri
context: CoroutineContext = EmptyCoroutineContext	CoroutineContext da utilizzare per la raccolta.

getValue

CM

Aggiunto in 1.5.0

inline operator fun DoubleState.getValue(thisObj: Any?, property: KProperty<*>): Double

Consente la delega di proprietà di val utilizzando by per DoubleState.

getValue

CM

inline operator fun FloatState.getValue(thisObj: Any?, property: KProperty<*>): Float

Consente la delega di proprietà di val utilizzando by per FloatState.

getValue

CM

Aggiunto in 1.5.0

inline operator fun IntState.getValue(thisObj: Any?, property: KProperty<*>): Int

Consente la delega di proprietà di val utilizzando by per IntState.

getValue

CM

Aggiunto in 1.5.0

inline operator fun LongState.getValue(thisObj: Any?, property: KProperty<*>): Long

Consente la delega di proprietà di val utilizzando by per LongState.

getValue

CM

inline operator fun <T : Any?> State<T>.getValue(thisObj: Any?, property: KProperty<*>): T

Consente la delega di proprietà di val utilizzando by per State.

import androidx.compose.foundation.layout.Row
import androidx.compose.material.Text

// Composable function that manages a subscription to a data source, returning it as State
@Composable
fun observeSampleData(): State<String> = TODO()

// Subscription is managed here, but currentValue is not read yet
val currentValue by observeSampleData()

Row {
    // This scope will recompose when currentValue changes
    Text("Data: $currentValue")
}

Valore

CM

Aggiunto in 1.5.0

inline operator fun MutableDoubleState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Double
): Unit

Consente la delega di proprietà di var utilizzando by per MutableDoubleState.

Valore

CM

inline operator fun MutableFloatState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Float
): Unit

Consente la delega di proprietà di var utilizzando by per MutableFloatState.

Valore

CM

Aggiunto in 1.5.0

inline operator fun MutableIntState.setValue(thisObj: Any?, property: KProperty<*>, value: Int): Unit

Consente la delega di proprietà di var utilizzando by per MutableIntState.

Valore

CM

Aggiunto in 1.5.0

inline operator fun MutableLongState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Long
): Unit

Consente la delega di proprietà di var utilizzando by per MutableLongState.

Valore

CM

Aggiunto in 1.0.0

inline operator fun <T : Any?> MutableState<T>.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: T
): Unit

Consente la delega di proprietà di var utilizzando by per MutableState.

import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

var count by remember { mutableStateOf(0) }

Text(text = "You clicked $count times")
Button(onClick = { count = count + 1 }) {
    Text("Click me")
}

toMutableStateList

CM

fun <T : Any?> Collection<T>.toMutableStateList(): SnapshotStateList<T>

Crea un'istanza di MutableList da una raccolta osservabile e che può essere istantanea.

toMutableStateMap

CM

fun <K : Any?, V : Any?> Iterable<Pair<K, V>>.toMutableStateMap(): SnapshotStateMap<K, V>

Crea un'istanza di MutableMap<k, v=""> da una raccolta di coppie osservabile e che può essere istantanea.</k,>

conFrameMillis

CM

suspend inline fun <R : Any?> MonotonicFrameClock.withFrameMillis(
    crossinline onFrame: (frameTimeMillis: Long) -> R
): R

Esegue la sospensione finché non viene richiesto un nuovo frame, richiama immediatamente onFrame con la durata frame in millisecondi nel contesto di chiamata dell'invio dei frame, quindi riprende con il risultato da onFrame.

frameTimeMillis deve essere utilizzato durante il calcolo dei delta della durata dell'animazione da un fotogramma all'altro, in quanto può essere normalizzato al tempo target per il frame, non necessariamente a un valore "ora" diretto.

La base di tempo del valore fornito da MonotonicFrameClock.withFrameMillis è definita per l'implementazione. I valori temporali specificati aumentano monotonicamente; una volta completata una chiamata a withFrameMillis, non deve essere fornito un valore inferiore per una chiamata successiva.

Proprietà di primo livello

Orologio monotonico predefinito

Cmn android

val DefaultMonotonicFrameClock: MonotonicFrameClock

Questa proprietà è deprecata.
I dispositivi MonotonicFrameClock non sono applicabili a livello globale su più piattaforme. Usa un orologio locale appropriato.

MonotonicFrameClock utilizzato da withFrameNanos e withFrameMillis, se non è presente nell'elemento kotlin.coroutines.CoroutineContext di chiamata.

Questo valore non è più utilizzato dal runtime di composizione.

compositore attuale

CM

Aggiunto in 1.0.0

val currentComposer: Composer

TODO(lmr): fornire la documentazione

correnteCompositeKeyHash

CM

Aggiunto in 1.0.0

val currentCompositeKeyHash: Int

Si tratta di un valore hash utilizzato per coordinare la mappatura dello stato memorizzato esternamente alla composizione. Ad esempio, questo valore viene utilizzato dallo stato dell'istanza salvata per preservare lo stato oltre i limiti della durata dell'attività.

Questo valore è probabilmente univoco, ma non ne è garantito l'unicità. Esistono casi noti, ad esempio i loop for senza key, in cui il runtime non ha informazioni sufficienti per rendere univoco l'hash della chiave composta.

ContestoLocaleComposizioneattuale

CM

Aggiunto in 1.1.0

val currentCompositionLocalContext: CompositionLocalContext

Restituisce l'attuale CompositionLocalContext che contiene tutti gli elementi di CompositionLocal nella composizione corrente e i relativi valori forniti da CompositionLocalProvider. Questo contesto può essere utilizzato per trasmettere i residenti in un'altra composizione tramite CompositionLocalProvider. Questa operazione è solitamente necessaria se un'altra composizione non è una sottocomposizione di quella corrente.

correnteRecomposeScope

CM

Aggiunto in 1.0.0

val currentRecomposeScope: RecomposeScope

Restituisce un oggetto che può essere utilizzato per invalidare l'ambito corrente a questo punto della composizione. Questo oggetto può essere utilizzato per causare manualmente ricomposizioni.

Proprietà estensione

monotonicFrameClock

CM

Aggiunto in 1.0.0

@ExperimentalComposeApi
val CoroutineContext.monotonicFrameClock: MonotonicFrameClock

Restituisce MonotonicFrameClock per questo CoroutineContext o restituisce IllegalStateException se non è presente.

ricomponiCoroutineContext

CM

Aggiunto in 1.0.0

@ExperimentalComposeApi
val ControlledComposition.recomposeCoroutineContext: CoroutineContext

Il CoroutineContext che dovrebbe essere utilizzato per eseguire ricomposizioni simultanee di ControlledComposition quando utilizzato in un ambiente che supporta la composizione simultanea.

Vedi Recomposer.runRecomposeConcurrentlyAndApplyChanges come esempio di configurazione di un ambiente di questo tipo.