androidx.compose.runtime

Kotlin |Java

شائعة/كلنظام التشغيل Android/JVM

في هذه الصفحة، ستجد مستندات حول الأنواع والخصائص والدوال المتوفّرة في حزمة androidx.compose.runtime. مثلاً:

• واجهات برمجة التطبيقات الخاصة بالحالة، مثل State وremember وmutableStateOf وcollectAsState

• واجهات برمجة تطبيقات التأثيرات الجانبية، مثل LaunchedEffect وSideEffect

• واجهات برمجة التطبيقات ذات الصلة بالكوروتينات، مثل rememberCoroutineScope وsnapshotFlow

• CompositionLocal من واجهات برمجة التطبيقات، مثل compositionLocalOf

• واجهات برمجة التطبيقات ذات الصلة بالمقطوعة الموسيقية، مثل Composition وRecomposer وComposeNode وRecomposeScope

• واجهات برمجة التطبيقات للساعة مثل MonotonicFrameClock وwithFrameMillis

• تعليقات توضيحية معيّنة مثل Composable وStable

إذا كنت تبحث عن إرشادات بدلاً من ذلك، يمكنك الاطّلاع على أدلة الإنشاء التالية:

• التفكير في "الإنشاء":

• الحالة الإدارية في Compose:

• دورة حياة الأجهزة القابلة للإنشاء:

• الآثار الجانبية في Compose:

واجهات

Applier	يكون مُصنِّف التطبيق مسؤولاً عن تطبيق العمليات القائمة على الأشجار التي يتم إطلاقها خلال المقطوعة الموسيقية.	Cmn
ComposeNodeLifecycleCallback	مراقبة دورة حياة العقدة المنبعثة باستخدام ReusableComposeNode أو ComposeNode داخل ReusableContentHost وReusableContent.	Cmn
Composer	Composer هي الواجهة التي يتم استهدافها بواسطة المكوّن الإضافي لبرنامج Compose Kotlin الإضافي ويستخدمها أدوات المساعدة لإنشاء الرموز.	Cmn
Composition	ويتم عادةً إنشاء كائن تركيبة لك، ويتم عرضه من واجهة برمجة تطبيقات تُستخدم في البداية لإنشاء واجهة مستخدم.	Cmn
CompositionLocalMap	لقطة للقراءة فقط وغير قابلة للتغيير من CompositionLocals، والتي يتم ضبطها في موضع معيّن في التدرّج الهرمي للمقطوعة الموسيقية.	Cmn
CompositionServiceKey	مفتاح لتحديد موقع خدمة باستخدام واجهة CompositionServices التي تم تنفيذها اختياريًا من خلال عمليات تنفيذ Composition.	Cmn
CompositionServices	للسماح بالعثور على خدمات المقطوعة الموسيقية من وقت التشغيل.	Cmn
CompositionTracer	واجهة برمجة التطبيقات للتتبع الداخلي	Cmn
ControlledComposition	المقطوعة الموسيقية التي يتم التحكم فيها هي Composition يمكن للمتصل التحكم فيها مباشرةً.	Cmn
DisposableEffectResult		Cmn
DoubleState	عند قراءة قيمة السمة doubleValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
FloatState	عند قراءة قيمة السمة floatValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
IntState	عند قراءة قيمة السمة intValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
LongState	عند قراءة قيمة السمة longValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
MonotonicFrameClock	توفر مصدرًا زمنيًا لإطارات العرض وإمكانية تنفيذ إجراء في الإطار التالي.	Cmn
MutableDoubleState	عند قراءة قيمة السمة doubleValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
MutableFloatState	عند قراءة قيمة السمة floatValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
MutableIntState	عند قراءة قيمة السمة intValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
MutableLongState	عند قراءة قيمة السمة longValue أثناء تنفيذ دالة Composable، يؤدي صاحب القيمة إلى اشتراك RecomposeScope الحالي في إجراء تغييرات على تلك القيمة.	Cmn
MutableState	يشير ذلك المصطلح إلى حامل قيمة قابلة للتغيير حيث تتم قراءته في السمة value أثناء تنفيذ دالة Composable، وسيتم اشتراك قيمة RecomposeScope الحالية في التغييرات التي يتم إجراؤها على تلك القيمة.	Cmn
ProduceStateScope	نطاق الاستقبال للاستخدام مع produceState	Cmn
RecomposeScope	يمثّل نطاقًا أو قسمًا قابلاً لإعادة الإنشاء من التسلسل الهرمي للمقطوعة الموسيقية.	Cmn
RecomposerInfo	معلومات للقراءة فقط حول Recomposer	Cmn
RememberObserver	ويتم إرسال إشعارات إلى العناصر التي تنفذ هذه الواجهة عند استخدامها للمرة الأولى في مقطوعة موسيقية وعند عدم استخدامها.	Cmn
ReusableComposition	ReusableComposition هي مادة Composition يمكن إعادة استخدامها لمحتوى مختلف يمكن إنشاؤه.	Cmn
ScopeUpdateScope	واجهة برمجة التطبيقات الداخلية للمكوّن الإضافي للمؤلِّف البرمجي يتم استخدامها لتحديث الوظيفة التي سيطلبها المؤلف لإعادة إنشاء نطاق إعادة التركيب.	Cmn
SnapshotMutationPolicy	تتحكّم هذه السياسة في كيفية تغيير نتيجة تقرير mutableStateOf ودمجها في كائن الحالة.	Cmn
State	يشير ذلك المصطلح إلى صاحب القيمة حيث تتم قراءته في السمة value أثناء تنفيذ دالة Composable، وسيتم اشتراك RecomposeScope الحالي في التغييرات ذات الصلة بهذه القيمة.	Cmn

صفوف

AbstractApplier	عملية تنفيذ Applier مختصرة.	Cmn
AtomicReference		Cmn
BroadcastFrameClock	ساعة إطار بسيطة.	Cmn
CompositionContext	CompositionContext هو نوع مبهم يتم استخدامه "لربط" تركيبتين معًا بشكل منطقي.	Cmn
CompositionLocal	يمرر Compose البيانات من خلال شجرة التكوين بشكل صريح عبر وسائل المعاملات إلى الدوال القابلة للإنشاء.	Cmn
CompositionLocalContext	لتخزين CompositionLocal وقيمها.	Cmn
DisposableEffectScope	نطاق المستلِم في DisposableEffect الذي يوفّر عبارة onDispose التي يجب أن تكون آخر عبارة في أي استدعاء إلى DisposableEffect	Cmn
MovableContent	واجهة برمجة تطبيقات للمكوّن الإضافي Compose المجمع.	Cmn
MovableContentState	واجهة برمجة تطبيقات للمكوّن الإضافي Compose المجمع.	Cmn
MovableContentStateReference	واجهة برمجة تطبيقات للمكوّن الإضافي Compose المجمع.	Cmn
PausableMonotonicFrameClock	برنامج تضمين MonotonicFrameClock يمكن أن يكون paused وresumed.	Cmn
ProvidableCompositionLocal	يمكن استخدام ProvidableCompositionLocal في CompositionLocalProvider لتقديم القيم.	Cmn
ProvidedValue	مثيل للاحتفاظ بقيمة مقدّمة من CompositionLocalProvider ويتم إنشاؤه بواسطة عامل التشغيل ProvidableCompositionLocal.provides	Cmn
Recomposer	أداة الجدولة لتنفيذ إعادة التركيب وتطبيق التعديلات على ثانية واحدة أو أكثر من Composition	Cmn
SkippableUpdater		Cmn
Updater	فئة نطاق مستلِم مساعد Google التي يستخدمها ComposeNode للمساعدة في كتابة رمز لإعداد عقدة وتعديلها.	Cmn

