androidx.compose.runtime

Bu sayfada, androidx.compose.runtime paketinde bulunan türler, özellikler ve işlevlerle ilgili belgeleri bulabilirsiniz. Örneğin:

Bunun yerine rehberlik almak istiyorsanız aşağıdaki Oluşturma kılavuzlarına göz atın:

Arayüzler

Applier

Uygulayıcı, bir beste sırasında yayınlanan ağaç tabanlı işlemlerin uygulanmasından sorumludur.
Cmn
ComposeNodeLifecycleCallback

ReusableContentHost ve ReusableContent içinde ReusableComposeNode veya ComposeNode ile yayınlanan düğümün yaşam döngüsünü gözlemler.
Cmn
Composer

Composer, Compose Kotlin derleyici eklentisi tarafından hedeflenen ve kod oluşturma yardımcıları tarafından kullanılan arayüzdür.
Cmn
Composition

Bir beste nesnesi genellikle sizin için oluşturulur ve başlangıçta kullanıcı arayüzü oluşturmak için kullanılan bir API'den döndürülür.
Cmn
CompositionLocalMap

Beste hiyerarşisinde belirli bir konumda ayarlanan CompositionLocals öğesinin salt okunur, sabit anlık görüntüsü.
Cmn
CompositionServiceKey

Composition uygulamaları tarafından isteğe bağlı olarak uygulanan CompositionServices arayüzünü kullanarak bir hizmeti bulma anahtarı.
Cmn
CompositionServices

Çalışma zamanından beste hizmetlerinin bulunmasını sağlar.
Cmn
CompositionTracer

Dahili izleme API'si.
Cmn
ControlledComposition

Kontrol edilen beste, arayan tarafından doğrudan kontrol edilebilen bir Composition'dir.
Cmn
DisposableEffectResult
Cmn
DoubleState

Bir Composable işlevi yürütülürken doubleValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
FloatState

Bir Composable işlevi yürütülürken floatValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
IntState

Bir Composable işlevi yürütülürken intValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
LongState

Bir Composable işlevi yürütülürken longValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
MonotonicFrameClock

Görüntülü reklam çerçeveleri için bir zaman kaynağı ve sonraki karede bir işlem gerçekleştirebilme olanağı sağlar.
Cmn
MutableDoubleState

Bir Composable işlevi yürütülürken doubleValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
MutableFloatState

Bir Composable işlevi yürütülürken floatValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
MutableIntState

Bir Composable işlevi yürütülürken intValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
MutableLongState

Bir Composable işlevi yürütülürken longValue özelliğine okunan bir değer sahibi, geçerli RecomposeScope öğesinin bu değerdeki değişikliklere abone olmasına neden olur.
Cmn
MutableState

Bir Composable işlevi yürütülürken value özelliğini okuyan değişken bir değer sahibi olan mevcut RecomposeScope, bu değerdeki değişikliklere abone olur.
Cmn
ProduceStateScope

produceState ile kullanılacak alıcı kapsamı.
Cmn
RecomposeScope

Beste hiyerarşisinin yeniden oluşturulabilir bir kapsamı veya bölümünü temsil eder.
Cmn
RecomposerInfo

Recomposer hakkında salt okunur bilgiler.
Cmn
RememberObserver

Bu arayüzü uygulayan nesneler, bir bestede ilk kez kullanıldıklarında ve artık kullanılmadıklarında bildirilir.
Cmn
ReusableComposition

ReusableComposition, farklı oluşturulabilecek içerikler için yeniden kullanılabilen bir Composition'dir.
Cmn
ScopeUpdateScope

Oluşturucunun bir yeniden derleme kapsamını yeniden oluşturmak için çağıracağı işlevi güncellemek için kullanılan dahili yazma derleyici eklentisi API'si.
Cmn
SnapshotMutationPolicy

mutableStateOf sonucunun nasıl raporlandığını ve durum nesnesinde değişiklikleri nasıl birleştirdiğini kontrol eden bir politika.
Cmn
State

Bir Composable işlevi yürütülürken value özelliğine okuma yapan bir değer sahibi olan mevcut RecomposeScope, bu değerdeki değişikliklere abone olur.
Cmn

Sınıflar

AbstractApplier

Soyut bir Applier uygulaması.
Cmn
AtomicReference
Cmn
BroadcastFrameClock

Basit bir çerçeve saat.
Cmn
CompositionContext

CompositionContext, iki besteyi mantıksal olarak "bağlamak" için kullanılan opak bir türdür.
Cmn
CompositionLocal

Oluşturma, verileri beste ağacından açık bir şekilde parametreler aracılığıyla birleştirilebilir işlevlere geçirir.
Cmn
CompositionLocalContext

CompositionLocal öğelerini ve değerlerini depolar.
Cmn
DisposableEffectScope

Herhangi bir DisposableEffect çağrısında son ifade olması gereken onDispose koşulunu sunan DisposableEffect için alıcı kapsamı.
Cmn
MovableContent

Compose derleyici eklentisi API'si.
Cmn
MovableContentState

Compose derleyici eklentisi API'si.
Cmn
MovableContentStateReference

Compose derleyici eklentisi API'si.
Cmn
PausableMonotonicFrameClock

paused ve resumed olabilecek bir MonotonicFrameClock sarmalayıcısı.
Cmn
ProvidableCompositionLocal

CompositionLocalProvider öğesinde değer sağlamak için ProvidableCompositionLocal kullanılabilir.
Cmn
ProvidedValue

CompositionLocalProvider tarafından sağlanan ve ProvidableCompositionLocal.provides sabit operatörü tarafından oluşturulan bir değeri barındıran bir örnek.
Cmn
Recomposer

Yeniden oluşturmayı gerçekleştirmek ve güncellemeleri bir veya daha fazla Composition öğesine uygulamak için planlayıcı.
Cmn
SkippableUpdater
Cmn
Updater

Bir düğümü başlatmak ve güncellemek için kod yazmaya yardımcı olmak için ComposeNode tarafından kullanılan bir yardımcı alıcı kapsam sınıfı.
Cmn

Nesneler

MonotonicFrameClock.Key
Cmn

Ek açıklamalar

CheckResult
Cmn
android
Composable

Composable işlevleri, Compose ile oluşturulan bir uygulamanın temel yapı taşlarıdır.
Cmn
ComposableInferredTarget

Yazma derleyici eklentisi tarafından oluşturulan ek açıklama.
Cmn
ComposableOpenTarget

Composable, belirli bir uygulayıcı beklemediğini beyan eder.
Cmn
ComposableTarget

Composable işlevi, applier adlı bir uygulayıcı gerektirecek şekilde tanımlanmıştır.
Cmn
ComposableTargetMarker

Bu ek açıklama, ComposableTarget kullanılarak bir ek açıklamayı eşdeğer olarak işaretlemek ve applier değeri olarak işaretlenen ek açıklamanın tam nitelikli adını almak için kullanılır.
Cmn
ComposeCompilerApi
Cmn
DisallowComposableCalls

Bu ayar, oluşturulabilir çağrıların geçerli olduğu işlevin içinde gerçekleşmesini önler.
Cmn
ExperimentalComposeApi
Cmn
ExperimentalComposeRuntimeApi
Cmn
ExplicitGroupsComposable

Bu ek açıklama, Composable işlevlerine uygulanabilir. Böylece, ek açıklama eklediği işlevin gövdesinde hiçbir grup oluşturulmaz.
Cmn
Immutable

Sınıfı sabit örnekler oluşturuyor olarak işaretlemek için Immutable kullanılabilir.
Cmn
InternalComposeApi
Cmn
InternalComposeTracingApi
Cmn
NoLiveLiterals

Bu ek açıklama, Compose Derleyici'ye, canlı hazır hazır değerler kod oluşturma açık olsa bile, uygulandığı bildirimin kapsamında canlı hazır değerler oluşturma girişiminde bulunmaması gerektiğini belirtmek için kullanılır.
Cmn
NonRestartableComposable

Bu ek açıklama, bu işlevin yürütülmesinin atlanmasına veya yeniden başlatılmasına izin verecek şekilde kod oluşturulmasını önlemek için Composable işlevlerine uygulanabilir.
Cmn
ReadOnlyComposable

Bu ek açıklama, Composable işlevlerine uygulanabilir. Böylece, ek açıklama eklediği işlevin gövdesinde hiçbir grup oluşturulmaz.
Cmn
Stable

Kararlı, yazma derleyicisine belirli bir türün veya işlevin nasıl davranacağına ilişkin bazı garantiler iletmek için kullanılır.
Cmn
StableMarker

StableMarker, bir ek açıklamayı türün kararlı olduğunu belirtecek şekilde işaretler.
Cmn
TestOnly
Cmn

Sıralamalar

Recomposer.State

Recomposer öğesinin geçerli operasyonel durumları.
Cmn

Üst düzey işlevlerin özeti

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

T türünün bileşimine bir düğüm yayar.
Cmn
inline Unit
@Composable
<T : Any?, E : Applier<*>> ComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit,
    content: @Composable () -> Unit
)

T türünün bileşimine bir düğüm yayar.
Cmn
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
)

T türünün bileşimine bir düğüm yayar.
Cmn
Composition
Composition(applier: Applier<*>, parent: CompositionContext)

Bu yöntem, bir beste başlatmanın yoludur.
Cmn
Composition
@ExperimentalComposeApi
Composition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
)

parent adlı çocuğun alt öğesi olarak besteyi yönetmek için applier kullanarak bir Composition oluşturun.
Cmn
Unit
@Composable
CompositionLocalProvider(
    context: CompositionLocalContext,
    content: @Composable () -> Unit
)

CompositionLocalProvider, değerleri context tarafından sağlanan CompositionLocal değerlerine bağlar.
Cmn
Unit
@Composable
CompositionLocalProvider(
    value: ProvidedValue<*>,
    content: @Composable () -> Unit
)

CompositionLocalProvider, değeri ProvidableCompositionLocal anahtarına bağlar.
Cmn
Unit
@Composable
CompositionLocalProvider(
    vararg values: ProvidedValue<*>,
    content: @Composable () -> Unit
)

CompositionLocalProvider, değerleri ProvidableCompositionLocal anahtara bağlar.
Cmn
ControlledComposition

Bu yöntem, bir beste başlatmanın bir yoludur.
Cmn
ControlledComposition
@TestOnly
@ExperimentalComposeApi
ControlledComposition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
)
Cmn
Unit

Bu işlev kullanımdan kaldırılmıştır. DisposableEffect, DisposableEffect'in kimliğini tanımlayan, önceki etkisinin ne zaman atılacağını ve yeni anahtar için yeni bir etkinin ne zaman başlatılacağını belirleyen bir veya daha fazla "anahtar" parametresi sağlamalıdır.
Cmn
Unit

Yeni bir benzersiz key1 değeri için çalışması ve key1 değişirse ya da DisposableEffect besteden ayrılırsa geri alınması veya temizlenmesi gereken bir bestenin yan etkisi.
Cmn
Unit

Yeni bir benzersiz keys değeri için çalışması gereken bir bestenin yan etkisi; keys değişirse veya DisposableEffect besteden ayrılırsa tersine çevrilmesi ya da temizlenmesi gerekir.
Cmn
Unit

Yeni bir key1 veya key2 değeri için çalışması gereken bir bestenin yan etkisi; key1 veya key2 değişirse ya da DisposableEffect besteden ayrılırsa geri alınması veya temizlenmesi gerekir.
Cmn
Unit
@Composable
@NonRestartableComposable
DisposableEffect(
    key1: Any?,
    key2: Any?,
    key3: Any?,
    effect: DisposableEffectScope.() -> DisposableEffectResult
)

Yeni benzersiz key1, key2 veya key3 değerleri için çalışması gereken bir bestenin yan etkisi; key1, key2 veya key3 değişirse ya da DisposableEffect besteden ayrılırsa geri alınması veya temizlenmesi gerekir.
Cmn
Unit

Bu işlev kullanımdan kaldırılmıştır. LaunchedEffect, LaunchedEffect'in kimliğini tanımlayan bir veya daha fazla "anahtar" parametresi sağlamalıdır. Bu parametre, önceki etki eşgüdümünün ne zaman iptal edileceğini ve yeni anahtar için yeni bir efektin ne zaman kullanıma sunulacağını belirler.
Cmn
Unit

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır.
Cmn
Unit
@Composable
@NonRestartableComposable
LaunchedEffect(vararg keys: Any?, block: suspend CoroutineScope.() -> Unit)

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır.
Cmn
Unit
@Composable
@NonRestartableComposable
LaunchedEffect(key1: Any?, key2: Any?, block: suspend CoroutineScope.() -> Unit)

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır.
Cmn
Unit
@Composable
@NonRestartableComposable
LaunchedEffect(key1: Any?, key2: Any?, key3: Any?, block: suspend CoroutineScope.() -> Unit)

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır.
Cmn
inline Unit
@Composable
<T : Any, E : Applier<*>> ReusableComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit
)

