androidx.compose.runtime

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

ينقل عقدة إلى تركيبة النوع T.

ستطرح هذه الدالة استثناء وقت التشغيل إذا لم يكن E نوعًا فرعيًا من تطبيق 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

ينقل عقدة إلى تركيبة النوع T. ستصبح العُقد المنبعثة داخل content عناصر ثانوية للعقدة الصادرة.

ستطرح هذه الدالة استثناء وقت التشغيل إذا لم يكن E نوعًا فرعيًا من تطبيق 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

ينقل عقدة إلى تركيبة النوع T. ستصبح العُقد المنبعثة داخل content عناصر ثانوية للعقدة الصادرة.

ستطرح هذه الدالة استثناء وقت التشغيل إذا لم يكن E نوعًا فرعيًا من تطبيق 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

وهذه الطريقة هي طريقة إنشاء مقطوعة موسيقية. يمكن أن يكون parent

• لجعل المقطوعة الموسيقية تعمل كتركيبة فرعية من الأصل. إذا كانت تركيبة الصورة

• ليس لها أصل، يجب تقديم مثيل Recomposer.

من المهم طلب الرمز Composition.dispose عندما لا تكون هناك حاجة إلى المقطوعة الموسيقية من أجل إصدار الموارد.

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

يمكنك إنشاء Composition باستخدام applier لإدارة المقطوعة الموسيقية، وهي عنصر ثانوي لـ parent.

وعند استخدامه في إعداد يتوافق مع إعادة التركيب المتزامنة، يُرجى الإشارة إلى البيئة التي تفرض استخدام recomposeCoroutineContext لإجراء إعادة التركيب. سيتم إطلاق عمليات إعادة الدمج في

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

يربط CompositionLocalProvider القيم بقيم CompositionLocal، المقدمة من context. ستؤدي قراءة CompositionLocal باستخدام CompositionLocal.current إلى عرض القيمة المقدَّمة في القيم المخزَّنة داخل context لجميع الدوال القابلة للإنشاء والتي يتم طلبها بشكل مباشر أو غير مباشر في دالة 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 القيمة بالمفتاح ProvidableCompositionLocal. ستؤدي قراءة CompositionLocal باستخدام CompositionLocal.current إلى عرض القيمة المقدَّمة في المعلَمة value في CompositionLocalProvider لجميع الدوال القابلة للإنشاء والتي يتم طلبها بشكل مباشر أو غير مباشر في دالة 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 القيم بمفاتيح ProvidableCompositionLocal. ستؤدي قراءة CompositionLocal باستخدام CompositionLocal.current إلى عرض القيمة المقدَّمة في المعلَمة values في CompositionLocalProvider لجميع الدوال القابلة للإنشاء والتي يتم طلبها بشكل مباشر أو غير مباشر في دالة 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

وهذه الطريقة هي طريقة لإنشاء مقطوعة موسيقية. اختياريًا، يمكن توفير parent لجعل المقطوعة الموسيقية تعمل كتركيبة فرعية من الأصل أو Recomposer.

تتيح المقطوعة التي يتم التحكم فيها إمكانية التحكم المباشر فيها بدلاً من أن يتم التحكم فيها من خلال Recomposer التي يتم تمريرها عبر التركيبة الجذرية.

من المهم استدعاء Composition.dispose لم يعد هذا المؤلف بحاجة إلى إصدار الموارد.

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

أثر جانبي للمركبة يجب عكسها أو تنظيفها إذا تمت إزالة DisposableEffect من التركيبة.

حدث خطأ عند استدعاء الدالة DisposableEffect بدون معلَمة key واحدة على الأقل.

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

تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ key1 ويجب عكسها أو إزالتها في حال تغيير key1 أو في حال مغادرة DisposableEffect للمقطوعة الموسيقية.

مفتاح DisposableEffect هو قيمة تحدِّد هوية DisposableEffect. في حال تغيير أحد المفاتيح، يجب على DisposableEffect dispose إعادة ضبط effect الحالي وإعادة ضبطه من خلال معاودة الاتصال بـ effect. تتضمن أمثلة المفاتيح ما يلي:

• الكائنات القابلة للملاحظة التي يشترك فيها التأثير

• مَعلمات طلب فريدة إلى عملية يجب إلغاؤها وإعادة المحاولة في حال تغيير هذه المَعلمات

يمكن استخدام DisposableEffect لإعداد مفتاح أو الاشتراك فيه ثم إعادة ضبطه عند توفير مفتاح مختلف، ما يؤدي إلى إزالة البرامج غير المرغوب فيها للعملية القديمة قبل إعداد المفتاح الجديد. مثلاً:

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 يجب تضمين عبارة onDispose باعتبارها العبارة النهائية في قالب effect. إذا كانت العملية لا تتطلّب التخلص من المنتج، قد تكون SideEffect بدلاً من ذلك أو LaunchedEffect إذا شغّلت مادة الكوروتين التي يجب أن تديرها المقطوعة الموسيقية.

هناك مكالمة واحدة مضمونة للاتصال بالرقم dispose لكل مكالمة إلى الرقم effect. سيتم دائمًا تشغيل كل من effect وdispose على مُرسِل تطبيق المقطوعة الموسيقية، ولا يتم مطلقًا تشغيل التطبيقات المتوافقة مع بعضها البعض أو مع بعضها البعض أو تطبيق التغييرات على العرض التدرّجي للمقطوعة الموسيقية أو تشغيل عمليات استدعاء أحداث RememberObserver.

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

تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ keys ويجب عكسها أو إزالتها في حال تغيير keys أو إزالة DisposableEffect من المقطوعة الموسيقية.

مفتاح DisposableEffect هو قيمة تحدِّد هوية DisposableEffect. في حال تغيير أحد المفاتيح، يجب على DisposableEffect dispose إعادة ضبط effect الحالي وإعادة ضبطه من خلال معاودة الاتصال بـ effect. تتضمن أمثلة المفاتيح ما يلي:

• الكائنات القابلة للملاحظة التي يشترك فيها التأثير

• مَعلمات طلب فريدة إلى عملية يجب إلغاؤها وإعادة المحاولة في حال تغيير هذه المَعلمات

