androidx.compose.runtime

Di halaman ini, Anda akan menemukan dokumentasi untuk jenis, properti, dan fungsi yang tersedia dalam paket androidx.compose.runtime. Contoh:

Jika Anda mencari panduan, lihat panduan Compose berikut:

Antarmuka

Applier

Applier bertanggung jawab untuk menerapkan operasi berbasis pohon yang dimunculkan selama komposisi.
Cmn
ComposeNodeLifecycleCallback

Mengamati siklus proses node yang ditampilkan dengan ReusableComposeNode atau ComposeNode di dalam ReusableContentHost dan ReusableContent.
Cmn
Composer

Composer adalah antarmuka yang ditargetkan oleh plugin compiler Kotlin Compose dan digunakan oleh helper pembuatan kode.
Cmn
Composition

Objek komposisi biasanya dibuat untuk Anda, dan ditampilkan dari API yang digunakan untuk pertama kali membuat UI.
Cmn
CompositionLocalMap

Snapshot CompositionLocals yang bersifat hanya baca dan tidak dapat diubah yang ditetapkan pada posisi tertentu dalam hierarki komposisi.
Cmn
CompositionServiceKey

Kunci untuk menemukan layanan menggunakan antarmuka CompositionServices yang secara opsional diterapkan oleh implementasi Composition.
Cmn
CompositionServices

Memungkinkan pencarian layanan komposisi dari runtime.
Cmn
CompositionTracer

API perekaman aktivitas internal.
Cmn
ControlledComposition

Komposisi yang dikontrol adalah Composition yang dapat dikontrol secara langsung oleh pemanggil.
Cmn
DisposableEffectResult
Cmn
DoubleState

Holder nilai tempat membaca properti doubleValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
FloatState

Holder nilai tempat membaca properti floatValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
IntState

Holder nilai tempat membaca properti intValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
LongState

Holder nilai tempat membaca properti longValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
MonotonicFrameClock

Memberikan sumber waktu untuk frame tampilan dan kemampuan untuk melakukan tindakan pada frame berikutnya.
Cmn
MutableDoubleState

Holder nilai tempat membaca properti doubleValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
MutableFloatState

Holder nilai tempat membaca properti floatValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
MutableIntState

Holder nilai tempat membaca properti intValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
MutableLongState

Holder nilai tempat membaca properti longValue selama eksekusi fungsi Composable menyebabkan RecomposeScope saat ini berlangganan perubahan nilai tersebut.
Cmn
MutableState

Holder nilai yang dapat berubah yang membaca properti value selama eksekusi fungsi Composable, RecomposeScope saat ini akan berlangganan perubahan nilai tersebut.
Cmn
ProduceStateScope

Cakupan penerima untuk digunakan dengan produceState.
Cmn
RecomposeScope

Mewakili cakupan atau bagian dari hierarki komposisi yang dapat dikomposisi ulang.
Cmn
RecomposerInfo

Informasi hanya baca tentang Recomposer.
Cmn
RememberObserver

Objek yang menerapkan antarmuka ini akan diberi tahu saat objek tersebut pertama kali digunakan dalam komposisi dan saat tidak lagi digunakan.
Cmn
ReusableComposition

ReusableComposition adalah Composition yang dapat digunakan kembali untuk berbagai konten composable.
Cmn
ScopeUpdateScope

API plugin compiler compose internal yang digunakan untuk mengupdate fungsi yang akan dipanggil komposer untuk merekomposisi cakupan rekomposisi.
Cmn
SnapshotMutationPolicy

Kebijakan untuk mengontrol cara hasil mutableStateOf melaporkan dan menggabungkan perubahan pada objek status.
Cmn
State

Holder nilai yang membaca properti value selama eksekusi fungsi Composable, RecomposeScope saat ini akan berlangganan perubahan nilai tersebut.
Cmn

Class

AbstractApplier

Implementasi Applier abstrak.
Cmn
AtomicReference
Cmn
BroadcastFrameClock

Jam frame sederhana.
Cmn
CompositionContext

CompositionContext adalah tipe buram yang digunakan untuk "menautkan" dua komposisi secara logis.
Cmn
CompositionLocal

Compose meneruskan data melalui hierarki komposisi secara eksplisit melalui sarana parameter ke fungsi composable.
Cmn
CompositionLocalContext

Menyimpan CompositionLocal dan nilainya.
Cmn
DisposableEffectScope

Cakupan penerima untuk DisposableEffect yang menawarkan klausa onDispose yang harus menjadi pernyataan terakhir dalam panggilan ke DisposableEffect.
Cmn
MovableContent

API plugin compiler Compose.
Cmn
MovableContentState

API plugin compiler Compose.
Cmn
MovableContentStateReference

API plugin compiler Compose.
Cmn
PausableMonotonicFrameClock

Wrapper MonotonicFrameClock yang dapat di-paused dan resumed.
Cmn
ProvidableCompositionLocal

ProvidableCompositionLocal dapat digunakan di CompositionLocalProvider untuk memberikan nilai.
Cmn
ProvidedValue

Instance untuk memiliki nilai yang disediakan oleh CompositionLocalProvider dan dibuat oleh operator tetap ProvidableCompositionLocal.provides.
Cmn
Recomposer

Penjadwal untuk menjalankan rekomposisi dan menerapkan update ke satu atau beberapa Composition.
Cmn
SkippableUpdater
Cmn
Updater

Class cakupan penerima helper yang digunakan oleh ComposeNode untuk membantu menulis kode untuk melakukan inisialisasi dan mengupdate node.
Cmn

Objek

MonotonicFrameClock.Key
Cmn

Anotasi

CheckResult
Cmn
Android
Composable

Fungsi Composable adalah elemen penyusun dasar aplikasi yang di-build dengan Compose.
Cmn
ComposableInferredTarget

Anotasi yang dibuat oleh plugin compiler compose.
Cmn
ComposableOpenTarget

Composable mendeklarasikan bahwa applier tertentu tidak diharapkan.
Cmn
ComposableTarget

Fungsi Composable dideklarasikan untuk mengharapkan applier dengan nama applier.
Cmn
ComposableTargetMarker

Anotasi ini digunakan untuk menandai anotasi sebagai setara menggunakan ComposableTarget dengan nama yang sepenuhnya memenuhi syarat dari anotasi yang ditandai sebagai nilai applier.
Cmn
ComposeCompilerApi
Cmn
DisallowComposableCalls

Ini akan mencegah panggilan composable terjadi di dalam fungsi yang diterapkan.
Cmn
ExperimentalComposeApi
Cmn
ExperimentalComposeRuntimeApi
Cmn
ExplicitGroupsComposable

Anotasi ini dapat diterapkan ke fungsi Composable sehingga tidak ada grup yang akan dibuat dalam isi fungsi yang dianotasikan.
Cmn
Immutable

Immutable dapat digunakan untuk menandai class sebagai menghasilkan instance yang tidak dapat diubah.
Cmn
InternalComposeApi
Cmn
InternalComposeTracingApi
Cmn
NoLiveLiterals

Anotasi ini digunakan untuk menunjukkan kepada Compose Compiler agar tidak mencoba membuat literal langsung di dalam cakupan deklarasi yang diterapkan, meskipun pembuatan kode literal langsung diaktifkan.
Cmn
NonRestartableComposable

Anotasi ini dapat diterapkan ke fungsi Composable untuk mencegah kode dibuat yang memungkinkan eksekusi fungsi ini dilewati atau dimulai ulang.
Cmn
ReadOnlyComposable

Anotasi ini dapat diterapkan ke fungsi Composable sehingga tidak ada grup yang akan dibuat di sekitar isi fungsi yang dianotasi.
Cmn
Stable

Stabil digunakan untuk mengomunikasikan beberapa jaminan ke compiler compose tentang bagaimana jenis atau fungsi tertentu akan berperilaku.
Cmn
StableMarker

StableMarker menandai anotasi sebagai menunjukkan bahwa suatu jenis stabil.
Cmn
TestOnly
Cmn

Enum

Recomposer.State

Status operasional Recomposer yang valid.
Cmn

Ringkasan fungsi level atas

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

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

Memberikan node ke komposisi jenis T.
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
)

Memberikan node ke komposisi jenis T.
Cmn
Composition
Composition(applier: Applier<*>, parent: CompositionContext)

Metode ini adalah cara untuk memulai komposisi.
Cmn
Composition
@ExperimentalComposeApi
Composition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
)

Buat Composition menggunakan applier untuk mengelola komposisi, sebagai turunan dari parent.
Cmn
Unit
@Composable
CompositionLocalProvider(
    context: CompositionLocalContext,
    content: @Composable () -> Unit
)

CompositionLocalProvider mengikat nilai ke CompositionLocal, yang diberikan oleh context.
Cmn
Unit
@Composable
CompositionLocalProvider(
    value: ProvidedValue<*>,
    content: @Composable () -> Unit
)

CompositionLocalProvider mengikat nilai ke kunci ProvidableCompositionLocal.
Cmn
Unit
@Composable
CompositionLocalProvider(
    vararg values: ProvidedValue<*>,
    content: @Composable () -> Unit
)

CompositionLocalProvider mengikat nilai ke kunci ProvidableCompositionLocal.
Cmn
ControlledComposition

Metode ini adalah suatu cara untuk memulai komposisi.
Cmn
ControlledComposition
@TestOnly
@ExperimentalComposeApi
ControlledComposition(
    applier: Applier<*>,
    parent: CompositionContext,
    recomposeCoroutineContext: CoroutineContext
)
Cmn
Unit

Fungsi ini tidak digunakan lagi. DisposableEffect harus menyediakan satu atau beberapa parameter 'key' yang menentukan identitas DisposableEffect dan menentukan kapan efek sebelumnya harus digunakan dan efek baru dimulai untuk kunci baru.
Cmn
Unit

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari key1 dan harus dikembalikan atau dibersihkan jika key1 berubah atau jika DisposableEffect keluar dari komposisi.
Cmn
Unit

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari keys dan harus dikembalikan atau dibersihkan jika ada perubahan keys atau jika DisposableEffect keluar dari komposisi.
Cmn
Unit

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari key1 atau key2 dan harus dikembalikan atau dibersihkan jika key1 atau key2 berubah, atau jika DisposableEffect keluar dari komposisi.
Cmn
Unit
@Composable
@NonRestartableComposable
DisposableEffect(
    key1: Any?,
    key2: Any?,
    key3: Any?,
    effect: DisposableEffectScope.() -> DisposableEffectResult
)

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari key1, key2, atau key3 dan harus dikembalikan atau dibersihkan jika key1, key2, atau key3 berubah, atau jika DisposableEffect keluar dari komposisi.
Cmn
Unit