T türünün bileşimine geri dönüştürülebilir bir düğüm yayar.
Cmn
inline Unit
@Composable
<T : Any?, E : Applier<*>> ReusableComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit,
    content: @Composable () -> Unit
)

T türünün bileşimine geri dönüştürülebilir bir düğüm yayar.
Cmn
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
)

T türünün bileşimine geri dönüştürülebilir bir düğüm yayar.
Cmn
ReusableComposition

Bu yöntem, yeniden kullanılabilir bir bestenin başlatılmasının yoludur.
Cmn
inline Unit
@Composable
ReusableContent(key: Any?, content: @Composable () -> Unit)

Bir besteyi destekleyici geri dönüşüm olarak işaretlemek için kullanılan yardımcı program işlevi.
Cmn
inline Unit
@Composable
@ExplicitGroupsComposable
ReusableContentHost(
    active: Boolean,
    crossinline content: @Composable () -> Unit
)

ReusableContent barındırılırken kullanılan isteğe bağlı bir yardımcı program işlevi.
Cmn
Unit

effect programını mevcut beste başarıyla tamamlandığında ve değişiklikleri uyguladığında çalışacak şekilde planlayın.
Cmn
ProvidableCompositionLocal<T>
<T : Any?> compositionLocalOf(
    policy: SnapshotMutationPolicy<T>,
    defaultFactory: () -> T
)

CompositionLocalProvider kullanılarak sağlanabilecek bir CompositionLocal anahtarı oluşturun.
Cmn
State<T>
@StateFactoryMarker
<T : Any?> derivedStateOf(calculation: () -> T)

State.value işlevinin calculation sonucu olduğu bir State nesnesi oluşturur.
Cmn
State<T>
@StateFactoryMarker
<T : Any?> derivedStateOf(
    policy: SnapshotMutationPolicy<T>,
    calculation: () -> T
)

State.value işlevinin calculation sonucu olduğu bir State nesnesi oluşturur.
Cmn
Boolean

Dahili izleme API'si.
Cmn
inline T
@Composable
<T : Any?> key(vararg keys: Any?, block: @Composable () -> T)

key, bir beste içindeki yürütme blokunu "gruplandırmak" veya "anahtarlamak" için kullanılan bir yardımcı programdır.
Cmn
@Composable () -> Unit
movableContentOf(content: @Composable () -> Unit)

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable (P) -> Unit
<P : Any?> movableContentOf(content: @Composable (P) -> Unit)

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable (P1, P2) -> Unit
<P1 : Any?, P2 : Any?> movableContentOf(content: @Composable (P1, P2) -> Unit)

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable (P1, P2, P3) -> Unit
<P1 : Any?, P2 : Any?, P3 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3) -> Unit
)

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable (P1, P2, P3, P4) -> Unit
<P1 : Any?, P2 : Any?, P3 : Any?, P4 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3, P4) -> Unit
)

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable R.() -> Unit
<R : Any?> movableContentWithReceiverOf(content: @Composable R.() -> Unit)

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable R.(P) -> Unit
<R : Any?, P : Any?> movableContentWithReceiverOf(content: @Composable R.(P) -> Unit)

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable R.(P1, P2) -> Unit
<R : Any?, P1 : Any?, P2 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2) -> Unit
)

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
@Composable R.(P1, P2, P3) -> Unit
<R : Any?, P1 : Any?, P2 : Any?, P3 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2, P3) -> Unit
)

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.
Cmn
MutableDoubleState

value içinde geçirilen ile başlatılmış yeni bir MutableDoubleState döndürme
Cmn
MutableFloatState

value içinde geçirilen ile başlatılmış yeni bir MutableFloatState döndürme
Cmn
MutableIntState

value içinde geçirilen ile başlatılmış yeni bir MutableIntState döndürme
Cmn
MutableLongState

value içinde geçirilen ile başlatılmış yeni bir MutableLongState döndürme
Cmn
SnapshotStateList<T>

Gözlemlenebilir ve anlık görüntü olabilecek bir MutableList örneği oluşturun.
Cmn
SnapshotStateList<T>
@StateFactoryMarker
<T : Any?> mutableStateListOf(vararg elements: T)

MutableList öğesinin gözlemlenebilir ve anlık görüntü olabilecek bir örneği oluşturun.
Cmn
SnapshotStateMap<K, V>

Gözlemlenebilir ve anlık görüntü olabilen bir MutableMap<k, v=""> örneği oluşturun.</k,>
Cmn
SnapshotStateMap<K, V>
@StateFactoryMarker
<K : Any?, V : Any?> mutableStateMapOf(vararg pairs: Pair<K, V>)

Gözlemlenebilir ve anlık görüntü olabilen bir MutableMap<k, v=""> örneği oluşturun.</k,>
Cmn
MutableState<T>

value içinde geçirilen ile başlatılmış yeni bir MutableState döndürme
Cmn
SnapshotMutationPolicy<T>

Bir politika, MutableState değerlerini hiçbir zaman eşdeğer olarak değerlendirmez.
Cmn
State<T>
@Composable
<T : Any?> produceState(initialValue: T, producer: suspend ProduceStateScope<T>.() -> Unit)

Tanımlı bir veri kaynağı olmadan zaman içinde değerler üreten gözlemlenebilir bir snapshot State döndürme.
Cmn
State<T>
@Composable
<T : Any?> produceState(initialValue: T, key1: Any?, producer: suspend ProduceStateScope<T>.() -> Unit)

key1 öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürün.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    vararg keys: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

keys öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürün.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

key1 ve key2 öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürme
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    key3: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

key1, key2 ve key3 öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürme
Cmn
SnapshotMutationPolicy<T>

MutableState değerlerinin referans olarak (===) eşit olması halinde bunların eşdeğeri olarak değerlendirilmesini sağlayan bir politika.
Cmn
inline T
@Composable
<T : Any?> remember(crossinline calculation: @DisallowComposableCalls () -> T)

calculation tarafından üretilen değeri unutmayın.
Cmn
inline T
@Composable
<T : Any?> remember(
    key1: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

key1 önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretin ve hatırlayın.
Cmn
inline T
@Composable
<T : Any?> remember(
    vararg keys: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

Tüm keys değerleri önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretin ve hatırlayın.
Cmn
inline T
@Composable
<T : Any?> remember(
    key1: Any?,
    key2: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

key1 ve key2 önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretip hatırlayın.
Cmn
inline T
@Composable
<T : Any?> remember(
    key1: Any?,
    key2: Any?,
    key3: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

key1, key2 ve key3 önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretip hatırlayın.
Cmn
CompositionContext

Mevcut bileşim noktasında bir CompositionContext oluşturma efekti.
Cmn
inline CoroutineScope

getContext tarafından sağlanan isteğe bağlı CoroutineContext öğesini kullanarak bestede bu noktaya bağlı bir CoroutineScope döndürün.
Cmn
State<T>
@Composable
<T : Any?> rememberUpdatedState(newValue: T)

Bir mutableStateOf için remember ve rememberUpdatedState çağrısının her yeniden oluşturmada değerini newValue olarak güncelleyin.
Cmn
Flow<T>
<T : Any?> snapshotFlow(block: () -> T)

Gözlemlenebilir Snapshot durumundan bir Flow oluşturun.
Cmn
Unit
@ComposeCompilerApi
sourceInformation(composer: Composer, sourceInformation: String)

Oluşturma dahili işlevi.
Cmn
Unit

Oluşturma dahili işlevi.
Cmn
Unit
@ComposeCompilerApi
sourceInformationMarkerStart(
    composer: Composer,
    key: Int,
    sourceInformation: String
)

Oluşturma dahili işlevi.
Cmn
ProvidableCompositionLocal<T>
<T : Any?> staticCompositionLocalOf(defaultFactory: () -> T)

CompositionLocalProvider kullanılarak sağlanabilecek bir CompositionLocal anahtarı oluşturun.
Cmn
SnapshotMutationPolicy<T>

MutableState değerlerinin yapısal olarak (==) eşit olması halinde bunların eşdeğeri olarak ele alınmasını sağlayan bir politika.
Cmn
Unit

Dahili izleme API'si.
Cmn
Unit
@ComposeCompilerApi
traceEventStart(key: Int, dirty1: Int, dirty2: Int, info: String)

Dahili izleme API'si.
Cmn
suspend R
<R : Any?> withFrameMillis(onFrame: (frameTimeMillis: Long) -> R)

Yeni bir kare istenene kadar askıya alınır, çerçeve dağıtımının çağrı bağlamında milisaniye cinsinden kare süresiyle hemen onFrame çağırır, ardından onFrame sonucuyla devam eder.
Cmn
suspend R
<R : Any?> withFrameNanos(onFrame: (frameTimeNanos: Long) -> R)

Yeni bir kare istenene kadar askıya alınır, çerçeve dağıtımının çağrı bağlamında nanosaniye cinsinden kare süresiyle hemen onFrame çağırır, ardından onFrame sonucuyla devam eder.
Cmn
suspend R
<R : Any?> withRunningRecomposer(block: suspend CoroutineScope.(recomposer: Recomposer) -> R)

block işlevini, CoroutineContext çağrısındaki değişiklikleri uygulayarak yeni ve etkin bir Recomposer ile çalıştırır.
Cmn

Uzantı işlevlerinin özeti

DoubleState

Bir State<Double> değerini (kutulu Double'lerden oluşan State) temel destekli bir Double değerine dönüştürür.
Cmn
FloatState

Bir State<Float> değerini (kutulu Float'lerden oluşan State) temel destekli bir Float değerine dönüştürür.
Cmn
IntState

Bir State<Int> değerini (kutulu Int'lerden oluşan State) temel destekli bir IntState değerine dönüştürür.
Cmn
LongState

Bir State<Long> değerini (kutulu Long'lerden oluşan State) temel destekli bir LongState değerine dönüştürür.
Cmn
inline T
@ComposeCompilerApi
<T : Any?> Composer.cache(
    invalid: Boolean,
    block: @DisallowComposableCalls () -> T
)

Compose derleyici eklentisi API'si.
Cmn
State<T>

Bu StateFlow öğesinden değerleri toplar ve State aracılığıyla en son değerini gösterir.
Cmn
State<R>
@Composable
<T : R, R : Any?> Flow<T>.collectAsState(initial: R, context: CoroutineContext)

Bu Flow öğesinden değerleri toplar ve State aracılığıyla en son değerini gösterir.
Cmn
inline operator Double
DoubleState.getValue(thisObj: Any?, property: KProperty<*>)

DoubleState için by kullanarak val mülklerine yetki verilmesine izin verir.
Cmn
inline operator Float
FloatState.getValue(thisObj: Any?, property: KProperty<*>)

FloatState için by kullanarak val mülklerine yetki verilmesine izin verir.
Cmn
inline operator Int
IntState.getValue(thisObj: Any?, property: KProperty<*>)

IntState için by kullanarak val mülklerine yetki verilmesine izin verir.
Cmn
inline operator Long
LongState.getValue(thisObj: Any?, property: KProperty<*>)

LongState için by kullanarak val mülklerine yetki verilmesine izin verir.
Cmn
inline operator T
<T : Any?> State<T>.getValue(thisObj: Any?, property: KProperty<*>)

State için by kullanarak val mülklerine yetki verilmesine izin verir.
Cmn
inline operator Unit
MutableDoubleState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Double
)

MutableDoubleState için by kullanarak var mülklerine yetki verilmesine izin verir.
Cmn
inline operator Unit
MutableFloatState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Float
)

MutableFloatState için by kullanarak var mülklerine yetki verilmesine izin verir.
Cmn
inline operator Unit
MutableIntState.setValue(thisObj: Any?, property: KProperty<*>, value: Int)

MutableIntState için by kullanarak var mülklerine yetki verilmesine izin verir.
Cmn
inline operator Unit
MutableLongState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Long
)

MutableLongState için by kullanarak var mülklerine yetki verilmesine izin verir.
Cmn
inline operator Unit
<T : Any?> MutableState<T>.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: T
)

MutableState için by kullanarak var mülklerine yetki verilmesine izin verir.
Cmn
SnapshotStateList<T>

Gözlemlenebilir ve anlık görüntü olabilen bir koleksiyondan MutableList örneği oluşturun.
Cmn
SnapshotStateMap<K, V>
<K : Any?, V : Any?> Iterable<Pair<K, V>>.toMutableStateMap()

Gözlemlenebilir ve anlık görüntü olabilen bir çiftler koleksiyonundan MutableMap<k, v=""> örneği oluşturun.</k,>
Cmn
suspend inline R
<R : Any?> MonotonicFrameClock.withFrameMillis(
    crossinline onFrame: (frameTimeMillis: Long) -> R
)

Yeni bir kare istenene kadar askıya alınır, çerçeve dağıtımının çağrı bağlamında milisaniye cinsinden kare süresiyle hemen onFrame çağırır, ardından onFrame sonucuyla devam eder.
Cmn

Üst düzey mülklerin özeti

MonotonicFrameClock

Bu özellik kullanımdan kaldırıldı. MonotonicFrameClocks, platformlar arasında genel olarak geçerli değildir.
Cmn
android
Composer

TODO(lmr): belge sağlayın
Cmn
Int

Bu, harici olarak depolanmış durumu bileşime koordine etmek için kullanılan bir karma değeridir.
Cmn
CompositionLocalContext

Geçerli bestedeki tüm CompositionLocal değerlerini ve bunların CompositionLocalProvider tarafından sağlanan değerlerini içeren geçerli CompositionLocalContext değerini döndürür.
Cmn
RecomposeScope

Yapının bu noktasında geçerli kapsamı geçersiz kılmak için kullanılabilecek bir nesne döndürür.
Cmn

Uzantı özellikleri özeti

MonotonicFrameClock

Bu CoroutineContext için MonotonicFrameClock değerini döndürür veya mevcut değilse IllegalStateException değerini döndürür.
Cmn
CoroutineContext

Eşzamanlı besteyi destekleyen bir ortamda kullanıldığında bu ControlledComposition öğesinin eş zamanlı olarak yeniden kompozisyonlarını gerçekleştirmek için kullanılması gereken CoroutineContext.
Cmn

Üst düzey işlevler

ComposeNode

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

T türünün bileşimine bir düğüm yayar.

E, currentComposer uygulamasının alt türü değilse bu işlev bir çalışma zamanı istisnası bildirir.

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++ }
        }
    }
}
Parametreler
noinline factory: () -> T