يمكن استخدام DisposableEffect لإعداد مفتاح أو الاشتراك فيه ثم إعادة ضبطه عند توفير مفتاح مختلف، ما يؤدي إلى إزالة البرامج غير المرغوب فيها للعملية القديمة قبل إعداد المفتاح الجديد. مثلاً:

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 يجب تضمين عبارة onDispose باعتبارها العبارة النهائية في قالب effect. إذا كانت العملية لا تتطلّب التخلص من المنتج، قد تكون SideEffect بدلاً من ذلك أو LaunchedEffect إذا شغّلت مادة الكوروتين التي يجب أن تديرها المقطوعة الموسيقية.

هناك مكالمة واحدة مضمونة للاتصال بالرقم dispose لكل مكالمة إلى الرقم effect. سيتم دائمًا تشغيل كل من effect وdispose على مُرسِل تطبيق المقطوعة الموسيقية، ولا يتم مطلقًا تشغيل التطبيقات المتوافقة مع بعضها البعض أو مع بعضها البعض أو تطبيق التغييرات على العرض التدرّجي للمقطوعة الموسيقية أو تشغيل عمليات استدعاء أحداث RememberObserver.

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

تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ key1 أو key2 ويجب عكسها أو إزالتها في حال تغيير key1 أو key2 أو في حال مغادرة DisposableEffect للمقطوعة الموسيقية.

مفتاح DisposableEffect هو قيمة تحدِّد هوية DisposableEffect. في حال تغيير أحد المفاتيح، يجب على DisposableEffect dispose إعادة ضبط effect الحالي وإعادة ضبطه من خلال معاودة الاتصال بـ effect. تتضمن أمثلة المفاتيح ما يلي:

• الكائنات القابلة للملاحظة التي يشترك فيها التأثير

• مَعلمات طلب فريدة إلى عملية يجب إلغاؤها وإعادة المحاولة في حال تغيير هذه المَعلمات

يمكن استخدام DisposableEffect لإعداد مفتاح أو الاشتراك فيه ثم إعادة ضبطه عند توفير مفتاح مختلف، ما يؤدي إلى إزالة البرامج غير المرغوب فيها للعملية القديمة قبل إعداد المفتاح الجديد. مثلاً:

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 يجب تضمين عبارة onDispose باعتبارها العبارة النهائية في قالب effect. إذا كانت العملية لا تتطلّب التخلص من المنتج، قد تكون SideEffect بدلاً من ذلك أو LaunchedEffect إذا شغّلت مادة الكوروتين التي يجب أن تديرها المقطوعة الموسيقية.

هناك مكالمة واحدة مضمونة للاتصال بالرقم dispose لكل مكالمة إلى الرقم effect. سيتم دائمًا تشغيل كل من effect وdispose على مُرسِل تطبيق المقطوعة الموسيقية، ولا يتم مطلقًا تشغيل التطبيقات المتوافقة مع بعضها البعض أو مع بعضها البعض أو تطبيق التغييرات على العرض التدرّجي للمقطوعة الموسيقية أو تشغيل عمليات استدعاء أحداث RememberObserver.

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

تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ key1 أو key2 أو key3 ويجب عكسها أو إزالتها في حال تغيير key1 أو key2 أو key3 أو في حال مغادرة DisposableEffect التركيبة.

مفتاح DisposableEffect هو قيمة تحدِّد هوية DisposableEffect. في حال تغيير أحد المفاتيح، يجب على DisposableEffect dispose إعادة ضبط effect الحالي وإعادة ضبطه من خلال معاودة الاتصال بـ effect. تتضمن أمثلة المفاتيح ما يلي:

• الكائنات القابلة للملاحظة التي يشترك فيها التأثير

• مَعلمات طلب فريدة إلى عملية يجب إلغاؤها وإعادة المحاولة في حال تغيير هذه المَعلمات

يمكن استخدام DisposableEffect لإعداد مفتاح أو الاشتراك فيه ثم إعادة ضبطه عند توفير مفتاح مختلف، ما يؤدي إلى إزالة البرامج غير المرغوب فيها للعملية القديمة قبل إعداد المفتاح الجديد. مثلاً:

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 يجب تضمين عبارة onDispose باعتبارها العبارة النهائية في قالب effect. إذا كانت العملية لا تتطلّب التخلص من المنتج، قد تكون SideEffect بدلاً من ذلك أو LaunchedEffect إذا شغّلت مادة الكوروتين التي يجب أن تديرها المقطوعة الموسيقية.

هناك مكالمة واحدة مضمونة للاتصال بالرقم dispose لكل مكالمة إلى الرقم effect. سيتم دائمًا تشغيل كل من effect وdispose على مُرسِل تطبيق المقطوعة الموسيقية، ولا يتم مطلقًا تشغيل التطبيقات المتوافقة مع بعضها البعض أو مع بعضها البعض أو تطبيق التغييرات على العرض التدرّجي للمقطوعة الموسيقية أو تشغيل عمليات استدعاء أحداث RememberObserver.

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

عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية. سيصبح الكوروتين cancelled عند مغادرة LaunchedEffect للمقطوعة الموسيقية.

حدث خطأ عند استدعاء الدالة LaunchedEffect بدون معلَمة key واحدة على الأقل.

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

عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية. سيكون الكوروتين cancelled وسيتم إعادة إطلاقه عند إعادة تركيب LaunchedEffect باستخدام جهاز key1 مختلف. سيصبح الكوروتين cancelled عند مغادرة LaunchedEffect للمقطوعة الموسيقية.

يجب عدم استخدام هذه الدالة (إعادة) تشغيل المهام الجارية استجابةً لأحداث معاودة الاتصال عن طريق تخزين بيانات معاودة الاتصال في MutableState التي تم تمريرها إلى key1. بدلاً من ذلك، يمكنك الاطّلاع على rememberCoroutineScope للحصول على CoroutineScope يمكن استخدامها لإطلاق مهام حالية مخصّصة للمقطوعة الموسيقية استجابةً لاستدعاءات الفعالية.

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

عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية. سيكون الكوروتين cancelled وسيتم إعادة إطلاقه عند إعادة تركيب LaunchedEffect باستخدام أي keys مختلف. سيصبح الكوروتين cancelled عند مغادرة LaunchedEffect للمقطوعة الموسيقية.

يجب عدم استخدام هذه الدالة (إعادة) تشغيل المهام الجارية استجابةً لأحداث معاودة الاتصال عن طريق تخزين بيانات معاودة الاتصال في MutableState التي تم تمريرها إلى key. بدلاً من ذلك، يمكنك الاطّلاع على rememberCoroutineScope للحصول على CoroutineScope يمكن استخدامها لإطلاق مهام حالية مخصّصة للمقطوعة الموسيقية استجابةً لاستدعاءات الفعالية.

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

عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية. سيكون الكوروتين cancelled وسيتم إعادة إطلاقه عند إعادة تركيب LaunchedEffect باستخدام جهاز key1 أو key2 مختلف. سيصبح الكوروتين cancelled عند مغادرة LaunchedEffect للمقطوعة الموسيقية.

يجب عدم استخدام هذه الدالة (إعادة) تشغيل المهام الجارية استجابةً لأحداث معاودة الاتصال عن طريق تخزين بيانات معاودة الاتصال في MutableState التي تم تمريرها إلى key. بدلاً من ذلك، يمكنك الاطّلاع على rememberCoroutineScope للحصول على CoroutineScope يمكن استخدامها لإطلاق مهام حالية مخصّصة للمقطوعة الموسيقية استجابةً لاستدعاءات الفعالية.

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

عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية. سيكون الكوروتين cancelled وسيتم إعادة إطلاقه عند إعادة تركيب LaunchedEffect باستخدام جهاز key1 أو key2 أو key3 مختلف. سيصبح الكوروتين cancelled عند مغادرة LaunchedEffect للمقطوعة الموسيقية.

يجب عدم استخدام هذه الدالة (إعادة) تشغيل المهام الجارية استجابةً لأحداث معاودة الاتصال عن طريق تخزين بيانات معاودة الاتصال في MutableState التي تم تمريرها إلى key. بدلاً من ذلك، يمكنك الاطّلاع على rememberCoroutineScope للحصول على CoroutineScope يمكن استخدامها لإطلاق مهام حالية مخصّصة للمقطوعة الموسيقية استجابةً لاستدعاءات الفعالية.

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

ينبعث منها عقدة قابلة لإعادة التدوير في تركيبة من النوع T.

ستطرح هذه الدالة استثناء وقت التشغيل إذا لم يكن E نوعًا فرعيًا من تطبيق 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

ينبعث منها عقدة قابلة لإعادة التدوير في تركيبة من النوع T. ستصبح العُقد المنبعثة داخل content عناصر ثانوية للعقدة الصادرة.

ستطرح هذه الدالة استثناء وقت التشغيل إذا لم يكن E نوعًا فرعيًا من تطبيق 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

ينبعث منها عقدة قابلة لإعادة التدوير في تركيبة من النوع T. ستصبح العُقد المنبعثة داخل content عناصر ثانوية للعقدة الصادرة.

ستطرح هذه الدالة استثناء وقت التشغيل إذا لم يكن E نوعًا فرعيًا من تطبيق 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

وهذه الطريقة هي طريقة بدء تركيبة قابلة لإعادة الاستخدام. يمكن توفير parent لجعل التركيبة تعمل كتركيبة فرعية من الأصل. إذا لم تكن المقطوعة الموسيقية تتضمن أصلاً، يجب تقديم مثيل Recomposer.

من المهم طلب الرمز Composition.dispose عندما لا تكون هناك حاجة إلى المقطوعة الموسيقية من أجل إصدار الموارد.

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

دالة منفعة يتم استخدامها لوضع علامة على مقطوعة موسيقية تشير إلى كونها قابلة لإعادة التدوير. إذا تم استبدال المقطوعة الموسيقية بمقطوعة موسيقية جديدة من خلال key (كما يحدث في key)، تتم إعادة استخدام العُقد القابلة لإعادة الاستخدام الصادرة عن ReusableComposeNode.

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

هي دالة مساعدة اختيارية تُستخدَم عند استضافة ReusableContent. إذا كانت السمة active غير صحيحة، يتم التعامل مع المحتوى كما لو تم حذفه من خلال إزالة جميع العناصر التي تم تذكّرها من التركيبة ولكن لا تتم إزالة العقدة الناتجة عن العرض التدرّجي. عندما تصبح المقطوعة الموسيقية نشطة لاحقًا، يمكن إعادة استخدام العُقد داخل محتوى ReusableContent بدون الحاجة إلى إطالة عمر المقطوعة الموسيقية بشكل عشوائي.

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

يمكنك جدولة "effect" ليتم تشغيله عند اكتمال المقطوعة الموسيقية الحالية بنجاح وتطبيق التغييرات. يمكن استخدام SideEffect لتطبيق التأثيرات الجانبية على عناصر مُدارة من خلال المقطوعة الموسيقية ولا يتم دعمها من خلال snapshots، وذلك لعدم ترك هذه العناصر في حالة غير متسقة في حال تعذّر التشغيل الحالي للمقطوعة الموسيقية.

سيتم تشغيل effect دائمًا على مرسِل تطبيق المقطوعة الموسيقية، ولا يتم مطلقًا تشغيل التطبيقات المتوافقة مع بعضها أو مع بعضها البعض أو يتم تطبيق التغييرات على العرض التدرّجي للمقطوعة الموسيقية أو تشغيل عمليات استدعاء أحداث RememberObserver. يتم تشغيل SideEffect دائمًا بعد استدعاء أحداث RememberObserver.

يتم تشغيل SideEffect بعد كل إعادة تركيب. لتشغيل مهمة جارية تمتد إلى العديد من عمليات إعادة الضبط، يُرجى الاطّلاع على LaunchedEffect. لإدارة اشتراك في حدث أو مراحل نشاط أخرى، يُرجى الاطّلاع على DisposableEffect.

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

يمكنك إنشاء مفتاح CompositionLocal يمكن تقديمه باستخدام CompositionLocalProvider. سيؤدي تغيير القيمة المقدَّمة أثناء إعادة التركيب إلى إبطال صلاحية محتوى CompositionLocalProvider الذي يقرأ القيمة باستخدام CompositionLocal.current.

ينشئ compositionLocalOf عنصر ProvidableCompositionLocal يمكن استخدامه في مكالمة مع CompositionLocalProvider. مثل MutableList في مقابل List، إذا تم ضبط المفتاح بشكل علني على CompositionLocal بدلاً من ProvidableCompositionLocal، يمكن قراءته باستخدام CompositionLocal.current ولكن لا يمكن إعادة تقديمه.

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