Fungsi ini tidak digunakan lagi. LaunchedEffect harus menyediakan satu atau beberapa parameter 'key' yang menentukan identitas LaunchedEffect dan menentukan kapan coroutine efek sebelumnya harus dibatalkan dan efek baru diluncurkan untuk kunci baru.
Cmn
Unit

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi.
Cmn
Unit
@Composable
@NonRestartableComposable
LaunchedEffect(vararg keys: Any?, block: suspend CoroutineScope.() -> Unit)

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi.
Cmn
Unit
@Composable
@NonRestartableComposable
LaunchedEffect(key1: Any?, key2: Any?, block: suspend CoroutineScope.() -> Unit)

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi.
Cmn
Unit
@Composable
@NonRestartableComposable
LaunchedEffect(key1: Any?, key2: Any?, key3: Any?, block: suspend CoroutineScope.() -> Unit)

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi.
Cmn
inline Unit
@Composable
<T : Any, E : Applier<*>> ReusableComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit
)

Memberikan node yang dapat didaur ulang ke dalam komposisi jenis T.
Cmn
inline Unit
@Composable
<T : Any?, E : Applier<*>> ReusableComposeNode(
    noinline factory: () -> T,
    update: @DisallowComposableCalls Updater<T>.() -> Unit,
    content: @Composable () -> Unit
)

Memberikan node yang dapat didaur ulang ke dalam komposisi jenis T.
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
)

Memberikan node yang dapat didaur ulang ke dalam komposisi jenis T.
Cmn
ReusableComposition

Metode ini adalah cara untuk memulai komposisi yang dapat digunakan kembali.
Cmn
inline Unit
@Composable
ReusableContent(key: Any?, content: @Composable () -> Unit)

Sebuah fungsi utilitas untuk menandai komposisi sebagai pendukung daur ulang.
Cmn
inline Unit
@Composable
@ExplicitGroupsComposable
ReusableContentHost(
    active: Boolean,
    crossinline content: @Composable () -> Unit
)

Fungsi utilitas opsional yang digunakan saat menghosting ReusableContent.
Cmn
Unit

Jadwalkan effect agar berjalan saat komposisi saat ini berhasil diselesaikan dan menerapkan perubahan.
Cmn
ProvidableCompositionLocal<T>
<T : Any?> compositionLocalOf(
    policy: SnapshotMutationPolicy<T>,
    defaultFactory: () -> T
)

Buat kunci CompositionLocal yang dapat disediakan menggunakan CompositionLocalProvider.
Cmn
State<T>
@StateFactoryMarker
<T : Any?> derivedStateOf(calculation: () -> T)

Membuat objek State yang State.value-nya merupakan hasil dari calculation.
Cmn
State<T>
@StateFactoryMarker
<T : Any?> derivedStateOf(
    policy: SnapshotMutationPolicy<T>,
    calculation: () -> T
)

Membuat objek State yang State.value-nya merupakan hasil dari calculation.
Cmn
Boolean

API perekaman aktivitas internal.
Cmn
inline T
@Composable
<T : Any?> key(vararg keys: Any?, block: @Composable () -> T)

key adalah composable utilitas yang digunakan untuk "mengelompokkan" atau "kunci" blok eksekusi di dalam komposisi.
Cmn
@Composable () -> Unit
movableContentOf(content: @Composable () -> Unit)

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable (P) -> Unit
<P : Any?> movableContentOf(content: @Composable (P) -> Unit)

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable (P1, P2) -> Unit
<P1 : Any?, P2 : Any?> movableContentOf(content: @Composable (P1, P2) -> Unit)

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable (P1, P2, P3) -> Unit
<P1 : Any?, P2 : Any?, P3 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3) -> Unit
)

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable (P1, P2, P3, P4) -> Unit
<P1 : Any?, P2 : Any?, P3 : Any?, P4 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3, P4) -> Unit
)

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable R.() -> Unit
<R : Any?> movableContentWithReceiverOf(content: @Composable R.() -> Unit)

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable R.(P) -> Unit
<R : Any?, P : Any?> movableContentWithReceiverOf(content: @Composable R.(P) -> Unit)

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable R.(P1, P2) -> Unit
<R : Any?, P1 : Any?, P2 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2) -> Unit
)

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
@Composable R.(P1, P2, P3) -> Unit
<R : Any?, P1 : Any?, P2 : Any?, P3 : Any?> movableContentWithReceiverOf(
    content: @Composable R.(P1, P2, P3) -> Unit
)

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.
Cmn
MutableDoubleState

Menampilkan MutableDoubleState baru yang diinisialisasi dengan value yang diteruskan
Cmn
MutableFloatState

Menampilkan MutableFloatState baru yang diinisialisasi dengan value yang diteruskan
Cmn
MutableIntState

Menampilkan MutableIntState baru yang diinisialisasi dengan value yang diteruskan
Cmn
MutableLongState

Menampilkan MutableLongState baru yang diinisialisasi dengan value yang diteruskan
Cmn
SnapshotStateList<T>

Buat instance MutableList yang dapat diamati dan dapat berupa snapshot.
Cmn
SnapshotStateList<T>
@StateFactoryMarker
<T : Any?> mutableStateListOf(vararg elements: T)

Buat instance MutableList yang dapat diamati dan dapat berupa snapshot.
Cmn
SnapshotStateMap<K, V>

Buat instance MutableMap<k, v=""> yang dapat diamati dan dapat berupa snapshot.</k,>
Cmn
SnapshotStateMap<K, V>
@StateFactoryMarker
<K : Any?, V : Any?> mutableStateMapOf(vararg pairs: Pair<K, V>)

Buat instance MutableMap<k, v=""> yang dapat diamati dan dapat berupa snapshot.</k,>
Cmn
MutableState<T>

Menampilkan MutableState baru yang diinisialisasi dengan value yang diteruskan
Cmn
SnapshotMutationPolicy<T>

Kebijakan tidak pernah memperlakukan nilai MutableState sebagai setara.
Cmn
State<T>
@Composable
<T : Any?> produceState(initialValue: T, producer: suspend ProduceStateScope<T>.() -> Unit)

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu tanpa sumber data yang ditentukan.
Cmn
State<T>
@Composable
<T : Any?> produceState(initialValue: T, key1: Any?, producer: suspend ProduceStateScope<T>.() -> Unit)

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari key1.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    vararg keys: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari keys.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari key1 dan key2.
Cmn
State<T>
@Composable
<T : Any?> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    key3: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit
)

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari key1, key2, dan key3.
Cmn
SnapshotMutationPolicy<T>

Kebijakan untuk memperlakukan nilai MutableState sebagai setara jika nilai tersebut secara referensial (===) sama.
Cmn
inline T
@Composable
<T : Any?> remember(crossinline calculation: @DisallowComposableCalls () -> T)

Ingat nilai yang dihasilkan oleh calculation.
Cmn
inline T
@Composable
<T : Any?> remember(
    key1: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

Ingat nilai yang ditampilkan oleh calculation jika key1 sama dengan komposisi sebelumnya. Jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.
Cmn
inline T
@Composable
<T : Any?> remember(
    vararg keys: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

Ingat nilai yang ditampilkan oleh calculation jika semua nilai keys sama dengan komposisi sebelumnya, jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.
Cmn
inline T
@Composable
<T : Any?> remember(
    key1: Any?,
    key2: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

Ingat nilai yang ditampilkan oleh calculation jika key1 dan key2 sama dengan komposisi sebelumnya. Jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.
Cmn
inline T
@Composable
<T : Any?> remember(
    key1: Any?,
    key2: Any?,
    key3: Any?,
    crossinline calculation: @DisallowComposableCalls () -> T
)

Ingat nilai yang ditampilkan oleh calculation jika key1, key2, dan key3 sama dengan komposisi sebelumnya. Jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.
Cmn
CompositionContext

Efek untuk membuat CompositionContext pada titik komposisi saat ini.
Cmn
inline CoroutineScope

Tampilkan CoroutineScope yang terikat ke titik ini dalam komposisi menggunakan CoroutineContext opsional yang disediakan oleh getContext.
Cmn
State<T>
@Composable
<T : Any?> rememberUpdatedState(newValue: T)

remember mutableStateOf dan update nilainya menjadi newValue pada setiap rekomposisi panggilan rememberUpdatedState.
Cmn
Flow<T>
<T : Any?> snapshotFlow(block: () -> T)

Membuat Flow dari status Snapshot yang dapat diamati.
Cmn
Unit
@ComposeCompilerApi
sourceInformation(composer: Composer, sourceInformation: String)

Fungsi internal Compose.
Cmn
Unit

Fungsi internal Compose.
Cmn
Unit
@ComposeCompilerApi
sourceInformationMarkerStart(
    composer: Composer,
    key: Int,
    sourceInformation: String
)

Fungsi internal Compose.
Cmn
ProvidableCompositionLocal<T>
<T : Any?> staticCompositionLocalOf(defaultFactory: () -> T)

Buat kunci CompositionLocal yang dapat disediakan menggunakan CompositionLocalProvider.
Cmn
SnapshotMutationPolicy<T>

Kebijakan untuk memperlakukan nilai MutableState sebagai setara jika secara struktural (==) sama.
Cmn
Unit

API perekaman aktivitas internal.
Cmn
Unit
@ComposeCompilerApi
traceEventStart(key: Int, dirty1: Int, dirty2: Int, info: String)

API perekaman aktivitas internal.
Cmn
suspend R
<R : Any?> withFrameMillis(onFrame: (frameTimeMillis: Long) -> R)

Menangguhkan hingga frame baru diminta, segera memanggil onFrame dengan waktu frame dalam milidetik dalam konteks panggilan pengiriman frame, lalu dilanjutkan dengan hasil dari onFrame.
Cmn
suspend R
<R : Any?> withFrameNanos(onFrame: (frameTimeNanos: Long) -> R)

Menangguhkan hingga frame baru diminta, segera memanggil onFrame dengan waktu frame dalam nanodetik dalam konteks panggilan pengiriman frame, lalu dilanjutkan dengan hasil dari onFrame.
Cmn
suspend R
<R : Any?> withRunningRecomposer(block: suspend CoroutineScope.(recomposer: Recomposer) -> R)

Menjalankan block dengan Recomposer baru yang aktif yang menerapkan perubahan pada CoroutineContext panggilan.
Cmn

Ringkasan fungsi ekstensi

DoubleState

Mengonversi State<Double> (seperti dalam State dari kotak Double) menjadi Double yang didukung primitif.
Cmn
FloatState

Mengonversi State<Float> (seperti dalam State dari kotak Float) menjadi Float yang didukung primitif.
Cmn
IntState

Mengonversi State<Int> (seperti dalam State dari kotak Int) menjadi IntState yang didukung primitif.
Cmn
LongState

Mengonversi State<Long> (seperti dalam State dari kotak Long) menjadi LongState yang didukung primitif.
Cmn
inline T
@ComposeCompilerApi
<T : Any?> Composer.cache(
    invalid: Boolean,
    block: @DisallowComposableCalls () -> T
)

API plugin compiler Compose.
Cmn
State<T>

Mengumpulkan nilai dari StateFlow ini dan mewakili nilai terbarunya melalui State.
Cmn
State<R>
@Composable
<T : R, R : Any?> Flow<T>.collectAsState(initial: R, context: CoroutineContext)

Mengumpulkan nilai dari Flow ini dan mewakili nilai terbarunya melalui State.
Cmn
inline operator Double
DoubleState.getValue(thisObj: Any?, property: KProperty<*>)

Mengizinkan delegasi properti val menggunakan by untuk DoubleState.
Cmn
inline operator Float
FloatState.getValue(thisObj: Any?, property: KProperty<*>)

Mengizinkan delegasi properti val menggunakan by untuk FloatState.
Cmn
inline operator Int
IntState.getValue(thisObj: Any?, property: KProperty<*>)

Mengizinkan delegasi properti val menggunakan by untuk IntState.
Cmn
inline operator Long
LongState.getValue(thisObj: Any?, property: KProperty<*>)

Mengizinkan delegasi properti val menggunakan by untuk LongState.
Cmn
inline operator T
<T : Any?> State<T>.getValue(thisObj: Any?, property: KProperty<*>)

Mengizinkan delegasi properti val menggunakan by untuk State.
Cmn
inline operator Unit
MutableDoubleState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Double
)

Mengizinkan delegasi properti var menggunakan by untuk MutableDoubleState.
Cmn
inline operator Unit
MutableFloatState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Float
)

Mengizinkan delegasi properti var menggunakan by untuk MutableFloatState.
Cmn
inline operator Unit
MutableIntState.setValue(thisObj: Any?, property: KProperty<*>, value: Int)

Mengizinkan delegasi properti var menggunakan by untuk MutableIntState.
Cmn
inline operator Unit
MutableLongState.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: Long
)