أغراض

MonotonicFrameClock.Key

Cmn

التعليقات التوضيحية

CheckResult		Cmn Android
Composable	الدوال Composable هي الوحدات الأساسية لتطبيق تم إنشاؤه باستخدام Compose.	Cmn
ComposableInferredTarget	تعليق توضيحي تم إنشاؤه من خلال المكوّن الإضافي لإنشاء برنامج التحويل البرمجي.	Cmn
ComposableOpenTarget	تشير السمة Composable إلى أنّها لا توفّر تطبيقًا معيّنًا.	Cmn
ComposableTarget	تم تعريف الدالة Composable بتوفّر تطبيق باسم applier.	Cmn
ComposableTargetMarker	يُستخدم هذا التعليق التوضيحي لوضع علامة على تعليق توضيحي باعتباره مكافئًا باستخدام ComposableTarget بالاسم المؤهل بالكامل للتعليق التوضيحي الذي تم وضع علامة عليه باعتباره القيمة applier.	Cmn
ComposeCompilerApi		Cmn
DisallowComposableCalls	سيمنع هذا حدوث الاتصالات القابلة للإنشاء داخل الدالة التي تنطبق عليها.	Cmn
ExperimentalComposeApi		Cmn
ExperimentalComposeRuntimeApi		Cmn
ExplicitGroupsComposable	يمكن تطبيق هذا التعليق التوضيحي على دوال Composable بحيث لا يتم إنشاء أي مجموعات في نص الدالة التي تتضمن تعليقًا توضيحيًا عليها.	Cmn
Immutable	يمكن استخدام Immutable لوضع علامة على الفئة على أنّها تنتج مثيلات غير قابلة للتغيير.	Cmn
InternalComposeApi		Cmn
InternalComposeTracingApi		Cmn
NoLiveLiterals	يُستخدم هذا التعليق التوضيحي للإشارة إلى برنامج تجميع Compose لعدم محاولة إنشاء قيم حرفية مباشرة داخل نطاق البيان الذي يتم تطبيقه عليه، حتى عندما يتم تشغيل إنشاء رمز القيم الحرفية المباشرة.	Cmn
NonRestartableComposable	يمكن تطبيق هذا التعليق التوضيحي على دوال Composable لمنع إنشاء رمز، ما يتيح تخطي تنفيذ هذه الدالة أو إعادة تشغيلها.	Cmn
ReadOnlyComposable	يمكن تطبيق هذا التعليق التوضيحي على دوال Composable بحيث لا يتم إنشاء أي مجموعة حول نص الدالة التي تتضمن تعليقًا توضيحيًا عليها.	Cmn
Stable	يُستخدم الإصدار الثابت لتوصيل بعض الضمانات إلى المحول البرمجي للإنشاء حول كيفية عمل نوع أو دالة معينة.	Cmn
StableMarker	StableMarker يضع علامة على تعليق توضيحي على أنه يشير إلى أن النوع ثابت.	Cmn
TestOnly		Cmn

عمليات التعداد

Recomposer.State

حالات التشغيل الصالحة لـ Recomposer

Cmn

ملخّص الدوال ذات المستوى الأعلى