تنشئ كائن State يكون State.value فيه نتيجة calculation. سيتم تخزين نتيجة العملية الحسابية مؤقتًا بطريقة تجعل استدعاء State.value بشكل متكرر لن يؤدي إلى تنفيذ calculation عدة مرات، ولكن قراءة State.value ستؤدي إلى قراءة جميع عناصر State التي تمت قراءتها أثناء calculation في Snapshot الحالية، ما يعني أن هذا سيؤدي إلى الاشتراك بشكل صحيح في كائنات الحالة المشتقة إذا كانت القيمة تتم قراءتها في سياق مرصود مثل دالة Composable. تؤدي الحالات المشتقة بدون سياسة التبديل إلى تشغيل التعديلات عند كل تغيير في التبعية. لتجنُّب إبطال التعديل عند التحديث، عليك توفير حمل زائد SnapshotMutationPolicy مناسب حتى 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>

تنشئ كائن State يكون State.value فيه نتيجة calculation. سيتم تخزين نتيجة العملية الحسابية مؤقتًا بطريقة تجعل استدعاء State.value بشكل متكرر لن يؤدي إلى تنفيذ calculation عدة مرات، ولكن قراءة State.value ستؤدي إلى قراءة جميع عناصر State التي تمت قراءتها أثناء calculation في Snapshot الحالية، ما يعني أن هذا سيؤدي إلى الاشتراك بشكل صحيح في كائنات الحالة المشتقة إذا كانت القيمة تتم قراءتها في سياق مرصود مثل دالة 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

واجهة برمجة التطبيقات للتتبع الداخلي

ينبغي أن يتم طلب البيانات بدون مزامنة سلسلة المحادثات مع فقدان المعلومات من حين لآخر.

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

key عبارة عن أداة قابلة للتركيب وتُستخدم "لتجميع" أو "مفتاح" جزء من التنفيذ داخل مقطوعة موسيقية. ويكون هذا الأمر مطلوبًا أحيانًا لتصحيح الحالة داخل تدفق التحكم الذي قد يؤدي إلى تنفيذ استدعاء قابل للإنشاء أكثر من مرة أثناء عملية الإنشاء.

ليس من الضروري أن تكون قيمة المفتاح فريدة عالميًا، ويجب أن تكون فريدة فقط بين استدعاءات key في هذه المرحلة من المقطوعة.

فعلى سبيل المثال، ضع في الاعتبار المثال التالي:

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

على الرغم من أنّ هناك مستخدمين لديهم المعرف نفسه مؤلف من كل من التكرار الحلقي العلوي والحلقة السفلية، نظرًا لأنهم استدعاءات مختلفة لـ key، فليس هناك حاجة لإنشاء مفاتيح مركبة.

يجب أن يكون المفتاح فريدًا لكل عنصر في المجموعة، وإلا قد تتم إعادة استخدام العناصر الثانوية والحالة المحلية بطرق غير مقصودة.

فعلى سبيل المثال، ضع في الاعتبار المثال التالي:

import androidx.compose.runtime.key

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

يفترض هذا المثال أنّ parent.id هو مفتاح فريد لكل عنصر في المجموعة، ولكن هذا صحيح فقط إذا كان من العدل الافتراض أنّ أحد الوالدَين سيكون له طفل واحد فقط، وقد لا يكون هذا هو الحال. بدلاً من ذلك، قد يكون من الأفضل إجراء ما يلي:

import androidx.compose.runtime.key

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

يمكن إنشاء مفتاح مركب بتمرير عدة وسيطات:

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

يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.

يمكن استخدام تركيبات التتبع لإنتاج مادة مركّبة تنقل المحتوى بين صف وعمود استنادًا إلى معامل، مثل

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

أو يمكن استخدامها لضمان مسارات حالة المقطوعة الموسيقية باستخدام نموذج مثل الحركات في التخطيط، مثل،

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

عرض MutableDoubleState جديد تم إعداده مع الذي تم تمريره في value

الفئة MutableDoubleState هي حامل قيمة فردي الذي تتم فيه ملاحظة عمليات القراءة والكتابة بواسطة Compose. بالإضافة إلى ذلك، يتم إجراء عمليات الكتابة إليه كجزء من نظام Snapshot. في جهاز JVM، يتم تخزين القيم في الذاكرة كنوع double الأساسي، ما يؤدي إلى تجنُّب العلبة التلقائية التي تحدث عند استخدام MutableState<Double>.

@StateFactoryMarker
fun mutableFloatStateOf(value: Float): MutableFloatState

عرض MutableFloatState جديد تم إعداده مع الذي تم تمريره في value

الفئة MutableFloatState هي حامل قيمة فردية تتم ملاحظة عمليات قراءة وكتاباته بواسطة Compose. بالإضافة إلى ذلك، يتم إجراء عمليات الكتابة إليه كجزء من نظام Snapshot. في جهاز JVM، يتم تخزين القيم في الذاكرة كنوع float الأساسي، ما يؤدي إلى تجنُّب العلبة التلقائية التي تحدث عند استخدام MutableState<Float>.

@StateFactoryMarker
fun mutableIntStateOf(value: Int): MutableIntState

عرض MutableIntState جديد تم إعداده مع الذي تم تمريره في value

الفئة MutableIntState هي حامل قيمة فردي تتم فيه ملاحظة عمليات القراءة والكتابة بواسطة Compose. بالإضافة إلى ذلك، يتم إجراء عمليات الكتابة إليه كجزء من نظام Snapshot. في جهاز JVM، يتم تخزين القيم في الذاكرة كنوع int الأساسي، ما يؤدي إلى تجنُّب العلبة التلقائية التي تحدث عند استخدام MutableState<Int>.

@StateFactoryMarker
fun mutableLongStateOf(value: Long): MutableLongState

عرض MutableLongState جديد تم إعداده مع الذي تم تمريره في value

فئة MutableLongState هي حامل قيمة فردي تتم فيه ملاحظة عمليات القراءة والكتابة بواسطة Compose. بالإضافة إلى ذلك، يتم إجراء عمليات الكتابة إليه كجزء من نظام Snapshot. في جهاز JVM، يتم تخزين القيم في الذاكرة كنوع long الأساسي، ما يؤدي إلى تجنُّب العلبة التلقائية التي تحدث عند استخدام MutableState<Long>.

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

إنشاء مثيل لـ MutableList يمكن ملاحظته ويمكن تسجيله كلقطة.

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>

إنشاء مثيل لـ MutableList يمكن ملاحظته ويمكن تسجيله كلقطة.

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

أنشِئ مثيلاً لـ MutableMap<k, v=""> يمكن ملاحظته ويمكن تسجيله في لقطة.</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>

أنشِئ مثيلاً لـ MutableMap<k, v=""> يمكن ملاحظته ويمكن تسجيله في لقطة.</k,>

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

عرض MutableState جديد تم إعداده مع الذي تم تمريره في value