Mengizinkan delegasi properti var menggunakan by untuk MutableLongState.
Cmn
inline operator Unit
<T : Any?> MutableState<T>.setValue(
    thisObj: Any?,
    property: KProperty<*>,
    value: T
)

Mengizinkan delegasi properti var menggunakan by untuk MutableState.
Cmn
SnapshotStateList<T>

Buat instance MutableList dari koleksi yang dapat diamati dan dapat berupa snapshot.
Cmn
SnapshotStateMap<K, V>
<K : Any?, V : Any?> Iterable<Pair<K, V>>.toMutableStateMap()

Buat instance MutableMap<k, v=""> dari kumpulan pasangan yang dapat diamati dan dapat diambil snapshot-nya.</k,>
Cmn
suspend inline R
<R : Any?> MonotonicFrameClock.withFrameMillis(
    crossinline onFrame: (frameTimeMillis: Long) -> R
)

Menangguhkan hingga frame baru diminta, segera memanggil onFrame dengan waktu frame dalam milidetik dalam konteks panggilan pengiriman frame, lalu dilanjutkan dengan hasil dari onFrame.
Cmn

Ringkasan properti tingkat atas

MonotonicFrameClock

Properti ini tidak digunakan lagi. MonotonicFrameClocks tidak berlaku secara global di seluruh platform.
Cmn
Android
Composer

TODO(lmr): memberikan dokumentasi
Cmn
Int

Nilai hash ini digunakan untuk mengoordinasikan peta status yang disimpan secara eksternal ke komposisi.
Cmn
CompositionLocalContext

Menampilkan CompositionLocalContext saat ini yang berisi semua CompositionLocal dalam komposisi saat ini dan nilainya yang diberikan oleh CompositionLocalProvider.
Cmn
RecomposeScope

Menampilkan objek yang dapat digunakan untuk membatalkan cakupan saat ini pada titik komposisi ini.
Cmn

Ringkasan properti ekstensi

MonotonicFrameClock

Menampilkan MonotonicFrameClock untuk CoroutineContext ini atau menampilkan IllegalStateException jika tidak ada.
Cmn
CoroutineContext

CoroutineContext yang harus digunakan untuk melakukan rekomposisi serentak dari ControlledComposition ini saat digunakan di lingkungan yang mendukung komposisi serentak.
Cmn

Fungsi level atas

ComposeNode

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

Memberikan node ke komposisi jenis T.

Fungsi ini akan menampilkan pengecualian runtime jika E bukan subjenis applier dari currentComposer.

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

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

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

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

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

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

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

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

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

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

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

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

Fungsi yang akan membuat instance T baru. Fungsi ini TIDAK dijamin akan dipanggil.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Fungsi ini akan berjalan setiap kali emit dieksekusi. Fungsi ini dipanggil di tempatnya dan akan disisipkan.
Lihat juga
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

Memberikan node ke komposisi jenis T. Node yang dimunculkan di dalam content akan menjadi turunan dari node yang dimunculkan.

Fungsi ini akan menampilkan pengecualian runtime jika E bukan subjenis applier dari currentComposer.

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

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

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

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

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

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

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

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

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

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

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

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

Fungsi yang akan membuat instance T baru. Fungsi ini TIDAK dijamin akan dipanggil.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Fungsi ini akan berjalan setiap kali emit dieksekusi. Fungsi ini dipanggil di tempatnya dan akan disisipkan.
content: @Composable () -> Unit

konten composable yang akan memunculkan "turunan" node ini.
Lihat juga
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

Memberikan node ke komposisi jenis T. Node yang dimunculkan di dalam content akan menjadi turunan dari node yang dimunculkan.

Fungsi ini akan menampilkan pengecualian runtime jika E bukan subjenis applier dari currentComposer.

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

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

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

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

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

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

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

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

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

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

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

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

Fungsi yang akan membuat instance T baru. Fungsi ini TIDAK dijamin akan dipanggil.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Fungsi ini akan berjalan setiap kali emit dieksekusi. Fungsi ini dipanggil di tempatnya dan akan disisipkan.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Tidak seperti update, fungsi ini bersifat Composable dan akan dilewati kecuali jika dibatalkan oleh beberapa mekanisme lainnya. Hal ini dapat berguna dalam melakukan penghitungan yang mahal untuk memperbarui node di mana perhitungan cenderung memiliki input yang sama dari waktu ke waktu, sehingga eksekusi fungsi dapat dilewati.
content: @Composable () -> Unit

konten composable yang akan memunculkan "turunan" node ini.
Lihat juga
Updater
SkippableUpdater
Applier
Composition

Komposisi

Cmn
Ditambahkan di 1.0.0
fun Composition(applier: Applier<*>, parent: CompositionContext): Composition

Metode ini adalah cara untuk memulai komposisi. parent dapat berupa

  • disediakan untuk membuat komposisi berperilaku sebagai subkomposisi dari induk. Jika komposisi melakukan

  • tidak memiliki induk, instance Recomposer harus disediakan.

Penting untuk memanggil Composition.dispose saat komposisi tidak lagi diperlukan untuk melepaskan resource.

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

Instance Applier yang akan digunakan dalam komposisi.
parent: CompositionContext

Induk CompositionContext.
Lihat juga
Applier
Composition
Recomposer

Komposisi

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

Buat Composition menggunakan applier untuk mengelola komposisi, sebagai turunan dari parent.

Saat digunakan dalam konfigurasi yang mendukung rekomposisi serentak, petunjuk tentang lingkungan bahwa recomposeCoroutineContext harus digunakan untuk melakukan rekomposisi. Rekomposisi akan diluncurkan ke dalam

CompositionLocalProvider

Cmn
Ditambahkan di 1.1.0
@Composable
fun CompositionLocalProvider(
    context: CompositionLocalContext,
    content: @Composable () -> Unit
): Unit

CompositionLocalProvider mengikat nilai ke CompositionLocal, yang diberikan oleh context. Membaca CompositionLocal menggunakan CompositionLocal.current akan menampilkan nilai yang diberikan dalam nilai yang disimpan di dalam context untuk semua fungsi composable yang dipanggil secara langsung atau tidak langsung di lambda content.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}
Lihat juga
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

CompositionLocalProvider

Cmn
Ditambahkan di 1.6.0-alpha07
@Composable
fun CompositionLocalProvider(
    value: ProvidedValue<*>,
    content: @Composable () -> Unit
): Unit

CompositionLocalProvider mengikat nilai ke kunci ProvidableCompositionLocal. Membaca CompositionLocal menggunakan CompositionLocal.current akan menampilkan nilai yang disediakan dalam parameter value CompositionLocalProvider untuk semua fungsi composable yang dipanggil secara langsung atau tidak langsung di lambda content.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}
Lihat juga
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

CompositionLocalProvider

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

CompositionLocalProvider mengikat nilai ke kunci ProvidableCompositionLocal. Membaca CompositionLocal menggunakan CompositionLocal.current akan menampilkan nilai yang disediakan dalam parameter values CompositionLocalProvider untuk semua fungsi composable yang dipanggil secara langsung atau tidak langsung di lambda content.

import androidx.compose.runtime.CompositionLocalProvider

@Composable
fun App(user: User) {
    CompositionLocalProvider(ActiveUser provides user) {
        SomeScreen()
    }
}
Lihat juga
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

Komposisi Terkontrol

Cmn
Ditambahkan di 1.0.0
@TestOnly
fun ControlledComposition(applier: Applier<*>, parent: CompositionContext): ControlledComposition

Metode ini adalah suatu cara untuk memulai komposisi. Secara opsional, parent dapat diberikan untuk membuat komposisi berperilaku sebagai subkomposisi induk atau Recomposer dapat diberikan.

Komposisi yang dikontrol memungkinkan kontrol langsung atas komposisi, bukan dikontrol oleh Recomposer yang diteruskan oleh komposisi root.

Penting untuk memanggil Composition.dispose yang tidak diperlukan lagi komposer ini untuk melepaskan resource.

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

Instance Applier yang akan digunakan dalam komposisi.
parent: CompositionContext

Induk CompositionContext.
Lihat juga
Applier
Composition
Recomposer

Komposisi Terkontrol

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

DisposableEffect

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

Efek samping komposisi yang harus dibalik atau dibersihkan jika DisposableEffect keluar dari komposisi.

Memanggil DisposableEffect tanpa setidaknya satu parameter key adalah error.

DisposableEffect

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

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari key1 dan harus dikembalikan atau dibersihkan jika key1 berubah atau jika DisposableEffect keluar dari komposisi.

Kunci DisposableEffect adalah nilai yang menentukan identitas DisposableEffect. Jika tombol berubah, DisposableEffect harus dispose effect saat ini dan direset dengan memanggil effect lagi. Contoh kunci meliputi:

  • Objek yang dapat diobservasi yang diikuti efek

  • Parameter permintaan unik untuk operasi yang harus dibatalkan dan mencoba lagi jika parameter tersebut berubah

DisposableEffect dapat digunakan untuk menginisialisasi atau berlangganan kunci dan menginisialisasi ulang saat kunci lain diberikan, yang melakukan pembersihan untuk operasi lama sebelum menginisialisasi yang baru. Contoh:

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 harus menyertakan klausa onDispose sebagai pernyataan akhir dalam blok effect-nya. Jika operasi Anda tidak memerlukan penghapusan, operasi tersebut mungkin berupa SideEffect, atau LaunchedEffect jika meluncurkan coroutine yang harus dikelola oleh komposisi.

Dijamin ada satu panggilan ke dispose untuk setiap panggilan ke effect. effect dan dispose akan selalu dijalankan pada dispatcher dan applier komposisi yang tidak pernah dijalankan secara bersamaan dengan dirinya sendiri, satu sama lain, menerapkan perubahan pada hierarki komposisi, atau menjalankan callback peristiwa RememberObserver.

