androidx.compose.runtime

@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++ }
        }
    }
}

@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++ }
        }
    }
}

@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++ }
        }
    }
}

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

@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

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

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

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

@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++ }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

@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++ }
        }
    }
}

@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++ }
        }
    }
}

@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++ }
        }
    }
}

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.

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

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

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

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.

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

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

@ComposeCompilerApi
fun isTraceInProgress(): Boolean

API perekaman aktivitas internal.

Harus dipanggil tanpa sinkronisasi thread dengan hilangnya informasi sesekali.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Buat instance MutableList yang dapat diamati dan dapat berupa snapshot.

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

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

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

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.

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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.

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

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

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

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.

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.

@ComposeCompilerApi
fun traceEventEnd(): Unit

API perekaman aktivitas internal.

Harus dipanggil tanpa sinkronisasi thread dengan hilangnya informasi sesekali.

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

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.

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.

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.

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.

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.

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.

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.

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

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

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

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

Mengizinkan delegasi properti val menggunakan by untuk DoubleState.

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

Mengizinkan delegasi properti val menggunakan by untuk FloatState.

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

Mengizinkan delegasi properti val menggunakan by untuk IntState.

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

Mengizinkan delegasi properti val menggunakan by untuk LongState.

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

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

Mengizinkan delegasi properti var menggunakan by untuk MutableDoubleState.

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

Mengizinkan delegasi properti var menggunakan by untuk MutableFloatState.

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

Mengizinkan delegasi properti var menggunakan by untuk MutableIntState.

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

Mengizinkan delegasi properti var menggunakan by untuk MutableLongState.

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