Yeni T örneğini oluşturacak bir işlev. Bu işlevin çağrılacağı garanti EDİLMEZ.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. Bu, emit her yürütüldüğünde çalışır. Bu işlev yerinde çağrılır ve satır içine alınır.
Aşağıdaki kaynakları da incelemenizi öneririz:
Updater
Applier
Composition

ComposeNode

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

T türünün bileşimine bir düğüm yayar. content içinde yayınlanan düğümler, yayınlanan düğümün alt öğeleri olur.

E, currentComposer uygulamasının alt türü değilse bu işlev bir çalışma zamanı istisnası bildirir.

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++ }
        }
    }
}
Parametreler
noinline factory: () -> T

Yeni T örneğini oluşturacak bir işlev. Bu işlevin çağrılacağı garanti EDİLMEZ.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. Bu, emit her yürütüldüğünde çalışır. Bu işlev yerinde çağrılır ve satır içine alınır.
content: @Composable () -> Unit

bu düğümün "alt öğelerini" yayacak olan oluşturulabilir içeriği oluşturur.
Aşağıdaki kaynakları da incelemenizi öneririz:
Updater
Applier
Composition

ComposeNode

Cmn 
@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

T türünün bileşimine bir düğüm yayar. content içinde yayınlanan düğümler, yayınlanan düğümün alt öğeleri olur.

E, currentComposer uygulamasının alt türü değilse bu işlev bir çalışma zamanı istisnası bildirir.

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++ }
        }
    }
}
Parametreler
noinline factory: () -> T

Yeni T örneğini oluşturacak bir işlev. Bu işlevin çağrılacağı garanti EDİLMEZ.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. Bu, emit her yürütüldüğünde çalışır. Bu işlev yerinde çağrılır ve satır içine alınır.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. update işlevinin aksine bu işlev Oluşturulabilir ve bu nedenle başka bir mekanizma tarafından geçersiz kılınmadığı sürece atlanır. Bu, hesaplamaların zaman içinde aynı girişlere sahip olabileceği düğümü güncellerken pahalı hesaplamalar yapmak için yararlı olabilir. Bu nedenle işlevin yürütülmesi atlanabilir.
content: @Composable () -> Unit

bu düğümün "alt öğelerini" yayacak olan oluşturulabilir içeriği oluşturur.
Aşağıdaki kaynakları da incelemenizi öneririz:
Updater
SkippableUpdater
Applier
Composition

Beste

Cmn
1.0.0 sürümünde eklendi
fun Composition(applier: Applier<*>, parent: CompositionContext): Composition

Bu yöntem, bir beste başlatmanın yoludur. parent şunlardan biri olabilir:

  • sağlanmasıyla birlikte gereklidir. Bestenin ihlali

  • üst öğesi yoksa Recomposer örneği sağlanmalıdır.

Kaynakları serbest bırakmak için besteye artık ihtiyaç duyulmadığında Composition.dispose yöntemini çağırmak önemlidir.

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++ }
        }
    }
}
Parametreler
applier: Applier<*>

Bestede kullanılacak Applier örneği.
parent: CompositionContext

Üst CompositionContext.
Aşağıdaki kaynakları da incelemenizi öneririz:
Applier
Composition
Recomposer

Beste

Cmn
1.0.0 sürümünde eklendi
@ExperimentalComposeApi
fun Composition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
): Composition

parent adlı çocuğun alt öğesi olarak besteyi yönetmek için applier kullanarak bir Composition oluşturun.

Eşzamanlı yeniden oluşturmayı destekleyen bir yapılandırmada kullanıldığında, ortama yeniden oluşturma işlemi için recomposeCoroutineContext kullanılması gerektiğine dair ipucu verir. Yeniden besteler

KompozisyonLocalProvider

Cmn
1.1.0 sürümünde eklendi
@Composable
fun CompositionLocalProvider(
    context: CompositionLocalContext,
    content: @Composable () -> Unit
): Unit

CompositionLocalProvider, değerleri context tarafından sağlanan CompositionLocal değerlerine bağlar. CompositionLocal işlevinin CompositionLocal.current kullanılarak okunması, content lambdasında doğrudan veya dolaylı olarak çağrılan tüm birleştirilebilir işlevler için context içinde depolanan değerlerde sağlanan değeri döndürür.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}
Aşağıdaki kaynakları da incelemenizi öneririz:
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

KompozisyonLocalProvider

Cmn
1.6.0-alpha07 sürümünde eklendi
@Composable
fun CompositionLocalProvider(
    value: ProvidedValue<*>,
    content: @Composable () -> Unit
): Unit

CompositionLocalProvider, değeri ProvidableCompositionLocal anahtarına bağlar. CompositionLocal işlevinin CompositionLocal.current kullanılarak okunması, content lambdasında doğrudan veya dolaylı olarak çağrılan tüm birleştirilebilir işlevler için CompositionLocalProvider value parametresinde sağlanan değeri döndürür.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}
Aşağıdaki kaynakları da incelemenizi öneririz:
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

KompozisyonLocalProvider

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

CompositionLocalProvider, değerleri ProvidableCompositionLocal anahtara bağlar. CompositionLocal işlevinin CompositionLocal.current kullanılarak okunması, content lambdasında doğrudan veya dolaylı olarak çağrılan tüm birleştirilebilir işlevler için CompositionLocalProvider values parametresinde sağlanan değeri döndürür.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}
Aşağıdaki kaynakları da incelemenizi öneririz:
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

KontrollüBileşim

Cmn
1.0.0 sürümünde eklendi
@TestOnly
fun ControlledComposition(applier: Applier<*>, parent: CompositionContext): ControlledComposition

Bu yöntem, bir beste başlatmanın bir yoludur. İsteğe bağlı olarak, bestenin üst öğenin bir alt bileşeni gibi davranması için bir parent sağlanabilir veya bir Recomposer sağlanabilir.

Kontrollü bir bileşim, kök bileşime iletilen Recomposer tarafından kontrol edilmesi yerine bileşimin doğrudan kontrol edilmesini sağlar.

Kaynakları serbest bırakmak için artık bu oluşturucunun Composition.dispose olarak adlandırılması önemlidir.

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++ }
        }
    }
}
Parametreler
applier: Applier<*>

Bestede kullanılacak Applier örneği.
parent: CompositionContext

Üst CompositionContext.
Aşağıdaki kaynakları da incelemenizi öneririz:
Applier
Composition
Recomposer

KontrollüBileşim

Cmn
1.0.0 sürümünde eklendi
@TestOnly
@ExperimentalComposeApi
fun ControlledComposition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
): ControlledComposition

Tek Kullanımlık Efekt

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

DisposableEffect besteden ayrılırsa tersine çevrilmesi veya temizlenmesi gereken bir bestenin yan etkisi.

En az bir key parametresi olmadan DisposableEffect çağırmak hatadır.

Tek Kullanımlık Efekt

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

Yeni bir benzersiz key1 değeri için çalışması ve key1 değişirse ya da DisposableEffect besteden ayrılırsa geri alınması veya temizlenmesi gereken bir bestenin yan etkisi.

DisposableEffect anahtarı, DisposableEffect kimliğini tanımlayan bir değerdir. Bir anahtar değişirse DisposableEffect, mevcut effect değerini dispose tutmalı ve effect numaralı telefonu tekrar arayarak sıfırlanmalıdır. Anahtarlara örnek olarak şunlar verilebilir:

  • Efektin abone olduğu gözlemlenebilir nesneler

  • Bir işlemin benzersiz istek parametreleridir. Bu parametreler değişirse iptal edip yeniden denenir

Farklı bir anahtar sağlandığında bir anahtarı başlatmak veya bir anahtara abone olmak ve yeniden başlatmak için DisposableEffect kullanılabilir. Böylece, yenisini başlatmadan önce eski işlem için temizlik yapılır. Örneğin:

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

    // ...
}

DisposableEffect, effect bloğunda son ifade olarak onDispose koşulunu içermelidir. Faaliyetinizin imha edilmesini gerektirmiyorsa bunun yerine bir SideEffect veya beste tarafından yönetilmesi gereken bir kortin başlatıyorsa LaunchedEffect olabilir.

effect numarasına yapılan her arama için dispose numaralı telefona bir arama yapılacağı garanti edilir. Hem effect hem de dispose her zaman bestenin uygulama görev dağıtıcısında çalıştırılır ve uygulayıcılar hiçbir zaman birbirleriyle, beste ağacına değişiklikler uygulayarak veya RememberObserver etkinlik geri çağırmalarıyla eşzamanlı olarak çalıştırılmaz.

Tek Kullanımlık Efekt

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

Yeni bir benzersiz keys değeri için çalışması gereken bir bestenin yan etkisi; keys değişirse veya DisposableEffect besteden ayrılırsa tersine çevrilmesi ya da temizlenmesi gerekir.

DisposableEffect anahtarı, DisposableEffect kimliğini tanımlayan bir değerdir. Bir anahtar değişirse DisposableEffect, mevcut effect değerini dispose tutmalı ve effect numaralı telefonu tekrar arayarak sıfırlanmalıdır. Anahtarlara örnek olarak şunlar verilebilir:

  • Efektin abone olduğu gözlemlenebilir nesneler

  • Bir işlemin benzersiz istek parametreleridir. Bu parametreler değişirse iptal edip yeniden denenir

Farklı bir anahtar sağlandığında bir anahtarı başlatmak veya bir anahtara abone olmak ve yeniden başlatmak için DisposableEffect kullanılabilir. Böylece, yenisini başlatmadan önce eski işlem için temizlik yapılır. Örneğin:

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

    // ...
}

DisposableEffect, effect bloğunda son ifade olarak onDispose koşulunu içermelidir. Faaliyetinizin imha edilmesini gerektirmiyorsa bunun yerine bir SideEffect veya beste tarafından yönetilmesi gereken bir kortin başlatıyorsa LaunchedEffect olabilir.

effect numarasına yapılan her arama için dispose numaralı telefona bir arama yapılacağı garanti edilir. Hem effect hem de dispose her zaman bestenin uygulama görev dağıtıcısında çalıştırılır ve uygulayıcılar hiçbir zaman birbirleriyle, beste ağacına değişiklikler uygulayarak veya RememberObserver etkinlik geri çağırmalarıyla eşzamanlı olarak çalıştırılmaz.

Tek Kullanımlık Efekt

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