DisposableEffect

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

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari keys dan harus dikembalikan atau dibersihkan jika ada perubahan keys atau jika DisposableEffect keluar dari komposisi.

Kunci DisposableEffect adalah nilai yang menentukan identitas DisposableEffect. Jika tombol berubah, DisposableEffect harus dispose effect saat ini dan direset dengan memanggil effect lagi. Contoh kunci meliputi:

  • Objek yang dapat diobservasi yang diikuti efek

  • Parameter permintaan unik untuk operasi yang harus dibatalkan dan mencoba lagi jika parameter tersebut berubah

DisposableEffect dapat digunakan untuk menginisialisasi atau berlangganan kunci dan menginisialisasi ulang saat kunci lain diberikan, yang melakukan pembersihan untuk operasi lama sebelum menginisialisasi yang baru. Contoh:

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 harus menyertakan klausa onDispose sebagai pernyataan akhir dalam blok effect-nya. Jika operasi Anda tidak memerlukan penghapusan, operasi tersebut mungkin berupa SideEffect, atau LaunchedEffect jika meluncurkan coroutine yang harus dikelola oleh komposisi.

Dijamin ada satu panggilan ke dispose untuk setiap panggilan ke effect. effect dan dispose akan selalu dijalankan pada dispatcher dan applier komposisi yang tidak pernah dijalankan secara bersamaan dengan dirinya sendiri, satu sama lain, menerapkan perubahan pada hierarki komposisi, atau menjalankan callback peristiwa RememberObserver.

DisposableEffect

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

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari key1 atau key2 dan harus dikembalikan atau dibersihkan jika key1 atau key2 berubah, atau jika DisposableEffect keluar dari komposisi.

Kunci DisposableEffect adalah nilai yang menentukan identitas DisposableEffect. Jika tombol berubah, DisposableEffect harus dispose effect saat ini dan direset dengan memanggil effect lagi. Contoh kunci meliputi:

  • Objek yang dapat diobservasi yang diikuti efek

  • Parameter permintaan unik untuk operasi yang harus dibatalkan dan mencoba lagi jika parameter tersebut berubah

DisposableEffect dapat digunakan untuk menginisialisasi atau berlangganan kunci dan menginisialisasi ulang saat kunci lain diberikan, yang melakukan pembersihan untuk operasi lama sebelum menginisialisasi yang baru. Contoh:

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 harus menyertakan klausa onDispose sebagai pernyataan akhir dalam blok effect-nya. Jika operasi Anda tidak memerlukan penghapusan, operasi tersebut mungkin berupa SideEffect, atau LaunchedEffect jika meluncurkan coroutine yang harus dikelola oleh komposisi.

Dijamin ada satu panggilan ke dispose untuk setiap panggilan ke effect. effect dan dispose akan selalu dijalankan pada dispatcher dan applier komposisi yang tidak pernah dijalankan secara bersamaan dengan dirinya sendiri, satu sama lain, menerapkan perubahan pada hierarki komposisi, atau menjalankan callback peristiwa RememberObserver.

DisposableEffect

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

Efek samping komposisi yang harus dijalankan untuk nilai unik baru apa pun dari key1, key2, atau key3 dan harus dikembalikan atau dibersihkan jika key1, key2, atau key3 berubah, atau jika DisposableEffect keluar dari komposisi.

Kunci DisposableEffect adalah nilai yang menentukan identitas DisposableEffect. Jika tombol berubah, DisposableEffect harus dispose effect saat ini dan direset dengan memanggil effect lagi. Contoh kunci meliputi:

  • Objek yang dapat diobservasi yang diikuti efek

  • Parameter permintaan unik untuk operasi yang harus dibatalkan dan mencoba lagi jika parameter tersebut berubah

DisposableEffect dapat digunakan untuk menginisialisasi atau berlangganan kunci dan menginisialisasi ulang saat kunci lain diberikan, yang melakukan pembersihan untuk operasi lama sebelum menginisialisasi yang baru. Contoh:

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 harus menyertakan klausa onDispose sebagai pernyataan akhir dalam blok effect-nya. Jika operasi Anda tidak memerlukan penghapusan, operasi tersebut mungkin berupa SideEffect, atau LaunchedEffect jika meluncurkan coroutine yang harus dikelola oleh komposisi.

Dijamin ada satu panggilan ke dispose untuk setiap panggilan ke effect. effect dan dispose akan selalu dijalankan pada dispatcher dan applier komposisi yang tidak pernah dijalankan secara bersamaan dengan dirinya sendiri, satu sama lain, menerapkan perubahan pada hierarki komposisi, atau menjalankan callback peristiwa RememberObserver.

LaunchedEffect

Cmn
Ditambahkan di 1.0.0
Tidak digunakan lagi di 1.0.0
@Composable
fun LaunchedEffect(block: suspend CoroutineScope.() -> Unit): Unit

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi. Coroutine akan menjadi cancelled saat LaunchedEffect keluar dari komposisi.

Memanggil LaunchedEffect tanpa setidaknya satu parameter key adalah error.

LaunchedEffect

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

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi. Coroutine akan menjadi cancelled dan diluncurkan ulang saat LaunchedEffect direkomposisi dengan key1 yang berbeda. Coroutine akan menjadi cancelled saat LaunchedEffect keluar dari komposisi.

Fungsi ini tidak boleh digunakan untuk (kembali) meluncurkan tugas yang sedang berlangsung sebagai respons terhadap peristiwa callback dengan cara menyimpan data callback di MutableState yang diteruskan ke key1. Sebagai gantinya, lihat rememberCoroutineScope untuk mendapatkan CoroutineScope yang dapat digunakan untuk meluncurkan tugas yang sedang berlangsung yang dicakupkan ke komposisi sebagai respons terhadap callback peristiwa.

LaunchedEffect

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

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi. Coroutine akan menjadi cancelled dan diluncurkan ulang saat LaunchedEffect direkomposisi dengan keys yang berbeda. Coroutine akan menjadi cancelled saat LaunchedEffect keluar dari komposisi.

Fungsi ini tidak boleh digunakan untuk (kembali) meluncurkan tugas yang sedang berlangsung sebagai respons terhadap peristiwa callback dengan cara menyimpan data callback di MutableState yang diteruskan ke key. Sebagai gantinya, lihat rememberCoroutineScope untuk mendapatkan CoroutineScope yang dapat digunakan untuk meluncurkan tugas yang sedang berlangsung yang dicakupkan ke komposisi sebagai respons terhadap callback peristiwa.

LaunchedEffect

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

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi. Coroutine akan menjadi cancelled dan diluncurkan ulang saat LaunchedEffect direkomposisi dengan key1 atau key2 yang berbeda. Coroutine akan menjadi cancelled saat LaunchedEffect keluar dari komposisi.

Fungsi ini tidak boleh digunakan untuk (kembali) meluncurkan tugas yang sedang berlangsung sebagai respons terhadap peristiwa callback dengan cara menyimpan data callback di MutableState yang diteruskan ke key. Sebagai gantinya, lihat rememberCoroutineScope untuk mendapatkan CoroutineScope yang dapat digunakan untuk meluncurkan tugas yang sedang berlangsung yang dicakupkan ke komposisi sebagai respons terhadap callback peristiwa.

LaunchedEffect

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

Saat LaunchedEffect memasuki komposisi, block akan diluncurkan ke CoroutineContext komposisi. Coroutine akan menjadi cancelled dan diluncurkan ulang saat LaunchedEffect direkomposisi dengan key1, key2, atau key3 yang berbeda. Coroutine akan menjadi cancelled saat LaunchedEffect keluar dari komposisi.

Fungsi ini tidak boleh digunakan untuk (kembali) meluncurkan tugas yang sedang berlangsung sebagai respons terhadap peristiwa callback dengan cara menyimpan data callback di MutableState yang diteruskan ke key. Sebagai gantinya, lihat rememberCoroutineScope untuk mendapatkan CoroutineScope yang dapat digunakan untuk meluncurkan tugas yang sedang berlangsung yang dicakupkan ke komposisi sebagai respons terhadap callback peristiwa.

ReusableComposeNode

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

Memberikan node yang dapat didaur ulang ke dalam komposisi jenis T.

Fungsi ini akan menampilkan pengecualian runtime jika E bukan subjenis applier dari currentComposer.

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

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

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

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

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

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

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

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

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

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

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

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

Fungsi yang akan membuat instance T baru. Fungsi ini TIDAK dijamin akan dipanggil.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Fungsi ini akan berjalan setiap kali emit dieksekusi. Fungsi ini dipanggil di tempatnya dan akan disisipkan.
Lihat juga
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

Memberikan node yang dapat didaur ulang ke dalam komposisi jenis T. Node yang dimunculkan di dalam content akan menjadi turunan dari node yang dimunculkan.

Fungsi ini akan menampilkan pengecualian runtime jika E bukan subjenis applier dari currentComposer.

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

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

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

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

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

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

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

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

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

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

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

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

Fungsi yang akan membuat instance T baru. Fungsi ini TIDAK dijamin akan dipanggil.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Fungsi ini akan berjalan setiap kali emit dieksekusi. Fungsi ini dipanggil di tempatnya dan akan disisipkan.
content: @Composable () -> Unit

konten composable yang akan memunculkan "turunan" node ini.
Lihat juga
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

Memberikan node yang dapat didaur ulang ke dalam komposisi jenis T. Node yang dimunculkan di dalam content akan menjadi turunan dari node yang dimunculkan.

Fungsi ini akan menampilkan pengecualian runtime jika E bukan subjenis applier dari currentComposer.

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

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

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

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

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

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

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

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

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

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

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

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

Fungsi yang akan membuat instance T baru. Fungsi ini TIDAK dijamin akan dipanggil.
update: @DisallowComposableCalls Updater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Fungsi ini akan berjalan setiap kali emit dieksekusi. Fungsi ini dipanggil di tempatnya dan akan disisipkan.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit

Fungsi untuk melakukan update pada node. Tidak seperti update, fungsi ini bersifat Composable dan akan dilewati kecuali jika dibatalkan oleh beberapa mekanisme lainnya. Hal ini dapat berguna dalam melakukan penghitungan yang mahal untuk memperbarui node di mana perhitungan cenderung memiliki input yang sama dari waktu ke waktu, sehingga eksekusi fungsi dapat dilewati.
content: @Composable () -> Unit

konten composable yang akan memunculkan "turunan" node ini.
Lihat juga
Updater
SkippableUpdater
Applier
Composition

Komposisi Dapat Digunakan Kembali

Cmn
Ditambahkan di 1.6.0-alpha07
fun ReusableComposition(applier: Applier<*>, parent: CompositionContext): ReusableComposition

Metode ini adalah cara untuk memulai komposisi yang dapat digunakan kembali. parent dapat diberikan untuk membuat komposisi berperilaku sebagai subkomposisi induk. Jika komposisi tidak memiliki induk, instance Recomposer harus disediakan.