فئة MutableState هي حامل قيمة فردي تتم فيه ملاحظة عمليات القراءة والكتابة بواسطة Compose. بالإضافة إلى ذلك، يتم إجراء عمليات الكتابة إليه كجزء من نظام 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>

لا تتعامل السياسة مطلقًا مع قيم MutableState كقيمة مكافئة.

سيُعتبر إعداد MutableState.value دائمًا تغييرًا. عند تطبيق دالة MutableSnapshot التي تغيّر الحالة، ستتعارض دائمًا مع اللقطات الأخرى التي تغيّر الحالة نفسها.

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

عرض قيمة State snapshot قابلة للتتبّع وتنشئ قيمًا بمرور الوقت بدون مصدر بيانات محدّد

يتم تشغيل producer عند دخول produceState إلى المقطوعة الموسيقية ويتم إلغاؤه عند مغادرة produceState للمقطوعة الموسيقية. يجب أن تستخدم producer السمة ProduceStateScope.value لضبط قيم جديدة في State التي يتم عرضها.

تدمج القيمة State المعروضة القيم، ولن يكون بالإمكان ملاحظة أي تغيير في حال استخدام ProduceStateScope.value لضبط قيمة تساوي equal على قيمتها القديمة، وقد يرى المراقبون فقط أحدث قيمة إذا تم ضبط عدة قيم في تتابع سريع.

يمكن استخدام produceState لملاحظة مصادر البيانات الخارجية إما غير معلّقة أو غير معلّقة، على سبيل المثال:

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>

عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من key1.

يتم تشغيل producer عند دخول produceState إلى المقطوعة الموسيقية ويتم إلغاؤه عند مغادرة produceState للمقطوعة الموسيقية. في حال تغيير key1، سيتم إلغاء producer قيد التشغيل وإعادة تشغيلها للمصدر الجديد. يجب أن تستخدم producer السمة ProduceStateScope.value لضبط قيم جديدة في State التي يتم عرضها.

تدمج القيمة State المعروضة القيم، ولن يكون بالإمكان ملاحظة أي تغيير في حال استخدام ProduceStateScope.value لضبط قيمة تساوي equal على قيمتها القديمة، وقد يرى المراقبون فقط أحدث قيمة إذا تم ضبط عدة قيم في تتابع سريع.

يمكن استخدام produceState لملاحظة مصادر البيانات الخارجية إما غير معلّقة أو غير معلّقة، على سبيل المثال:

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>

عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من keys.

يتم تشغيل producer عند دخول produceState إلى المقطوعة الموسيقية ويتم إلغاؤه عند مغادرة produceState للمقطوعة الموسيقية. في حال تغيير keys، سيتم إلغاء producer قيد التشغيل وإعادة تشغيلها للمصدر الجديد. يجب أن تستخدم producer السمة ProduceStateScope.value لضبط قيم جديدة في State التي يتم عرضها.

تدمج القيمة State المعروضة القيم، ولن يكون بالإمكان ملاحظة أي تغيير في حال استخدام ProduceStateScope.value لضبط قيمة تساوي equal على قيمتها القديمة، وقد يرى المراقبون فقط أحدث قيمة إذا تم ضبط عدة قيم في تتابع سريع.

يمكن استخدام produceState لملاحظة مصادر البيانات الخارجية إما غير معلّقة أو غير معلّقة، على سبيل المثال:

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>

عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من key1 وkey2

يتم تشغيل producer عند دخول produceState إلى المقطوعة الموسيقية ويتم إلغاؤه عند مغادرة produceState للمقطوعة الموسيقية. في حال تغيير key1 أو key2، سيتم إلغاء producer قيد التشغيل وإعادة تشغيلها للمصدر الجديد. يجب أن تستخدم producer السمة ProduceStateScope.value لضبط قيم جديدة في State التي يتم عرضها.

تدمج القيمة State المعروضة القيم، ولن يكون بالإمكان ملاحظة أي تغيير في حال استخدام ProduceStateScope.value لضبط قيمة تساوي equal على قيمتها القديمة، وقد يرى المراقبون فقط أحدث قيمة إذا تم ضبط عدة قيم في تتابع سريع.

يمكن استخدام produceState لملاحظة مصادر البيانات الخارجية إما غير معلّقة أو غير معلّقة، على سبيل المثال:

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>

عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من key1 وkey2 وkey3.