inline Unit	@Composable <T : Any, E : Applier<*>> ComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit ) ينقل عقدة إلى تركيبة النوع T.	Cmn
inline Unit	@Composable <T : Any?, E : Applier<*>> ComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     content: @Composable () -> Unit ) ينقل عقدة إلى تركيبة النوع T.	Cmn
inline Unit	@Composable @ExplicitGroupsComposable <T : Any?, E : Applier<*>> ComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit,     content: @Composable () -> Unit ) ينقل عقدة إلى تركيبة النوع T.	Cmn
Composition	Composition(applier: Applier<*>, parent: CompositionContext) وهذه الطريقة هي طريقة إنشاء مقطوعة موسيقية.	Cmn
Composition	@ExperimentalComposeApi Composition(     applier: Applier<*>,     parent: CompositionContext,     recomposeCoroutineContext: CoroutineContext ) يمكنك إنشاء Composition باستخدام applier لإدارة المقطوعة الموسيقية، وهي عنصر ثانوي لـ parent.	Cmn
Unit	@Composable CompositionLocalProvider(     context: CompositionLocalContext,     content: @Composable () -> Unit ) يربط CompositionLocalProvider القيم بقيم CompositionLocal، المقدمة من context.	Cmn
Unit	@Composable CompositionLocalProvider(     value: ProvidedValue<*>,     content: @Composable () -> Unit ) يربط CompositionLocalProvider القيمة بالمفتاح ProvidableCompositionLocal.	Cmn
Unit	@Composable CompositionLocalProvider(     vararg values: ProvidedValue<*>,     content: @Composable () -> Unit ) يربط CompositionLocalProvider القيم بمفاتيح ProvidableCompositionLocal.	Cmn
ControlledComposition	@TestOnly ControlledComposition(applier: Applier<*>, parent: CompositionContext) وهذه الطريقة هي طريقة لإنشاء مقطوعة موسيقية.	Cmn
ControlledComposition	@TestOnly @ExperimentalComposeApi ControlledComposition(     applier: Applier<*>,     parent: CompositionContext,     recomposeCoroutineContext: CoroutineContext )	Cmn
Unit	@Composable @NonRestartableComposable DisposableEffect(effect: DisposableEffectScope.() -> DisposableEffectResult) تم إيقاف هذه الدالة نهائيًا. يجب أن توفر ميزة DisposableEffect واحدة أو أكثر من معلمات "المفتاح" التي تحدد هوية DisposableEffect وتحدد متى يجب التخلص من تأثيرها السابق وبدء تأثير جديد للمفتاح الجديد.	Cmn
Unit	@Composable @NonRestartableComposable DisposableEffect(key1: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult) تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ key1 ويجب عكسها أو إزالتها في حال تغيير key1 أو في حال مغادرة DisposableEffect للمقطوعة الموسيقية.	Cmn
Unit	@Composable @NonRestartableComposable DisposableEffect(vararg keys: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult) تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ keys ويجب عكسها أو إزالتها في حال تغيير keys أو إزالة DisposableEffect من المقطوعة الموسيقية.	Cmn
Unit	@Composable @NonRestartableComposable DisposableEffect(key1: Any?, key2: Any?, effect: DisposableEffectScope.() -> DisposableEffectResult) تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ key1 أو key2 ويجب عكسها أو إزالتها في حال تغيير key1 أو key2 أو في حال مغادرة DisposableEffect للمقطوعة الموسيقية.	Cmn
Unit	@Composable @NonRestartableComposable DisposableEffect(     key1: Any?,     key2: Any?,     key3: Any?,     effect: DisposableEffectScope.() -> DisposableEffectResult ) تأثير جانبي للمقطوعة الموسيقية يجب عرضه لأي قيمة فريدة جديدة تبلغ key1 أو key2 أو key3 ويجب عكسها أو إزالتها في حال تغيير key1 أو key2 أو key3 أو في حال مغادرة DisposableEffect التركيبة.	Cmn
Unit	@Composable LaunchedEffect(block: suspend CoroutineScope.() -> Unit) تم إيقاف هذه الدالة نهائيًا. يجب أن يوفر LaunchedEffect معلمة "key" واحدة أو أكثر تحدد هوية LaunchedEffect وتحدد متى يجب إلغاء الكوروتين بتأثيره السابق وسيتم تشغيل تأثير جديد للمفتاح الجديد.	Cmn
Unit	@Composable @NonRestartableComposable LaunchedEffect(key1: Any?, block: suspend CoroutineScope.() -> Unit) عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية.	Cmn
Unit	@Composable @NonRestartableComposable LaunchedEffect(vararg keys: Any?, block: suspend CoroutineScope.() -> Unit) عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية.	Cmn
Unit	@Composable @NonRestartableComposable LaunchedEffect(key1: Any?, key2: Any?, block: suspend CoroutineScope.() -> Unit) عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية.	Cmn
Unit	@Composable @NonRestartableComposable LaunchedEffect(key1: Any?, key2: Any?, key3: Any?, block: suspend CoroutineScope.() -> Unit) عندما تدخل "LaunchedEffect" المقطوعة الموسيقية، سيتم تشغيل "block" في "CoroutineContext" للمقطوعة الموسيقية.	Cmn
inline Unit	@Composable <T : Any, E : Applier<*>> ReusableComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit ) ينبعث منها عقدة قابلة لإعادة التدوير في تركيبة من النوع T.	Cmn
inline Unit	@Composable <T : Any?, E : Applier<*>> ReusableComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     content: @Composable () -> Unit ) ينبعث منها عقدة قابلة لإعادة التدوير في تركيبة من النوع T.	Cmn
inline Unit	@Composable @ExplicitGroupsComposable <T : Any?, E : Applier<*>> ReusableComposeNode(     noinline factory: () -> T,     update: @DisallowComposableCalls Updater<T>.() -> Unit,     noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit,     content: @Composable () -> Unit ) ينبعث منها عقدة قابلة لإعادة التدوير في تركيبة من النوع T.	Cmn
ReusableComposition	ReusableComposition(applier: Applier<*>, parent: CompositionContext) وهذه الطريقة هي طريقة بدء تركيبة قابلة لإعادة الاستخدام.	Cmn
inline Unit	@Composable ReusableContent(key: Any?, content: @Composable () -> Unit) دالة منفعة يتم استخدامها لوضع علامة على مقطوعة موسيقية تشير إلى كونها قابلة لإعادة التدوير.	Cmn
inline Unit	@Composable @ExplicitGroupsComposable ReusableContentHost(     active: Boolean,     crossinline content: @Composable () -> Unit ) هي دالة مساعدة اختيارية تُستخدَم عند استضافة ReusableContent.	Cmn
Unit	@Composable @NonRestartableComposable @ExplicitGroupsComposable SideEffect(effect: () -> Unit) يمكنك جدولة "effect" ليتم تشغيله عند اكتمال المقطوعة الموسيقية الحالية بنجاح وتطبيق التغييرات.	Cmn
ProvidableCompositionLocal<T>	<T : Any?> compositionLocalOf(     policy: SnapshotMutationPolicy<T>,     defaultFactory: () -> T ) يمكنك إنشاء مفتاح CompositionLocal يمكن تقديمه باستخدام CompositionLocalProvider.	Cmn
State<T>	@StateFactoryMarker <T : Any?> derivedStateOf(calculation: () -> T) تنشئ كائن State يكون State.value فيه نتيجة calculation.	Cmn
State<T>	@StateFactoryMarker <T : Any?> derivedStateOf(     policy: SnapshotMutationPolicy<T>,     calculation: () -> T ) تنشئ كائن State يكون State.value فيه نتيجة calculation.	Cmn
Boolean	@ComposeCompilerApi isTraceInProgress() واجهة برمجة التطبيقات للتتبع الداخلي	Cmn
inline T	@Composable <T : Any?> key(vararg keys: Any?, block: @Composable () -> T) key عبارة عن أداة قابلة للتركيب وتُستخدم "لتجميع" أو "مفتاح" جزء من التنفيذ داخل مقطوعة موسيقية.	Cmn
@Composable () -> Unit	movableContentOf(content: @Composable () -> Unit) يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable (P) -> Unit	<P : Any?> movableContentOf(content: @Composable (P) -> Unit) يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable (P1, P2) -> Unit	<P1 : Any?, P2 : Any?> movableContentOf(content: @Composable (P1, P2) -> Unit) يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable (P1, P2, P3) -> Unit	<P1 : Any?, P2 : Any?, P3 : Any?> movableContentOf(     content: @Composable (P1, P2, P3) -> Unit ) يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable (P1, P2, P3, P4) -> Unit	<P1 : Any?, P2 : Any?, P3 : Any?, P4 : Any?> movableContentOf(     content: @Composable (P1, P2, P3, P4) -> Unit ) يمكنك تحويل دالة lambda إلى دالة واحدة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable R.() -> Unit	<R : Any?> movableContentWithReceiverOf(content: @Composable R.() -> Unit) يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable R.(P) -> Unit	<R : Any?, P : Any?> movableContentWithReceiverOf(content: @Composable R.(P) -> Unit) يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable R.(P1, P2) -> Unit	<R : Any?, P1 : Any?, P2 : Any?> movableContentWithReceiverOf(     content: @Composable R.(P1, P2) -> Unit ) يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
@Composable R.(P1, P2, P3) -> Unit	<R : Any?, P1 : Any?, P2 : Any?, P3 : Any?> movableContentWithReceiverOf(     content: @Composable R.(P1, P2, P3) -> Unit ) يمكنك تحويل دالة lambda باستخدام جهاز استقبال إلى دالة تنقل الحالة التي تم تذكُّرها والعُقد التي تم إنشاؤها في استدعاء سابق إلى الموقع الجديد الذي يتم استدعاؤه.	Cmn
MutableDoubleState	@StateFactoryMarker mutableDoubleStateOf(value: Double) عرض MutableDoubleState جديد تم إعداده مع الذي تم تمريره في value	Cmn
MutableFloatState	@StateFactoryMarker mutableFloatStateOf(value: Float) عرض MutableFloatState جديد تم إعداده مع الذي تم تمريره في value	Cmn
MutableIntState	@StateFactoryMarker mutableIntStateOf(value: Int) عرض MutableIntState جديد تم إعداده مع الذي تم تمريره في value	Cmn
MutableLongState	@StateFactoryMarker mutableLongStateOf(value: Long) عرض MutableLongState جديد تم إعداده مع الذي تم تمريره في value	Cmn
SnapshotStateList<T>	@StateFactoryMarker <T : Any?> mutableStateListOf() إنشاء مثيل لـ MutableList يمكن ملاحظته ويمكن تسجيله كلقطة.	Cmn
SnapshotStateList<T>	@StateFactoryMarker <T : Any?> mutableStateListOf(vararg elements: T) إنشاء مثيل لـ MutableList يمكن ملاحظته ويمكن تسجيله كلقطة.	Cmn
SnapshotStateMap<K, V>	@StateFactoryMarker <K : Any?, V : Any?> mutableStateMapOf() أنشِئ مثيلاً لـ MutableMap<k, v=""> يمكن ملاحظته ويمكن تسجيله في لقطة.</k,>	Cmn
SnapshotStateMap<K, V>	@StateFactoryMarker <K : Any?, V : Any?> mutableStateMapOf(vararg pairs: Pair<K, V>) أنشِئ مثيلاً لـ MutableMap<k, v=""> يمكن ملاحظته ويمكن تسجيله في لقطة.</k,>	Cmn
MutableState<T>	@StateFactoryMarker <T : Any?> mutableStateOf(value: T, policy: SnapshotMutationPolicy<T>) عرض MutableState جديد تم إعداده مع الذي تم تمريره في value	Cmn
SnapshotMutationPolicy<T>	<T : Any?> neverEqualPolicy() لا تتعامل السياسة مطلقًا مع قيم MutableState كقيمة مكافئة.	Cmn
State<T>	@Composable <T : Any?> produceState(initialValue: T, producer: suspend ProduceStateScope<T>.() -> Unit) عرض قيمة State snapshot قابلة للتتبّع وتنشئ قيمًا بمرور الوقت بدون مصدر بيانات محدّد	Cmn
State<T>	@Composable <T : Any?> produceState(initialValue: T, key1: Any?, producer: suspend ProduceStateScope<T>.() -> Unit) عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من key1.	Cmn
State<T>	@Composable <T : Any?> produceState(     initialValue: T,     vararg keys: Any?,     producer: suspend ProduceStateScope<T>.() -> Unit ) عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من keys.	Cmn
State<T>	@Composable <T : Any?> produceState(     initialValue: T,     key1: Any?,     key2: Any?,     producer: suspend ProduceStateScope<T>.() -> Unit ) عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من key1 وkey2	Cmn
State<T>	@Composable <T : Any?> produceState(     initialValue: T,     key1: Any?,     key2: Any?,     key3: Any?,     producer: suspend ProduceStateScope<T>.() -> Unit ) عرض قيمة State snapshot قابلة للملاحظة والتي تنتج قيمًا بمرور الوقت من key1 وkey2 وkey3.	Cmn
SnapshotMutationPolicy<T>	<T : Any?> referentialEqualityPolicy() تمثّل هذه السياسة سياسة للتعامل مع قيَم MutableState باعتبارها مكافئة إذا كانت مساوية للإحالة (===).	Cmn
inline T	@Composable <T : Any?> remember(crossinline calculation: @DisallowComposableCalls () -> T) لا تنسَ القيمة الناتجة من calculation.	Cmn
inline T	@Composable <T : Any?> remember(     key1: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) يجب تذكُّر القيمة التي تعرضها calculation إذا كان key1 يساوي المقطوعة الموسيقية السابقة، أو يمكنك إنتاج قيمة جديدة وتذكُّرها من خلال استدعاء calculation.	Cmn
inline T	@Composable <T : Any?> remember(     vararg keys: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) تذكّر القيمة التي تعرضها calculation إذا كانت جميع قيم keys تساوي التركيبة السابقة، أو استنتج قيمة جديدة وتذكرها من خلال استدعاء calculation.	Cmn
inline T	@Composable <T : Any?> remember(     key1: Any?,     key2: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) تذكّر القيمة التي تعرضها calculation إذا كان key1 وkey2 يساويان التركيبة السابقة، أو يمكنك إنتاج قيمة جديدة وتذكُّرها من خلال استدعاء القيمة calculation.	Cmn
inline T	@Composable <T : Any?> remember(     key1: Any?,     key2: Any?,     key3: Any?,     crossinline calculation: @DisallowComposableCalls () -> T ) تذكّر القيمة التي تعرضها calculation إذا كانت key1 وkey2 وkey3 تساوي التركيبة السابقة، وإلا تنتج قيمة جديدة وتذكرها من خلال طلب البيانات من calculation.	Cmn
CompositionContext	@Composable rememberCompositionContext() تأثير لإنشاء CompositionContext عند نقطة التركيب الحالية.	Cmn
inline CoroutineScope	@Composable rememberCoroutineScope(     crossinline getContext: @DisallowComposableCalls () -> CoroutineContext ) عرض CoroutineScope مرتبط بهذه النقطة في المقطوعة الموسيقية باستخدام عنصر CoroutineContext الاختياري المقدَّم من getContext.	Cmn
State<T>	@Composable <T : Any?> rememberUpdatedState(newValue: T) remember mutableStateOf وعدِّل قيمتها إلى newValue في كل إعادة تركيب لمكالمة rememberUpdatedState.	Cmn
Flow<T>	<T : Any?> snapshotFlow(block: () -> T) أنشِئ Flow من حالة Snapshot قابلة للملاحظة.	Cmn
Unit	@ComposeCompilerApi sourceInformation(composer: Composer, sourceInformation: String) دالة Compose الداخلية.	Cmn
Unit	@ComposeCompilerApi sourceInformationMarkerEnd(composer: Composer) دالة Compose الداخلية.	Cmn
Unit	@ComposeCompilerApi sourceInformationMarkerStart(     composer: Composer,     key: Int,     sourceInformation: String ) دالة Compose الداخلية.	Cmn
ProvidableCompositionLocal<T>	<T : Any?> staticCompositionLocalOf(defaultFactory: () -> T) يمكنك إنشاء مفتاح CompositionLocal يمكن تقديمه باستخدام CompositionLocalProvider.	Cmn
SnapshotMutationPolicy<T>	<T : Any?> structuralEqualityPolicy() تمثّل هذه السمة سياسة للتعامل مع قيَم MutableState كقيمة مكافئة إذا كانت هيكلية (==) متساوية.	Cmn
Unit	@ComposeCompilerApi traceEventEnd() واجهة برمجة التطبيقات للتتبع الداخلي	Cmn
Unit	@ComposeCompilerApi traceEventStart(key: Int, dirty1: Int, dirty2: Int, info: String) واجهة برمجة التطبيقات للتتبع الداخلي	Cmn
suspend R	<R : Any?> withFrameMillis(onFrame: (frameTimeMillis: Long) -> R) يتم تعليقه حتى يتم طلب إطار جديد، ويستدعي onFrame على الفور مع وقت عرض الإطار بالمللي ثانية في سياق الاتصال لإرسال الإطار، ثم يتم استئنافه مع النتيجة من onFrame.	Cmn
suspend R	<R : Any?> withFrameNanos(onFrame: (frameTimeNanos: Long) -> R) يتم تعليق الاشتراك إلى أن يتم طلب إطار جديد، ويستدعي onFrame على الفور مع وقت عرض الإطار بالنانو ثانية في سياق الطلب لإرسال الإطار، ثم يتم استئنافه مع النتيجة من onFrame.	Cmn
suspend R	<R : Any?> withRunningRecomposer(block: suspend CoroutineScope.(recomposer: Recomposer) -> R) يتم تشغيل block مع Recomposer جديد ونشط لتطبيق التغييرات في CoroutineContext الخاص بالاستدعاء.	Cmn