Penting untuk memanggil Composition.dispose saat komposisi tidak lagi diperlukan untuk melepaskan resource.

Parameter
applier: Applier<*>

Instance Applier yang akan digunakan dalam komposisi.
parent: CompositionContext

Induk CompositionContext.
Lihat juga
Applier
ReusableComposition
rememberCompositionContext

Konten yang Dapat Digunakan Kembali

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

Sebuah fungsi utilitas untuk menandai komposisi sebagai pendukung daur ulang. Jika key mengubah komposisi, akan diganti dengan komposisi baru (seperti yang akan terjadi untuk key), tetapi node yang dapat digunakan kembali yang dimunculkan oleh ReusableComposeNode akan digunakan kembali.

Parameter
key: Any?

nilai yang digunakan untuk memicu daur ulang. Jika dikomposisi ulang dengan nilai yang berbeda, komposer akan membuat komposisi baru, tetapi akan mencoba menggunakan kembali node yang dapat digunakan kembali.
content: @Composable () -> Unit

turunan composable yang dapat didaur ulang.

Host Konten yang Dapat Digunakan Kembali

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

Fungsi utilitas opsional yang digunakan saat menghosting ReusableContent. Jika active bernilai salah, konten akan diperlakukan seolah-olah dihapus dengan menghapus semua objek yang diingat dari komposisi, tetapi node yang dihasilkan untuk hierarki tidak dihapus. Saat komposisi nanti menjadi aktif, node dapat digunakan kembali di dalam konten ReusableContent tanpa memerlukan status yang diingat dari masa aktif komposisi yang diperpanjang secara acak.

Parameter
active: Boolean

jika active adalah true, content dikomposisi secara normal. Jika active adalah false, konten akan dinonaktifkan dan semua status yang diingat diperlakukan seolah-olah konten telah dihapus, tetapi node yang dikelola oleh Applier komposisi tidak akan terpengaruh. active menjadi true setiap node yang dapat digunakan kembali dari komposisi sebelumnya yang aktif akan menjadi kandidat untuk digunakan kembali.
crossinline content: @Composable () -> Unit

konten composable yang dikelola oleh composable ini.

Efek Samping

Cmn
Ditambahkan di 1.0.0
@Composable
@NonRestartableComposable
@ExplicitGroupsComposable
fun SideEffect(effect: () -> Unit): Unit

Jadwalkan effect agar berjalan saat komposisi saat ini berhasil diselesaikan dan menerapkan perubahan. SideEffect dapat digunakan untuk menerapkan efek samping pada objek yang dikelola oleh komposisi yang tidak didukung oleh snapshots sehingga tidak meninggalkan objek tersebut dalam keadaan yang tidak konsisten jika operasi komposisi saat ini gagal.

effect akan selalu dijalankan pada dispatcher dan applier komposisi tidak pernah berjalan serentak dengan dirinya sendiri, satu sama lain, menerapkan perubahan pada hierarki komposisi, atau menjalankan callback peristiwa RememberObserver. SideEffect selalu dijalankan setelah callback peristiwa RememberObserver.

SideEffect berjalan setelah setiap rekomposisi. Untuk meluncurkan tugas yang sedang berlangsung yang kemungkinan mencakup banyak rekomposisi, lihat LaunchedEffect. Untuk mengelola langganan peristiwa atau siklus proses objek lainnya, lihat DisposableEffect.

komposisiLocalOf

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

Buat kunci CompositionLocal yang dapat disediakan menggunakan CompositionLocalProvider. Mengubah nilai yang diberikan selama rekomposisi akan membuat konten CompositionLocalProvider yang membaca nilai menggunakan CompositionLocal.current menjadi tidak valid.

compositionLocalOf membuat ProvidableCompositionLocal yang dapat digunakan dalam panggilan ke CompositionLocalProvider. Serupa dengan MutableList vs. List, jika kunci disetel ke publik sebagai CompositionLocal, bukan ProvidableCompositionLocal, kunci dapat dibaca menggunakan CompositionLocal.current tetapi tidak disediakan ulang.

Parameter
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()

kebijakan untuk menentukan kapan CompositionLocal dianggap berubah. Untuk lebih detailnya, lihat SnapshotMutationPolicy.
defaultFactory: () -> T

pabrik nilai untuk menyediakan nilai ketika nilai tidak diberikan. Factory ini dipanggil jika tidak ada nilai yang diberikan melalui CompositionLocalProvider pemanggil komponen menggunakan CompositionLocal.current. Jika tidak ada default yang wajar yang dapat diberikan, pertimbangkan untuk menampilkan pengecualian.
Lihat juga
CompositionLocal
staticCompositionLocalOf
mutableStateOf

derivedStateOf

Cmn
Ditambahkan di 1.0.0
@StateFactoryMarker
fun <T : Any?> derivedStateOf(calculation: () -> T): State<T>

Membuat objek State yang State.value-nya merupakan hasil dari calculation. Hasil penghitungan akan di-cache sedemikian rupa sehingga memanggil State.value berulang kali tidak akan menyebabkan calculation dieksekusi beberapa kali, tetapi pembacaan State.value akan menyebabkan semua objek State yang dibaca selama calculation dibaca di Snapshot saat ini, yang berarti bahwa objek ini akan berlangganan dengan benar ke objek status turunan jika nilainya dibaca dalam konteks yang diamati seperti fungsi Composable. Status turunan tanpa kebijakan mutasi memicu update pada setiap perubahan dependensi. Untuk menghindari pembatalan validasi update, berikan SnapshotMutationPolicy yang sesuai melalui overload derivedStateOf.

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

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

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

penghitungan untuk membuat nilai yang diwakili oleh objek status ini.

derivedStateOf

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

Membuat objek State yang State.value-nya merupakan hasil dari calculation. Hasil penghitungan akan di-cache sedemikian rupa sehingga memanggil State.value berulang kali tidak akan menyebabkan calculation dieksekusi beberapa kali, tetapi pembacaan State.value akan menyebabkan semua objek State yang dibaca selama calculation dibaca di Snapshot saat ini, yang berarti bahwa objek ini akan berlangganan dengan benar ke objek status turunan jika nilainya dibaca dalam konteks yang diamati seperti fungsi Composable.

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

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

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

kebijakan mutasi untuk mengontrol kapan perubahan pada hasil calculation memicu pembaruan.
calculation: () -> T

penghitungan untuk membuat nilai yang diwakili oleh objek status ini.

isTraceInProgress

Cmn
Ditambahkan di 1.2.0
@ComposeCompilerApi
fun isTraceInProgress(): Boolean

API perekaman aktivitas internal.

Harus dipanggil tanpa sinkronisasi thread dengan hilangnya informasi sesekali.

kunci

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

key adalah composable utilitas yang digunakan untuk "mengelompokkan" atau "kunci" blok eksekusi di dalam komposisi. Hal ini terkadang diperlukan untuk ketepatan di dalam alur kontrol yang dapat menyebabkan pemanggilan composable tertentu dijalankan lebih dari sekali selama komposisi.

Nilai untuk kunci tidak harus unik secara global, dan hanya perlu unik di antara pemanggilan key pada titik tersebut dalam komposisi.

Misalnya, perhatikan contoh berikut:

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

Meskipun ada pengguna dengan ID yang sama yang ada di loop atas dan bawah, karena mereka merupakan panggilan yang berbeda ke key, Anda tidak perlu membuat kunci gabungan.

Namun, kunci harus unik untuk setiap elemen dalam koleksi, atau turunan dan status lokal dapat digunakan kembali dengan cara yang tidak diinginkan.

Misalnya, perhatikan contoh berikut:

import androidx.compose.runtime.key

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

Contoh ini mengasumsikan bahwa parent.id adalah kunci unik untuk setiap item dalam koleksi, tetapi ini hanya berlaku jika dianggap bahwa induk hanya akan memiliki satu turunan, dan mungkin tidak demikian. Sebagai gantinya, mungkin akan lebih tepat jika Anda melakukan hal berikut:

import androidx.compose.runtime.key

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

Kunci gabungan dapat dibuat dengan meneruskan beberapa argumen:

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

Kumpulan nilai yang akan digunakan untuk membuat kunci gabungan. Nilai ini akan dibandingkan dengan nilai sebelumnya menggunakan equals dan hashCode
block: @Composable () -> T

Turunan composable untuk grup ini.

movableContentOf

Cmn
Ditambahkan di 1.2.0
fun movableContentOf(content: @Composable () -> Unit): @Composable () -> Unit

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable () -> Unit

Lambda composable pelacakan

movableContentOf

Cmn
Ditambahkan di 1.2.0
fun <P : Any?> movableContentOf(content: @Composable (P) -> Unit): @Composable (P) -> Unit

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable (P) -> Unit

Lambda composable pelacakan

movableContentOf

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

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable (P1, P2) -> Unit

Lambda composable pelacakan

movableContentOf

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

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable (P1, P2, P3) -> Unit

Lambda composable pelacakan

movableContentOf

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

Konversi lambda menjadi lambda yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable (P1, P2, P3, P4) -> Unit

Lambda composable pelacakan

movableContentWithReceiverOf

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

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable R.() -> Unit

Lambda composable pelacakan

movableContentWithReceiverOf

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

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable R.(P) -> Unit

Lambda composable pelacakan

movableContentWithReceiverOf

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

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable R.(P1, P2) -> Unit

Lambda composable pelacakan

movableContentWithReceiverOf

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

Konversi lambda dengan penerima menjadi penerima yang memindahkan status yang diingat dan node yang dibuat dalam panggilan sebelumnya ke lokasi baru yang memanggilnya.

Komposisi pelacakan dapat digunakan untuk menghasilkan composable yang memindahkan kontennya antara baris dan kolom berdasarkan parameter, seperti,

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

Atau, keduanya dapat digunakan untuk memastikan status komposisi melacak dengan model saat bergerak dalam tata letak, seperti,

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

Lambda composable untuk dikonversi menjadi lambda pelacakan status.
Hasil
@Composable R.(P1, P2, P3) -> Unit

Lambda composable pelacakan

mutableDoubleStateOf

Cmn
Ditambahkan di 1.5.0
@StateFactoryMarker
fun mutableDoubleStateOf(value: Double): MutableDoubleState

Menampilkan MutableDoubleState baru yang diinisialisasi dengan value yang diteruskan

Class MutableDoubleState adalah holder nilai tunggal yang pembacaan dan penulisannya diamati oleh Compose. Selain itu, penulisan ke token tersebut ditransaksikan sebagai bagian dari sistem Snapshot. Di JVM, nilai disimpan di memori sebagai jenis double primitif, sehingga menghindari autoboxing yang terjadi saat menggunakan MutableState<Double>.

Parameter
value: Double

nilai awal untuk MutableDoubleState
Lihat juga
DoubleState
MutableDoubleState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf

{i>mutableFloatStateOf<i}

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

Menampilkan MutableFloatState baru yang diinisialisasi dengan value yang diteruskan