يتم تشغيل producer عند دخول produceState إلى المقطوعة الموسيقية ويتم إلغاؤه عند مغادرة produceState للمقطوعة الموسيقية. في حال تغيير key1 أو key2 أو key3، سيتم إلغاء producer قيد التشغيل وإعادة إطلاقها للمصدر الجديد. [يجب على المنتج استخدام ProduceStateScope.value لضبط قيم جديدة في State المعروضة.

تدمج القيمة State المعروضة القيم، ولن يكون بالإمكان ملاحظة أي تغيير في حال استخدام ProduceStateScope.value لضبط قيمة تساوي equal على قيمتها القديمة، وقد يرى المراقبون فقط أحدث قيمة إذا تم ضبط عدة قيم في تتابع سريع.

يمكن استخدام produceState لملاحظة مصادر البيانات الخارجية إما غير معلّقة أو غير معلّقة، على سبيل المثال:

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>

تمثّل هذه السياسة سياسة للتعامل مع قيَم MutableState باعتبارها مكافئة إذا كانت مساوية للإحالة (===).

أمّا عند ضبط MutableState.value على قيمته الحالية المُتساوية (===) كمرجع، فهو لا يُعدّ تغييرًا. عند تطبيق MutableSnapshot، إذا كانت اللقطة تغيّر القيمة إلى القيمة المكافئة، لن تُعتبر اللقطة الرئيسية تعارضًا.

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

لا تنسَ القيمة الناتجة من calculation. سيتم تقييم calculation فقط أثناء المقطوعة الموسيقية. ستعرض إعادة التركيب دائمًا القيمة الناتجة عن المقطوعة الموسيقية.

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

يجب تذكُّر القيمة التي تعرضها calculation إذا كان key1 يساوي المقطوعة الموسيقية السابقة، أو يمكنك إنتاج قيمة جديدة وتذكُّرها من خلال استدعاء calculation.

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

تذكّر القيمة التي تعرضها calculation إذا كانت جميع قيم keys تساوي التركيبة السابقة، أو استنتج قيمة جديدة وتذكرها من خلال استدعاء calculation.

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

تذكّر القيمة التي تعرضها calculation إذا كان key1 وkey2 يساويان التركيبة السابقة، أو يمكنك إنتاج قيمة جديدة وتذكُّرها من خلال استدعاء القيمة calculation.

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

تذكّر القيمة التي تعرضها calculation إذا كانت key1 وkey2 وkey3 تساوي التركيبة السابقة، وإلا تنتج قيمة جديدة وتذكرها من خلال طلب البيانات من calculation.

@Composable
fun rememberCompositionContext(): CompositionContext

تأثير لإنشاء CompositionContext عند نقطة التركيب الحالية. يمكن استخدام هذه الميزة لتشغيل مقطوعة موسيقية منفصلة في سياق الأغنية الحالية، مع الحفاظ على CompositionLocal ونشر عمليات إبطال النصوص. وعند مغادرة هذه المكالمة للمقطوعة الموسيقية، يتم إبطال السياق.

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

عرض CoroutineScope مرتبط بهذه النقطة في المقطوعة الموسيقية باستخدام عنصر CoroutineContext الاختياري المقدَّم من getContext. سيتم استدعاء getContext مرة واحدة فقط وسيتم عرض مثيل CoroutineScope نفسه عبر التركيبات.

سيصبح هذا النطاق cancelled عند مغادرة هذه المكالمة للمقطوعة الموسيقية. لا يمكن أن يحتوي CoroutineContext الذي يعرضه getContext على Job لأنّ هذا النطاق يُعتبر فرعيًا من المقطوعة الموسيقية.

سيكون المرسِل التلقائي لهذا النطاق في حال عدم توفيره من خلال السياق الذي يعرضه getContext هو المُرسِل الذي يتم تطبيقه على Recomposer للمقطوعة الموسيقية.

استخدِم هذا النطاق لإطلاق المهام استجابةً لأحداث معاودة الاتصال، مثل النقرات أو غير ذلك من تفاعلات المستخدم، حيث يجب أن تظهر الاستجابة لهذا الحدث بمرور الوقت وإلغاؤها في حال خرجت هذه العملية من عملية الإنشاء. يجب عدم إطلاق المهام في أي نطاق الكوروتين كتأثير جانبي للتكوين نفسه. لمعرفة المهام الجارية على نطاق والتي تم البدء بها حسب المقطوعة الموسيقية، يُرجى الاطّلاع على LaunchedEffect.

لن يتم طرح هذه الدالة إذا لم يتم استيفاء الشروط المسبقة، لأن الدوال القابلة للإنشاء لا تدعم الاستثناءات بشكل كامل بعد. وبدلاً من ذلك، ستحتوي CoroutineScope.coroutineContext للنطاق المعروض على Job تعذّر تطبيق الإجراء عليها باستثناء ذي صلة ولن تتمكّن من إطلاق مهام فرعية.

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

remember mutableStateOf وعدِّل قيمتها إلى newValue في كل إعادة تركيب لمكالمة rememberUpdatedState.

يجب استخدام rememberUpdatedState عندما تتم الإشارة إلى المَعلمات أو القيم المحسوبة أثناء الإنشاء باستخدام تعبير lambda أو كائن طويل العمر. ستعمل عملية إعادة التركيب على تعديل State الناتجة بدون إعادة إنشاء دالة lambda أو الكائن الطويل الأمد، ما يسمح بمواصلة استخدام هذا العنصر بدون الإلغاء وإعادة الاشتراك، أو إعادة إطلاق عملية طويلة الأمد قد تكون مكلفة أو تحظر إعادة إنشاء العناصر وإعادة تشغيلها. قد يكون هذا الأمر شائعًا عند العمل مع DisposableEffect أو LaunchedEffect، على سبيل المثال:

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 غالبًا أجهزة الحالة التي يجب إعادة ضبطها وإعادة تشغيلها في حال تغيير مَعلمة أو استدعاء حدث، ولكن يجب أن تتوفّر لها القيمة الحالية عند الحاجة. مثلاً:

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

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

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

    // ...
}

باستخدام rememberUpdatedState، يمكن لوظيفة قابلة للإنشاء تعديل هذه العمليات الجارية.

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

أنشِئ Flow من حالة Snapshot قابلة للملاحظة. (على سبيل المثال، جهات الولاية التي تم إرجاعها بواسطة mutableStateOf).

تنشئ دالة snapshotFlow عنصر Flow الذي يشغِّل block عند جمع البيانات ويصدر النتيجة، مع تسجيل أي حالة لقطة تم الوصول إليها. أثناء عملية جمع البيانات، إذا تم تطبيق سمة Snapshot جديدة وغيّرت الحالة التي تم الوصول إليها من خلال block، سيتم تشغيل التدفق block مرة أخرى، مع إعادة تسجيل حالة اللقطة التي تم الوصول إليها. إذا لم تكن نتيجة block هي equal to هي النتيجة السابقة، سيصدر التدفق تلك النتيجة الجديدة. (يشبه هذا السلوك سلوك Flow.distinctUntilChanged.) ستستمر عملية جمع البيانات إلى أجل غير مسمى ما لم يتم إلغاؤها أو تقييدها صراحةً من خلال استخدام عوامل تشغيل Flow أخرى.

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

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

// ...

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

// ...

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

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

// ...

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

يتم تشغيل block في Snapshot للقراءة فقط، لذا لا يمكن تعديل بيانات اللقطة. إذا حاول block تعديل بيانات اللقطة، سيتعذّر جمع التدفق مع IllegalStateException.

قد يتم تشغيل block أكثر من مرة لمجموعات متساوية من الإدخالات أو مرة واحدة فقط بعد عدة تغييرات سريعة، لذا يجب أن يكون ثابتًا وخاليًا من أي آثار جانبية.

عند العمل مع Snapshot، من المفيد مراعاة التمييز بين الأحداث والحالة. تتغيّر نبذة عن نماذج snapshotFlow بصفتها أحداثًا، ولكن لا يمكن وضع نموذج فعّال للأحداث على أنّها حالة يمكن رصدها. الحالة القابلة للملاحظة هي ضغط معقد للأحداث التي أدت إلى تلك الحالة.

يقع حدث يمكن ملاحظته في وقت معيَّن ويتم تجاهله. يتم إشعار جميع المراقبين المسجَّلين في وقت وقوع الحدث. من المفترض أن تكون جميع الأحداث الفردية في البث ذات صلة ويمكن أن تعتمد على بعضها. بالنسبة إلى الأحداث المتساوية المتكررة، يكون لها معنى، وبالتالي على المراقب المسجَّل مراقبة جميع الأحداث بدون تخطّيها.