ملخص وظائف الإضافات

DoubleState	State<Double>.asDoubleState() لتحويل State<Double> (مثل قيمة State لمربّع Double في علبة) إلى Double متوافق مع الإصدار الأساسي.	Cmn
FloatState	State<Float>.asFloatState() لتحويل State<Float> (مثل قيمة State لمربّع Float في علبة) إلى Float متوافق مع الإصدار الأساسي.	Cmn
IntState	State<Int>.asIntState() لتحويل State<Int> (مثل قيمة State لمربّع Int في علبة) إلى IntState متوافق مع الإصدار الأساسي.	Cmn
LongState	State<Long>.asLongState() لتحويل State<Long> (مثل قيمة State لمربّع Long في علبة) إلى LongState متوافق مع الإصدار الأساسي.	Cmn
inline T	@ComposeCompilerApi <T : Any?> Composer.cache(     invalid: Boolean,     block: @DisallowComposableCalls () -> T ) واجهة برمجة تطبيقات للمكوّن الإضافي Compose المجمع.	Cmn
State<T>	@Composable <T : Any?> StateFlow<T>.collectAsState(context: CoroutineContext) يجمع القيم من StateFlow ويمثّل أحدث قيمه من خلال State.	Cmn
State<R>	@Composable <T : R, R : Any?> Flow<T>.collectAsState(initial: R, context: CoroutineContext) يجمع القيم من Flow ويمثّل أحدث قيمه من خلال State.	Cmn
inline operator Double	DoubleState.getValue(thisObj: Any?, property: KProperty<*>) يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق DoubleState.	Cmn
inline operator Float	FloatState.getValue(thisObj: Any?, property: KProperty<*>) يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق FloatState.	Cmn
inline operator Int	IntState.getValue(thisObj: Any?, property: KProperty<*>) يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق IntState.	Cmn
inline operator Long	LongState.getValue(thisObj: Any?, property: KProperty<*>) يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق LongState.	Cmn
inline operator T	<T : Any?> State<T>.getValue(thisObj: Any?, property: KProperty<*>) يسمح بتفويض المواقع الإلكترونية لـ val باستخدام by للنطاق State.	Cmn
inline operator Unit	MutableDoubleState.setValue(     thisObj: Any?,     property: KProperty<*>,     value: Double ) يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableDoubleState.	Cmn
inline operator Unit	MutableFloatState.setValue(     thisObj: Any?,     property: KProperty<*>,     value: Float ) يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableFloatState.	Cmn
inline operator Unit	MutableIntState.setValue(thisObj: Any?, property: KProperty<*>, value: Int) يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableIntState.	Cmn
inline operator Unit	MutableLongState.setValue(     thisObj: Any?,     property: KProperty<*>,     value: Long ) يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableLongState.	Cmn
inline operator Unit	<T : Any?> MutableState<T>.setValue(     thisObj: Any?,     property: KProperty<*>,     value: T ) يسمح بتفويض المواقع الإلكترونية لـ var باستخدام by للنطاق MutableState.	Cmn
SnapshotStateList<T>	<T : Any?> Collection<T>.toMutableStateList() إنشاء مثيل لـ MutableList من مجموعة يمكن ملاحظتها ويمكن أخذها كلقطة.	Cmn
SnapshotStateMap<K, V>	<K : Any?, V : Any?> Iterable<Pair<K, V>>.toMutableStateMap() يمكنك إنشاء مثيل لـ MutableMap<k, v=""> من مجموعة من الأزواج التي يمكن ملاحظتها ويمكن أخذها في اللقطة.</k,>	Cmn
suspend inline R	<R : Any?> MonotonicFrameClock.withFrameMillis(     crossinline onFrame: (frameTimeMillis: Long) -> R ) يتم تعليقه حتى يتم طلب إطار جديد، ويستدعي onFrame على الفور مع وقت عرض الإطار بالمللي ثانية في سياق الاتصال لإرسال الإطار، ثم يتم استئنافه مع النتيجة من onFrame.	Cmn