Class MutableFloatState adalah holder nilai tunggal yang pembacaan dan penulisannya diamati oleh Compose. Selain itu, penulisan ke token tersebut ditransaksikan sebagai bagian dari sistem Snapshot. Di JVM, nilai disimpan di memori sebagai jenis float primitif, sehingga menghindari autoboxing yang terjadi saat menggunakan MutableState<Float>.

Parameter
value: Float

nilai awal untuk MutableFloatState
Lihat juga
FloatState
MutableFloatState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableDoubleStateOf

mutableIntStateOf

Cmn
Ditambahkan di 1.5.0
@StateFactoryMarker
fun mutableIntStateOf(value: Int): MutableIntState

Menampilkan MutableIntState baru yang diinisialisasi dengan value yang diteruskan

Class MutableIntState adalah holder nilai tunggal yang pembacaan dan penulisannya diamati oleh Compose. Selain itu, penulisan ke token tersebut ditransaksikan sebagai bagian dari sistem Snapshot. Di JVM, nilai disimpan di memori sebagai jenis int primitif, sehingga menghindari autoboxing yang terjadi saat menggunakan MutableState<Int>.

Parameter
value: Int

nilai awal untuk MutableIntState
Lihat juga
IntState
MutableIntState
mutableStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

{i>mutableLongStateOf<i}

Cmn
Ditambahkan di 1.5.0
@StateFactoryMarker
fun mutableLongStateOf(value: Long): MutableLongState

Menampilkan MutableLongState baru yang diinisialisasi dengan value yang diteruskan

Class MutableLongState adalah holder nilai tunggal yang pembacaan dan penulisannya diamati oleh Compose. Selain itu, penulisan ke token tersebut ditransaksikan sebagai bagian dari sistem Snapshot. Di JVM, nilai disimpan di memori sebagai jenis long primitif, sehingga menghindari autoboxing yang terjadi saat menggunakan MutableState<Long>.

Parameter
value: Long

nilai awal untuk MutableLongState
Lihat juga
LongState
MutableLongState
mutableStateOf
mutableIntStateOf
mutableFloatStateOf
mutableDoubleStateOf

{i>mutableStateListOf<i}

Cmn
Ditambahkan di 1.0.0
@StateFactoryMarker
fun <T : Any?> mutableStateListOf(): SnapshotStateList<T>

Buat instance MutableList yang dapat diamati dan dapat berupa snapshot.

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)
            }
        }
    }
}
Lihat juga
mutableStateOf
mutableListOf
MutableList
takeSnapshot

{i>mutableStateListOf<i}

Cmn
Ditambahkan di 1.0.0
@StateFactoryMarker
fun <T : Any?> mutableStateListOf(vararg elements: T): SnapshotStateList<T>

Buat instance MutableList yang dapat diamati dan dapat berupa snapshot.

Lihat juga
mutableStateOf
mutableListOf
MutableList
takeSnapshot

{i>mutableStateMapOf<i}

Cmn
Ditambahkan di 1.0.0
@StateFactoryMarker
fun <K : Any?, V : Any?> mutableStateMapOf(): SnapshotStateMap<K, V>

Buat instance MutableMap<k, v=""> yang dapat diamati dan dapat berupa snapshot.</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}'")
            }
        }
    }
}
Lihat juga
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

{i>mutableStateMapOf<i}

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

Buat instance MutableMap<k, v=""> yang dapat diamati dan dapat berupa snapshot.</k,>

Lihat juga
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

mutableStateOf

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

Menampilkan MutableState baru yang diinisialisasi dengan value yang diteruskan

Class MutableState adalah holder nilai tunggal yang pembacaan dan penulisannya diamati oleh Compose. Selain itu, penulisan ke token tersebut ditransaksikan sebagai bagian dari sistem Snapshot.

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

val count = remember { mutableStateOf(0) }

Text(text = "You clicked ${count.value} times")
Button(onClick = { count.value++ }) {
    Text("Click me")
}
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

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

Text(text = "You clicked $count times")
Button(onClick = { setCount(count + 1) }) {
    Text("Click me")
}
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun observeUser(userId: Int): User? {
    val user = remember(userId) { mutableStateOf<User?>(null) }
    DisposableEffect(userId) {
        val subscription = UserAPI.subscribeToUser(userId) {
            user.value = it
        }
        onDispose {
            subscription.unsubscribe()
        }
    }
    return user.value
}
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

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

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

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

nilai awal untuk MutableState
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()

kebijakan untuk mengontrol cara penanganan perubahan di snapshot yang dapat berubah.
Lihat juga
State
MutableState
SnapshotMutationPolicy
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

tidak pernahEqualPolicy

Cmn
Ditambahkan di 1.0.0
fun <T : Any?> neverEqualPolicy(): SnapshotMutationPolicy<T>

Kebijakan tidak pernah memperlakukan nilai MutableState sebagai setara.

Setelan MutableState.value akan selalu dianggap sebagai perubahan. Saat menerapkan MutableSnapshot yang mengubah status akan selalu bertentangan dengan snapshot lain yang mengubah status yang sama.

produceState

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

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu tanpa sumber data yang ditentukan.

producer diluncurkan saat produceState memasuki komposisi dan dibatalkan saat produceState keluar dari komposisi. producer harus menggunakan ProduceStateScope.value untuk menetapkan nilai baru pada State yang ditampilkan.

State yang ditampilkan menggabungkan nilai; tidak ada perubahan yang dapat diamati jika ProduceStateScope.value digunakan untuk menetapkan nilai yang berupa equal ke nilai lamanya, dan observer hanya dapat melihat nilai terbaru jika beberapa nilai ditetapkan secara berurutan.

produceState dapat digunakan untuk mengamati sumber data eksternal yang ditangguhkan atau tidak, misalnya:

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

produceState

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

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari key1.

producer diluncurkan saat produceState memasuki komposisi dan dibatalkan saat produceState keluar dari komposisi. Jika key1 berubah, producer yang sedang berjalan akan dibatalkan dan diluncurkan kembali untuk sumber baru. producer harus menggunakan ProduceStateScope.value untuk menetapkan nilai baru pada State yang ditampilkan.

State yang ditampilkan menggabungkan nilai; tidak ada perubahan yang dapat diamati jika ProduceStateScope.value digunakan untuk menetapkan nilai yang berupa equal ke nilai lamanya, dan observer hanya dapat melihat nilai terbaru jika beberapa nilai ditetapkan secara berurutan.

produceState dapat digunakan untuk mengamati sumber data eksternal yang ditangguhkan atau tidak, misalnya:

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

produceState

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

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari keys.

producer diluncurkan saat produceState memasuki komposisi dan dibatalkan saat produceState keluar dari komposisi. Jika keys berubah, producer yang berjalan akan dibatalkan dan diluncurkan kembali untuk sumber baru. producer harus menggunakan ProduceStateScope.value untuk menetapkan nilai baru pada State yang ditampilkan.

State yang ditampilkan menggabungkan nilai; tidak ada perubahan yang dapat diamati jika ProduceStateScope.value digunakan untuk menetapkan nilai yang berupa equal ke nilai lamanya, dan observer hanya dapat melihat nilai terbaru jika beberapa nilai ditetapkan secara berurutan.

produceState dapat digunakan untuk mengamati sumber data eksternal yang ditangguhkan atau tidak, misalnya:

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

produceState

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

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari key1 dan key2.

producer diluncurkan saat produceState memasuki komposisi dan dibatalkan saat produceState keluar dari komposisi. Jika key1 atau key2 berubah, producer yang sedang berjalan akan dibatalkan dan diluncurkan kembali untuk sumber baru. producer harus menggunakan ProduceStateScope.value untuk menetapkan nilai baru pada State yang ditampilkan.

State yang ditampilkan menggabungkan nilai; tidak ada perubahan yang dapat diamati jika ProduceStateScope.value digunakan untuk menetapkan nilai yang berupa equal ke nilai lamanya, dan observer hanya dapat melihat nilai terbaru jika beberapa nilai ditetapkan secara berurutan.

produceState dapat digunakan untuk mengamati sumber data eksternal yang ditangguhkan atau tidak, misalnya:

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

produceState

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

Menampilkan snapshot State yang dapat diamati, yang menghasilkan nilai dari waktu ke waktu dari key1, key2, dan key3.

producer diluncurkan saat produceState memasuki komposisi dan dibatalkan saat produceState keluar dari komposisi. Jika key1, key2, atau key3 berubah, producer yang berjalan akan dibatalkan dan diluncurkan kembali untuk sumber baru. [produser harus menggunakan ProduceStateScope.value untuk menetapkan nilai baru pada State yang ditampilkan.

State yang ditampilkan menggabungkan nilai; tidak ada perubahan yang dapat diamati jika ProduceStateScope.value digunakan untuk menetapkan nilai yang berupa equal ke nilai lamanya, dan observer hanya dapat melihat nilai terbaru jika beberapa nilai ditetapkan secara berurutan.

produceState dapat digunakan untuk mengamati sumber data eksternal yang ditangguhkan atau tidak, misalnya:

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

referensiEqualityPolicy

Cmn
Ditambahkan di 1.0.0
fun <T : Any?> referentialEqualityPolicy(): SnapshotMutationPolicy<T>

Kebijakan untuk memperlakukan nilai MutableState sebagai setara jika nilai tersebut secara referensial (===) sama.

Menyetel MutableState.value ke nilai yang sama secara referensial saat ini (===) tidak dianggap sebagai perubahan. Saat menerapkan MutableSnapshot, jika snapshot mengubah nilai ke nilai setara, snapshot induk tidak dianggap sebagai konflik.

ingat

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

Ingat nilai yang dihasilkan oleh calculation. calculation hanya akan dievaluasi selama komposisi. Rekomposisi akan selalu menampilkan nilai yang dihasilkan oleh komposisi.

ingat

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

Ingat nilai yang ditampilkan oleh calculation jika key1 sama dengan komposisi sebelumnya. Jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.

ingat

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

Ingat nilai yang ditampilkan oleh calculation jika semua nilai keys sama dengan komposisi sebelumnya, jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.

ingat

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

Ingat nilai yang ditampilkan oleh calculation jika key1 dan key2 sama dengan komposisi sebelumnya. Jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.

ingat

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

Ingat nilai yang ditampilkan oleh calculation jika key1, key2, dan key3 sama dengan komposisi sebelumnya. Jika tidak, hasilkan dan ingat nilai baru dengan memanggil calculation.

rememberCompositionContext

Cmn
Ditambahkan di 1.0.0
@Composable
fun rememberCompositionContext(): CompositionContext

Efek untuk membuat CompositionContext pada titik komposisi saat ini. Ini dapat digunakan untuk menjalankan komposisi terpisah dalam konteks komposisi saat ini, mempertahankan CompositionLocal dan menyebarkan pembatalan validasi. Saat panggilan ini keluar dari komposisi, konteksnya menjadi tidak valid.

rememberCoroutineScope

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

Tampilkan CoroutineScope yang terikat ke titik ini dalam komposisi menggunakan CoroutineContext opsional yang disediakan oleh getContext. getContext hanya akan dipanggil sekali dan instance CoroutineScope yang sama akan ditampilkan di seluruh rekomposisi.

Cakupan ini akan menjadi cancelled saat panggilan ini keluar dari komposisi. CoroutineContext yang ditampilkan oleh getContext mungkin tidak berisi Job karena cakupan ini dianggap sebagai turunan dari komposisi.

Dispatcher default cakupan ini jika tidak disediakan oleh konteks yang ditampilkan oleh getContext akan menjadi dispatcher yang menerapkan Recomposer komposisi.

Gunakan cakupan ini untuk meluncurkan tugas sebagai respons terhadap peristiwa callback seperti klik atau interaksi pengguna lainnya saat respons terhadap peristiwa tersebut perlu dibentangkan dari waktu ke waktu dan dibatalkan jika composable yang mengelola proses tersebut keluar dari komposisi. Tugas tidak boleh diluncurkan ke dalam cakupan coroutine apa pun sebagai efek samping dari komposisi itu sendiri. Untuk membuat cakupan tugas yang sedang berlangsung yang dimulai oleh komposisi, lihat LaunchedEffect.

Fungsi ini tidak akan ditampilkan jika prasyarat tidak terpenuhi, karena fungsi composable belum sepenuhnya mendukung pengecualian. Sebagai gantinya, CoroutineScope.coroutineContext cakupan yang ditampilkan akan berisi Job yang gagal dengan pengecualian terkait dan tidak akan dapat meluncurkan tugas turunan.

rememberUpdatedState

Cmn
Ditambahkan di 1.0.0
@Composable
fun <T : Any?> rememberUpdatedState(newValue: T): State<T>

remember mutableStateOf dan update nilainya menjadi newValue pada setiap rekomposisi panggilan rememberUpdatedState.

rememberUpdatedState harus digunakan saat parameter atau nilai yang dihitung selama komposisi direferensikan oleh lambda atau ekspresi objek berumur panjang. Rekomposisi akan mengupdate State yang dihasilkan tanpa membuat ulang lambda atau objek yang aktif dalam waktu lama, yang memungkinkan objek tersebut tetap ada tanpa membatalkan dan berlangganan lagi, atau meluncurkan kembali operasi berumur panjang yang mungkin mahal atau mahal untuk dibuat ulang dan dimulai ulang. Hal ini mungkin umum terjadi saat menggunakan DisposableEffect atau LaunchedEffect, misalnya:

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 sering menjelaskan mesin status yang tidak boleh direset dan dimulai ulang jika parameter atau callback peristiwa berubah, tetapi mesin tersebut harus memiliki nilai saat ini yang tersedia saat diperlukan. Contoh:

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

    // ...
}