Yeni bir key1 veya key2 değeri için çalışması gereken bir bestenin yan etkisi; key1 veya key2 değişirse ya da DisposableEffect besteden ayrılırsa geri alınması veya temizlenmesi gerekir.

DisposableEffect anahtarı, DisposableEffect kimliğini tanımlayan bir değerdir. Bir anahtar değişirse DisposableEffect, mevcut effect değerini dispose tutmalı ve effect numaralı telefonu tekrar arayarak sıfırlanmalıdır. Anahtarlara örnek olarak şunlar verilebilir:

  • Efektin abone olduğu gözlemlenebilir nesneler

  • Bir işlemin benzersiz istek parametreleridir. Bu parametreler değişirse iptal edip yeniden denenir

Farklı bir anahtar sağlandığında bir anahtarı başlatmak veya bir anahtara abone olmak ve yeniden başlatmak için DisposableEffect kullanılabilir. Böylece, yenisini başlatmadan önce eski işlem için temizlik yapılır. Örneğin:

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

    // ...
}

DisposableEffect, effect bloğunda son ifade olarak onDispose koşulunu içermelidir. Faaliyetinizin imha edilmesini gerektirmiyorsa bunun yerine bir SideEffect veya beste tarafından yönetilmesi gereken bir kortin başlatıyorsa LaunchedEffect olabilir.

effect numarasına yapılan her arama için dispose numaralı telefona bir arama yapılacağı garanti edilir. Hem effect hem de dispose her zaman bestenin uygulama görev dağıtıcısında çalıştırılır ve uygulayıcılar hiçbir zaman birbirleriyle, beste ağacına değişiklikler uygulayarak veya RememberObserver etkinlik geri çağırmalarıyla eşzamanlı olarak çalıştırılmaz.

Tek Kullanımlık Efekt

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

Yeni benzersiz key1, key2 veya key3 değerleri için çalışması gereken bir bestenin yan etkisi; key1, key2 veya key3 değişirse ya da DisposableEffect besteden ayrılırsa geri alınması veya temizlenmesi gerekir.

DisposableEffect anahtarı, DisposableEffect kimliğini tanımlayan bir değerdir. Bir anahtar değişirse DisposableEffect, mevcut effect değerini dispose tutmalı ve effect numaralı telefonu tekrar arayarak sıfırlanmalıdır. Anahtarlara örnek olarak şunlar verilebilir:

  • Efektin abone olduğu gözlemlenebilir nesneler

  • Bir işlemin benzersiz istek parametreleridir. Bu parametreler değişirse iptal edip yeniden denenir

Farklı bir anahtar sağlandığında bir anahtarı başlatmak veya bir anahtara abone olmak ve yeniden başlatmak için DisposableEffect kullanılabilir. Böylece, yenisini başlatmadan önce eski işlem için temizlik yapılır. Örneğin:

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

    // ...
}

DisposableEffect, effect bloğunda son ifade olarak onDispose koşulunu içermelidir. Faaliyetinizin imha edilmesini gerektirmiyorsa bunun yerine bir SideEffect veya beste tarafından yönetilmesi gereken bir kortin başlatıyorsa LaunchedEffect olabilir.

effect numarasına yapılan her arama için dispose numaralı telefona bir arama yapılacağı garanti edilir. Hem effect hem de dispose her zaman bestenin uygulama görev dağıtıcısında çalıştırılır ve uygulayıcılar hiçbir zaman birbirleriyle, beste ağacına değişiklikler uygulayarak veya RememberObserver etkinlik geri çağırmalarıyla eşzamanlı olarak çalıştırılmaz.

Başlatılan Efekt

Cmn
1.0.0 sürümünde eklendi
1.0.0 sürümünde kullanımdan kaldırıldı
@Composable
fun LaunchedEffect(block: suspend CoroutineScope.() -> Unit): Unit

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır. LaunchedEffect besteden ayrıldığında eş yordam cancelled olur.

En az bir key parametresi olmadan LaunchedEffect çağırmak hatadır.

Başlatılan Efekt

Cmn
1.0.0 sürümünde eklendi
@Composable
@NonRestartableComposable
fun LaunchedEffect(key1: Any?, block: suspend CoroutineScope.() -> Unit): Unit

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır. LaunchedEffect farklı bir key1 ile yeniden oluşturulduğunda eş yordam cancelled olacak ve yeniden başlatılacak. LaunchedEffect besteden ayrıldığında eş yordam cancelled olur.

Bu işlev, key1 öğesine iletilen MutableState içinde geri çağırma verilerini depolayarak geri çağırma etkinliklerine yanıt olarak devam eden görevleri (yeniden) başlatmak için kullanılmamalıdır. Bunun yerine, etkinlik geri çağırmalarına yanıt olarak bestenin kapsamında yer alan devam eden işleri başlatmak amacıyla kullanılabilecek bir CoroutineScope almak için rememberCoroutineScope bakın.

Başlatılan Efekt

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

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır. LaunchedEffect, farklı bir keys ile yeniden oluşturulduğunda eş yordam cancelled olacak ve yeniden başlatılacak. LaunchedEffect besteden ayrıldığında eş yordam cancelled olur.

Bu işlev, key öğesine iletilen MutableState içinde geri çağırma verilerini depolayarak geri çağırma etkinliklerine yanıt olarak devam eden görevleri (yeniden) başlatmak için kullanılmamalıdır. Bunun yerine, etkinlik geri çağırmalarına yanıt olarak bestenin kapsamında yer alan devam eden işleri başlatmak amacıyla kullanılabilecek bir CoroutineScope almak için rememberCoroutineScope bakın.

Başlatılan Efekt

Cmn
1.0.0 sürümünde eklendi
@Composable
@NonRestartableComposable
fun LaunchedEffect(key1: Any?, key2: Any?, block: suspend CoroutineScope.() -> Unit): Unit

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır. LaunchedEffect farklı bir key1 veya key2 ile yeniden oluşturulduğunda eş yordam cancelled olacak ve yeniden başlatılacak. LaunchedEffect besteden ayrıldığında eş yordam cancelled olur.

Bu işlev, key öğesine iletilen MutableState içinde geri çağırma verilerini depolayarak geri çağırma etkinliklerine yanıt olarak devam eden görevleri (yeniden) başlatmak için kullanılmamalıdır. Bunun yerine, etkinlik geri çağırmalarına yanıt olarak bestenin kapsamında yer alan devam eden işleri başlatmak amacıyla kullanılabilecek bir CoroutineScope almak için rememberCoroutineScope bakın.

Başlatılan Efekt

Cmn
1.0.0 sürümünde eklendi
@Composable
@NonRestartableComposable
fun LaunchedEffect(key1: Any?, key2: Any?, key3: Any?, block: suspend CoroutineScope.() -> Unit): Unit

LaunchedEffect besteye girdiğinde, bestenin CoroutineContext öğesinde block öğesini başlatır. LaunchedEffect farklı bir key1, key2 veya key3 ile yeniden oluşturulduğunda eş yordam cancelled olacak ve yeniden başlatılacak. LaunchedEffect besteden ayrıldığında eş yordam cancelled olur.

Bu işlev, key öğesine iletilen MutableState içinde geri çağırma verilerini depolayarak geri çağırma etkinliklerine yanıt olarak devam eden görevleri (yeniden) başlatmak için kullanılmamalıdır. Bunun yerine, etkinlik geri çağırmalarına yanıt olarak bestenin kapsamında yer alan devam eden işleri başlatmak amacıyla kullanılabilecek bir CoroutineScope almak için rememberCoroutineScope bakın.

ReusableComposeNode

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

T türünün bileşimine geri dönüştürülebilir bir düğüm yayar.

E, currentComposer uygulamasının alt türü değilse bu işlev bir çalışma zamanı istisnası bildirir.

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++ }
        }
    }
}
Parametreler
noinline factory: () -> T

Yeni T örneğini oluşturacak bir işlev. Bu işlevin çağrılacağı garanti EDİLMEZ.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. Bu, emit her yürütüldüğünde çalışır. Bu işlev yerinde çağrılır ve satır içine alınır.
Aşağıdaki kaynakları da incelemenizi öneririz:
Updater
Applier
Composition

ReusableComposeNode

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

T türünün bileşimine geri dönüştürülebilir bir düğüm yayar. content içinde yayınlanan düğümler, yayınlanan düğümün alt öğeleri olur.

E, currentComposer uygulamasının alt türü değilse bu işlev bir çalışma zamanı istisnası bildirir.

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++ }
        }
    }
}
Parametreler
noinline factory: () -> T

Yeni T örneğini oluşturacak bir işlev. Bu işlevin çağrılacağı garanti EDİLMEZ.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. Bu, emit her yürütüldüğünde çalışır. Bu işlev yerinde çağrılır ve satır içine alınır.
content: @Composable () -> Unit

bu düğümün "alt öğelerini" yayacak olan oluşturulabilir içeriği oluşturur.
Aşağıdaki kaynakları da incelemenizi öneririz:
Updater
Applier
Composition

ReusableComposeNode

Cmn 
@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

T türünün bileşimine geri dönüştürülebilir bir düğüm yayar. content içinde yayınlanan düğümler, yayınlanan düğümün alt öğeleri olur.

E, currentComposer uygulamasının alt türü değilse bu işlev bir çalışma zamanı istisnası bildirir.

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++ }
        }
    }
}
Parametreler
noinline factory: () -> T

Yeni T örneğini oluşturacak bir işlev. Bu işlevin çağrılacağı garanti EDİLMEZ.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. Bu, emit her yürütüldüğünde çalışır. Bu işlev yerinde çağrılır ve satır içine alınır.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit

Düğümde güncelleme gerçekleştiren bir işlev. update işlevinin aksine bu işlev Oluşturulabilir ve bu nedenle başka bir mekanizma tarafından geçersiz kılınmadığı sürece atlanır. Bu, hesaplamaların zaman içinde aynı girişlere sahip olabileceği düğümü güncellerken pahalı hesaplamalar yapmak için yararlı olabilir. Bu nedenle işlevin yürütülmesi atlanabilir.
content: @Composable () -> Unit

bu düğümün "alt öğelerini" yayacak olan oluşturulabilir içeriği oluşturur.
Aşağıdaki kaynakları da incelemenizi öneririz:
Updater
SkippableUpdater
Applier
Composition

Yeniden Kullanılabilir Bileşim

Cmn
1.6.0-alpha07 sürümünde eklendi
fun ReusableComposition(applier: Applier<*>, parent: CompositionContext): ReusableComposition

Bu yöntem, yeniden kullanılabilir bir bestenin başlatılmasının yoludur. Bestenin, üst öğenin alt bileşeni olarak davranması için parent sağlanabilir. Bestenin bir üst öğesi yoksa Recomposer örneği sağlanmalıdır.

Kaynakları serbest bırakmak için besteye artık ihtiyaç duyulmadığında Composition.dispose yöntemini çağırmak önemlidir.

Parametreler
applier: Applier<*>

Bestede kullanılacak Applier örneği.
parent: CompositionContext

Üst CompositionContext.
Aşağıdaki kaynakları da incelemenizi öneririz:
Applier
ReusableComposition
rememberCompositionContext

Yeniden Kullanılabilir İçerik

Cmn
1.0.0 sürümünde eklendi
@Composable
inline fun ReusableContent(key: Any?, content: @Composable () -> Unit): Unit

Bir besteyi destekleyici geri dönüşüm olarak işaretlemek için kullanılan yardımcı program işlevi. key değişirse beste yeni bir besteyle değiştirilir (key için olduğu gibi) ancak ReusableComposeNode tarafından yayınlanan yeniden kullanılabilir düğümler yeniden kullanılır.

Parametreler
key: Any?

geri dönüşümü tetiklemek için kullanılan değer. Farklı bir değerle yeniden birleştirilirse besteci yeni bir beste oluşturur ancak yeniden kullanılabilir düğümleri yeniden kullanmaya çalışır.
content: @Composable () -> Unit

ve geri dönüştürülebilen çocuklar için kullanılabilir.

ReusableContentHost

Cmn
1.2.0 sürümünde eklendi
@Composable
@ExplicitGroupsComposable
inline fun ReusableContentHost(
    active: Boolean,
    crossinline content: @Composable () -> Unit
): Unit

ReusableContent barındırılırken kullanılan isteğe bağlı bir yardımcı program işlevi. active yanlışsa, hatırlanan tüm nesneler besteden kaldırılarak silinmiş gibi değerlendirilir, ancak ağaç için oluşturulan düğüm kaldırılmaz. Beste daha sonra etkin hale geldiğinde düğümler, bestenin kullanım ömrünün rastgele bir şekilde uzatılmasına gerek kalmadan ReusableContent içeriğinin içinde yeniden kullanılabilir.