ملخّص المواقع ذات المستوى الأعلى

MonotonicFrameClock	DefaultMonotonicFrameClock تم إيقاف هذا الموقع نهائيًا. لا يمكن تطبيق MonotonicFrameClocks عالميًا عبر المنصات.	Cmn Android
Composer	currentComposer TODO(lmr): تقديم وثائق	Cmn
Int	currentCompositeKeyHash هذه هي قيمة تجزئة تُستخدَم لتنسيق الحالة المخزّنة خارجيًا للخريطة مع التركيبة.	Cmn
CompositionLocalContext	currentCompositionLocalContext لعرض قيمة CompositionLocalContext الحالية التي تشتمل على كل قيم CompositionLocal ضمن المقطوعة الموسيقية الحالية وقيمها التي تم توفيرها من خلال قيم CompositionLocalProvider.	Cmn
RecomposeScope	currentRecomposeScope تعرض كائنًا يمكن استخدامه لإلغاء صلاحية النطاق الحالي في هذه النقطة من التركيبة.	Cmn

ملخّص خصائص الإضافة

MonotonicFrameClock	@ExperimentalComposeApi CoroutineContext.monotonicFrameClock تعرض MonotonicFrameClock الخاصة بـ CoroutineContext هذه أو تعرض IllegalStateException في حال عدم توفّرها.	Cmn
CoroutineContext	@ExperimentalComposeApi ControlledComposition.recomposeCoroutineContext مادة عرض CoroutineContext التي يجب استخدامها لإجراء عمليات إعادة تركيب متزامنة لهذه ControlledComposition عند استخدامها في بيئة تدعم المقطوعة الموسيقية المتزامنة.	Cmn

الدوال ذات المستوى الأعلى

ComposeNode

رقم الاتصالات

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

المَعلمات
noinline factory: () -> T	دالة تنشئ مثيل T جديدًا. لا يمكن ضمان تطبيق هذه الدالة في مكانها.
update: @DisallowComposableCalls Updater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. سيتم تنفيذ هذا الإجراء في كل مرة يتم فيها تنفيذ emit. يتم استدعاء هذه الدالة في مكانها وسيتم تضمينها.

يمكن أيضًا مراجعة
Updater
Applier
Composition

ComposeNode

رقم الاتصالات

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

المَعلمات
noinline factory: () -> T	دالة تنشئ مثيل T جديدًا. لا يمكن ضمان تطبيق هذه الدالة في مكانها.
update: @DisallowComposableCalls Updater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. سيتم تنفيذ هذا الإجراء في كل مرة يتم فيها تنفيذ emit. يتم استدعاء هذه الدالة في مكانها وسيتم تضمينها.
content: @Composable () -> Unit	المحتوى القابل للإنشاء الذي سيصدر "التابعين" لهذه العقدة.

يمكن أيضًا مراجعة
Updater
Applier
Composition

ComposeNode

رقم الاتصالات

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

المَعلمات
noinline factory: () -> T	دالة تنشئ مثيل T جديدًا. لا يمكن ضمان تطبيق هذه الدالة في مكانها.
update: @DisallowComposableCalls Updater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. سيتم تنفيذ هذا الإجراء في كل مرة يتم فيها تنفيذ emit. يتم استدعاء هذه الدالة في مكانها وسيتم تضمينها.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. على عكس update، هذه الدالة قابلة للإنشاء وبالتالي سيتم تخطّيها ما لم يتم إبطالها بواسطة آلية أخرى. يمكن أن يكون هذا مفيدًا لإجراء عمليات حسابية باهظة الثمن لتحديث العقدة التي من المحتمل أن تحتوي العمليات الحسابية فيها على نفس المدخلات بمرور الوقت، بحيث يمكن تخطي تنفيذ الدالة.
content: @Composable () -> Unit	المحتوى القابل للإنشاء الذي سيصدر "التابعين" لهذه العقدة.