Dengan menggunakan rememberUpdatedState, fungsi composable dapat memperbarui operasi yang sedang berlangsung.

snapshotFlow

Cmn
Ditambahkan di 1.0.0
fun <T : Any?> snapshotFlow(block: () -> T): Flow<T>

Membuat Flow dari status Snapshot yang dapat diamati. (misalnya holder status yang ditampilkan oleh mutableStateOf.)

snapshotFlow membuat Flow yang menjalankan block saat dikumpulkan dan menampilkan hasilnya, mencatat status snapshot apa pun yang diakses. Saat pengumpulan berlanjut, jika Snapshot baru diterapkan sehingga perubahan status diakses oleh block, alur akan menjalankan block lagi, dan merekam ulang status snapshot yang diakses. Jika hasil block bukan equal to dari hasil sebelumnya, flow akan memunculkan hasil baru tersebut. (Perilaku ini mirip dengan Flow.distinctUntilChanged.) Koleksi akan berlanjut tanpa batas, kecuali jika dibatalkan secara eksplisit atau dibatasi oleh penggunaan operator Flow lainnya.

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 dijalankan dalam Snapshot hanya baca dan tidak dapat mengubah data snapshot. Jika block mencoba mengubah data snapshot, pengumpulan alur akan gagal dengan IllegalStateException.

block dapat dijalankan lebih dari sekali untuk kumpulan input yang sama atau hanya sekali setelah banyak perubahan snapshot cepat; harus idempoten dan bebas dari efek samping.

Saat menangani status Snapshot, sebaiknya perhatikan perbedaan antara peristiwa dan status. snapshotFlow membuat model perubahan snapshot sebagai peristiwa, tetapi peristiwa tidak dapat dimodelkan secara efektif sebagai status yang dapat diamati. Status yang dapat diamati adalah kompresi lossy dari peristiwa yang menghasilkan status tersebut.

Peristiwa yang dapat diamati terjadi pada satu waktu dan akan dihapus. Semua pengamat yang terdaftar pada saat peristiwa terjadi akan diberi tahu. Setiap peristiwa individu dalam streaming dianggap relevan dan dapat dibangun satu sama lain; peristiwa sama yang berulang memiliki makna, sehingga observer terdaftar harus mengamati semua peristiwa tanpa melewatinya.

Status yang dapat diamati akan memicu peristiwa perubahan saat status berubah dari satu nilai ke nilai baru yang tidak setara. Peristiwa perubahan status digabungkan; hanya status terbaru yang penting. Oleh karena itu, pengamat perubahan status harus idempoten; mengingat nilai status yang sama, pengamat harus menghasilkan hasil yang sama. Ini valid bagi observer status untuk melewati status perantara serta berjalan beberapa kali untuk status yang sama dan hasilnya harus sama.

informasisumber

Cmn
Ditambahkan di 1.0.0
@ComposeCompilerApi
fun sourceInformation(composer: Composer, sourceInformation: String): Unit

Fungsi internal Compose. JANGAN menelepon secara langsung.

Merekam informasi sumber yang dapat digunakan untuk alat guna menentukan lokasi sumber fungsi composable yang sesuai. Secara default, fungsi ini dideklarasikan sebagai tidak memiliki efek samping. Aman untuk alat penyingkatan kode (seperti R8 atau ProGuard) untuk menghapusnya.

sourceInformationMarkerEnd

Cmn
Ditambahkan di 1.0.0
@ComposeCompilerApi
fun sourceInformationMarkerEnd(composer: Composer): Unit

Fungsi internal Compose. JANGAN menelepon secara langsung.

Merekam akhir penanda informasi sumber yang dapat digunakan untuk alat guna menentukan lokasi sumber fungsi composable yang sesuai dan tidak memerlukan informasi pelacakan seperti fungsi ReadOnlyComposable. Secara default, fungsi ini dideklarasikan sebagai tidak memiliki efek samping. Aman untuk alat penyingkatan kode (seperti R8 atau ProGuard) untuk menghapusnya.

Perlu diperhatikan bahwa sourceInformationMarkerStart dan sourceInformationMarkerEnd dihapus bersamaan atau keduanya disimpan. Menghapus satu saja akan menyebabkan perilaku runtime yang salah.

sourceInformationMarkerStart

Cmn
Ditambahkan di 1.0.0
@ComposeCompilerApi
fun sourceInformationMarkerStart(
    composer: Composer,
    key: Int,
    sourceInformation: String
): Unit

Fungsi internal Compose. JANGAN menelepon secara langsung.

Merekam awal penanda informasi sumber yang dapat digunakan untuk alat guna menentukan lokasi sumber fungsi composable yang sesuai dan tidak memerlukan informasi pelacakan seperti fungsi ReadOnlyComposable. Secara default, fungsi ini dideklarasikan sebagai tidak memiliki efek samping. Aman untuk alat penyingkatan kode (seperti R8 atau ProGuard) untuk menghapusnya.

Perlu diperhatikan bahwa sourceInformationMarkerStart dan sourceInformationMarkerEnd dihapus bersamaan atau keduanya disimpan. Menghapus satu saja akan menyebabkan perilaku runtime yang salah.

staticCompositionLocalOf

Cmn
Ditambahkan di 1.0.0
fun <T : Any?> staticCompositionLocalOf(defaultFactory: () -> T): ProvidableCompositionLocal<T>

Buat kunci CompositionLocal yang dapat disediakan menggunakan CompositionLocalProvider.

Tidak seperti compositionLocalOf, pembacaan staticCompositionLocalOf tidak dilacak oleh komposer dan mengubah nilai yang diberikan dalam panggilan CompositionLocalProvider akan menyebabkan keseluruhan konten direkomposisi, bukan hanya lokasi penggunaan nilai lokal dalam komposisi. Namun, kurangnya pelacakan ini membuat staticCompositionLocalOf lebih efisien jika nilai yang diberikan sangat tidak mungkin atau tidak akan pernah berubah. Misalnya, konteks Android, loader font, atau nilai bersama yang serupa, cenderung tidak berubah untuk komponen dalam konten CompositionLocalProvider dan harus mempertimbangkan penggunaan staticCompositionLocalOf. Warna, atau tema lain seperti nilai, dapat berubah atau bahkan dianimasikan, sehingga compositionLocalOf harus digunakan.

staticCompositionLocalOf membuat ProvidableCompositionLocal yang dapat digunakan dalam panggilan ke CompositionLocalProvider. Serupa dengan MutableList vs. List, jika kunci disetel ke publik sebagai CompositionLocal, bukan ProvidableCompositionLocal, kunci dapat dibaca menggunakan CompositionLocal.current tetapi tidak disediakan ulang.

Parameter
defaultFactory: () -> T

pabrik nilai untuk menyediakan nilai ketika nilai tidak diberikan. Factory ini dipanggil jika tidak ada nilai yang diberikan melalui CompositionLocalProvider pemanggil komponen menggunakan CompositionLocal.current. Jika tidak ada default yang wajar yang dapat diberikan, pertimbangkan untuk menampilkan pengecualian.
Lihat juga
CompositionLocal
compositionLocalOf

{i>structuralEqualityPolicy<i}

Cmn
Ditambahkan di 1.0.0
fun <T : Any?> structuralEqualityPolicy(): SnapshotMutationPolicy<T>

Kebijakan untuk memperlakukan nilai MutableState sebagai setara jika secara struktural (==) sama.

Menetapkan MutableState.value ke nilai yang sama secara struktural saat ini (==) tidak dianggap sebagai perubahan. Saat menerapkan MutableSnapshot, jika snapshot mengubah nilai ke nilai setara, snapshot induk tidak dianggap sebagai konflik.

traceEventEnd

Cmn
Ditambahkan di 1.2.0
@ComposeCompilerApi
fun traceEventEnd(): Unit

API perekaman aktivitas internal.

Harus dipanggil tanpa sinkronisasi thread dengan hilangnya informasi sesekali.

{i>traceEventStart<i}

Cmn
Ditambahkan di 1.2.0
@ComposeCompilerApi
fun traceEventStart(key: Int, dirty1: Int, dirty2: Int, info: String): Unit

API perekaman aktivitas internal.

Harus dipanggil tanpa sinkronisasi thread dengan hilangnya informasi sesekali.

Parameter
dirty1: Int

metadata $dirty: rekomposisi paksa dan parameter fungsi 1..10 jika ada
dirty2: Int

metadata $dirty2: rekomposisi paksa dan parameter fungsi 11..20 jika ada

withFrameMillis

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

Menangguhkan hingga frame baru diminta, segera memanggil onFrame dengan waktu frame dalam milidetik dalam konteks panggilan pengiriman frame, lalu dilanjutkan dengan hasil dari onFrame.