Parametreler
active: Boolean

active true olduğunda content normal şekilde oluşturulur. active false olduğunda içerik devre dışı bırakılır ve tüm hatırlanan durum sanki içerik silinmiş gibi kabul edilir ancak bestenin Applier öğesi tarafından yönetilen düğümler etkilenmez. active, true olur. Daha önce etkin olan bestedeki tüm yeniden kullanılabilir düğümler yeniden kullanılabilir.
crossinline content: @Composable () -> Unit

yönetilen bu bestecilere ait içeriklerdir.

Yan Efekt

Cmn
1.0.0 sürümünde eklendi
@Composable
@NonRestartableComposable
@ExplicitGroupsComposable
fun SideEffect(effect: () -> Unit): Unit

effect programını mevcut beste başarıyla tamamlandığında ve değişiklikleri uyguladığında çalışacak şekilde planlayın. SideEffect, snapshots tarafından desteklenmeyen beste tarafından yönetilen nesnelere, mevcut oluşturma işlemi başarısız olursa bu nesnelerin tutarsız bir durumda bırakılmasını önlemek için yan efektler uygulamak için kullanılabilir.

effect her zaman bestenin uygulama görev dağıtıcısında çalıştırılır ve uygulayıcılar hiçbir zaman kendileri veya birbirleriyle eş zamanlı olarak çalıştırılmaz, beste ağacında değişiklikler uygulanarak veya RememberObserver etkinlik geri çağırmaları çalıştırılır. SideEffect'ler her zaman RememberObserver etkinlik geri çağırma işleminden sonra çalıştırılır.

SideEffect, her yeniden oluşturma işleminden sonra çalışır. Çok sayıda yeniden oluşturma işlemini kapsayan, devam eden bir görevi başlatmak için LaunchedEffect politikasına bakın. Bir etkinlik aboneliğini veya başka bir nesnenin yaşam döngüsünü yönetmek için DisposableEffect adresine bakın.

kompozisyonLocalOf

Cmn
1.0.0 sürümünde eklendi
fun <T : Any?> compositionLocalOf(
    policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy(),
    defaultFactory: () -> T
): ProvidableCompositionLocal<T>

CompositionLocalProvider kullanılarak sağlanabilecek bir CompositionLocal anahtarı oluşturun. Yeniden oluşturma sırasında sağlanan değer değiştirildiğinde, CompositionLocal.current kullanarak değeri okuyan CompositionLocalProvider içeriği geçersiz kılınır.

compositionLocalOf, CompositionLocalProvider çağrısında kullanılabilecek bir ProvidableCompositionLocal oluşturur. MutableList ve List karşılaştırmasına benzer şekilde, anahtar ProvidableCompositionLocal yerine CompositionLocal olarak herkese açık hâle getirilirse CompositionLocal.current kullanılarak okunabilir ancak yeniden sağlanamaz.

Parametreler
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()

CompositionLocal içeriğinin ne zaman değiştirileceğini belirleyen bir politika. Ayrıntılar için SnapshotMutationPolicy sayfasını ziyaret edin.
defaultFactory: () -> T

bir değer sağlanmadığında bir değer sağlayan bir değer fabrikası. Bu fabrika, CompositionLocal.current kullanılarak bileşeni çağıran CompositionLocalProvider aracılığıyla hiçbir değer sağlanmadığında çağrılır. Makul bir varsayılan sağlanamıyorsa bir istisna uygulayabilirsiniz.
Aşağıdaki kaynakları da incelemenizi öneririz:
CompositionLocal
staticCompositionLocalOf
mutableStateOf

türetilmişStateOf

Cmn
1.0.0 sürümünde eklendi
@StateFactoryMarker
fun <T : Any?> derivedStateOf(calculation: () -> T): State<T>

State.value işlevinin calculation sonucu olduğu bir State nesnesi oluşturur. Hesaplama sonucu, State.value öğesini tekrar tekrar çağırmak calculation işleminin birden çok kez yürütülmesine neden olmayacak şekilde önbelleğe alınır. Ancak State.value okuması, calculation sırasında okunan tüm State nesnelerinin geçerli Snapshot içinde okunmasına neden olur. Diğer bir deyişle, değer Composable işlevi gibi gözlemlenen bir bağlamda okunuyorsa bu işlem türetilen durum nesnelerine doğru şekilde abone olur. Mutasyon politikası olmayan türetilmiş durumlar her bağımlılık değişikliğinde güncellemeleri tetikler. Güncelleme sonrasında geçersiz kılınmasını önlemek için uygun SnapshotMutationPolicy-derivedStateOf aşırı yükleme işlemi gerçekleştirin.

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)
}
Parametreler
calculation: () -> T

bu durum nesnesinin temsil ettiği değeri oluşturmak için gereken hesaplamayı kullanır.

türetilmişStateOf

Cmn
1.3.0 sürümünde eklendi
@StateFactoryMarker
fun <T : Any?> derivedStateOf(
    policy: SnapshotMutationPolicy<T>,
    calculation: () -> T
): State<T>

State.value işlevinin calculation sonucu olduğu bir State nesnesi oluşturur. Hesaplama sonucu, State.value öğesini tekrar tekrar çağırmak calculation işleminin birden çok kez yürütülmesine neden olmayacak şekilde önbelleğe alınır. Ancak State.value okuması, calculation sırasında okunan tüm State nesnelerinin geçerli Snapshot içinde okunmasına neden olur. Diğer bir deyişle, değer Composable işlevi gibi gözlemlenen bir bağlamda okunuyorsa bu işlem türetilen durum nesnelerine doğru şekilde abone olur.

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)
}
Parametreler
policy: SnapshotMutationPolicy<T>

calculation sonucunda yapılan değişikliklerin ne zaman güncellenmesini tetikleyeceğini kontrol etmek için mutasyon politikası.
calculation: () -> T

bu durum nesnesinin temsil ettiği değeri oluşturmak için gereken hesaplamayı kullanır.

Devam Ediyor

Cmn
1.2.0 sürümünde eklendi
@ComposeCompilerApi
fun isTraceInProgress(): Boolean

Dahili izleme API'si.

İş parçacığı senkronizasyonu olmadan ve zaman zaman bilgi kaybı olmadan çağrılmalıdır.

anahtar

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

key, bir beste içindeki yürütme blokunu "gruplandırmak" veya "anahtarlamak" için kullanılan bir yardımcı programdır. Bu, belirli bir oluşturulmuş çağrının, oluşturma sırasında birden fazla kez yürütülmesine neden olabilecek kontrol akışı içinde doğruluk için bazen gereklidir.

Bir anahtarın değerinin genel olarak benzersiz olması gerekmez ve yalnızca söz konusu noktada key çağrıları arasında benzersiz olmalıdır.

Örneğin, aşağıdaki örneği inceleyin:

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

Hem üst hem de alt döngüde aynı kimliğe sahip kullanıcılar olsa da, bunlar farklı key çağrıları olmaları nedeniyle birleşik anahtar oluşturmaya gerek yoktur.

Ancak anahtar, koleksiyondaki her öğe için benzersiz olmalıdır. Aksi takdirde, alt öğeler ve yerel durum istenmeyen şekillerde yeniden kullanılabilir.

Örneğin, aşağıdaki örneği inceleyin:

import androidx.compose.runtime.key

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

Bu örnekte, parent.id değerinin koleksiyondaki her öğe için benzersiz bir anahtar olduğu varsayılır. Ancak bu durum yalnızca bir ebeveynin her zaman yalnızca tek bir çocuğu olacağının varsayılması doğruysa geçerlidir (bu durum böyle olmayabilir). Bunun yerine, aşağıdakileri yapmak daha doğru olabilir:

import androidx.compose.runtime.key

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

Birden fazla bağımsız değişken iletilerek bileşik anahtar oluşturulabilir:

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)
}
Parametreler
vararg keys: Any?

Bileşik anahtar oluşturmak için kullanılacak değer grubu. Bunlar, equals ve hashCode kullanılarak önceki değerleriyle karşılaştırılır.
block: @Composable () -> T

Bu grubun bestelenebilir alt öğeleri.

taşınabilirContentOf

Cmn
1.2.0 sürümünde eklendi
fun movableContentOf(content: @Composable () -> Unit): @Composable () -> Unit

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable () -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable () -> Unit

Oluşturulabilir lambda izleme

taşınabilirContentOf

Cmn
1.2.0 sürümünde eklendi
fun <P : Any?> movableContentOf(content: @Composable (P) -> Unit): @Composable (P) -> Unit

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable (P) -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable (P) -> Unit

Oluşturulabilir lambda izleme

taşınabilirContentOf

Cmn
1.2.0 sürümünde eklendi
fun <P1 : Any?, P2 : Any?> movableContentOf(content: @Composable (P1, P2) -> Unit): @Composable (P1, P2) -> Unit

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable (P1, P2) -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable (P1, P2) -> Unit

Oluşturulabilir lambda izleme

taşınabilirContentOf

Cmn
1.2.0 sürümünde eklendi
fun <P1 : Any?, P2 : Any?, P3 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3) -> Unit
): @Composable (P1, P2, P3) -> Unit

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable (P1, P2, P3) -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable (P1, P2, P3) -> Unit

Oluşturulabilir lambda izleme

taşınabilirContentOf

Cmn
1.2.0 sürümünde eklendi
fun <P1 : Any?, P2 : Any?, P3 : Any?, P4 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3, P4) -> Unit
): @Composable (P1, P2, P3, P4) -> Unit

Bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri adını yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable (P1, P2, P3, P4) -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable (P1, P2, P3, P4) -> Unit

Oluşturulabilir lambda izleme

Alıcısı olan hareketliİçerikİçerik

Cmn
1.2.0 sürümünde eklendi
fun <R : Any?> movableContentWithReceiverOf(content: @Composable R.() -> Unit): @Composable R.() -> Unit

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable R.() -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable R.() -> Unit

Oluşturulabilir lambda izleme

Alıcısı olan hareketliİçerikİçerik

Cmn
1.2.0 sürümünde eklendi
fun <R : Any?, P : Any?> movableContentWithReceiverOf(content: @Composable R.(P) -> Unit): @Composable R.(P) -> Unit

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable R.(P) -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable R.(P) -> Unit

Oluşturulabilir lambda izleme

Alıcısı olan hareketliİçerikİçerik

Cmn
1.2.0 sürümünde eklendi
fun <R : Any?, P1 : Any?, P2 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2) -> Unit
): @Composable R.(P1, P2) -> Unit

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable R.(P1, P2) -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable R.(P1, P2) -> Unit

Oluşturulabilir lambda izleme

Alıcısı olan hareketliİçerikİçerik

Cmn
1.2.0 sürümünde eklendi
fun <R : Any?, P1 : Any?, P2 : Any?, P3 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2, P3) -> Unit
): @Composable R.(P1, P2, P3) -> Unit

Alıcısı olan bir lambdayı, hatırlanan durumu ve önceki bir çağrıda oluşturulan düğümleri çağrıldığı yeni konuma taşıyan bir lambdaya dönüştürün.

İzleme bileşimleri, içeriğini bir satır ve sütun arasında bir parametreye dayalı olarak hareket ettiren bir beste oluşturmak için kullanılabilir. Örneğin:

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

Alternatif olarak, bileşim durumunun bir modelle düzendeki hareketler olarak takip edilmesini sağlamak için kullanılabilirler. Örneğin:

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]()
            }
        }
    }
}
Parametreler
content: @Composable R.(P1, P2, P3) -> Unit

Eyalet izleme lambdasına dönüştürülecek oluşturulabilecek lambda.
İadeler
@Composable R.(P1, P2, P3) -> Unit

Oluşturulabilir lambda izleme

mutableDoubleStateOf

Cmn
1.5.0 sürümünde eklendi
@StateFactoryMarker
fun mutableDoubleStateOf(value: Double): MutableDoubleState

value içinde geçirilen ile başlatılmış yeni bir MutableDoubleState döndürme

MutableDoubleState sınıfı, okuma ve yazma işlemleri Compose tarafından gözlemlenen tek bir değer sahibidir. Ayrıca, buraya yazma işlemleri Snapshot sisteminin bir parçası olarak gerçekleştirilir. JVM'de değerler bellekte temel double türü olarak depolanır. Böylece, MutableState<Double> kullanılırken oluşan otomatik kutulama önlenmiş olur.

Parametreler
value: Double