يمكن أيضًا مراجعة
Updater
SkippableUpdater
Applier
Composition

مقطوعة موسيقية

رقم الاتصالات

تمت إضافتها في 1.0.0

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

المَعلمات
applier: Applier<*>	مثيل Applier المطلوب استخدامه في التركيبة
parent: CompositionContext	العنصر الرئيسي CompositionContext

يمكن أيضًا مراجعة
Applier
Composition
Recomposer

مقطوعة موسيقية

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

MembershipLocalProvider

رقم الاتصالات

تمت إضافتها في 1.1.0

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

يمكن أيضًا مراجعة
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

MembershipLocalProvider

رقم الاتصالات

تمت الإضافة في 1.6.0-alpha07.

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

يمكن أيضًا مراجعة
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

MembershipLocalProvider

رقم الاتصالات

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

يمكن أيضًا مراجعة
CompositionLocal
compositionLocalOf
staticCompositionLocalOf

التركيبة الخاضعة للرقابة

رقم الاتصالات

تمت إضافتها في 1.0.0

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

المَعلمات
applier: Applier<*>	مثيل Applier المطلوب استخدامه في التركيبة
parent: CompositionContext	العنصر الرئيسي CompositionContext

يمكن أيضًا مراجعة
Applier
Composition
Recomposer

التركيبة الخاضعة للرقابة

رقم الاتصالات

تمت إضافتها في 1.0.0

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

تأثير للاستعمال مرة واحدة

رقم الاتصالات

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

تم إيقاف هذه الدالة.
يجب أن توفّر DisposableEffect معلمة "مفتاح" واحدة أو أكثر تحدد هوية DisposableEffect وتحدد متى يجب التخلص من تأثيرها السابق وبدء تأثير جديد للمفتاح الجديد.

أثر جانبي للمركبة يجب عكسها أو تنظيفها إذا تمت إزالة 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.

LaunchedEffect

رقم الاتصالات

تمت إضافتها في 1.0.0

تم إيقافها نهائيًا في 1.0.0

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

تم إيقاف هذه الدالة.
يجب أن توفر LaunchedEffect معلمة 'key' واحدة أو أكثر تحدد هوية LaunchedEffect وتحدد متى يجب إلغاء تأثير الكوروتين السابق له ويتم تشغيل تأثير جديد للمفتاح الجديد.

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

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

LaunchedEffect

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

LaunchedEffect

رقم الاتصالات

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

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

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

LaunchedEffect

رقم الاتصالات

تمت إضافتها في 1.0.0

@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 يمكن استخدامها لإطلاق مهام حالية مخصّصة للمقطوعة الموسيقية استجابةً لاستدعاءات الفعالية.

LaunchedEffect

رقم الاتصالات

تمت إضافتها في 1.0.0

@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 يمكن استخدامها لإطلاق مهام حالية مخصّصة للمقطوعة الموسيقية استجابةً لاستدعاءات الفعالية.

ComposeNode قابلة لإعادة الاستخدام

رقم الاتصالات

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

المَعلمات
noinline factory: () -> T	دالة تنشئ مثيل T جديدًا. لا يمكن ضمان تطبيق هذه الدالة في مكانها.
update: @DisallowComposableCalls Updater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. سيتم تنفيذ هذا الإجراء في كل مرة يتم فيها تنفيذ emit. يتم استدعاء هذه الدالة في مكانها وسيتم تضمينها.

يمكن أيضًا مراجعة
Updater
Applier
Composition

ComposeNode قابلة لإعادة الاستخدام

رقم الاتصالات

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

المَعلمات
noinline factory: () -> T	دالة تنشئ مثيل T جديدًا. لا يمكن ضمان تطبيق هذه الدالة في مكانها.
update: @DisallowComposableCalls Updater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. سيتم تنفيذ هذا الإجراء في كل مرة يتم فيها تنفيذ emit. يتم استدعاء هذه الدالة في مكانها وسيتم تضمينها.
content: @Composable () -> Unit	المحتوى القابل للإنشاء الذي سيصدر "التابعين" لهذه العقدة.

يمكن أيضًا مراجعة
Updater
Applier
Composition

ComposeNode قابلة لإعادة الاستخدام

رقم الاتصالات

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

المَعلمات
noinline factory: () -> T	دالة تنشئ مثيل T جديدًا. لا يمكن ضمان تطبيق هذه الدالة في مكانها.
update: @DisallowComposableCalls Updater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. سيتم تنفيذ هذا الإجراء في كل مرة يتم فيها تنفيذ emit. يتم استدعاء هذه الدالة في مكانها وسيتم تضمينها.
noinline skippableUpdate: @Composable SkippableUpdater<T>.() -> Unit	دالة لإجراء التحديثات على العقدة. على عكس update، هذه الدالة قابلة للإنشاء وبالتالي سيتم تخطّيها ما لم يتم إبطالها بواسطة آلية أخرى. يمكن أن يكون هذا مفيدًا لإجراء عمليات حسابية باهظة الثمن لتحديث العقدة التي من المحتمل أن تحتوي العمليات الحسابية فيها على نفس المدخلات بمرور الوقت، بحيث يمكن تخطي تنفيذ الدالة.
content: @Composable () -> Unit	المحتوى القابل للإنشاء الذي سيصدر "التابعين" لهذه العقدة.

يمكن أيضًا مراجعة
Updater
SkippableUpdater
Applier
Composition

تركيبة قابلة لإعادة الاستخدام

رقم الاتصالات

تمت الإضافة في 1.6.0-alpha07.

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

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

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

المَعلمات
applier: Applier<*>	مثيل Applier المطلوب استخدامه في التركيبة
parent: CompositionContext	العنصر الرئيسي CompositionContext

يمكن أيضًا مراجعة
Applier
ReusableComposition
rememberCompositionContext

محتوى قابل لإعادة الاستخدام

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

المَعلمات
key: Any?	والقيمة المستخدمة لتشغيل إعادة التدوير. إذا تم إعادة إنشائها بقيمة مختلفة، ينشئ المؤلف مقطوعة موسيقية جديدة ولكنه يحاول إعادة استخدام العُقد القابلة لإعادة الاستخدام.
content: @Composable () -> Unit	لتركيبات الأطفال القابلة لإعادة التدوير.

مضيف محتوى قابل لإعادة الاستخدام

رقم الاتصالات

تمت إضافتها في 1.2.0

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

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

المَعلمات
active: Boolean	عندما تكون قيمة active true content يتم إنشاؤها بشكل طبيعي. وعندما تكون قيمة السمة active هي false، يتم إيقاف المحتوى ويتم التعامل مع جميع حالات التذكُّر كما لو تم حذف المحتوى، ولكن لن تتأثر العُقد التي تديرها "Applier" للمقطوعة الموسيقية. تصبح active true أي عُقد قابلة لإعادة الاستخدام من التركيبة النشطة سابقًا صالحة لإعادة استخدامها.
crossinline content: @Composable () -> Unit	المحتوى القابل للإنشاء الذي يديره هذا الجهاز القابل للإنشاء.

SideEffect

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

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

تكوين محلي

رقم الاتصالات

تمت إضافتها في 1.0.0

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 ولكن لا يمكن إعادة تقديمه.