تؤدي الحالة القابلة للملاحظة إلى رفع أحداث التغيير عندما تتغير الحالة من قيمة إلى قيمة جديدة غير متساوية. يتم الخلط بين أحداث تغيير الحالة، والمسائل المتعلقة بأحدث حالة فقط. وبالتالي، يجب أن يكون مراقبو تغيّرات الحالة غير قويين، بمنحهم قيمة الولاية نفسها، يجب أن يقدّم المراقب النتيجة نفسها. ويصلح مراقب الحالة لكل من تخطي الحالات الوسيطة بالإضافة إلى الجري عدة مرات للحالة ذاتها ويجب أن تكون النتيجة واحدة.

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

دالة Compose الداخلية. يُرجى عدم الاتصال مباشرةً.

يسجل معلومات المصدر التي يمكن استخدامها للأدوات لتحديد موقع المصدر للدالة القابلة للإنشاء المقابلة. حسب الإعدادات التلقائية، يتم الإعلان عن عدم حدوث أي آثار جانبية في هذه الدالة. ومن الآمن استخدام أدوات تقليص الرموز (مثل R8 أو ProGuard) لإزالتها.

@ComposeCompilerApi
fun sourceInformationMarkerEnd(composer: Composer): Unit

دالة Compose الداخلية. يُرجى عدم الاتصال مباشرةً.

يسجِّل نهاية علامة معلومات المصدر التي يمكن استخدامها في الأدوات لتحديد موقع المصدر للدالة القابلة للإنشاء المقابلة والتي لا تتطلّب معلومات تتبُّع، مثل دوال ReadOnlyComposable. حسب الإعدادات التلقائية، يتم الإعلان عن عدم حدوث أي آثار جانبية في هذه الدالة. ومن الآمن استخدام أدوات تقليص الرموز (مثل R8 أو ProGuard) لإزالتها.

من المهم أن تتم إزالة كل من sourceInformationMarkerStart وsourceInformationMarkerEnd معًا أو الاحتفاظ بكل منهما. ستؤدي إزالة مادة عرض واحدة فقط إلى حدوث سلوك غير صحيح في وقت التشغيل.

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

دالة Compose الداخلية. يُرجى عدم الاتصال مباشرةً.

يسجّل بداية علامة معلومات المصدر التي يمكن استخدامها في الأدوات لتحديد موقع المصدر للدالة القابلة للإنشاء المقابلة والتي لا تتطلب معلومات تتبُّع، مثل دوال ReadOnlyComposable. حسب الإعدادات التلقائية، يتم الإعلان عن عدم حدوث أي آثار جانبية في هذه الدالة. ومن الآمن استخدام أدوات تقليص الرموز (مثل R8 أو ProGuard) لإزالتها.

من المهم أن تتم إزالة كل من sourceInformationMarkerStart وsourceInformationMarkerEnd معًا أو الاحتفاظ بكل منهما. ستؤدي إزالة مادة عرض واحدة فقط إلى حدوث سلوك غير صحيح في وقت التشغيل.

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

يمكنك إنشاء مفتاح CompositionLocal يمكن تقديمه باستخدام CompositionLocalProvider.

على عكس compositionLocalOf، لا يتتبّع المؤلف قراءات staticCompositionLocalOf، وسيؤدي تغيير القيمة المقدَّمة في الطلب CompositionLocalProvider إلى إعادة تركيب المحتوى بالكامل بدلاً من الأماكن التي تُستخدم فيها القيمة المحلية في المقطوعة الموسيقية فقط. ومع ذلك، فإن عدم تتبُّع هذه البيانات يجعل staticCompositionLocalOf أكثر فعالية عندما يكون من غير المرجّح أن تتغيّر القيمة المقدَّمة أو لن تتغير أبدًا. على سبيل المثال، من غير المرجّح أن يتغيّر سياق Android أو برامج تحميل الخطوط أو قيم مشتركة مشابهة في مكوّنات محتوى CompositionLocalProvider، لذا يجب استخدام staticCompositionLocalOf. قد يتغيّر لون أو مظهر آخر مثل القيمة أو قد تكون متحركة، لذلك يجب استخدام compositionLocalOf.

ينشئ staticCompositionLocalOf عنصر ProvidableCompositionLocal يمكن استخدامه في مكالمة مع CompositionLocalProvider. مثل MutableList في مقابل List، إذا تم ضبط المفتاح بشكل علني على CompositionLocal بدلاً من ProvidableCompositionLocal، يمكن قراءته باستخدام CompositionLocal.current ولكن لا يمكن إعادة تقديمه.

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

تمثّل هذه السمة سياسة للتعامل مع قيَم MutableState كقيمة مكافئة إذا كانت هيكلية (==) متساوية.

يُرجى العلم أنّ ضبط MutableState.value على القيمة المتساوية الحالية بشكل هيكل (==) لا يُعدّ تغييرًا. عند تطبيق MutableSnapshot، إذا كانت اللقطة تغيّر القيمة إلى القيمة المكافئة، لن تُعتبر اللقطة الرئيسية تعارضًا.

@ComposeCompilerApi
fun traceEventEnd(): Unit

واجهة برمجة التطبيقات للتتبع الداخلي

ينبغي أن يتم طلب البيانات بدون مزامنة سلسلة المحادثات مع فقدان المعلومات من حين لآخر.

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

واجهة برمجة التطبيقات للتتبع الداخلي

ينبغي أن يتم طلب البيانات بدون مزامنة سلسلة المحادثات مع فقدان المعلومات من حين لآخر.

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

يتم تعليقه حتى يتم طلب إطار جديد، ويستدعي onFrame على الفور مع وقت عرض الإطار بالمللي ثانية في سياق الاتصال لإرسال الإطار، ثم يتم استئنافه مع النتيجة من onFrame.

يجب استخدام السمة frameTimeMillis عند احتساب قيم دلتا لوقت الصورة المتحركة من إطار إلى آخر، لأنّه قد تتم تسويتها وفقًا للوقت المستهدَف للإطار، وليس بالضرورة القيمة "الآن" المباشرة.

يتم تحديد الأساس الزمني للقيمة المقدَّمة من MonotonicFrameClock.withFrameMillis. تزداد قيم الوقت المقدمة بشكل منتظم، أي بعد اكتمال الاستدعاء إلى withFrameMillis، يجب ألا توفر قيمة أصغر للمكالمة اللاحقة.