frameTimeMillis harus digunakan saat menghitung delta waktu animasi dari frame ke frame karena dapat dinormalkan ke waktu target untuk frame tersebut, tidak selalu nilai "sekarang" langsung.

Basis waktu nilai yang disediakan oleh MonotonicFrameClock.withFrameMillis ditentukan oleh implementasi. Nilai waktu yang diberikan meningkat secara monoton; setelah panggilan ke withFrameMillis selesai, nilai tersebut tidak boleh memberikan nilai yang lebih kecil untuk panggilan berikutnya.

Fungsi ini akan memanggil MonotonicFrameClock.withFrameNanos menggunakan MonotonicFrameClock CoroutineContext panggilan dan akan menampilkan IllegalStateException jika tidak ada di CoroutineContext.

withFrameNanos

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

Menangguhkan hingga frame baru diminta, segera memanggil onFrame dengan waktu frame dalam nanodetik dalam konteks panggilan pengiriman frame, lalu dilanjutkan dengan hasil dari onFrame.

frameTimeNanos harus digunakan saat menghitung delta waktu animasi dari frame ke frame karena dapat dinormalkan ke waktu target untuk frame tersebut, tidak selalu nilai "sekarang" langsung.

Basis waktu nilai yang disediakan oleh withFrameNanos ditentukan oleh implementasi. Nilai waktu yang diberikan meningkat secara monoton; setelah panggilan ke withFrameNanos selesai, nilai tersebut tidak boleh memberikan nilai yang sama lagi untuk panggilan berikutnya.

Fungsi ini akan memanggil MonotonicFrameClock.withFrameNanos menggunakan MonotonicFrameClock CoroutineContext panggilan dan akan menampilkan IllegalStateException jika tidak ada di CoroutineContext.

denganRunningRecomposer

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

Menjalankan block dengan Recomposer baru yang aktif yang menerapkan perubahan pada CoroutineContext panggilan. Recomposer akan menjadi closed setelah block ditampilkan. withRunningRecomposer akan ditampilkan setelah Recomposer adalah Recomposer.State.ShutDown dan semua tugas turunan yang diluncurkan oleh block memiliki joined.

Fungsi ekstensi

{i>AsDoubleState<i}

Cmn
Ditambahkan di 1.5.0
fun State<Double>.asDoubleState(): DoubleState

Mengonversi State<Double> (seperti dalam State dari kotak Double) menjadi Double yang didukung primitif. Status akan otomatis dikeluarkan dari jenis primitif yang diperlukan. Status yang ditampilkan bersifat hanya baca. Status yang ditampilkan akan mencerminkan nilai status dasar dan menerapkan update dengan cara yang sama seperti yang ditentukan penerima.

Di JVM, konversi ini tidak menghindari autoboxing yang coba di-escape oleh Double, tetapi dimaksudkan untuk memungkinkan interoperabilitas antar-komponen yang menggunakan salah satu representasi status jenis Double.

{i>asFloatState<i}

Cmn
Ditambahkan di 1.5.0
fun State<Float>.asFloatState(): FloatState

Mengonversi State<Float> (seperti dalam State dari kotak Float) menjadi Float yang didukung primitif. Status akan otomatis dikeluarkan dari jenis primitif yang diperlukan. Status yang ditampilkan bersifat hanya baca. Status yang ditampilkan akan mencerminkan nilai status dasar dan menerapkan update dengan cara yang sama seperti yang ditentukan penerima.

Di JVM, konversi ini tidak menghindari autoboxing yang coba di-escape oleh Float, tetapi dimaksudkan untuk memungkinkan interoperabilitas antar-komponen yang menggunakan salah satu representasi status jenis Float.

{i>asIntState<i}

Cmn
Ditambahkan di 1.5.0
fun State<Int>.asIntState(): IntState

Mengonversi State<Int> (seperti dalam State dari kotak Int) menjadi IntState yang didukung primitif. Status akan otomatis dikeluarkan dari jenis primitif yang diperlukan. Status yang ditampilkan bersifat hanya baca. Status yang ditampilkan akan mencerminkan nilai status dasar dan menerapkan update dengan cara yang sama seperti yang ditentukan penerima.

Di JVM, konversi ini tidak menghindari autoboxing yang coba di-escape oleh IntState, tetapi dimaksudkan untuk memungkinkan interoperabilitas antar-komponen yang menggunakan salah satu representasi status jenis Int.

{i>asLongState<i}

Cmn
Ditambahkan di 1.5.0
fun State<Long>.asLongState(): LongState

Mengonversi State<Long> (seperti dalam State dari kotak Long) menjadi LongState yang didukung primitif. Status akan otomatis dikeluarkan dari jenis primitif yang diperlukan. Status yang ditampilkan bersifat hanya baca. Status yang ditampilkan akan mencerminkan nilai status dasar dan menerapkan update dengan cara yang sama seperti yang ditentukan penerima.

Di JVM, konversi ini tidak menghindari autoboxing yang coba di-escape oleh LongState, tetapi dimaksudkan untuk memungkinkan interoperabilitas antar-komponen yang menggunakan salah satu representasi status jenis Long.

cache

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

API plugin compiler Compose. JANGAN menelepon secara langsung.

Cache, yaitu nilai yang ada dalam data komposisi sebuah komposisi. Ini digunakan untuk mengimplementasikan remember dan digunakan oleh plugin compiler untuk menghasilkan panggilan yang lebih efisien ke remember saat menentukan bahwa pengoptimalan ini aman.

CollectAsState

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

Mengumpulkan nilai dari StateFlow ini dan mewakili nilai terbarunya melalui State. StateFlow.value digunakan sebagai nilai awal. Setiap kali akan ada nilai baru yang diposting ke StateFlow, State yang ditampilkan akan diperbarui yang menyebabkan rekomposisi dari setiap penggunaan State.value.

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

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

CoroutineContext yang akan digunakan untuk mengumpulkan.

CollectAsState

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

Mengumpulkan nilai dari Flow ini dan mewakili nilai terbarunya melalui State. Setiap kali akan ada nilai baru yang diposting ke Flow, State yang ditampilkan akan diperbarui yang menyebabkan rekomposisi dari setiap penggunaan State.value.

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

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

CoroutineContext yang akan digunakan untuk mengumpulkan.

getValue

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

Mengizinkan delegasi properti val menggunakan by untuk DoubleState.

getValue

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

Mengizinkan delegasi properti val menggunakan by untuk FloatState.

getValue

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

Mengizinkan delegasi properti val menggunakan by untuk IntState.

getValue

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

Mengizinkan delegasi properti val menggunakan by untuk LongState.

getValue

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

Mengizinkan delegasi properti val menggunakan by untuk State.

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

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

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

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

setValue

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

Mengizinkan delegasi properti var menggunakan by untuk MutableDoubleState.

setValue

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

Mengizinkan delegasi properti var menggunakan by untuk MutableFloatState.

setValue

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

Mengizinkan delegasi properti var menggunakan by untuk MutableIntState.

setValue

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

Mengizinkan delegasi properti var menggunakan by untuk MutableLongState.

setValue

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

Mengizinkan delegasi properti var menggunakan by untuk MutableState.

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

var count by remember { mutableStateOf(0) }

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

toMutableStateList

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

Buat instance MutableList dari koleksi yang dapat diamati dan dapat berupa snapshot.

toMutableStateMap

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

Buat instance MutableMap<k, v=""> dari kumpulan pasangan yang dapat diamati dan dapat diambil snapshot-nya.</k,>

withFrameMillis

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

Menangguhkan hingga frame baru diminta, segera memanggil onFrame dengan waktu frame dalam milidetik dalam konteks panggilan pengiriman frame, lalu dilanjutkan dengan hasil dari onFrame.

frameTimeMillis harus digunakan saat menghitung delta waktu animasi dari frame ke frame karena dapat dinormalkan ke waktu target untuk frame tersebut, tidak selalu nilai "sekarang" langsung.

Basis waktu nilai yang disediakan oleh MonotonicFrameClock.withFrameMillis ditentukan oleh implementasi. Nilai waktu yang diberikan meningkat secara monoton; setelah panggilan ke withFrameMillis selesai, nilai tersebut tidak boleh memberikan nilai yang lebih kecil untuk panggilan berikutnya.

Properti tingkat teratas

DefaultMonotonicFrameClock

Cmn android 
val DefaultMonotonicFrameClock: MonotonicFrameClock

MonotonicFrameClock digunakan oleh withFrameNanos dan withFrameMillis jika tidak ada dalam kotlin.coroutines.CoroutineContext panggilan.

Nilai ini tidak lagi digunakan oleh runtime compose.

saat iniComposer

Cmn
Ditambahkan di 1.0.0
val currentComposer: Composer

TODO(lmr): memberikan dokumentasi

currentCompositeKeyHash

Cmn
Ditambahkan di 1.0.0
val currentCompositeKeyHash: Int

Nilai hash ini digunakan untuk mengoordinasikan peta status yang disimpan secara eksternal ke komposisi. Misalnya, ini digunakan oleh status instance tersimpan untuk mempertahankan status di seluruh batas masa aktif aktivitas.

Nilai ini kemungkinan akan unik, tetapi tidak dijamin akan unik. Terdapat kasus yang diketahui, seperti untuk loop tanpa key, saat runtime tidak memiliki cukup informasi untuk membuat hash kunci gabungan menjadi unik.

currentCompositionLocalContext

Cmn
Ditambahkan di 1.1.0
val currentCompositionLocalContext: CompositionLocalContext

Menampilkan CompositionLocalContext saat ini yang berisi semua CompositionLocal dalam komposisi saat ini dan nilainya yang diberikan oleh CompositionLocalProvider. Konteks ini dapat digunakan untuk meneruskan lokalitas ke komposisi lain melalui CompositionLocalProvider. Hal itu biasanya diperlukan jika komposisi lain bukan subkomposisi dari komposisi saat ini.

currentRecomposeScope

Cmn
Ditambahkan di 1.0.0
val currentRecomposeScope: RecomposeScope

Menampilkan objek yang dapat digunakan untuk membatalkan cakupan saat ini pada titik komposisi ini. Objek ini dapat digunakan untuk menyebabkan rekomposisi secara manual.

Properti ekstensi

monotonicFrameClock

Cmn
Ditambahkan di 1.0.0
@ExperimentalComposeApi
val CoroutineContext.monotonicFrameClock: MonotonicFrameClock

Menampilkan MonotonicFrameClock untuk CoroutineContext ini atau menampilkan IllegalStateException jika tidak ada.

recomposeCoroutineContext

Cmn
Ditambahkan di 1.0.0
@ExperimentalComposeApi
val ControlledComposition.recomposeCoroutineContext: CoroutineContext

CoroutineContext yang harus digunakan untuk melakukan rekomposisi serentak dari ControlledComposition ini saat digunakan di lingkungan yang mendukung komposisi serentak.

Lihat Recomposer.runRecomposeConcurrentlyAndApplyChanges sebagai contoh konfigurasi lingkungan tersebut.