المَعلمات
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()	سياسة لتحديد وقت اعتبار CompositionLocal أنه قد تم تغييرها. لمزيد من التفاصيل، انتقِل إلى SnapshotMutationPolicy.
defaultFactory: () -> T	مصنع قيمة لتقديم قيمة عند عدم توفر قيمة. يتم استدعاء هذا المصنع في حال عدم تقديم أي قيمة من خلال CompositionLocalProvider من المتصل الخاص بالمكوِّن باستخدام CompositionLocal.current. إذا لم يكن من الممكن تقديم خطأ افتراضي معقول، يمكنك عندئذٍ تقديم استثناء.

يمكن أيضًا مراجعة
CompositionLocal
staticCompositionLocalOf
mutableStateOf

حالة مشتقة

رقم الاتصالات

تمت إضافتها في 1.0.0

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

المَعلمات
calculation: () -> T	الحساب لإنشاء القيمة التي يمثلها كائن الحالة هذا.

حالة مشتقة

رقم الاتصالات

تمت إضافتها في 1.3.0

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

المَعلمات
policy: SnapshotMutationPolicy<T>	سياسة التغيير للتحكّم في وقت إجراء التغييرات على مشغِّل نتيجة calculation
calculation: () -> T	الحساب لإنشاء القيمة التي يمثلها كائن الحالة هذا.

isTraceInProgress

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
vararg keys: Any?	يشير ذلك المصطلح إلى مجموعة القيم التي سيتم استخدامها لإنشاء مفتاح مركب. ستتم مقارنتها بالقيم السابقة باستخدام equals وhashCode.
block: @Composable () -> T	الأطفال الذين يمكن تكوينهم لهذه المجموعة

movableContentOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
content: @Composable () -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable () -> Unit	لحم دجاجة قابلة للتركيب

movableContentOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
content: @Composable (P) -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable (P) -> Unit	لحم دجاجة قابلة للتركيب

movableContentOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
content: @Composable (P1, P2) -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable (P1, P2) -> Unit	لحم دجاجة قابلة للتركيب

movableContentOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
content: @Composable (P1, P2, P3) -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable (P1, P2, P3) -> Unit	لحم دجاجة قابلة للتركيب

movableContentOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

يمكنك تحويل دالة 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]()
            }
        }
    }
}

المَعلمات
content: @Composable (P1, P2, P3, P4) -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable (P1, P2, P3, P4) -> Unit	لحم دجاجة قابلة للتركيب

movableContentWithReceivedrOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
content: @Composable R.() -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable R.() -> Unit	لحم دجاجة قابلة للتركيب

movableContentWithReceivedrOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
content: @Composable R.(P) -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable R.(P) -> Unit	لحم دجاجة قابلة للتركيب

movableContentWithReceivedrOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

المَعلمات
content: @Composable R.(P1, P2) -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable R.(P1, P2) -> Unit	لحم دجاجة قابلة للتركيب

movableContentWithReceivedrOf

رقم الاتصالات

تمت إضافتها في 1.2.0

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

يمكنك تحويل دالة 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]()
            }
        }
    }
}

المَعلمات
content: @Composable R.(P1, P2, P3) -> Unit	دالة lambda المركبة المطلوب تحويلها إلى دالة lambda التي تتبع حالة.

المرتجعات
@Composable R.(P1, P2, P3) -> Unit	لحم دجاجة قابلة للتركيب

mutableDoubleStateOf

رقم الاتصالات

تمت إضافتها في 1.5.0

@StateFactoryMarker
fun mutableDoubleStateOf(value: Double): MutableDoubleState

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

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

المَعلمات
value: Double	القيمة الأولية لـ MutableDoubleState

يمكن أيضًا مراجعة
DoubleState
MutableDoubleState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf

mutableFloatStateOf

رقم الاتصالات

@StateFactoryMarker
fun mutableFloatStateOf(value: Float): MutableFloatState

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

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

المَعلمات
value: Float	القيمة الأولية لـ MutableFloatState

يمكن أيضًا مراجعة
FloatState
MutableFloatState
mutableStateOf
mutableIntStateOf
mutableLongStateOf
mutableDoubleStateOf

mutableIntStateOf

رقم الاتصالات

تمت إضافتها في 1.5.0

@StateFactoryMarker
fun mutableIntStateOf(value: Int): MutableIntState

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

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

المَعلمات
value: Int	القيمة الأولية لـ MutableIntState

يمكن أيضًا مراجعة
IntState
MutableIntState
mutableStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

mutableLongStateOf

رقم الاتصالات

تمت إضافتها في 1.5.0

@StateFactoryMarker
fun mutableLongStateOf(value: Long): MutableLongState

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

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

المَعلمات
value: Long	القيمة الأولية لـ MutableLongState

يمكن أيضًا مراجعة
LongState
MutableLongState
mutableStateOf
mutableIntStateOf
mutableFloatStateOf
mutableDoubleStateOf

mutableStateListOf

رقم الاتصالات

تمت إضافتها في 1.0.0

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

يمكن أيضًا مراجعة
mutableStateOf
mutableListOf
MutableList
takeSnapshot

mutableStateListOf

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

يمكن أيضًا مراجعة
mutableStateOf
mutableListOf
MutableList
takeSnapshot

mutableStateMapOf

رقم الاتصالات

تمت إضافتها في 1.0.0

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

يمكن أيضًا مراجعة
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

mutableStateMapOf

رقم الاتصالات

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

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

يمكن أيضًا مراجعة
mutableStateOf
mutableMapOf
MutableMap
takeSnapshot

حالة متغيّرة

رقم الاتصالات

تمت إضافتها في 1.0.0

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

المَعلمات
value: T	القيمة الأولية لـ MutableState
policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy()	تتحكّم هذه السياسة في كيفية التعامل مع التغييرات في اللقطات القابلة للتغيير.

يمكن أيضًا مراجعة
State
MutableState
SnapshotMutationPolicy
mutableIntStateOf
mutableLongStateOf
mutableFloatStateOf
mutableDoubleStateOf

notEqualPolicy

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

productState

رقم الاتصالات

تمت إضافتها في 1.0.0

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

productState

رقم الاتصالات

تمت إضافتها في 1.0.0

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

productState

رقم الاتصالات

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

productState

رقم الاتصالات

تمت إضافتها في 1.0.0

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

productState

رقم الاتصالات

تمت إضافتها في 1.0.0

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

SignentialEqualityPolicy

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

تذكُّر

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

تذكُّر

رقم الاتصالات

تمت إضافتها في 1.0.0

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

تذكُّر

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

تذكُّر

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

تذكُّر تركيب المحتوى

رقم الاتصالات

تمت إضافتها في 1.0.0

@Composable
fun rememberCompositionContext(): CompositionContext

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

يتذكرCoroutineScope

رقم الاتصالات

@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 تعذّر تطبيق الإجراء عليها باستثناء ذي صلة ولن تتمكّن من إطلاق مهام فرعية.

تذكير محدّث

رقم الاتصالات

تمت إضافتها في 1.0.0

@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، يمكن لوظيفة قابلة للإنشاء تعديل هذه العمليات الجارية.

لقطةFlow

رقم الاتصالات