ستستدعي هذه الدالة MonotonicFrameClock.withFrameNanos باستخدام MonotonicFrameClock لاستدعاء CoroutineContext وستطرح IllegalStateException إذا لم تكن متوفّرة في CoroutineContext.

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

يتم تعليق الاشتراك إلى أن يتم طلب إطار جديد، ويستدعي onFrame على الفور مع وقت عرض الإطار بالنانو ثانية في سياق الطلب لإرسال الإطار، ثم يتم استئنافه مع النتيجة من onFrame.

يجب استخدام السمة frameTimeNanos عند احتساب قيم دلتا لوقت الصورة المتحركة من إطار إلى آخر، لأنّه قد تتم تسويتها وفقًا للوقت المستهدَف للإطار، وليس بالضرورة القيمة "الآن" المباشرة.

يتم تحديد الأساس الزمني للقيمة المقدَّمة من withFrameNanos. تزداد قيم الوقت المقدمة بشكل رتيب للغاية، وبعد اكتمال الاستدعاء إلى withFrameNanos، يجب ألا يتم تقديم القيمة نفسها مرة أخرى لمكالمة لاحقة.

ستستدعي هذه الدالة MonotonicFrameClock.withFrameNanos باستخدام MonotonicFrameClock لاستدعاء CoroutineContext وستطرح IllegalStateException إذا لم تكن متوفّرة في CoroutineContext.

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

يتم تشغيل block مع Recomposer جديد ونشط لتطبيق التغييرات في CoroutineContext الخاص بالاستدعاء. سيصبح سعر Recomposer closed بعد إرجاع المشتريات من block. يعود "withRunningRecomposer" بعد أن تصبح قيمة "Recomposer" هي "Recomposer.State.ShutDown"، ويكون joined في جميع الوظائف الفرعية التي أطلقها "block".

fun State<Double>.asDoubleState(): DoubleState

لتحويل State<Double> (مثل قيمة State لمربّع Double في علبة) إلى Double متوافق مع الإصدار الأساسي. وسيتم تلقائيًا فتح علبة الحالة حسب نوع الوحدة الأساسية المطلوب. تكون الحالة المعروضة للقراءة فقط. وستعكس الحالة المعروضة قيم الحالة الأساسية وتطبِّق التحديثات بالطريقة نفسها التي يُحدِّدها المُستلِم.

في جهاز JVM، لا يتجنّب هذا التحويل العبء التلقائي الذي يحاول Double تجاوزه، ولكنه يهدف إلى السماح بإمكانية التشغيل التفاعلي بين المكوّنات التي تستخدم أيًّا من تمثيلات الحالة من النوع Double.

fun State<Float>.asFloatState(): FloatState

لتحويل State<Float> (مثل قيمة State لمربّع Float في علبة) إلى Float متوافق مع الإصدار الأساسي. وسيتم تلقائيًا فتح علبة الحالة حسب نوع الوحدة الأساسية المطلوب. تكون الحالة المعروضة للقراءة فقط. وستعكس الحالة المعروضة قيم الحالة الأساسية وتطبِّق التحديثات بالطريقة نفسها التي يُحدِّدها المُستلِم.

في جهاز JVM، لا يتجنّب هذا التحويل العبء التلقائي الذي يحاول Float تجاوزه، ولكنه يهدف إلى السماح بإمكانية التشغيل التفاعلي بين المكوّنات التي تستخدم أيًّا من تمثيلات الحالة من النوع Float.

fun State<Int>.asIntState(): IntState

لتحويل State<Int> (مثل قيمة State لمربّع Int في علبة) إلى IntState متوافق مع الإصدار الأساسي. وسيتم تلقائيًا فتح علبة الحالة حسب نوع الوحدة الأساسية المطلوب. تكون الحالة المعروضة للقراءة فقط. وستعكس الحالة المعروضة قيم الحالة الأساسية وتطبِّق التحديثات بالطريقة نفسها التي يُحدِّدها المُستلِم.

في جهاز JVM، لا يتجنّب هذا التحويل العبء التلقائي الذي يحاول IntState تجاوزه، ولكنه يهدف إلى السماح بإمكانية التشغيل التفاعلي بين المكوّنات التي تستخدم أيًّا من تمثيلات الحالة من النوع Int.

fun State<Long>.asLongState(): LongState

لتحويل State<Long> (مثل قيمة State لمربّع Long في علبة) إلى LongState متوافق مع الإصدار الأساسي. وسيتم تلقائيًا فتح علبة الحالة حسب نوع الوحدة الأساسية المطلوب. تكون الحالة المعروضة للقراءة فقط. وستعكس الحالة المعروضة قيم الحالة الأساسية وتطبِّق التحديثات بالطريقة نفسها التي يُحدِّدها المُستلِم.

في جهاز JVM، لا يتجنّب هذا التحويل العبء التلقائي الذي يحاول LongState تجاوزه، ولكنه يهدف إلى السماح بإمكانية التشغيل التفاعلي بين المكوّنات التي تستخدم أيًّا من تمثيلات الحالة من النوع Long.

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

واجهة برمجة تطبيقات للمكوّن الإضافي Compose المجمع. يُرجى عدم الاتصال مباشرةً.

تذكّر أنّ ذاكرة التخزين المؤقت هي قيمة في بيانات المقطوعة الموسيقية. يتم استخدام هذه السمة لتنفيذ remember، كما يتم استخدامها بواسطة المكوّن الإضافي لبرنامج التجميع لإنشاء استدعاءات أكثر فعالية إلى remember عندما يتبيّن أنّ هذه التحسينات آمنة.

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

يجمع القيم من StateFlow ويمثّل أحدث قيمه من خلال State. يتم استخدام StateFlow.value كقيمة أولية. وفي كل مرة يتم فيها نشر قيمة جديدة في StateFlow، سيتم تعديل State المعروضة، ما يؤدي إلى إعادة تركيب كل استخدام لـ 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>

يجمع القيم من Flow ويمثّل أحدث قيمه من خلال State. وفي كل مرة يتم فيها نشر قيمة جديدة في Flow، سيتم تعديل State المعروضة، ما يؤدي إلى إعادة تركيب كل استخدام لـ 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

يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق DoubleState.

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

يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق FloatState.

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

يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق IntState.

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

يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق LongState.

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

يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق 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

يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableDoubleState.

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

يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableFloatState.

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

يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableIntState.

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

يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableLongState.

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

يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق 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")
}