MutableDoubleState için ilk değer
Aşağıdaki kaynakları da incelemenizi öneririz:
DoubleState
MutableDoubleState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf

mutableFloatStateOf

Cmn 
@StateFactoryMarker
fun mutableFloatStateOf(value: Float): MutableFloatState

value içinde geçirilen ile başlatılmış yeni bir MutableFloatState döndürme

MutableFloatState sınıfı, okuma ve yazma işlemleri Compose tarafından gözlemlenen tek bir değer sahibidir. Ayrıca, buraya yazma işlemleri Snapshot sisteminin bir parçası olarak gerçekleştirilir. JVM'de değerler bellekte temel float türü olarak depolanır. Böylece, MutableState<Float> kullanılırken oluşan otomatik kutulama önlenmiş olur.

Parametreler
value: Float

MutableFloatState için ilk değer
Aşağıdaki kaynakları da incelemenizi öneririz:
FloatState
MutableFloatState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableDoubleStateOf

mutableIntStateOf

Cmn
1.5.0 sürümünde eklendi
@StateFactoryMarker
fun mutableIntStateOf(value: Int): MutableIntState

value içinde geçirilen ile başlatılmış yeni bir MutableIntState döndürme

MutableIntState sınıfı, okuma ve yazma işlemleri Compose tarafından gözlemlenen tek bir değer sahibidir. Ayrıca, buraya yazma işlemleri Snapshot sisteminin bir parçası olarak gerçekleştirilir. JVM'de değerler bellekte temel int türü olarak depolanır. Böylece, MutableState<Int> kullanılırken oluşan otomatik kutulama önlenmiş olur.

Parametreler
value: Int

MutableIntState için ilk değer
Aşağıdaki kaynakları da incelemenizi öneririz:
IntState
MutableIntState
mutableStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

mutableLongStateOf

Cmn
1.5.0 sürümünde eklendi
@StateFactoryMarker
fun mutableLongStateOf(value: Long): MutableLongState

value içinde geçirilen ile başlatılmış yeni bir MutableLongState döndürme

MutableLongState sınıfı, okuma ve yazma işlemleri Compose tarafından gözlemlenen tek bir değer sahibidir. Ayrıca, buraya yazma işlemleri Snapshot sisteminin bir parçası olarak gerçekleştirilir. JVM'de değerler bellekte temel long türü olarak depolanır. Böylece, MutableState<Long> kullanılırken oluşan otomatik kutulama önlenmiş olur.

Parametreler
value: Long

MutableLongState için ilk değer
Aşağıdaki kaynakları da incelemenizi öneririz:
LongState
MutableLongState
mutableStateOf
mutableIntStateOf
mutableFloatStateOf
mutableDoubleStateOf

mutableStateListOf

Cmn
1.0.0 sürümünde eklendi
@StateFactoryMarker
fun <T : Any?> mutableStateListOf(): SnapshotStateList<T>

Gözlemlenebilir ve anlık görüntü olabilecek bir MutableList örneği oluşturun.

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)
            }
        }
    }
}
Aşağıdaki kaynakları da incelemenizi öneririz:
mutableStateOf
mutableListOf
MutableList
takeSnapshot

mutableStateListOf

Cmn
1.0.0 sürümünde eklendi
@StateFactoryMarker
fun <T : Any?> mutableStateListOf(vararg elements: T): SnapshotStateList<T>

MutableList öğesinin gözlemlenebilir ve anlık görüntü olabilecek bir örneği oluşturun.

Aşağıdaki kaynakları da incelemenizi öneririz:
mutableStateOf
mutableListOf
MutableList
takeSnapshot

mutableStateMapOf

Cmn
1.0.0 sürümünde eklendi
@StateFactoryMarker
fun <K : Any?, V : Any?> mutableStateMapOf(): SnapshotStateMap<K, V>

Gözlemlenebilir ve anlık görüntü olabilen bir MutableMap<k, v=""> örneği oluşturun.</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}'")
            }
        }
    }
}
Aşağıdaki kaynakları da incelemenizi öneririz:
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

mutableStateMapOf

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

Gözlemlenebilir ve anlık görüntü olabilen bir MutableMap<k, v=""> örneği oluşturun.</k,>

Aşağıdaki kaynakları da incelemenizi öneririz:
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

mutableStateOf

Cmn
1.0.0 sürümünde eklendi
@StateFactoryMarker
fun <T : Any?> mutableStateOf(
    value: T,
    policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()
): MutableState<T>

value içinde geçirilen ile başlatılmış yeni bir MutableState döndürme

MutableState sınıfı, okuma ve yazma işlemleri Compose tarafından gözlemlenen tek bir değer sahibidir. Ayrıca, buraya yazma işlemleri Snapshot sisteminin bir parçası olarak gerçekleştirilir.

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")
    }
}
Parametreler
value: T

MutableState için ilk değer
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()

değiştirilebilir anlık görüntülerde değişikliklerin nasıl işleneceğini kontrol eden bir politika.
Aşağıdaki kaynakları da incelemenizi öneririz:
State
MutableState
SnapshotMutationPolicy
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

aslaEşittirPolitikası

Cmn
1.0.0 sürümünde eklendi
fun <T : Any?> neverEqualPolicy(): SnapshotMutationPolicy<T>

Bir politika, MutableState değerlerini hiçbir zaman eşdeğer olarak değerlendirmez.

MutableState.value ayarı her zaman bir değişiklik olarak değerlendirilir. Durumu değiştiren bir MutableSnapshot uygularken, aynı durumu değiştiren diğer anlık görüntülerle her zaman çakışır.

üretim durumu

Cmn
1.0.0 sürümünde eklendi
@Composable
fun <T : Any?> produceState(initialValue: T, producer: suspend ProduceStateScope<T>.() -> Unit): State<T>

Tanımlı bir veri kaynağı olmadan zaman içinde değerler üreten gözlemlenebilir bir snapshot State döndürme.

produceState besteye girdiğinde producer başlatılır ve produceState besteden ayrıldığında iptal edilir. producer, döndürülen State parametresinde yeni değerler belirlemek için ProduceStateScope.value kullanmalıdır.

Döndürülen State, değerleri birleştirir. Eski değerine equal olan bir değer ayarlamak için ProduceStateScope.value kullanılırsa hiçbir değişiklik gözlemlenemez ve gözlemciler yalnızca birkaç değer art arda ayarlanmışsa en son değeri görebilir.

produceState, harici veri kaynaklarının askıya alındığını veya askıya alınmadığını gözlemlemek için kullanılabilir. Örneğin:

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

üretim durumu

Cmn
1.0.0 sürümünde eklendi
@Composable
fun <T : Any?> produceState(initialValue: T, key1: Any?, producer: suspend ProduceStateScope<T>.() -> Unit): State<T>

key1 öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürün.

produceState besteye girdiğinde producer başlatılır ve produceState besteden ayrıldığında iptal edilir. key1 değişirse çalışan bir producer iptal edilir ve yeni kaynak için yeniden başlatılır. producer, döndürülen State parametresinde yeni değerler belirlemek için ProduceStateScope.value kullanmalıdır.

Döndürülen State, değerleri birleştirir. Eski değerine equal olan bir değer ayarlamak için ProduceStateScope.value kullanılırsa hiçbir değişiklik gözlemlenemez ve gözlemciler yalnızca birkaç değer art arda ayarlanmışsa en son değeri görebilir.

produceState, harici veri kaynaklarının askıya alındığını veya askıya alınmadığını gözlemlemek için kullanılabilir. Örneğin:

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

üretim durumu

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

keys öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürün.

produceState besteye girdiğinde producer başlatılır ve produceState besteden ayrıldığında iptal edilir. keys değiştirilirse çalışan bir producer iptal edilir ve yeni kaynak için yeniden başlatılır. producer, döndürülen State parametresinde yeni değerler belirlemek için ProduceStateScope.value kullanmalıdır.

Döndürülen State, değerleri birleştirir. Eski değerine equal olan bir değer ayarlamak için ProduceStateScope.value kullanılırsa hiçbir değişiklik gözlemlenemez ve gözlemciler yalnızca birkaç değer art arda ayarlanmışsa en son değeri görebilir.

produceState, harici veri kaynaklarının askıya alındığını veya askıya alınmadığını gözlemlemek için kullanılabilir. Örneğin:

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

üretim durumu

Cmn
1.0.0 sürümünde eklendi
@Composable
fun <T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
): State<T>

key1 ve key2 öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürme

produceState besteye girdiğinde producer başlatılır ve produceState besteden ayrıldığında iptal edilir. key1 veya key2 değişirse çalışan bir producer iptal edilir ve yeni kaynak için yeniden başlatılır. producer, döndürülen State parametresinde yeni değerler belirlemek için ProduceStateScope.value kullanmalıdır.

Döndürülen State, değerleri birleştirir. Eski değerine equal olan bir değer ayarlamak için ProduceStateScope.value kullanılırsa hiçbir değişiklik gözlemlenemez ve gözlemciler yalnızca birkaç değer art arda ayarlanmışsa en son değeri görebilir.

produceState, harici veri kaynaklarının askıya alındığını veya askıya alınmadığını gözlemlemek için kullanılabilir. Örneğin:

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

üretim durumu

Cmn
1.0.0 sürümünde eklendi
@Composable
fun <T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    key3: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
): State<T>

key1, key2 ve key3 öğesinden zaman içinde değer üreten gözlemlenebilir bir snapshot State döndürme

produceState besteye girdiğinde producer başlatılır ve produceState besteden ayrıldığında iptal edilir. key1, key2 veya key3 değişirse çalışan bir producer iptal edilir ve yeni kaynak için yeniden başlatılır. [üretici, döndürülen State ile ilgili yeni değerler ayarlamak için ProduceStateScope.value kullanmalıdır.

Döndürülen State, değerleri birleştirir. Eski değerine equal olan bir değer ayarlamak için ProduceStateScope.value kullanılırsa hiçbir değişiklik gözlemlenemez ve gözlemciler yalnızca birkaç değer art arda ayarlanmışsa en son değeri görebilir.

produceState, harici veri kaynaklarının askıya alındığını veya askıya alınmadığını gözlemlemek için kullanılabilir. Örneğin:

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

referansEqualityPolitikası

Cmn
1.0.0 sürümünde eklendi
fun <T : Any?> referentialEqualityPolicy(): SnapshotMutationPolicy<T>

MutableState değerlerinin referans olarak (===) eşit olması halinde bunların eşdeğeri olarak değerlendirilmesini sağlayan bir politika.

MutableState.value öğesinin mevcut referans olarak (===) eşit değerine ayarlanması, değişiklik olarak kabul edilmez. MutableSnapshot uygulanırken anlık görüntünün değeri eşdeğer değerle değiştirilirse üst anlık görüntünün çakışma olduğu kabul edilmez.

hatırlama

Cmn
1.0.0 sürümünde eklendi
@Composable
inline fun <T : Any?> remember(crossinline calculation: @DisallowComposableCalls () -> T): T

calculation tarafından üretilen değeri unutmayın. calculation yalnızca beste sırasında değerlendirilir. Yeniden derleme her zaman bestenin ürettiği değeri döndürür.

hatırlama

Cmn
1.0.0 sürümünde eklendi
@Composable
inline fun <T : Any?> remember(
    key1: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
): T

key1 önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretin ve hatırlayın.

hatırlama

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

Tüm keys değerleri önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretin ve hatırlayın.

hatırlama

Cmn
1.0.0 sürümünde eklendi
@Composable
inline fun <T : Any?> remember(
    key1: Any?,
    key2: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
): T

key1 ve key2 önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretip hatırlayın.

hatırlama

Cmn
1.0.0 sürümünde eklendi
@Composable
inline fun <T : Any?> remember(
    key1: Any?,
    key2: Any?,
    key3: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
): T

key1, key2 ve key3 önceki besteye eşitse calculation tarafından döndürülen değeri unutmayın. Aksi takdirde, calculation yöntemini çağırarak yeni bir değer üretip hatırlayın.

HatırlamaCompositionBağlam

Cmn
1.0.0 sürümünde eklendi
@Composable
fun rememberCompositionContext(): CompositionContext

Mevcut bileşim noktasında bir CompositionContext oluşturma efekti. Bu, mevcut beste bağlamında ayrı bir beste çalıştırmak ve CompositionLocal'leri korumak ve geçersiz kılmaları yaymak için kullanılabilir. Bu çağrı besteden çıktığında bağlam geçersiz kılınır.

HatırlamaCoroutineScope

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

getContext tarafından sağlanan isteğe bağlı CoroutineContext öğesini kullanarak bestede bu noktaya bağlı bir CoroutineScope döndürün. getContext yalnızca bir kez çağrılır ve aynı CoroutineScope örneği, yeniden oluşturmalarda döndürülür.

Bu çağrı besteden ayrıldığında bu kapsam cancelled olur. getContext tarafından döndürülen CoroutineContext, bestenin alt öğesi olarak kabul edildiğinden Job içeremez.

getContext tarafından döndürülen bağlamda bunlardan biri sağlanmazsa bu kapsamın varsayılan görev dağıtıcısı, bestenin Recomposer görev dağıtıcısı olur.

Tıklamalar veya diğer kullanıcı etkileşimleri gibi geri çağırma etkinliklerine yanıt olarak işleri başlatmak için bu kapsamı kullanın. Bu etkinliklere verilen yanıtın zaman içinde gelişmesi ve söz konusu işlem, besteden ayrılırsa iptal edilmesi gerekir. İşler asla bileşimin kendisinin bir yan etkisi olarak herhangi bir eş yordam kapsamına dahil edilmemelidir. Besteye göre başlatılan kapsamlı ve devam eden işler için LaunchedEffect adresine bakın.

Oluşturulabilir işlevler henüz istisnaları tam olarak desteklemediğinden bu işlev ön koşullar karşılanmazsa hiçbir değer değerlendirmez. Bunun yerine, döndürülen kapsamın CoroutineScope.coroutineContext öğesi, ilişkili istisnayla birlikte başarısız bir Job içerir ve alt işleri başlatamaz.

Hatırlatıcı öğe durumu

Cmn
1.0.0 sürümünde eklendi
@Composable
fun <T : Any?> rememberUpdatedState(newValue: T): State<T>

Bir mutableStateOf için remember ve rememberUpdatedState çağrısının her yeniden oluşturmada değerini newValue olarak güncelleyin.

rememberUpdatedState, oluşturma sırasında hesaplanan parametreler veya değerlere uzun süreli bir lambda veya nesne ifadesiyle başvurulduğunda kullanılmalıdır. Yeniden düzenleme, uzun ömürlü lambda veya nesneyi yeniden oluşturmadan ortaya çıkan State değerini günceller. Böylece, nesne iptal edilip yeniden abone edilmeden ya da yeniden başlatılıp yeniden başlatılması pahalı veya yasak olabilecek uzun süreli bir işlemi yeniden başlatmadan devam edebilir. Bu durum, DisposableEffect veya LaunchedEffect ile çalışırken sık karşılaşılan bir durumdur. Örneğin:

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

LaunchedEffect'ler genellikle, bir parametre veya etkinlik geri çağırması değişirse sıfırlanması ve yeniden başlatılması gereken durum makinelerini tanımlar, ancak gerektiğinde mevcut değerin kullanılabilir olması gerekir. Örneğin:

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

    // ...
}