تمت إضافتها في 1.0.0

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 بصفتها أحداثًا، ولكن لا يمكن وضع نموذج فعّال للأحداث على أنّها حالة يمكن رصدها. الحالة القابلة للملاحظة هي ضغط معقد للأحداث التي أدت إلى تلك الحالة.

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

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

sourceInformation

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

sourceInformationMarkerEnd

رقم الاتصالات

تمت إضافتها في 1.0.0

@ComposeCompilerApi
fun sourceInformationMarkerEnd(composer: Composer): Unit

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

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

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

sourceInformationMarkerStart

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

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

موقع staticالتركيبLocalOf

رقم الاتصالات

تمت إضافتها في 1.0.0

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 ولكن لا يمكن إعادة تقديمه.

المَعلمات
defaultFactory: () -> T	مصنع قيمة لتقديم قيمة عند عدم توفر قيمة. يتم استدعاء هذا المصنع في حال عدم تقديم أي قيمة من خلال CompositionLocalProvider من المتصل الخاص بالمكوِّن باستخدام CompositionLocal.current. إذا لم يكن من الممكن تقديم خطأ افتراضي معقول، يمكنك عندئذٍ تقديم استثناء.

يمكن أيضًا مراجعة
CompositionLocal
compositionLocalOf

سياسة المساواة الهيكلية

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

traceEventEnd

رقم الاتصالات

تمت إضافتها في 1.2.0

@ComposeCompilerApi
fun traceEventEnd(): Unit

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

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

traceEventStart

رقم الاتصالات

تمت إضافتها في 1.2.0

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

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

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

المَعلمات
dirty1: Int	البيانات الوصفية $dirty: الإعدادات الإجبارية ومَعلمات الدالة 1..10 في حال توفّرها
dirty2: Int	بيانات $dirty2 الوصفية: إعادة التركيب الإجباري ومعلمات الدالة 11..20 إن كانت موجودة

withFrameMillis

رقم الاتصالات

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

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

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

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

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

withFrameNanos

رقم الاتصالات

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

وظائف الإضافات

asDoubleState

رقم الاتصالات

تمت إضافتها في 1.5.0

fun State<Double>.asDoubleState(): DoubleState

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

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

asFloatState

رقم الاتصالات

تمت إضافتها في 1.5.0

fun State<Float>.asFloatState(): FloatState

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

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

asIntState

رقم الاتصالات

تمت إضافتها في 1.5.0

fun State<Int>.asIntState(): IntState

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

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

asLongState

رقم الاتصالات

تمت إضافتها في 1.5.0

fun State<Long>.asLongState(): LongState

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

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

ذاكرة التخزين المؤقت

رقم الاتصالات

تمت إضافتها في 1.0.0

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

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

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

collectionAsState

رقم الاتصالات

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

المَعلمات
context: CoroutineContext = EmptyCoroutineContext	CoroutineContext للاستخدام في جمع الصور

collectionAsState

رقم الاتصالات

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

المَعلمات
context: CoroutineContext = EmptyCoroutineContext	CoroutineContext للاستخدام في جمع الصور

الحصول على القيمة

رقم الاتصالات

تمت إضافتها في 1.5.0

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.

الحصول على القيمة

رقم الاتصالات

تمت إضافتها في 1.5.0

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

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

الحصول على القيمة

رقم الاتصالات

تمت إضافتها في 1.5.0

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

setValue

رقم الاتصالات

تمت إضافتها في 1.5.0

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

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

setValue

رقم الاتصالات

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

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

setValue

رقم الاتصالات

تمت إضافتها في 1.5.0

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

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

setValue

رقم الاتصالات

تمت إضافتها في 1.5.0

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

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

setValue

رقم الاتصالات

تمت إضافتها في 1.0.0

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

toMutableStateList

رقم الاتصالات

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

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

toMutableStatemap

رقم الاتصالات

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

يمكنك إنشاء مثيل لـ MutableMap<k, v=""> من مجموعة من الأزواج التي يمكن ملاحظتها ويمكن أخذها في اللقطة.</k,>

withFrameMillis

رقم الاتصالات

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

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

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

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

مواقع المستوى الأعلى

إطار تلقائي MonotonicFrameClock

Cmn android

val DefaultMonotonicFrameClock: MonotonicFrameClock

تم إيقاف هذه السمة نهائيًا.
لا تنطبق MonotonicFrameClocks على جميع الأنظمة الأساسية. استخدِم ساعة محلية مناسبة.

يتم استخدام MonotonicFrameClock من قِبل withFrameNanos وwithFrameMillis إذا لم يكن أحدهما مدرجًا في المكالمة kotlin.coroutines.CoroutineContext.

لم تعُد هذه القيمة مستخدَمة في وقت تشغيل الإنشاء.

ملحن حالي

رقم الاتصالات

تمت إضافتها في 1.0.0

val currentComposer: Composer

TODO(lmr): تقديم وثائق

قيمة الحالية المركّبة لمفاتيح التجزئة

رقم الاتصالات

تمت إضافتها في 1.0.0

val currentCompositeKeyHash: Int

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

من المحتمل أن تكون هذه القيمة فريدة ولكن لا يمكن ضمان توفّرها. هناك حالات معروفة، مثل التكرارات الحلقية التي لا تحتوي على key، والتي لا يتضمّن وقت التشغيل معلومات كافية لجعل تجزئة المفتاح المركّب فريدة من نوعها.

الْمُوَاصَلَةُ الْحَالِيَّة لِحَالَةِ الْمُسْتَجِدَّاتْ

رقم الاتصالات

تمت إضافتها في 1.1.0

val currentCompositionLocalContext: CompositionLocalContext

لعرض قيمة CompositionLocalContext الحالية التي تشتمل على كل قيم CompositionLocal ضمن المقطوعة الموسيقية الحالية وقيمها التي تم توفيرها من خلال قيم CompositionLocalProvider. ويمكن استخدام هذا السياق لنقل السكان المحليين إلى مقطوعة موسيقية أخرى عبر CompositionLocalProvider. عادة ما يكون هذا ضروريًا إذا لم تكن مقطوعة أخرى من التركيبة الفرعية الحالية.

التنسيق الحالي لإعادة إنشاء النطاق

رقم الاتصالات

تمت إضافتها في 1.0.0

val currentRecomposeScope: RecomposeScope

تعرض كائنًا يمكن استخدامه لإلغاء صلاحية النطاق الحالي في هذه النقطة من التركيبة. يمكن استخدام هذا الكائن لإجراء عمليات إعادة التركيب يدويًا.

خصائص الإضافات

ساعة بإطار أحادي

رقم الاتصالات

تمت إضافتها في 1.0.0

@ExperimentalComposeApi
val CoroutineContext.monotonicFrameClock: MonotonicFrameClock

تعرض MonotonicFrameClock الخاصة بـ CoroutineContext هذه أو تعرض IllegalStateException في حال عدم توفّرها.

إعادة إنشاءCoroutineContext

رقم الاتصالات

تمت إضافتها في 1.0.0

@ExperimentalComposeApi
val ControlledComposition.recomposeCoroutineContext: CoroutineContext

مادة عرض CoroutineContext التي يجب استخدامها لإجراء عمليات إعادة تركيب متزامنة لهذه ControlledComposition عند استخدامها في بيئة تدعم المقطوعة الموسيقية المتزامنة.

يمكنك الاطّلاع على Recomposer.runRecomposeConcurrentlyAndApplyChanges كمثال على ضبط مثل هذه البيئة.