rememberUpdatedState bir beste işlevi kullanıldığında devam eden bu işlemleri güncelleyebilirsiniz.

SnapshotFlow

Cmn
1.0.0 sürümünde eklendi
fun <T : Any?> snapshotFlow(block: () -> T): Flow<T>

Gözlemlenebilir Snapshot durumundan bir Flow oluşturun. (örneğin, mutableStateOf tarafından geri gönderilen devlet sahipleri.)

snapshotFlow, toplandığında block çalıştıran ve sonucu yayan, erişilen herhangi bir anlık görüntü durumunu kaydederek bir Flow oluşturur. Toplama işlemi devam ederken, block tarafından erişilen durumu değiştiren yeni bir Snapshot uygulanırsa akış, erişilen anlık görüntü durumu yeniden kaydedilerek block öğesini tekrar çalıştırır. block işlevinin sonucu önceki sonuç equal to değilse akış bu yeni sonucu yayınlar. (Bu davranış Flow.distinctUntilChanged operatörüne benzer.) Açık bir şekilde iptal edilmediği veya diğer Flow operatörlerinin kullanımıyla sınırlandırılmadığı sürece toplama süresiz olarak devam edecektir.

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, salt okunur bir Snapshot içinde çalıştırılır ve anlık görüntü verilerini değiştiremez. block anlık görüntü verilerini değiştirmeye çalışırsa akış toplama işlemi IllegalStateException ile başarısız olur.

block, eşit giriş grupları için birden fazla kez veya çok sayıda hızlı anlık görüntü değişikliğinden sonra yalnızca bir kez çalışabilir. Etkili olmamalıdır ve yan etki içermemelidir.

Snapshot durumuyla çalışırken etkinlikler ile durum arasındaki farkı göz önünde bulundurmak faydalıdır. snapshotFlow modelleri anlık görüntüleri etkinlikler olarak değişir ancak etkinlikler, gözlemlenebilir durum olarak etkili bir şekilde modellenemez. Gözlemlenebilir durum, bu durumu oluşturan olayların kayıplı sıkıştırılmasıdır.

Gözlemlenebilir etkinlik, belirli bir zamanda gerçekleşir ve silinir. Etkinlik sırasında kayıtlı tüm gözlemcilere bildirim gönderilir. Bir akıştaki tüm bağımsız etkinliklerin alakalı olduğu ve birbirinin üzerine inşa edebileceği varsayılır. Tekrarlanan eşit etkinliklerin anlamı vardır ve bu nedenle kayıtlı bir gözlemci tüm etkinlikleri atlamadan gözlemlemelidir.

Gözlemlenebilir durum, durum bir değerden yeni, eşit olmayan bir değere değiştiğinde değişiklik etkinliklerini yükseltir. Durum değişikliği etkinlikleri birleştirilmiştir; yalnızca en son durum önemlidir. Bu nedenle, durum değişikliklerinin gözlemcileri idempotent (etkili) olmalıdır; aynı durum değeri verildiğinde gözlemleyici de aynı sonucu vermelidir. Bir durum gözlemleyicisinin hem ara durumları atlaması hem de aynı durum için birden çok kez çalıştırması geçerlidir. Sonuç aynı olmalıdır.

kaynakBilgi

Cmn
1.0.0 sürümünde eklendi
@ComposeCompilerApi
fun sourceInformation(composer: Composer, sourceInformation: String): Unit

Oluşturma dahili işlevi. Doğrudan ARAMAYIN.

İlgili oluşturma işlevinin kaynak konumunu belirlemek için araçta kullanılabilecek kaynak bilgilerini kaydeder. Varsayılan olarak, bu işlevin yan etkisi olmadığı belirtilir. Kod küçültme araçlarının (R8 veya ProGuard gibi) bunları kaldırması güvenlidir.

kaynakBilgi İşaretçisiSonu

Cmn
1.0.0 sürümünde eklendi
@ComposeCompilerApi
fun sourceInformationMarkerEnd(composer: Composer): Unit

Oluşturma dahili işlevi. Doğrudan ARAMAYIN.

Aksi takdirde ReadOnlyComposable işlevleri gibi izleme bilgileri gerektirmeyen karşılık gelen derlenebilir işlevin kaynak konumunu belirlemek üzere araçta kullanılabilecek bir kaynak bilgisi işaretçisinin sonunu kaydeder. Varsayılan olarak, bu işlevin yan etkisi olmadığı belirtilir. Kod küçültme araçlarının (R8 veya ProGuard gibi) bunları kaldırması güvenlidir.

sourceInformationMarkerStart ve sourceInformationMarkerEnd öğelerinin birlikte kaldırılması veya her ikisinin de saklanması önemlidir. Yalnızca birinin kaldırılması hatalı çalışma zamanı davranışına neden olur.

kaynakBilgi İşaretçisiBaşlatması

Cmn
1.0.0 sürümünde eklendi
@ComposeCompilerApi
fun sourceInformationMarkerStart(
    composer: Composer,
    key: Int,
    sourceInformation: String
): Unit

Oluşturma dahili işlevi. Doğrudan ARAMAYIN.

Normalde ReadOnlyComposable işlevleri gibi izleme bilgileri gerektirmeyen karşılık gelen derlenebilir işlevin kaynak konumunu belirlemek üzere araçta kullanılabilecek bir kaynak bilgisi işaretçisinin başlangıcını kaydeder. Varsayılan olarak, bu işlevin yan etkisi olmadığı belirtilir. Kod küçültme araçlarının (R8 veya ProGuard gibi) bunları kaldırması güvenlidir.

sourceInformationMarkerStart ve sourceInformationMarkerEnd öğelerinin birlikte kaldırılması veya her ikisinin de saklanması önemlidir. Yalnızca birinin kaldırılması hatalı çalışma zamanı davranışına neden olur.

staticCompositionLocal

Cmn
1.0.0 sürümünde eklendi
fun <T : Any?> staticCompositionLocalOf(defaultFactory: () -> T): ProvidableCompositionLocal<T>

CompositionLocalProvider kullanılarak sağlanabilecek bir CompositionLocal anahtarı oluşturun.

compositionLocalOf'ın aksine, staticCompositionLocalOf ile ilgili okumalar besteci tarafından izlenmez ve CompositionLocalProvider çağrısında sağlanan değerin değiştirilmesi, yalnızca bestede yerel değerin kullanıldığı yerler yerine içeriğin tamamının yeniden oluşturulmasına neden olur. Ancak bu takip eksikliği, sağlanan değerin büyük olasılıkla değişmediği veya hiçbir zaman değişmediği durumlarda staticCompositionLocalOf daha verimli hale getirir. Örneğin, Android bağlamı, yazı tipi yükleyiciler veya benzer paylaşılan değerler, CompositionLocalProvider içeriğindeki bileşenler için büyük olasılıkla değişmediğinden staticCompositionLocalOf kullanmayı düşünmelidir. Bir renk veya değer gibi başka bir tema değişebilir, hatta animasyonlu olabilir. Bu nedenle compositionLocalOf kullanılmalıdır.

staticCompositionLocalOf, CompositionLocalProvider çağrısında kullanılabilecek bir ProvidableCompositionLocal oluşturur. MutableList ve List karşılaştırmasına benzer şekilde, anahtar ProvidableCompositionLocal yerine CompositionLocal olarak herkese açık hâle getirilirse CompositionLocal.current kullanılarak okunabilir ancak yeniden sağlanamaz.

Parametreler
defaultFactory: () -> T

bir değer sağlanmadığında bir değer sağlayan bir değer fabrikası. Bu fabrika, CompositionLocal.current kullanılarak bileşeni çağıran CompositionLocalProvider aracılığıyla hiçbir değer sağlanmadığında çağrılır. Makul bir varsayılan sağlanamıyorsa bir istisna uygulayabilirsiniz.
Aşağıdaki kaynakları da incelemenizi öneririz:
CompositionLocal
compositionLocalOf

YapısalEkalitePolitikası

Cmn
1.0.0 sürümünde eklendi
fun <T : Any?> structuralEqualityPolicy(): SnapshotMutationPolicy<T>

MutableState değerlerinin yapısal olarak (==) eşit olması halinde bunların eşdeğeri olarak ele alınmasını sağlayan bir politika.

MutableState.value öğesinin mevcut yapısal olarak (==) eşit değerine ayarlanması bir değişiklik olarak kabul edilmez. MutableSnapshot uygulanırken anlık görüntünün değeri eşdeğer değerle değiştirilirse üst anlık görüntünün çakışma olduğu kabul edilmez.

traceEventEnd

Cmn
1.2.0 sürümünde eklendi
@ComposeCompilerApi
fun traceEventEnd(): Unit

Dahili izleme API'si.

İş parçacığı senkronizasyonu olmadan ve zaman zaman bilgi kaybı olmadan çağrılmalıdır.

traceEventStart

Cmn
1.2.0 sürümünde eklendi
@ComposeCompilerApi
fun traceEventStart(key: Int, dirty1: Int, dirty2: Int, info: String): Unit

Dahili izleme API'si.

İş parçacığı senkronizasyonu olmadan ve zaman zaman bilgi kaybı olmadan çağrılmalıdır.

Parametreler
dirty1: Int

$dirty meta verisi: zorunlu yeniden kompozisyon ve varsa işlev parametreleri 1..10
dirty2: Int

$dirty2 meta verisi: zorunlu yeniden kompozisyon ve varsa işlev parametreleri 11..20

ÇerçeveMillis

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

Yeni bir kare istenene kadar askıya alınır, çerçeve dağıtımının çağrı bağlamında milisaniye cinsinden kare süresiyle hemen onFrame çağırır, ardından onFrame sonucuyla devam eder.

Kareden kareye animasyon süresi deltaları hesaplanırken frameTimeMillis kullanılmalıdır. Çünkü bu, kare için hedef zamana göre normalleştirilebilir ve bunun doğrudan bir "şimdi" değeri olması gerekmez.

MonotonicFrameClock.withFrameMillis tarafından sağlanan değerin zaman tabanı uygulama tanımlanmıştır. Sağlanan zaman değerleri tekdüze şekilde artıyor. withFrameMillis çağrısı tamamlandıktan sonra, sonraki çağrı için daha küçük bir değer sağlamamalıdır.

Bu işlev, CoroutineContext çağrısının MonotonicFrameClock işlevini kullanarak MonotonicFrameClock.withFrameNanos yöntemini çağırır ve CoroutineContext içinde yoksa bir IllegalStateException döndürür.

withFrameNanos

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

Yeni bir kare istenene kadar askıya alınır, çerçeve dağıtımının çağrı bağlamında nanosaniye cinsinden kare süresiyle hemen onFrame çağırır, ardından onFrame sonucuyla devam eder.

Kareden kareye animasyon süresi deltaları hesaplanırken frameTimeNanos kullanılmalıdır. Çünkü bu, kare için hedef zamana göre normalleştirilebilir ve bunun doğrudan bir "şimdi" değeri olması gerekmez.

withFrameNanos tarafından sağlanan değerin zaman tabanı uygulama tanımlanmıştır. Sağlanan zaman değerleri tamamen tekdüze şekilde artıyor. withFrameNanos çağrısı tamamlandıktan sonra, sonraki bir çağrı için aynı değeri tekrar sağlamamalıdır.

Bu işlev, CoroutineContext çağrısının MonotonicFrameClock işlevini kullanarak MonotonicFrameClock.withFrameNanos yöntemini çağırır ve CoroutineContext içinde yoksa bir IllegalStateException döndürür.

RunningRecomposer ile

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

block işlevini, CoroutineContext çağrısındaki değişiklikleri uygulayarak yeni ve etkin bir Recomposer ile çalıştırır. block iade edildikten sonra Recomposer, closed olacak. withRunningRecomposer, Recomposer Recomposer.State.ShutDown olduğunda ve block tarafından başlatılan tüm alt işlerde joined olduğunda geri dönecektir.

Uzantı işlevleri

olarakÇiftDurum

Cmn
1.5.0 sürümünde eklendi
fun State<Double>.asDoubleState(): DoubleState

Bir State<Double> değerini (kutulu Double'lerden oluşan State) temel destekli bir Double değerine dönüştürür. Durum, gerekli temel türe göre otomatik olarak açılır. Döndürülen durum salt okunurdur. Döndürülen durum, temel durumun değerlerini yansıtır ve güncellemeleri, alıcının tanımladığı şekilde uygular.

JVM'de bu dönüştürme, Double ürününün kaçmaya çalıştığı otomatik kutulamayı engellemez. Bunun yerine, Double türünün her iki temsilini kullanan bileşenler arasında birlikte çalışabilirliğe olanak sağlamayı amaçlar.

KayanDurum

Cmn
1.5.0 sürümünde eklendi
fun State<Float>.asFloatState(): FloatState

Bir State<Float> değerini (kutulu Float'lerden oluşan State) temel destekli bir Float değerine dönüştürür. Durum, gerekli temel türe göre otomatik olarak açılır. Döndürülen durum salt okunurdur. Döndürülen durum, temel durumun değerlerini yansıtır ve güncellemeleri, alıcının tanımladığı şekilde uygular.

JVM'de bu dönüştürme, Float ürününün kaçmaya çalıştığı otomatik kutulamayı engellemez. Bunun yerine, Float türünün her iki temsilini kullanan bileşenler arasında birlikte çalışabilirliğe olanak sağlamayı amaçlar.

Uluslararası Eyalet

Cmn
1.5.0 sürümünde eklendi
fun State<Int>.asIntState(): IntState

Bir State<Int> değerini (kutulu Int'lerden oluşan State) temel destekli bir IntState değerine dönüştürür. Durum, gerekli temel türe göre otomatik olarak açılır. Döndürülen durum salt okunurdur. Döndürülen durum, temel durumun değerlerini yansıtır ve güncellemeleri, alıcının tanımladığı şekilde uygular.

JVM'de bu dönüştürme, IntState ürününün kaçmaya çalıştığı otomatik kutulamayı engellemez. Bunun yerine, Int türünün her iki temsilini kullanan bileşenler arasında birlikte çalışabilirliğe olanak sağlamayı amaçlar.

asLongState

Cmn
1.5.0 sürümünde eklendi
fun State<Long>.asLongState(): LongState

Bir State<Long> değerini (kutulu Long'lerden oluşan State) temel destekli bir LongState değerine dönüştürür. Durum, gerekli temel türe göre otomatik olarak açılır. Döndürülen durum salt okunurdur. Döndürülen durum, temel durumun değerlerini yansıtır ve güncellemeleri, alıcının tanımladığı şekilde uygular.

JVM'de bu dönüştürme, LongState ürününün kaçmaya çalıştığı otomatik kutulamayı engellemez. Bunun yerine, Long türünün her iki temsilini kullanan bileşenler arasında birlikte çalışabilirliğe olanak sağlamayı amaçlar.

önbellek

Cmn
1.0.0 sürümünde eklendi
@ComposeCompilerApi
inline fun <T : Any?> Composer.cache(
    invalid: Boolean,
    block: @DisallowComposableCalls () -> T
): T

Compose derleyici eklentisi API'si. Doğrudan ARAMAYIN.

Önbellek, yani unutmayın, bir bestenin beste verilerindeki bir değerdir. Bu, remember'yi uygulamak ve derleyici eklentisi tarafından, bu optimizasyonların güvenli olduğunu belirlediğinde remember öğesine daha etkili çağrılar oluşturmak için kullanılır.

ToplaAsState

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

Bu StateFlow öğesinden değerleri toplar ve State aracılığıyla en son değerini gösterir. StateFlow.value, başlangıç değeri olarak kullanılır. StateFlow öğesine her yeni değer gönderildiğinde, döndürülen State güncellenerek her State.value kullanımının yeniden düzenlenmesi sağlanır.

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

val value: String by stateFlow.collectAsState()
Text("Value is $value")
Parametreler
context: CoroutineContext = EmptyCoroutineContext

Toplama için kullanılacak CoroutineContext.

ToplaAsState

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

Bu Flow öğesinden değerleri toplar ve State aracılığıyla en son değerini gösterir. Flow öğesine her yeni değer gönderildiğinde, döndürülen State güncellenerek her State.value kullanımının yeniden düzenlenmesi sağlanır.

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

val value: String by flow.collectAsState("initial")
Text("Value is $value")
Parametreler
context: CoroutineContext = EmptyCoroutineContext

Toplama için kullanılacak CoroutineContext.

getValue

Cmn
1.5.0 sürümünde eklendi
inline operator fun DoubleState.getValue(thisObj: Any?, property: KProperty<*>): Double

DoubleState için by kullanarak val mülklerine yetki verilmesine izin verir.

getValue

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

FloatState için by kullanarak val mülklerine yetki verilmesine izin verir.

getValue

Cmn
1.5.0 sürümünde eklendi
inline operator fun IntState.getValue(thisObj: Any?, property: KProperty<*>): Int

IntState için by kullanarak val mülklerine yetki verilmesine izin verir.

getValue

Cmn
1.5.0 sürümünde eklendi
inline operator fun LongState.getValue(thisObj: Any?, property: KProperty<*>): Long

LongState için by kullanarak val mülklerine yetki verilmesine izin verir.

getValue

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

State için by kullanarak val mülklerine yetki verilmesine izin verir.

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

setValue

Cmn
1.5.0 sürümünde eklendi
inline operator fun MutableDoubleState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Double
): Unit

MutableDoubleState için by kullanarak var mülklerine yetki verilmesine izin verir.

setValue

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

MutableFloatState için by kullanarak var mülklerine yetki verilmesine izin verir.

setValue

Cmn
1.5.0 sürümünde eklendi
inline operator fun MutableIntState.setValue(thisObj: Any?, property: KProperty<*>, value: Int): Unit

MutableIntState için by kullanarak var mülklerine yetki verilmesine izin verir.

setValue

Cmn
1.5.0 sürümünde eklendi
inline operator fun MutableLongState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Long
): Unit

MutableLongState için by kullanarak var mülklerine yetki verilmesine izin verir.

setValue

Cmn
1.0.0 sürümünde eklendi
inline operator fun <T : Any?> MutableState<T>.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: T
): Unit

MutableState için by kullanarak var mülklerine yetki verilmesine izin verir.

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

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

Gözlemlenebilir ve anlık görüntü olabilen bir koleksiyondan MutableList örneği oluşturun.

toMutableStateMap

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

Gözlemlenebilir ve anlık görüntü olabilen bir çiftler koleksiyonundan MutableMap<k, v=""> örneği oluşturun.</k,>

ÇerçeveMillis

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

Yeni bir kare istenene kadar askıya alınır, çerçeve dağıtımının çağrı bağlamında milisaniye cinsinden kare süresiyle hemen onFrame çağırır, ardından onFrame sonucuyla devam eder.

Kareden kareye animasyon süresi deltaları hesaplanırken frameTimeMillis kullanılmalıdır. Çünkü bu, kare için hedef zamana göre normalleştirilebilir ve bunun doğrudan bir "şimdi" değeri olması gerekmez.

MonotonicFrameClock.withFrameMillis tarafından sağlanan değerin zaman tabanı uygulama tanımlanmıştır. Sağlanan zaman değerleri tekdüze şekilde artıyor. withFrameMillis çağrısı tamamlandıktan sonra, sonraki çağrı için daha küçük bir değer sağlamamalıdır.

Üst düzey mülkler

VarsayılanMonotonicKare Saati

Cmn android 
val DefaultMonotonicFrameClock: MonotonicFrameClock

kotlin.coroutines.CoroutineContext aramasında yoksa withFrameNanos ve withFrameMillis tarafından kullanılan MonotonicFrameClock.

Bu değer artık oluşturma çalışma zamanı tarafından kullanılmıyor.

currentComposer

Cmn
1.0.0 sürümünde eklendi
val currentComposer: Composer

TODO(lmr): belge sağlayın

mevcutCompositeKeyHash

Cmn
1.0.0 sürümünde eklendi
val currentCompositeKeyHash: Int

Bu, harici olarak depolanmış durumu bileşime koordine etmek için kullanılan bir karma değeridir. Örneğin bu, kayıtlı örnek durumu tarafından etkinlik ömrü sınırları içinde durumu korumak için kullanılır.

Bu değer büyük olasılıkla benzersiz olacaktır ancak benzersiz olacağı garanti edilmez. Çalışma zamanının, bileşik anahtar karmasını benzersiz kılmak için yeterli bilgiye sahip olmadığı için key içermeyen döngüler gibi bilinen durumlar vardır.

currentCompositionLocalBağlam

Cmn
1.1.0 sürümünde eklendi
val currentCompositionLocalContext: CompositionLocalContext

Geçerli bestedeki tüm CompositionLocal değerlerini ve bunların CompositionLocalProvider tarafından sağlanan değerlerini içeren geçerli CompositionLocalContext değerini döndürür. Bu bağlam, yerel halkı CompositionLocalProvider aracılığıyla başka bir besteye iletmek için kullanılabilir. Başka bir beste mevcut bestenin alt bileşeni değilse genellikle bu gereklidir.

currentRecomposeScope

Cmn
1.0.0 sürümünde eklendi
val currentRecomposeScope: RecomposeScope

Yapının bu noktasında geçerli kapsamı geçersiz kılmak için kullanılabilecek bir nesne döndürür. Bu nesne, manuel olarak yeniden derlemelere neden olmak için kullanılabilir.

Uzantı özellikleri

monotonikKare Saati

Cmn
1.0.0 sürümünde eklendi
@ExperimentalComposeApi
val CoroutineContext.monotonicFrameClock: MonotonicFrameClock

Bu CoroutineContext için MonotonicFrameClock değerini döndürür veya mevcut değilse IllegalStateException değerini döndürür.

recomposeCoroutineContext'i yeniden oluştur

Cmn
1.0.0 sürümünde eklendi
@ExperimentalComposeApi
val ControlledComposition.recomposeCoroutineContext: CoroutineContext

Eşzamanlı besteyi destekleyen bir ortamda kullanıldığında bu ControlledComposition öğesinin eş zamanlı olarak yeniden kompozisyonlarını gerçekleştirmek için kullanılması gereken CoroutineContext.

Böyle bir ortamı yapılandırma örneği olarak Recomposer.runRecomposeConcurrentlyAndApplyChanges sayfasına bakın.