Compose Runtime

מבנה

‫Compose הוא שילוב של 7 מזהי קבוצה ב-Maven בתוך androidx. כל קבוצה מכילה קבוצת משנה ממוקדת של פונקציונליות, ולכל אחת מהן יש קבוצה משלה של הערות לגבי הגרסה.

בטבלה הזו מוסברות הקבוצות ויש קישורים לכל קבוצה של הערות מוצר.

הצהרה על יחסי תלות

כדי להוסיף תלות ב-Compose, צריך להוסיף את מאגר Maven של Google לפרויקט. מידע נוסף זמין במאמר בנושא מאגר Maven של Google.

אתם יכולים להוסיף את יחסי התלות של הארטיפקטים שאתם צריכים בקובץ build.gradle של האפליקציה או המודול:

dependencies {
    implementation "androidx.compose.runtime:runtime:1.11.3"
    implementation "androidx.compose.runtime:runtime-livedata:1.11.3"
    implementation "androidx.compose.runtime:runtime-rxjava2:1.11.3"
}

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

dependencies {
    implementation("androidx.compose.runtime:runtime:1.11.3")
    implementation("androidx.compose.runtime:runtime-livedata:1.11.3")
    implementation("androidx.compose.runtime:runtime-rxjava2:1.11.3")
}

android {
    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

מידע נוסף זמין במאמר הוספת יחסי תלות ב-build.

משוב

המשוב שלכם עוזר לנו לשפר את Jetpack. נשמח לדעת אם גיליתם בעיות חדשות או אם יש לכם רעיונות איך לשפר את הספרייה הזו. כדאי לעיין בבעיות הידועות בספרייה הזו לפני שמדווחים על בעיה. כדי להוסיף הצבעה בדיווח על בעיה קיימת, לוחצים על כפתור הכוכב.

יצירת דיווח על בעיה חדשה

מידע נוסף זמין במאמרי העזרה בנושא Issue Tracker.

גרסה 1.12

גרסה ‎1.12.0-beta01

‫17 ביוני 2026

‫androidx.compose.runtime:runtime-*:1.12.0-beta01 מופץ. גרסה ‎1.12.0-beta01 מכילה את השמירות האלה.

תיקוני באגים

• תוקנה בעיה שבה לא נשלחה הודעה למאזינים של החלת תמונת מצב אם אובייקט מצב נוצר בתמונת מצב אחת ואז שונה בתמונת מצב מקבילה לפני שהתמונה הראשונה הוחלה. ‫(Ide27f, b/451479063)
• תוקנה דליפת זיכרון פוטנציאלית באופן שבו מתבצע מעקב אחרי ערכים בהרכבה.derivedStateOf() העברת פעולות כתיבה לאובייקטים שנקראו על ידי מצב נגזר גרמה לשמירת המופע derivedStateOf() על ידי ההרכבה עד שההרכבה בוטלה. אם המערכת לא זוכרת את derivedStateOf() בצורה נכונה, הדליפה הזו יכולה להיות משמעותית כי כל קומפוזיציה עשויה ליצור חדשה. (Ib5d87, ‏ b/516904513)
• תוקנה בעיה ב-LinkComposer שיכולה לגרום לכך שרכיבי composable ידלגו במקום לבצע קומפוזיציה מחדש כשמתבצעת פסילה במהלך הקומפוזיציה. (Ie29fe)
• תוקנה בעיה ב-vararg overload של remember שגרמה לכך שהערך שנשמר לא נפסל, וגרמה להחזרת ערך שגוי מ-remember. השגיאה הזו מתרחשת כשמבצעים קומפוזיציה מחדש של remember עם פחות מפתחות שזהים למפתחות הקודמים, פחות רכיבים מהסוף של המערך. כדי שהתיקון יחול, צריך לקמפל מחדש את הקוד המושפע. (I0736b)

External Contribution

• נוספה מעקב מפורט אחר העבודה של DisposableEffect ו-SideEffect בזמן הריצה של Compose. (Ie451f)

גרסה ‎1.12.0-alpha03

‫19 במאי 2026

‫androidx.compose.runtime:runtime-*:1.12.0-alpha03 מופץ. גרסה ‎1.12.0-alpha03 מכילה את השמירות האלה.

תיקוני באגים

• נפתרו כמה בעיות ב-LinkTable שבהן דוחות הקריסות לאכלוס נתוני אבחון היו ריקים או חסרים מידע (I3918c)
• תוקנה בעיה בסוג נתונים פנימי שיכולה לגרום לחריגה במקרים נדירים עם תוכן שניתן להעברה. (Ic478f, b/507724717)
• תוקנה בעיה בהתנהגות הדילוג של LinkComposer שגרמה להתנהגות לא עקבית בהשוואה ל-GapComposer, לחישוב מחדש לא צפוי של ארגומנטים שמוגדרים כברירת מחדל ולפסק זמן של בדיקות. (I783dc)

גרסה ‎1.12.0-alpha02

‫6 במאי 2026

‫androidx.compose.runtime:runtime-*:1.12.0-alpha02 מופץ. גרסה ‎1.12.0-alpha02 מכילה את השמירות האלה.

שינויים ב-API

• נוספה פונקציית עומס יתר ל-SideEffect שמקבלת ארגומנטים של מפתח. אפשר להשתמש ב-API החדש כדי להפעיל SideEffects חד-פעמי בלי להשתמש ב-LaunchedEffect או ב-DisposableEffect שהבלוקים CoroutineScope או onDispose שלהם לא בשימוש. ‫(I528b2, ‏ b/476108743)

גרסה ‎1.12.0-alpha01

‫22 באפריל 2026

‫androidx.compose.runtime:runtime-*:1.12.0-alpha01 מופץ. גרסה ‎1.12.0-alpha01 מכילה את השמירות האלה.

תיקוני באגים

• תוקנה בעיה ב-LinkTable שיכולה לגרום לפעולות לא תקינות של צומת. (I491c3)
• העדכון של Compose compileSdk ל-API 37. כלומר, כשמשתמשים ב-Compose, נדרשת גרסת AGP מינימלית של 9.2.0. (Id45cd, b/413674743)
• תוקנה בעיה במטמון ב-LinkTable שבה הוספות של תוכן שמפעילות שינוי גודל עלולות לגרום לקריאה של ערכים לא עדכניים, מה שעלול לגרום לכך ש-CompositionLocals לא ייפתרו. (I8016c)
• תוקן באג שגרם לכך ש-T.writableRecord הציג IllegalStateException מיותרים (Ia778f, ‏ b/440975176)

גרסה 1.7 של מעקב בזמן ריצה

גרסה ‎1.7.0-rc01

‫18 בספטמבר 2024

‫androidx.compose.runtime:runtime-tracing:1.7.0-rc01 מופץ. גרסה ‎1.7.0-rc01 מכילה את השמירות האלה.

גרסה 1.0 של Runtime Tracing

גרסה ‎1.0.0-beta01

‫29 בנובמבר 2023

‫androidx.compose.runtime:runtime-tracing:1.0.0-beta01 מופץ. גרסה ‎1.0.0-beta01 מכילה את השמירות האלה.

גרסה ‎1.0.0-alpha05

‫15 בנובמבר 2023

‫androidx.compose.runtime:runtime-tracing:1.0.0-alpha05 מופץ. גרסה ‎1.0.0-alpha05 מכילה את השמירות האלה.

תיקוני באגים

• הצמדת תלויות לגרסאות היציבות הנמוכות ביותר שנתמכות (כלומר compose-runtime ו-tracing-perfetto) – תיקון בעיה שבה compose-runtime-tracing היה מביא גרסה חדשה יותר של compose-runtime לאפליקציה.

גרסה ‎1.0.0-alpha04

‫23 באוגוסט 2023

‫androidx.compose.runtime:runtime-tracing:1.0.0-alpha04 מופץ. גרסה ‎1.0.0-alpha04 מכילה את השמירות האלה.

תכונות חדשות

• תואם לגרסאות העדכניות של Benchmark ו-Tracing Perfetto, ומאפשר תמיכה ב-Composition Tracing בהפעלה של אפליקציה (cold start), למשל ב-AndroidX Benchmark וב-Android Studio (החל מ-Hedgehog Beta 2).

שינויים ב-API

• השם של androidx.tracing.perfetto.Trace שונה ל-androidx.tracing.perfetto.PerfettoSdkTrace. (I44af8)
• התאמה של ממשקי ה-API של Tracing Perfetto SDK ל-android.os.Trace. (I73ba0, ‏ b/282199917)
• דרישות מוקדמות למעקב בזמן הפעלת האפליקציה. (Iad890)
• קבצים של ממשקי API ציבוריים וניסיוניים שמוזגו (I0f2e1, ‏ b/278769092)

גרסה ‎1.0.0-alpha02

‫8 בפברואר 2023

‫androidx.compose.runtime:runtime-tracing:1.0.0-alpha02 מופץ. גרסה ‎1.0.0-alpha02 מכילה את השמירות האלה.

תכונות חדשות

• לא בוצעו שינויים פונקציונליים. בוצעו אופטימיזציות רבות של ביצועים בתלות במורד הזרם androidx.tracing:tracing-perfetto*.

גרסה ‎1.0.0-alpha01

‫7 בספטמבר 2022

‫androidx.compose.runtime:runtime-tracing:1.0.0-alpha01 מופץ. גרסה 1.0.0-alpha01 מכילה את השמירות האלה.

תכונות חדשות

• ‫androidx.compose.runtime:runtime-tracing היא ספרייה שמאפשרת מעקב מורחב באפליקציית Compose – אם יש כלים שתומכים בה (בקרוב). הגרסה הראשונית הזו היא 1.0.0-alpha01.

גרסה 1.11

גרסה 1.11.3

‫17 ביוני 2026

‫androidx.compose.runtime:runtime-*:1.11.3 מופץ. גרסה 1.11.3 מכילה את השמירות האלה.

גרסה 1.11.2

‫19 במאי 2026

‫androidx.compose.runtime:runtime-*:1.11.2 מופץ. גרסה 1.11.2 מכילה את השמירות האלה.

תיקוני באגים

• תוקנה בעיה בסוג נתונים פנימי שיכולה לגרום לחריגה במקרים נדירים עם תוכן שניתן להעברה. (Ic478f, b/507724717)

גרסה 1.11.1

‫6 במאי 2026

‫androidx.compose.runtime:runtime-*:1.11.1 מופץ. גרסה 1.11.1 מכילה את השמירות האלה.

גרסה 1.11.0

‫22 באפריל 2026

‫androidx.compose.runtime:runtime-*:1.11.0 מופץ. גרסה 1.11.0 מכילה את השמירות האלה.

שינויים חשובים מאז גרסה 1.10.0:

New Experimental SlotTable

• כתבנו מחדש את SlotTable, שהוא מבנה הנתונים הפנימי שמשמש את זמן הריצה של Compose כדי לעקוב אחר היררכיית הקומפוזיציה, לקבוע את השינויים שנגרמים על ידי רה-קומפוזיציה ולאחסן ערכים שנשמרו. השינוי הזה מתמקד בשיפור הביצועים של ההרכבה מחדש, והוא עושה זאת בעיקר באמצעות שימוש בפחות פעולות של העתקת נתונים לזיכרון בהשוואה למאגר הנתונים הזמני SlotTable. שינויים מסוימים בהיררכיית הקומפוזיציה, כמו סידור מחדש של רשימה ארוכה של פריטים, יכולים להרכיב מחדש את הקומפוזיציה במהירות כפולה בהשוואה לגרסה הקודמת SlotTable. רוב הפעולות האחרות מהירות יותר ב-10% בערך בהרכבה מחדש בהטמעה החדשה של SlotTable. ההטמעה של SlotTable שבה נעשה שימוש בסביבת זמן הריצה משפיעה על כל השיטות של Composable ולא נדרשת קומפילציה מחדש. השימוש ב-SlotTable החדש הוא שינוי שחל על כל האפליקציה, כולל על יחסי תלות.
• ההטמעה הזו של SlotTable עדיין ניסיונית ומושבתת כרגע כברירת מחדל. כדי להפעיל את ההגדרה הזו, צריך להגדיר את ComposeRuntimeFlags.isLinkBufferComposerEnabled לערך true. בגרסאות build של אפליקציות עם הפעלה של מזעור, הערך הזה מוגדר כ-false כברירת מחדל בקובץ proguard-rules.pro שמסופק עם זמן הריצה. כדי להפעיל את התכונה החדשה SlotTable בסביבת הייצור, צריך לשנות את ההנחה הזו ל-true בקובץ proguard-rules.pro של האפליקציה. מידע נוסף זמין במאמרי העזרה בנושא ComposeRuntimeFlags.isLinkBufferComposerEnabled.

הגדרות ברירת מחדל של המארח להרכבת לוקאלים

• נוסף compositionLocalWithHostDefaultOf שמאפשר להגדיר CompositionLocals שמוגדרים כברירת מחדל לסביבת האירוח (למשל תגי Android View).

תצפית יעילה יותר באמצעות snapshotFlow SnapshotFlowManager

• השקנו את SnapshotFlowManager API כדי לאפשר תצפיות יעילות יותר על snapshotFlow. שימוש חוזר באותו SnapshotFlowManager לכמה מקרים של snapshotFlow יגרום לרישום של פחות משקיפים של החלת תמונת מצב, ולעיבוד מהיר יותר של עדכוני מצב.

גרסה ‎1.11.0-rc01

‫8 באפריל 2026

‫androidx.compose.runtime:runtime-*:1.11.0-rc01 מופץ. גרסה ‎1.11.0-rc01 מכילה את השמירות האלה.

גרסה ‎1.11.0-beta02

‫25 במרץ 2026

‫androidx.compose.runtime:runtime-*:1.11.0-beta02 מופץ. גרסה ‎1.11.0-beta02 מכילה את השמירות האלה.

תיקוני באגים

• תוקנה בעיה ב-WASM שבה קודי הגיבוב של הזהויות תמיד החזירו 0 (I9d70c)
• תוקנה בעיה שבה יכול להיות שמצב נגזר של רכיב אב לא יבוטל בצורה נכונה כשמשתנים יחסי התלות של מצב נגזר מוטמע (Ia7981, ‏ b/481750019)
• תוקנה בעיה ב-LinkTable שיכולה לגרום לכתיבות לא תקינות אחרי סילוק של קומפוזיציה. (I5c97a)
• תוקנה בעיה ב-LinkTable שיכולה לגרום לכתיבות לא תקינות כשהטבלה משנה את הגודל שלה במהלך פעולת העתקה (Ie7edf)
• תוקנה בעיה ב-LinkTable שבה הערך המאוחסן של צומת (I58a4a) מתעדכן באופן שגוי
• הקיבולת של LinkTable עכשיו קטנה יותר, כדי למנוע שגיאות OOM כשיוצרים הרבה קומפוזיציות משנה במכשירים עם גודל ערימה קטן יותר (I112b9)

גרסה ‎1.11.0-beta01

‫11 במרץ 2026

‫androidx.compose.runtime:runtime-*:1.11.0-beta01 מופץ. גרסה ‎1.11.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• ‫SnapshotFlowManager והעומס של snapshotFlow שמקבל את הפרמטר manager מסומנים עכשיו כניסיוניים (I5c1a5, ‏ b/486077876, ‏ I0de71, ‏ b/486077876)

תיקוני באגים

• תיקון קריסת האפליקציה 'Apply is called on deactivated node' בהרכב שניתן להשהיה (I880c0, ‏ b/484300733)
• תוקנה בעיה ב-LinkTable שיכולה לגרום לArrayIndexOutOfBoundsExceptions או למטא-נתונים להיפגם כשמשתמשים ב-MovableContent. (I8452b)
• תוקנה בעיה ב-LinkTable שמנעה את האכלוס התקין של עקבות אבחון (I59868)
• תוקנה בעיה ב-SlotTable החדש שבה שימוש ב-RememberObservers ב-MovableContent עלול לגרום ללולאת OutOfMemoryError/infinite כשמסירים אותו. (I884e7)

גרסה ‎1.11.0-alpha06

‫25 בפברואר 2026

‫androidx.compose.runtime:runtime-*:1.11.0-alpha06 מופץ. גרסה ‎1.11.0-alpha06 מכילה את השמירות האלה.

גרסה ‎1.11.0-alpha05

‫11 בפברואר 2026

‫androidx.compose.runtime:runtime-*:1.11.0-alpha05 מופץ. גרסה ‎1.11.0-alpha05 מכילה את השמירות האלה.

שינויים ב-API

• ComposeRuntimeFlags.isMovingNestedMovableContentEnabled, feature flag בזמן ריצה, הוסר. (I3ee62, ‏ b/455588848)
• המרנו את HostDefaultKey מ-open class ל-interface. כך אפשר להטמיע במפתחות מנגנוני חיפוש מרובים (כמו ViewTreeHostDefaultKey) בלי להיות מוגבלים על ידי ירושה של מחלקה יחידה, ולשפר את ההרחבה של סביבות אירוח בהתאמה אישית. (I917a2)
• הערכים של HostDefaultProvider ו-LocalHostDefaultProvider הם עכשיו public, כך שסביבות אירוח בהתאמה אישית יכולות להגדיר ערכים ללוקאלים ספציפיים לפלטפורמה. (I5bdbe)

תיקוני באגים

• הוסרה האפשרות של קיפאון (deadlock) כשמריצים שני snapshotFlows בו-זמנית בשני שרשורים. (Ib4339)
• תוקנה בעיה בטבלת הקישורים שיכולה לגרום לכלי להשמיט קומפוזיציות בהיררכיה ולקשר באופן שגוי קומפוזיציות משנה (I7178e)

External Contribution

• תוקנה בעיה של תוצאת Lint חיובית כוזבת כשמשתמשים באופרטור אונרי כדי לשנות את הערך בבלוק produceState (I1c7c9)

גרסה ‎1.11.0-alpha04

‫28 בינואר 2026

‫androidx.compose.runtime:runtime-*:1.11.0-alpha04 מופץ. גרסה ‎1.11.0-alpha04 מכילה את השמירות האלה.

שינויים ב-API.

• כתבנו מחדש את SlotTable, שהוא מבנה הנתונים הפנימי שמשמש את זמן הריצה של Compose כדי לעקוב אחר היררכיית הקומפוזיציה, לקבוע את השינויים שנגרמים על ידי רה-קומפוזיציה ולאחסן ערכים שנשמרו. השינוי הזה מתמקד בשיפור הביצועים של ההרכבה מחדש, והוא עושה זאת בעיקר באמצעות שימוש בפחות פעולות של העתקת נתונים לזיכרון בהשוואה למאגר הנתונים הזמני SlotTable. שינויים מסוימים בהיררכיית הקומפוזיציה, כמו סידור מחדש של רשימה ארוכה של פריטים, יכולים להרכיב מחדש את הקומפוזיציה במהירות כפולה בהשוואה לגרסה הקודמת SlotTable. רוב הפעולות האחרות מהירות יותר ב-10% בערך בהרכבה מחדש בהטמעה החדשה של SlotTable. ההטמעה של SlotTable שבה נעשה שימוש בסביבת זמן הריצה משפיעה על כל השיטות של Composable ולא נדרשת קומפילציה מחדש. השימוש ב-SlotTable החדש הוא שינוי שחל על כל האפליקציה, כולל על יחסי תלות.
• ההטמעה של SlotTable מושבתת כרגע כברירת מחדל, ואפשר להפעיל אותה על ידי הגדרת ComposeRuntimeFlags.isLinkBufferComposerEnabled לערך true.
• בגרסאות build של הפצה שבהן מופעלת מזעור, הערך הזה מוגדר כ-false בקובץ ברירת המחדל proguard-rules.pro שמסופק עם זמן הריצה. כדי להפעיל את SlotTable החדש בסביבת הייצור, צריך לשנות את ההנחה הזו ל-true בקובץ proguard-rules.pro של האפליקציה. מידע נוסף זמין במאמרי העזרה בנושא ComposeRuntimeFlags.isLinkBufferComposerEnabled. ‫(Ib741d, ‏ b/268366116)

תכונות חדשות

• נוסף compositionLocalWithHostDefaultOf שמאפשר להגדיר CompositionLocals שמוגדרות כברירת מחדל לסביבת האירוח (למשל תגי Android View). (I15b81)

תיקוני באגים

• הבטחנו שאי אפשר יהיה להחזיר שיחות של Snapshot.sendApplyNotifications עד שיישלחו ההתראות הנדרשות על הגשת בקשה. (I95f20, b/418800424)
• למנוע הורדה של עקבות מחסנית של מידע על מקור למפתחות קבוצה במקרים שבהם מידע על מקור לא קיים בזמן הריצה. (If3712)
• הצגת ComposeToolingFlags. ההגדרות האלה מיועדות להיות קבועות (בניגוד ל-ComposeRuntimeFlags) והן משמשות לתכונות של כלי פיתוח שיש להן השפעה משמעותית על הביצועים. (I87863)

External Contribution

• ‫API ניסיוני חדש של RecomposerInfo#errorState (I0decc)
• שינוי הערך של ההערה AnnotationRetention של FunctionKeyMeta ל-'BINARY' (I53495)

גרסה ‎1.11.0-alpha03

‫14 בינואר 2026

‫androidx.compose.runtime:runtime-*:1.11.0-alpha03 מופץ. גרסה ‎1.11.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• הצגנו את המחלקה SnapshotFlowManager והוספנו פרמטר אופציונלי SnapshotFlowManager ל-snapshotFlow, כדי לאפשר למשתמשים לבצע אופטימיזציה של מספר הצופים בהחלת תמונת המצב שנרשמים. ‫(I6289b, ‏ b/446746211)

תיקוני באגים

• נוספה הערת מעקב להוספת תוכן שניתן להזזה (Ibf176)

גרסה ‎1.11.0-alpha02

‫17 בדצמבר 2025

‫androidx.compose.runtime:runtime-*:1.11.0-alpha02 מופץ. גרסה ‎1.11.0-alpha02 מכילה את השמירות האלה.

שינויים ב-API

• הדגל isMovableContentUsageTrackingEnabled הוסר (I71e2b, ‏ b/427960130)

External Contribution

• תוקן באג ב-Live Edit שגרם לכך שלא ניתן היה לשחזר את העריכה אחרי שגיאה. (Ieb34f)

גרסה ‎1.11.0-alpha01

‫3 בדצמבר 2025

‫androidx.compose.runtime:runtime-*:1.11.0-alpha01 מופץ. גרסה ‎1.11.0-alpha01 מכילה את השמירות האלה.

שינויים ב-API

• השם של RetainedValuesStore.getExitedValueOrDefault שונה ל-consumeExitedValueOrDefaultc7a0929
• הסרה של API ניסיוני להרכבה מחדש בו-זמנית.(c8af15d)

גרסה 1.10

גרסה 1.10.6

‫25 במרץ 2026

‫androidx.compose.runtime:runtime-*:1.10.6 מופץ. גרסה 1.10.6 מכילה את השמירות האלה.

תיקוני באגים

• פתרון הקריסה 'לא ניתן להשבית שימוש חוזר מהשורש אם היא נגרמה על ידי קבוצות אחרות' בהרכבה שניתן להשהות (I474b5, ‏ b/488433633)
• תיקון קריסת האפליקציה 'Apply is called on deactivated node' בהרכב שניתן להשהיה (I880c0, ‏ b/484300733)

גרסה 1.10.5

‫11 במרץ 2026

‫androidx.compose.runtime:runtime-*:1.10.5 מופץ. גרסה 1.10.5 מכילה את השמירות האלה.

גרסה 1.10.4

‫25 בפברואר 2026

הגרסה androidx.compose.runtime:runtime-*:1.10.4 הושקה ללא שינויים מאז גרסה 1.10.3. גרסה 1.10.4 מכילה את השמירות האלה.

גרסה 1.10.3

‫11 בפברואר 2026

‫androidx.compose.runtime:runtime-*:1.10.3 מופץ. גרסה 1.10.3 מכילה את השמירות האלה.

גרסה 1.10.2

‫28 בינואר 2026

‫androidx.compose.runtime:runtime-*:1.10.2 מופץ. גרסה ‎1.10.2 מכילה את השמירות האלה.

גרסה 1.10.1

‫14 בינואר 2026

‫androidx.compose.runtime:runtime-*:1.10.1 מופץ. גרסה 1.10.1 מכילה את השמירות האלה.

גרסה 1.10.0

‫3 בדצמבר 2025

‫androidx.compose.runtime:runtime-*:1.10.0 מופץ. גרסה ‎1.10.0 מכילה את השמירות האלה.

גרסה ‎1.10.0-rc01

‫19 בנובמבר 2025

‫androidx.compose.runtime:runtime-*:1.10.0-rc01 מופץ. גרסה ‎1.10.0-rc01 מכילה את השמירות האלה.

תיקוני באגים

• הגנה מפני שינוי חוזר כשמבצעים הקלטה של מצבים נגזרים ב-SnapshotStateObserver (I7b862, ‏ b/435655844, ‏ b/456249373, ‏ b/402535073)
• ‫[Lint] תיקון באג קטן שגורם לכלי לזיהוי בעיות להזהיר מפני הקצאת ערך מורכב בצורה תקינה. (I08319, b/456775556)

גרסה ‎1.10.0-beta02

‫5 בנובמבר 2025

‫androidx.compose.runtime:runtime-*:1.10.0-beta02 מופץ. גרסה ‎1.10.0-beta02 מכילה את השמירות האלה.

שינויים ב-API

• ביצענו כמה שינויים שלא תואמים ל-API כדי לפשט את ההתקנה והניהול של RetainedValuesStore. השיחות הקיימות אל retain ו-RetainedEffect לא יושפעו, אבל כדי ש-RetainedValuesStore מותאמים אישית יהיו תואמים לגרסה הזו, יהיה צורך להעביר אותם. (If3c2f, b/451921682, b/450539803)

• ‫RetainedValuesStore כבר לא חושף ממשקי API ברמה נמוכה כדי להתחיל או להפסיק שמירה. מצב השמירה עכשיו עוקב אחרי התוכן באופן אוטומטי. מוצעת לכם עכשיו האפשרות להתקין את LocalRetainedValuesStoreProvider.RetainedValuesStore אין לספק את LocalRetainedValuesStore באופן ישיר. למידע נוסף על השינויים האלה, אפשר לעיין במסמכים ובדוגמאות המעודכנים.

• השם של RetainedValuesStoreProvider השתנה לRetainedValuesStoreRegistry. המחלקה הזו חושפת עכשיו רק ממשקי API להתקנה ולניהול של RetainedValuesStores בקומפוזיציה.

• ‫ControlledRetainedValuesStore הוחלף ב-ManagedRetainedValuesStore.

• RetainedValuesStore הוא עכשיו ממשק.

בעבר, התקנה של RetainedValuesStore בהתאמה אישית הייתה יכולה להיראות כך:

  val retainedValuesStore = retainControlledRetainedValuesStore()
  if (active) {
      CompositionLocalProvider(LocalRetainedValuesStore provides retainedValuesStore) {
          content()
      }

      val composer = currentComposer
      DisposableEffect(retainedValuesStore) {
          val cancellationHandle =
              if (retainedValuesStore.retainExitedValuesRequestsFromSelf > 0) {
                  composer.scheduleFrameEndCallback {
                      retainedValuesStore.stopRetainingExitedValues()
                  }
              } else {
                  null
              }

          onDispose {
              cancellationHandle?.cancel()
              retainedValuesStore.startRetainingExitedValues()
          }
      }
  }

בעקבות השינויים האלה ב-API, אפשר להשתמש בקוד הבא במקום בקוד הקודם כדי לבצע את ההתקנה:

  val retainedValuesStore = retainManagedRetainedValuesStore()
  if (active) {
      LocalRetainedValuesStoreProvider(retainedValuesStore) {
          content()
      }
  }

תיקוני באגים

• העברות ביטולים של ההיקף בתוכן שניתן להעברה לפני העברת התוכן הזה מחוץ לטבלת המשבצות (I9d123, b/451651649)

גרסה ‎1.10.0-beta01

‫22 באוקטובר 2025

‫androidx.compose.runtime:runtime-*:1.10.0-beta01 מופץ. גרסה ‎1.10.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• השם של RetainedValuesStore.getExitedValueOrDefault משתנה ל-RetainedValuesStore.getExitedValueOrElse (If9653, b/452340613)
• השם של isKeepingExitedValues השתנה לisRetainingExitedValues (I660bf, ‏ b/437095756)
• השם של RetainScope שונה ל-RetainedValuesStore. השם של RetainScopeHolder שונה ל-RetainedValuesStoreRegistry. השם של RetainScopeHolder.RetainScopeProvider שונה ל-RetainedValuesStoreRegistry.ProvideChildRetainedValuesStore. (Idf23a, ‏ b/437095756)

תיקוני באגים

• הפעלה מאוחרת של SavedState ב-SaveableStateRegistry עד לשימוש הראשון. (Ic0a93)

גרסה ‎1.10.0-alpha05

‫8 באוקטובר 2025

‫androidx.compose.runtime:runtime-*:1.10.0-alpha05 מופץ. גרסה ‎1.10.0-alpha05 מכילה את השמירות האלה.

תיקוני באגים

• ממלאים את דוח הקריסות של DiagnosticComposeException במצב פרסום. (Ib76cb)
• תוקנה בעיה במצב Snapshot שבה, כשמשתמשים במדיניות מיזוג עבור סוג מסוים, יכול להיות שהערך הקודם יחושב בצורה שגויה, וכתוצאה מכך יוחזר ערך עתידי של המצב במקום הערך הקודם. זה קורה אם יש יותר משני מצבי תמונת מצב שניתנים לשינוי בהמתנה, ולפחות אחד מהערכים שמיושמים כולל מדיניות מיזוג. ‫(I527b5, ‏ b/442791065)

גרסה ‎1.10.0-alpha04

‫24 בספטמבר 2025

‫androidx.compose.runtime:runtime-*:1.10.0-alpha04 מופץ. גרסה ‎1.10.0-alpha04 מכילה את השמירות האלה.

שינויים ב-API

• הוספנו RetainScopeHolder API לניהול אוסף של RetainScopes. אפשר להשתמש בזה כדי להטמיע שמירה של מאגרי תגים ומארחי ניווט שמורכבים מהרבה רכיבי צאצא עם תקופות שמירה שונות. (I10e0f)
• נוספו ממשקי API‏ RetainedContentHost ו-retainControlledRetainScope, שאפשר להשתמש בהם כדי ליצור באופן אוטומטי RetainScopes לתוכן שנעלם, כמו חלוניות שניתן לכווץ (If81f6)
• הפונקציה Updater#set הוצאה משימוש כי היא ביצעה המרה של הערך שסופק יותר מדי פעמים. נוספה עומס יתר של Updater#init שמקבל פרמטר שמונע את הצורך ב-lambda ללכידה. (Id679e)
• הסבר על RetainedEffect, API עם תופעות לוואי שדומה ל-DisposableEffect, אבל פועל לפי מחזור החיים של השמירה ולא לפי מחזור החיים של הקומפוזיציה. ממשק ה-API הזה מיועד לשימוש באפקטים שקשורים לשמירה של אובייקט אחר שלא מטמיע את RetainObserver או שלא יכול להטמיע אותו. (I1c61f, ‏ b/177562901)
• תיקנו את התיעוד של RetainObserver.onRetained והוספנו את RetainObserver.onUnused, שמשקף את RememberObserver.onAbandoned (Ia6fc5)

תיקוני באגים

• תוקן באג שגרם לשליחה של dispatching remember אחרי הקבוצה הראשונה בפונקציה (כמו קריאה של composable) ולפני קבוצה שאפשר להסיר (כמו הצהרת if) שיכולה לשלוח onForgotten בסדר שגוי. (I453f6, b/346821372)
• כדאי להימנע ממעבר בין הקשרים של קורוטינות כשמפעילים את LaunchedEffect. (I8d2c3b)

גרסה ‎1.10.0-alpha03

‫10 בספטמבר 2025

‫androidx.compose.runtime:runtime-*:1.10.0-alpha03 מופץ. גרסה ‎1.10.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• הוספנו אפשרות ליצור עקבות מחסנית (stack traces) שמבוססות על מפתח קבוצה, שפועלות באפליקציות שעברו מיניפיקציה. מיפוי ה-proguard של העקבות האלה ייווצר על ידי הפלאגין של Compose compiler Gradle החל מ-Kotlin 2.3.0. ההתראות האלה מושבתות כברירת מחדל. כדי להפעיל אותן, משתמשים ב-ComposeStackTraceMode.GroupKeys. (Ifbcb5)
• הוספת ממשק: IdentifiableRecomposeScope לכלי (Idd5e0, ‏ b/434194620)
• נמנעו פסילות מיותרות בהרכבות שכוללות CompositionLocalContext (I3fa21, ‏ b/412750209)

תיקוני באגים

• הוספנו הבהרה בתיעוד ובכלי שגם מפתחות שמועברים ל-retain נשמרים. מומלץ להימנע מהעברת מפתחות לשימור שיובילו לדליפת זיכרון. ‫(Ib553b, ‏ b/177562901)
• תוקנה בעיה שבה כשקוראים ל-resume() של קומפוזיציה מושהית ב-thread אחר, יכול להיות שהמצב של ההתראות בהמתנה יתבלבל כש-thread ראשי מנסה להרכיב מחדש את הקומפוזיציה שניתנת להשהיה עבור הפריים הבא. (Ie5f17, ‏ b/442649894)
• תיעוד חריגים שנתפסו ביצירה. (I47d78, ‏ b/432799675, ‏ b/436878515, ‏ b/359623674, ‏ b/400436355)

גרסה ‎1.10.0-alpha02

‫27 באוגוסט 2025

‫androidx.compose.runtime:runtime-*:1.10.0-alpha02 מופץ. גרסה ‎1.10.0-alpha02 מכילה את השמירות האלה.

שינויים ב-API

• הוספנו את @DoNotRetain, שאפשר להשתמש בו כדי להוסיף הערות לסוגים שאסור להשתמש בהם עם retain API, יכול להיות בגלל שהם יגרמו לדליפת משאבים. (Ie5435)
• כדי להשתמש בפרויקטים שפורסמו עם Kotlin 2.0, צריך KGP בגרסה 2.0.0 ומעלה. (Idb6b5)

תיקוני באגים

• תיקנו תוכן שניתן להזזה כדי לחשב נכון את הפעולות ב-Applier כשהתוכן משנה את צומת הבסיס של קומפוזיציה. כשמחשבים שינויים בתוכן שאפשר להעביר, יכול להיות שקריאה ל-up() תישאר בהמתנה ולא תישלח ל-applier, וכתוצאה מכך המיקום של מצב ה-applier יהיה שגוי לכל שימוש עתידי. ‫(I7c583), (I47b70)
• התג CheckResult מסומן כהוצאה משימוש כי הוא לא מיועד לשימוש. (I32934)

גרסה ‎1.10.0-alpha01

‫13 באוגוסט 2025

‫androidx.compose.runtime:runtime-*:1.10.0-alpha01 מופץ. גרסה ‎1.10.0-alpha01 מכילה את השמירות האלה.

שינויים ב-API

• הוספנו את retain API. בדומה ל-rememberSaveable, הפונקציה retain יכולה לשמור ערכים שנזכרו ולשמר אותם גם אחרי שהם יוצאים מהיררכיית ההרכבה. הערכים שנשמרים לא עוברים סריאליזציה, והם תקפים לזמן קצר יותר מהערכים שנשמרים. הם מתנהגים באופן דומה ל-ViewModel של androidx. פרטים נוספים מופיעים במסמכי התיעוד. (Ia3105, ‏ b/177562901)
• נוסף awaitOrScheduleNextCompositionEnd() API, שמנפיק קריאה חוזרת כשהרכיב Recomposer מסיים את ההרכבה של הפריים הנוכחי. אם ה-Recomposer לא יוצר כרגע פריים, ה-API מושהה עד לסיום היצירה של הפריים הבא, ומתזמן יצירה של פריים חדש. (Ib873c)
• הוספת API של ספק מקומי של קומפוזיציה שלא מחזיר יחידה (I22521, ‏ b/271871288)
• נוסף feature flag, isMovableContentUsageTrackingEnabled, שמאפשר לעקוב אחרי השימוש בתוכן שאפשר להזיז כדי להימנע מתקורה מסוימת כשיוצרים את התוכן בפעם הראשונה. התכונה הזו מושבתת כרגע כברירת מחדל. (Ia713d)

תיקוני באגים

• תוקן קריסה בתוכן שאפשר להזיז אותו, כשמזיזים אותו בין קומפוזיציות משנה. (I3fa1e, ‏ b/436858107)
• תוקן באג שגרם לכך שחלק מדוח קריסות של רכיב קומפוזבילי חסר כשהוא נמצא בתוך מספר קומפוזיציות משנה מקוננות. (I98c6f)
• העברת ברירת המחדל של minSdk מ-API 21 ל-API 23 (Ibdfca, ‏ b/380448311, ‏ b/435705964, ‏ b/435705223)
• תוקנה בעיה של מרוץ תהליכים כשסטטוס פנימי של קומפוזיציה שניתן להשהות עודכן מכמה שרשורים. (I03895)
• עדכנו את רכיב ה-observer של רישום הקומפוזיציה כך שהוא יופעל לפני הקומפוזיציה הראשונית. ‫(I4adca, ‏ b/430600932)
• תיקון באג קל כדי להפוך את AutoboxingStateValuePropertyDetector לתואם ל-K1 ול-K2. (Ie81c1)

External Contribution

• הופכים את ארטיפקט runtime-rxjava2 למולטי-פלטפורמה ומוסיפים את JVM כיעד נתמך. (I5409e)
• הופכים את ארטיפקט runtime-rxjava3 למולטי-פלטפורמה ומוסיפים את JVM כיעד נתמך. (I97e84)

גרסה 1.9

גרסה 1.9.5

‫19 בנובמבר 2025

‫androidx.compose.runtime:runtime-*:1.9.5 מופץ. גרסה 1.9.5 מכילה את השמירות האלה.

תיקוני באגים

• העברות ביטולים של ההיקף בתוכן שניתן להעברה לפני העברת התוכן הזה מחוץ לטבלת המשבצות (I9d123, b/451651649)

גרסה 1.9.4

‫22 באוקטובר 2025

‫androidx.compose.runtime:runtime-*:1.9.4 מופץ. גרסה 1.9.4 מכילה את השמירות האלה.

גרסה 1.9.3

‫8 באוקטובר 2025

‫androidx.compose.runtime:runtime-*:1.9.3 מופץ. גרסה 1.9.3 מכילה את השמירות האלה.

גרסה 1.9.2

‫24 בספטמבר 2025

‫androidx.compose.runtime:runtime-*:1.9.2 מופץ. גרסה 1.9.2 מכילה את השמירות האלה.

גרסה 1.9.1

‫10 בספטמבר 2025

‫androidx.compose.runtime:runtime-*:1.9.1 מופץ. גרסה 1.9.1 מכילה את השמירות האלה.

תיקוני באגים

• לא מומלץ להרכיב מחדש יצירות שנמצאות בתהליך של הרכבה. (Iacb01)
• למנוע מצבים שבהם היקפי הכתיבה מחדש מושהים פעמיים. (I060b2, b/431584881)

גרסה 1.9.0

‫13 באוגוסט 2025

‫androidx.compose.runtime:runtime-*:1.9.0 מופץ. גרסה 1.9.0 מכילה את השמירות האלה.

שינויים חשובים מאז גרסה 1.8.0

• בדיקות ה-Lint שמגיעות עם Compose דורשות עכשיו גרסת AGP מינימלית של 8.8.2. אם אין לכם אפשרות לשדרג את AGP, אתם יכולים לשדרג את Lint בנפרד באמצעות android.experimental.lint.version=8.8.2 (או גרסה חדשה יותר) בקובץ gradle.properties. כדי להריץ בדיקות lint של Compose בתוך סביבת הפיתוח המשולבת (IDE), צריך להשתמש ב-Android Studio Ladybug או בגרסה חדשה יותר.
• נוצרה ספרייה חדשה של הערות בזמן ריצה. הספרייה הזו מכילה הגדרות של הערות בלי תלות בזמן הריצה של Compose, כך שאפשר להשתמש בה ממודולים שאינם Compose.
  • האפליקציות @Stable,‏ @Immutable ו-@StableMarker הועברו ל-runtime-annotation, כדי לאפשר הוספת הערות למודולים שאינם Compose
  • ההערות @FrequentlyChangingValue ו-@RememberInComposition נוספו ל-runtime-annotation. הסימן @FrequentlyChangingValue מציין הצהרות שיכולות לגרום להרכבה מחדש לעיתים קרובות, והסימן @RememberInComposition מציין הצהרות שכדאי לזכור בהרכבה. בדיקות ה-lint המתאימות מציגות אזהרה לגבי שימוש לא נכון.

גרסה ‎1.9.0-rc01

‫30 ביולי 2025

‫androidx.compose.runtime:runtime-*:1.9.0-rc01 מופץ. גרסה ‎1.9.0-rc01 מכילה את השמירות האלה.

תיקוני באגים

• עדכנו את רכיב ה-observer של רישום הקומפוזיציה כך שהוא יופעל לפני הקומפוזיציה הראשונית. ‫(I4adca, ‏ b/430600932)

גרסה ‎1.9.0-beta03

‫16 ביולי 2025

‫androidx.compose.runtime:runtime-*:1.9.0-beta03 מופץ. גרסה ‎1.9.0-beta03 מכילה את השמירות האלה.

גרסה ‎1.9.0-beta02

‫2 ביולי 2025

‫androidx.compose.runtime:runtime-*:1.9.0-beta02 מופץ. גרסה ‎1.9.0-beta02 מכילה את השמירות האלה.

תיקוני באגים

• הפחתנו את משך החיים של הפניות לערכים בטבלת המשבצות בין קומפוזיציות. יש מקרים שבהם הפניה בטבלת המשבצות יכולה להימשך פריים אחד יותר מהנדרש. (I49e74, b/418516940)
• הסרת שינוי השם של Kotlin ל-Hot Reload של שיטות. ‫(Ic56a3, ‏ b/426871325)

גרסה ‎1.9.0-beta01

‫18 ביוני 2025

‫androidx.compose.runtime:runtime-*:1.9.0-beta01 מופץ. גרסה ‎1.9.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• נוסף API של כלי לניתוח מידע על מקור שנוסף על ידי מהדר Compose. ‫(Iceaf9, ‏ b/408492167)
• SnapshotStateSet מטמיע עכשיו את Parcelable ב-Android, ולכן אפשר להשתמש בו כחלק מ-rememberSaveable { ... }. (I755dd, b/378623803)
• ‫SnapshotStateList מטמיע עכשיו את Parcelable ב-Android, ולכן אפשר להשתמש בו כחלק מ-rememberSaveable { ... }. ‫(Id18be, ‏ b/378623803)
• ‫movableContentOf() מסומן עכשיו בהערה @RememberInComposition, שמאפשרת ל-lint לזהות שימושים שגויים (I2738d)
• ה-API הניסיוני של כלי המעקב אחר קומפוזיציה עודכן כדי לאפשר מעקב מקיף יותר אחר הסיבות לרה-קומפוזיציה (I32b6a)
• כדי להתכונן לפיתוח עתידי של התכונה הזו, צריך לשנות את הערך setDiagnosticStackTraceEnabled ל-experimental. (I11db3)
• המאפיין currentCompositeKeyHash הוצא משימוש. במקומה צריך להשתמש במדיניות currentCompositeKeyHashCode. ה-API החלופי מקודד את אותו הגיבוב עם יותר ביטים, מה שמקטין באופן משמעותי את הסיכוי שלשתי קבוצות אקראיות לא קשורות בהיררכיית הקומפוזיציה יהיה אותו מפתח גיבוב. (I4cb6a, b/177562901)
• כדי להשתמש בפרויקטים שפורסמו עם Kotlin 2.0, צריך KGP 2.0.0 או גרסה חדשה יותר (Idb6b5)
• האפליקציות @Stable,‏ @Immutable ו-@StableMarker הועברו ל-runtime-annotation (באופן תואם). עכשיו אפשר להסתמך על runtime-annotation אם רוצים להשתמש באנוטציות האלה מספרייה שלא תלויה ב-Compose. (I23a16)
• השם של העומס היתר rememberSaveable שמשתמש ב-KSerializer שונה ל-rememberSerializable. השינוי הזה מבהיר את השימוש המיועד ב-kotlinx.serialization. תמיכה במחלקות כלליות של kotlinx.Serializable ישירות ב-rememberSaveable תדרוש פרמטר מסוג reified, שיגרום לבעיות תאימות למקור כי הוא ידרוש מכל אתרי הקריאה לספק מידע על סוגים מוחשיים בזמן ההידור. (Idb875, ‏ I38627, ‏ b/376028110)

תיקוני באגים

• צריך להשמיד קומפוזיציות שהוגדרו עם תוכן שאפשר להשהות ושבוטל. הקומפוזיציה בודקת את זה עכשיו, ואם נעשה שימוש חוזר, היא תקפיץ הודעת שגיאה. ‫(I2daa5, b/406792785)
• תוקנה קומפוזיציה שניתן להשהות, כך שהיא לא שולחת יותר onForgotten מזויף כדי לזכור צופים כשהקומפוזיציה שניתן להשהות מושמדת. אם RememberObservers נמצא בהרכב שניתן להשהיה ובוטל, צריך לשלוח לו רק onAbandoned. (I26f54)
• תוקנה בעיה בתוכן שניתן להזזה, שבה פסילות שמגיעות בשלבים מאוחרים של עיבוד תוכן שניתן להזזה מתווספות לכלי ההלחנה, אבל הפסילות האלה לא מתעדכנות כשהתוכן מוזז, ולכן התוכן מורכב מחדש במקום הלא נכון. (Icd2fa, b/409439507)
• תוקנה הבעיה שבה תוכן שאפשר להעביר נפסל אחרי שהוא נוצר אבל לפני שהוא הועבר. (I99eac, ‏ b/229001114)
• קריאה ל-remove() של איטרטור רשימה שנוצר על ידי SnapshotStateList אחרי קריאה ל-previous() עלולה להסיר את הרכיב הלא נכון מהרשימה, ולא תהיה התאמה למה ש-ArrayList עושה עבור אותה רצף של קריאות. (I05ab7, b/417493222)
• תוקנה בעיה בסדר השליחה של onForgotton, שיכולה לגרום, למשל, להפעלה של onDispose של אפקטים חד-פעמיים בסדר שגוי. ‫(Ic1c91, ‏ b/417450712)
• תיקון לשימוש חוזר בטיפול במצבים בהרכבה שניתן להשהות (Ife96e, ‏ b/404058957)
• תוקן באג שקשור לשימוש חוזר במצב כשקומפוזיציה הושהתה והופעלה מחדש, אבל היה צורך לבצע קומפוזיציה מחדש של מצב שהושהה קודם לכן כי מצב מסוים שהיא קראה השתנה בזמן שהקומפוזיציה הושהתה. (I441d1, b/416209738)
• הושלם התיקון של בעיה b/404058957 שקשורה לשליחת הודעות שניתן להשהות את ההרכבה שלהן. התיקון הקודם היה חלקי. (I1afd4, b/404058957)
• ‫OffsetApplier מחליף עכשיו בצורה נכונה את apply(), שהוצג עם האפשרות להשהות את ההרכבה. אם לא תהיה לכם האפשרות הזו, יכול להיות שעדכון של צמתים וירטואליים יגרום לקומפוזיציה שניתן להשהות להקפיץ הודעת שגיאה (throw). (Idbf31, b/409291131)
• תוקן מצב של קיפאון שיכול להשפיע על משתמשי Molecule כששיחה מושעית ל-FrameClock.withFrameNanos מבוטלת בזמן שפריים נשלח. (I89cab, b/407027032)
• הכלי לשינוי פריסה יכול לעבור למצב בלי פעילות עם תוכן שאפשר להזיז (Ie5416, ‏ b/409267170)
• הסדר שבו onReuse ו-onDeactivate יכולים להתהפך במהלך קומפוזיציה שניתן להשהות. הם מתרחשים עכשיו בוודאות לפי הסדר של onDeactivate/onReuse. (I996e4, b/404058957)
• תיקון השליחה של observers שזוכרים בהרכב שניתן להשהיה כדי למנוע שליחה של remembered/forgotten באותו apply (‏I570b2, ‏ b/404645679, ‏ b/407931790)
• החלפנו את LifecycleRegistry למצב לא בטוח ב-Compose Multiplatform כדי להשבית את הבדיקות של MainThread ולפתור בעיות שקשורות לשרשורים. פרטים נוספים מופיעים במאמר CMP-8227. (Icee87)

External Contribution

• תוקן באג שמשפיע על משתמשי Molecule, שבו שימוש ב-RecompositionMode.Immediate עלול לגרום להחמצת קומפוזיציות מחדש. (I9f3a9, b/419527812)
• הוספנו את הפונקציות PausableComposition isApplied ו-isCancelled לקבלת נתונים, שמאפשרות לבדוק את המצב של PausableComposition. (I994aa)
• ההערה AnnotationTarget.FUNCTION נוספה להערה FunctionKeyMeta. (I08021)

גרסה ‎1.9.0-alpha04

‫4 ביוני 2025

‫androidx.compose.runtime:runtime-*:1.9.0-alpha04 מופץ. גרסה ‎1.9.0-alpha04 מכילה את השמירות האלה.

שינויים ב-API

• ‫SnapshotStateSet תומך עכשיו ב-Parcelable ב-Android, ולכן אפשר להשתמש בו כחלק מ-rememberSaveable { ... }. (I755dd, b/378623803)
• ‫SnapshotStateList תומך עכשיו ב-Parcelable ב-Android, ולכן אפשר להשתמש בו כחלק מ-rememberSaveable { ... }. ‫(Id18be, ‏ b/378623803)
• ‫movableContentOf() מסומן עכשיו בהערה @RememberInComposition, שמאפשרת ל-lint לזהות שימושים שגויים (I2738d)
• ה-API הניסיוני של כלי המעקב אחר קומפוזיציה עודכן כדי לאפשר מעקב מקיף יותר אחר הסיבות לרה-קומפוזיציה (I32b6a)

תיקוני באגים

• תוקנה בעיה בסדר השליחה של onForgotton, שיכולה לגרום, למשל, להפעלה של onDispose של אפקטים חד-פעמיים בסדר שגוי. ‫(Ic1c91, ‏ b/417450712)
• תיקון לשימוש חוזר בטיפול במצבים בהרכבה שניתן להשהות (Ife96e, ‏ b/404058957)
• תיקון באג קטן כדי להפוך את זיהוי אוספים שניתנים לשינוי לתואם ל-K1 ול-K2 (Ie4878)
• תיקון באג קל כדי להפוך את החיפוש של הערות בגישה למאפיינים שהוגדרו מחדש לתואם גם ל-K1 וגם ל-K2 (I9900d)

External Contribution

• תוקן באג שמשפיע על משתמשי Molecule, שבו שימוש ב-RecompositionMode.Immediate עלול לגרום להחמצת קומפוזיציות מחדש. (I9f3a9, b/419527812)
• הוספנו את ה-getters‏ PausableComposition isApplied ו-isCancelled שמאפשרים לבדוק את המצב של PausableComposition. (I994aa)

גרסה ‎1.9.0-alpha03

‫20 במאי 2025

‫androidx.compose.runtime:runtime-*:1.9.0-alpha03 מופץ. גרסה ‎1.9.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• כדי להתכונן לפיתוח עתידי של התכונה הזו, צריך לשנות את הערך setDiagnosticStackTraceEnabled ל-experimental. (I11db3)

תיקוני באגים

• תוקן באג שקשור לשימוש חוזר במצב כשקומפוזיציה הושהתה והופעלה מחדש, אבל היה צורך לבצע קומפוזיציה מחדש של מצב שהושהה קודם לכן כי מצב מסוים שהיא קראה השתנה בזמן שהקומפוזיציה הושהתה. (I441d1, b/416209738)
• הושלם התיקון של הבעיה b/404058957 בנוגע לשליחה של הודעות שאפשר להשהות את הכתיבה שלהן. התיקון הקודם היה חלקי. (I1afd4, b/404058957)
• ‫SaveableStateHolder.SaveableStateProvider מספקת עכשיו LocalSavedStateRegistryOwner לתוכן שלה באמצעות קומפוזיציה. (Ia2761, ‏ b/413108878)
• ‫androidx.compose.runtime.saveable תלוי עכשיו ב-androidx.lifecycle.runtime.compose. (I53228, b/413108878)

גרסה ‎1.9.0-alpha02

‫7 במאי 2025

‫androidx.compose.runtime:runtime-*:1.9.0-alpha02 מופץ. גרסה ‎1.9.0-alpha02 מכילה את השמירות האלה.

שינויים ב-API

• הוצאה משימוש של rememberSaveable עם 'מפתח' מותאם אישית. הוא עוקף את הגדרת ההיקף לפי מיקום, מה שמוביל לבאגים במצב ולהתנהגות לא עקבית (למשל, שיתוף או אובדן מצב לא מכוון, בעיות ב-LazyLayouts מוטמע). כדי להשתמש בהגדרת היקף לפי מיקום למצב עקבי עם היקף מקומי, צריך להסיר את הפרמטר key. פרטים נוספים זמינים בהודעת המסירה המלאה. (I5e6ff, ‏ b/357685851)

תיקוני באגים

• ‫OffsetApplier מחליף עכשיו בצורה נכונה את apply(), שהוצג עם האפשרות להשהות את ההרכבה. אם לא תהיה לכם גישה ל-API הזה, יכול להיות שעדכון של צמתים וירטואליים יגרום לקומפוזיציה שניתנת להשהיה להקפיץ הודעת שגיאה. (Idbf31, b/409291131)
• תוקן מצב של קיפאון שיכול להשפיע על משתמשי Molecule כששיחה מושעית ל-FrameClock.withFrameNanos מבוטלת בזמן שפריים נשלח. (I89cab, b/407027032)
• יכול להיות שהרכיב Recomposer יישאר במצב בלי פעילות עם תוכן שאפשר להעביר, עד שיבוטל. בדרך כלל זה לא קורה כי מצב התוכן הניתן להזזה נמחק בלולאה הראשית של Recomposer. עם זאת, זה יכול לקרות בקומפוזיציה שאפשר להשהות אם התוכן הניתן להזזה נמחק במהלך resume()(Ie5416, b/409267170)
• הסדר שבו onReuse ו-onDeactivate יכולים להתהפך במהלך קומפוזיציה שניתן להשהות. עכשיו מובטח שהם יתרחשו בסדר הבא: onDeactivate/onReuse. ‫(I996e4, ‏ b/404058957)

גרסה ‎1.9.0-alpha01

‫23 באפריל 2025

‫androidx.compose.runtime:runtime-*:1.9.0-alpha01 מופץ. גרסה ‎1.9.0-alpha01 מכילה את השמירות האלה.

שינויים בהתנהגות

• בדיקות ה-Lint שמגיעות עם Compose דורשות עכשיו גרסת AGP מינימלית של 8.8.2. אם אין לכם אפשרות לשדרג את AGP, אתם יכולים לשדרג את Lint בנפרד באמצעות android.experimental.lint.version=8.8.2 (או גרסה חדשה יותר) בקובץ gradle.properties. כדי להריץ בדיקות lint של Compose בתוך סביבת הפיתוח המשולבת (IDE), צריך להשתמש ב-Android Studio Ladybug או בגרסה חדשה יותר.

שינויים ב-API

• המאפיין currentCompositeKeyHash הוצא משימוש. במקומה צריך להשתמש במדיניות currentCompositeKeyHashCode. ה-API החלופי מקודד את אותו הגיבוב עם יותר ביטים, מה שמקטין באופן משמעותי את הסיכוי שלשתי קבוצות אקראיות לא קשורות בהיררכיית הקומפוזיציה יהיה אותו מפתח גיבוב. (I4cb6a, b/177562901)
• כדי להשתמש בפרויקטים שפורסמו עם Kotlin 2.0, צריך KGP 2.0.0 או גרסה חדשה יותר (Idb6b5)
• האפליקציות @Stable,‏ @Immutable ו-@StableMarker הועברו ל-runtime-annotation (באופן תואם). עכשיו אפשר להסתמך על runtime-annotation אם רוצים להשתמש באנוטציות האלה מספרייה שלא תלויה ב-Compose. (I23a16)
• הוסרו onCreating ו-onDisposing כי הם הוצאו משימוש ושמם שונה ל-onPreCreate ו-onPreDispose. השינוי הזה משלים את שינוי השם. (I97461)
• הוספת לוקאל של קומפוזיציה שמאפשר לצרף מעקב אחר מחסנית (stack trace) של קומפוזיציה על סמך מיקום של צומת קומפוזיציה בקומפוזיציה. (Ie0bda, ‏ b/354163858)
• הוספנו עקבות מחסנית של אבחון Compose על סמך מידע המקור שמאוחסן בקומפוזיציה. ‫(I3db9f, ‏ b/354163858)
• הוצאנו משימוש את runWithTimingDisabled לטובת runWithMeasurementDisabled, שמתאר בצורה ברורה יותר את ההתנהגות – כל המדדים מושהים. בנוסף, צריך לחשוף את מחלקת העל MicrobenchmarkScope כי אי אפשר להצהיר מחדש על הפונקציה runWithMeasurementDisabled כדי לפתוח גישה, כי היא מוטמעת. (I9e23b, ‏ b/389149423, ‏ b/149979716)
• הוספה של @FrequentlyChangingValue: הערה שיכולה לסמן פונקציות ושיטות לקבלת מאפיינים, כדי לציין שאסור לקרוא להן ישירות בתוך קומפוזיציה, כי זה עלול לגרום לקומפוזיציות חוזרות לעיתים קרובות. לדוגמה, כדי לסמן ערכים של מיקום גלילה וערכים של אנימציה. האזהרות מגיעות מבדיקת lint תואמת. ‫(I83630, ‏ b/234042500)
• מוסיפה @RememberInComposition: הערה שיכולה לסמן בנאים, פונקציות ושיטות גישה למאפיינים, כדי לציין שאסור לקרוא להם ישירות בתוך קומפוזיציה, בלי לזכור אותם. השגיאות יופיעו בבדיקת ה-lint המתאימה. אפשר להשתמש בהערה הזו כדי לסמן הצהרות שמחזירות אובייקטים עם מצב או אובייקטים שניתנים לשינוי, אובייקטים שהזהות שלהם חשובה לשמירה בין קומפוזיציות או אובייקטים שדורשים משאבים רבים ליצירת מופע שלהם וכדאי לשמור אותם במטמון בין קומפוזיציות. (Ie7db0)
• נוספה rememberSaveable עומס יתר חדש שתומך ב-KSerializer לצורך שמירת מצב בטוחה לסוג באמצעות KotlinX Serialization. ה-API הקיים שמבוסס על Saver עדיין נתמך. ‫(Iea4ab, ‏ b/376028110)

תיקוני באגים

• תיקון השליחה של observers שזוכרים בהרכב שניתן להשהיה כדי למנוע שליחה של remembered/forgotten באותו apply (‏I570b2, ‏ b/404645679, ‏ b/407931790)
• שינינו את השם של השיטות SnapshotObserver onCreating ל-onPreCreate ואת onDisposing ל-onPreDispose כדי להתאים להנחיות בנושא API. השיטות הקודמות הוצאו משימוש, והשיטות החדשות מוגדרות כברירת מחדל להפעלת השיטות הישנות, כך שהטמעות קיימות של הממשק הזה ימשיכו לפעול עד שהשיטות יוסרו. ה-methods האלה יוסרו בגרסה 1.9.0 אלפא ב-CL שיפורסם בקרוב אחרי זה. הם יוסרו מגרסת בטא 1.8 לפני גרסה יציבה 1.8. (I6d753)
• תוקנה בעיה שבה ערכים שנשמרו נשכחו בטעות וחושבו מחדש כשנוצרה מחדש קבוצה שהושמטה והופיעה אחרי קבוצה שאפשר להזיז (I62cab, b/383769314)
• הוספנו תמיכה בכתיבת עקבות מחסנית ב-LaunchedEffect וב-rememberCoroutineScope (I705c0, ‏ b/354163858)
• כדי להריץ בדיקות lint ב-Compose, צריך עכשיו גרסת AGP מינימלית של 8.8.2 משורת הפקודה, ולפחות Android Studio Ladybug לתמיכה ב-IDE. אם אתם משתמשים בגרסה ישנה יותר של AGP, אתם יכולים להגדיר את android.experimental.lint.version=8.8.2 ב-gradle.properties כדי לשדרג את גרסת Lint בלי להשפיע על AGP. (I6f2a8)

External Contribution

• ההערה AnnotationTarget.FUNCTION נוספה להערה FunctionKeyMeta. (I08021)

גרסה 1.8

גרסה 1.8.3

‫18 ביוני 2025

‫androidx.compose.runtime:runtime-*:1.8.3 מופץ. גרסה 1.8.3 מכילה את השמירות האלה.

גרסה 1.8.2

‫20 במאי 2025

‫androidx.compose.runtime:runtime-*:1.8.2 מופץ. גרסה 1.8.2 מכילה את השמירות האלה.

גרסה 1.8.1

‫7 במאי 2025

‫androidx.compose.runtime:runtime-*:1.8.1 מופץ. גרסה 1.8.1 מכילה את השמירות האלה.

גרסה 1.8.0

‫23 באפריל 2025

‫androidx.compose.runtime:runtime-*:1.8.0 מופץ. גרסה 1.8.0 מכילה את השמירות האלה.

גרסה ‎1.8.0-rc03

‫9 באפריל 2025

‫androidx.compose.runtime:runtime-*:1.8.0-rc03 מופץ. גרסה ‎1.8.0-rc03 מכילה את השמירות האלה.

גרסה ‎1.8.0-rc02

‫26 במרץ 2025

‫androidx.compose.runtime:runtime-*:1.8.0-rc02 מופץ. גרסה ‎1.8.0-rc02 מכילה את השמירות האלה.

גרסה ‎1.8.0-rc01

‫12 במרץ 2025

‫androidx.compose.runtime:runtime-*:1.8.0-rc01 מופץ. גרסה ‎1.8.0-rc01 מכילה את השמירות האלה.

שינויים ב-API

• שינינו את השם של השיטות SnapshotObserver onCreating ל-onPreCreate ואת onDisposing ל-onPreDispose כדי להתאים להנחיות בנושא API. השיטות הקודמות הוצאו משימוש, והשיטות החדשות מוגדרות כברירת מחדל להפעלת השיטות הישנות, כך שהטמעות קיימות של הממשק הזה ימשיכו לפעול עד שהשיטות יוסרו. ה-methods האלה יוסרו בגרסה 1.9.0 אלפא ב-CL שיפורסם בקרוב אחרי זה. הם יוסרו מגרסת בטא 1.8 לפני גרסה יציבה 1.8. (I6d753)

גרסה ‎1.8.0-beta03

‫26 בפברואר 2025

‫androidx.compose.runtime:runtime-*:1.8.0-beta03 מופץ. גרסה ‎1.8.0-beta03 מכילה את השמירות האלה.

גרסה ‎1.8.0-beta02

‫12 בפברואר 2025

‫androidx.compose.runtime:runtime-*:1.8.0-beta02 מופץ. גרסה ‎1.8.0-beta02 מכילה את השמירות האלה.

תיקוני באגים

• הקפצת הודעת שגיאה (throw) לחריגה שנתפסה בקומפוזיציה שניתן להשהות .(384486d)

גרסה ‎1.8.0-beta01

‫29 בינואר 2025

‫androidx.compose.runtime:runtime-*:1.8.0-beta01 מופץ. גרסה ‎1.8.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• תוקנה הבעיה שבה העלאת throwable במהלך יצירה שלא מורחבת מ-Exception עלולה להוביל לשגיאה 'היצירה בהמתנה לא הוחלה'. (I356be, b/382094412)

גרסה ‎1.8.0-alpha08

‫15 בינואר 2025

‫androidx.compose.runtime:runtime-*:1.8.0-alpha08 מופץ. גרסה ‎1.8.0-alpha08 מכילה את השמירות האלה.

גרסה ‎1.8.0-alpha07

‫11 בדצמבר 2024

‫androidx.compose.runtime:runtime-*:1.8.0-alpha07 מופץ. גרסה ‎1.8.0-alpha07 מכילה את השמירות האלה.

שינויים ב-API

• נוסף API של כלי עזר שעוזר לכלי לבדיקת פריסות לקשר בין קומפוזיציות משנה לקומפוזיציית האב במקרים שבהם צומת לא משמש לגישור בין הקומפוזיציות. (I4ce3d)
• הגדרנו את הקבועים האריתמטיים והמיוחדים של SnapshotId כפנימיים במקום כציבוריים. אם צריך, אפשר לבצע פעולות אריתמטיות על SnasphotId על ידי המרה שלו ל-Int או ל-Long באמצעות toInt() או toLong() בהתאמה. (Ic3a57)

External Contribution

• אופטימיזציה של האחסון לפרמטרים movableContentOf. (ed87177)

גרסה ‎1.8.0-alpha06

‫13 בנובמבר 2024

‫androidx.compose.runtime:runtime-*:1.8.0-alpha06 מופץ. גרסה ‎1.8.0-alpha06 מכילה את השמירות האלה.

שינויים ב-API

• שינויים ב-PausableComposition API. אלה שינויים שוברים בהשוואה לגרסאות קודמות של 1.8.0-alpha (מגרסה 1.8.0-alpha02), אבל מכיוון שאלה ממשקי API חדשים בגרסה 1.8.0, לא נשמרת תאימות לאחור כי ממשקי ה-API עדיין בגרסת אלפא. (I39819)
• נוספו ממשקי API של כלי פיתוח כדי לצפות ביצירה של קומפוזיציות חדשות בתוך Recomposer (Iaeb7e)
• הוספנו את snapshotId, מסוג Long, אל Snapshot והוצאנו משימוש את id. המזהה של תמונת מצב השתנה מ-Int ל-Long כדי למנוע גלישה של מזהה תמונת המצב במערכות עם קצב פריימים גבוה מאוד ואנימציות שפועלות לאורך זמן. הסוג הוגדר כ-expect/actual כדי לאפשר לסוג הזה להיות Int או סוג אחר בפלטפורמות שאין בהן סוג Long מקורי. בפלטפורמות שאין בהן Long מקורי, כמו JavaScript, מומלץ להימנע מקצב פריימים גבוה (מעל 1,000 FPS) כי הוא עלול לגרום לגלישה של Int בערך כל 24 ימים. ‫(I38ac3, ‏ b/374821679)

תיקוני באגים

• הבעיה providesDefault נפתרה לגבי provides אחד. (aosp/3318540 b/374263387)
• אופטימיזציה של ChangeList. (3318538)

גרסה ‎1.8.0-alpha05

‫30 באוקטובר 2024

‫androidx.compose.runtime:runtime-*:1.8.0-alpha05 מופץ. גרסה ‎1.8.0-alpha05 מכילה את השמירות האלה.

תיקוני באגים

• תיקון גלישת מחסנית על ידי הוספת Int.MAX_VALUE אל SnapshotIdSet. (b/370536104, Ic4179f6)
• מיקרו-אופטימיזציות בזמן ריצה (I50c60)
• מאפשרים ל-R8 להסיר קריאות של runtimeCheck לניפוי באגים (I8c44)
• הפיכת compoundKeyOf לאיטרטיבי במקום לרקורסיבי (I5817f)

External Contribution

• הטמעה של ערימות באמצעות רשימות אוספים (I7d47c)

גרסה ‎1.8.0-alpha04

‫16 באוקטובר 2024

‫androidx.compose.runtime:runtime-*:1.8.0-alpha04 מופץ. גרסה ‎1.8.0-alpha04 מכילה את השמירות האלה.

שיפורים בביצועים

• הוספת מזהה של snapshot לרשומות של מצב ב-constructor‏ (85c00f)
• שינוי מבנה הקוד של SnapshotState*** כדי למנוע שגיאות באימות המחלקה (6ee4a6)
• תיקון כללי R8 כדי למנוע הטמעה של throw (5beb92)
• אופטימיזציה של פעולות ברמת המיקרו (d73c5c)
• אופטימיזציה של הקצאות SynchronizedObject ב-JVM ‏ (2b043f)

גרסה ‎1.8.0-alpha03

‫2 באוקטובר 2024

‫androidx.compose.runtime:runtime-*:1.8.0-alpha03 מופץ. גרסה ‎1.8.0-alpha03 מכילה את השמירות האלה.

שיפורים בביצועים

• ‫Lazily create child context for rememberCoroutineScope (f61464)
  • הפונקציה rememberCoroutineScope משמשת בדרך כלל להפעלת קורוטינות בתגובה לאירועים שמתרחשים אחרי ההרכבה. בתרחישים מסוימים, יכול להיות שהאירועים האלה לא יתרחשו אף פעם, מה שיוביל לעלויות נוספות של יצירת משימות וביטולן בלי שתקבלו תועלת כלשהי.
  • הגדרת ההיקף שמוחזר על ידי rememberCoroutineScope יוצרת את coroutineContext באופן עצלני כשניגשים אליו, וכך נמנעת יצירה וביטול של משימות אם לא נעשה שימוש בהיקף.

גרסה ‎1.8.0-alpha02

‫18 בספטמבר 2024

‫androidx.compose.runtime:runtime-*:1.8.0-alpha02 מופץ. גרסה ‎1.8.0-alpha02 מכילה את השמירות האלה.

תכונות חדשות

• נוסף PausableComposition שמאפשר ליצור קטע משנה של יצירה שאפשר להשהות אותו במהלך היצירה ולהחיל אותו באופן אסינכרוני על היצירה. כדי להשהות את ההפעלה צריך תמיכה בקומפיילר, והאפשרות הזו נמצאת כרגע בפיתוח. (I3394b)

גרסה ‎1.8.0-alpha01

‫4 בספטמבר 2024

‫androidx.compose.runtime:runtime-*:1.8.0-alpha01 מופץ. גרסה ‎1.8.0-alpha01 מכילה את השמירות האלה.

גרסה 1.7

גרסה 1.7.8

‫12 בפברואר 2025

‫androidx.compose.runtime:runtime-*:1.7.8 מופץ. גרסה 1.7.8 מכילה את השמירות האלה.

גרסה 1.7.7

‫29 בינואר 2025

‫androidx.compose.runtime:runtime-*:1.7.7 מופץ. אין שינויים מגרסה 1.7.6.

‫androidx.compose.runtime:runtime-*:1.7.6 מופץ. גרסה 1.7.6 מכילה את השמירות האלה.

גרסה 1.7.5

‫30 באוקטובר 2024

‫androidx.compose.runtime:runtime-*:1.7.5 מופץ. גרסה 1.7.5 מכילה את השמירות האלה.

גרסה 1.7.4

‫16 באוקטובר 2024

‫androidx.compose.runtime:runtime-*:1.7.4 מופץ. גרסה 1.7.4 מכילה את השמירות האלה.

גרסה 1.7.3

‫2 באוקטובר 2024

‫androidx.compose.runtime:runtime-*:1.7.3 מופץ. גרסה 1.7.3 מכילה את השמירות האלה.

גרסה 1.7.2

‫18 בספטמבר 2024

‫androidx.compose.runtime:runtime-*:1.7.2 מופץ. גרסה 1.7.2 מכילה את השמירות האלה.

גרסה 1.7.1

‫10 בספטמבר 2024

• לא חלים שינויים בארטיפקטים של Android. -desktop ארטיפקטים הוסרו ו--jvmStubs ו--linuxx64Stubs ארטיפקטים נוספו. אף אחד מהיעדים האלה לא מיועד לשימוש, הם משמשים כ-placeholder כדי לעזור למאמצי Jetbrains Compose.

גרסה 1.7.0

‫4 בספטמבר 2024

‫androidx.compose.runtime:runtime-*:1.7.0 מופץ. גרסה 1.7.0 מכילה את השמירות האלה.

שינויים חשובים מאז גרסה 1.6.0

• נוספה האפשרות לספק לוקאל של קומפוזיציה שמחושב על סמך הערכים של לוקאלים אחרים של קומפוזיציה, כברירת מחדל באמצעות compositionLocalWithComputedDefault() או על ידי אספקת פונקציית למדה לחישוב הערך באמצעות providesComputed במקום provides.
• אפשר לקבל את הערך של קומפוזיציה מקומית באמצעות המאפיין currentValue של הקומפוזיציה המקומית שאפשר לגשת אליו מתוך ה-lambda שמחשב את הערך. הפונקציה הזו משמשת במקום current, שאפשר לגשת אליה רק בפונקציות @Composable. (Iadbc0)
• אפשר לגשת באופן מיידי לאובייקטים של מצב שנוצרו לאחרונה מתוך תמונות מצב אחרות, כולל תמונת המצב הגלובלית, עם המצב ההתחלתי שלהם. שינויים נוספים לא יהיו גלויים עד שהתמונה של מצב המערכת שבה האובייקט נוצר תוחל.
• המצב הראשוני של mutableStateOf(), וגם של הגרסאות הפרימיטיביות שלו, הוא הערך שמועבר כפרמטר אל mutableStateOf(). המצב ההתחלתי של mutableStateListOf() ו-mutableStateMapOf() הוא ריק.
• נוספו Snapshot.isInSnapshot ו-Snapshot.PreexistingSnapshotId שמשמשים להפעלת אובייקט מצב כדי לתמוך בגישה מיידית מ-snapshot גלובלי עם היצירה שלו.
• אפשר לגשת לאובייקטים של מצב בהתאמה אישית באופן מיידי אם פועלים לפי דפוס השינויים שבוצעו באובייקטים המובנים של התמונה. (I84a17)
• הפעלת nonSkippingGroupOptimization בספריות של כתיבת קוד. כתוצאה מכך, הקוד שנוצר לכל הפונקציות הניתנות להרכבה שאי אפשר להפעיל מחדש ב-androidx יהיה יעיל יותר. בעתיד אנחנו מתכננים להפעיל את האפשרות הזו כברירת מחדל. I(acbc08)
• ביטול תוקף של ביטויי למדה שאפשר להרכיב בהרכבות משנה באותו פריים. (98301c)
• הפעלת קריאה חוזרת (callback) של onRelease באותו סדר כמו onForgotten. (2cd790)
• הפעלת מצב דילוג חזק (ed1766)
• שיפורים בשיטת הבידינג currentCompoundHashKey (d4a872)

גרסה ‎1.7.0-rc01

‫21 באוגוסט 2024

‫androidx.compose.runtime:runtime-*:1.7.0-rc01 מופץ. גרסה ‎1.7.0-rc01 מכילה את השמירות האלה.

גרסה ‎1.7.0-beta07

‫7 באוגוסט 2024

‫androidx.compose.runtime:runtime-*:1.7.0-beta07 מופץ. גרסה ‎1.7.0-beta07 מכילה את השמירות האלה.

גרסה ‎1.7.0-beta06

‫24 ביולי 2024

‫androidx.compose.runtime:runtime-*:1.7.0-beta06 מופץ. גרסה ‎1.7.0-beta06 מכילה את השמירות האלה.

גרסה ‎1.7.0-beta05

‫10 ביולי 2024

‫androidx.compose.runtime:runtime-*:1.7.0-beta05 מופץ. גרסה ‎1.7.0-beta05 מכילה את השמירות האלה.

גרסה ‎1.7.0-beta04

‫26 ביוני 2024

‫androidx.compose.runtime:runtime-*:1.7.0-beta04 מופץ. גרסה ‎1.7.0-beta04 מכילה את השמירות האלה.

גרסה ‎1.7.0-beta03

‫12 ביוני 2024

‫androidx.compose.runtime:runtime-*:1.7.0-beta03 מופץ. גרסה ‎1.7.0-beta03 מכילה את השמירות האלה.

גרסה ‎1.7.0-beta02

‫29 במאי 2024

‫androidx.compose.runtime:runtime-*:1.7.0-beta02 מופץ. גרסה ‎1.7.0-beta02 מכילה את השמירות האלה.

גרסה ‎1.7.0-beta01

‫14 במאי 2024

‫androidx.compose.runtime:runtime-*:1.7.0-beta01 מופץ. גרסה ‎1.7.0-beta01 מכילה את השמירות האלה.

גרסה ‎1.7.0-alpha08

‫1 במאי 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha08 מופץ. גרסה ‎1.7.0-alpha08 מכילה את השמירות האלה.

גרסה ‎1.7.0-alpha07

‫17 באפריל 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha07 מופץ. גרסה ‎1.7.0-alpha07 מכילה את השמירות האלה.

תכונות חדשות

• נוספה האפשרות לספק לוקאל של קומפוזיציה שמחושב על סמך הערכים של לוקאלים אחרים של קומפוזיציה, כברירת מחדל באמצעות compositionLocalWithComputedDefault() או על ידי אספקת פונקציית למדה לחישוב הערך באמצעות providesComputed במקום provides.
• אפשר לקבל את הערך של קומפוזיציה מקומית באמצעות המאפיין currentValue של הקומפוזיציה המקומית שאפשר לגשת אליו מתוך ה-lambda שמחשב את הערך. הפונקציה הזו משמשת במקום current, שאפשר לגשת אליה רק בפונקציות @Composable. (Iadbc0)

שינויים ב-API

• אפשר לגשת באופן מיידי לאובייקטים של מצב שנוצרו לאחרונה מתוך תמונות מצב אחרות, כולל תמונת המצב הגלובלית, עם המצב ההתחלתי שלהם. שינויים נוספים לא יהיו גלויים עד שהתמונה של מצב המערכת שבה האובייקט נוצר תוחל.
• המצב הראשוני של mutableStateOf(), וגם של הגרסאות הפרימיטיביות שלו, הוא הערך שמועבר כפרמטר אל mutableStateOf(). המצב ההתחלתי של mutableStateListOf() ו-mutableStateMapOf() הוא ריק.
• נוספו Snapshot.isInSnapshot ו-Snapshot.PreexistingSnapshotId שמשמשים להפעלת אובייקט מצב כדי לתמוך בגישה מיידית מ-snapshot גלובלי עם היצירה שלו.
• אפשר לגשת לאובייקטים של מצב בהתאמה אישית באופן מיידי אם פועלים לפי דפוס השינויים שבוצעו באובייקטים המובנים של התמונה. (I84a17)

תיקוני באגים

• תוקן מיזוג של readObserver בתמונות מצב מוטמעות. הבעיה הזו גרמה למצבים נגזרים מקוננים להיות לא תקפים כשמשתמשים בהם בתוך snapshotFlow. (Idf138)

גרסה ‎1.7.0-alpha06

‫3 באפריל 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha06 מופץ. גרסה ‎1.7.0-alpha06 מכילה את השמירות האלה.

תיקוני באגים

• תיקון של טיפול בערכים יחידים providesDefault (538f45)
• מניעת מצב של קיפאון ב-Recomposer בזמן הגישה לשעון הפריימים (07e5c6)

גרסה ‎1.7.0-alpha05

‫20 במרץ 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha05 מופץ. גרסה ‎1.7.0-alpha05 מכילה את השמירות האלה.

תיקוני באגים

• מחיקת שינויים מאוחרים ביצירה מוזיקלית שהושבתה (5950bc)

גרסה ‎1.7.0-alpha04

6 במרץ 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha04 מופץ. גרסה ‎1.7.0-alpha04 מכילה את השמירות האלה.

שיפורים בביצועים

• התקשרות אל Snapshot.current פעם אחת לכל הערכה של מצב נגזר (ee7daf)
• קריאה של currentRecord פעם אחת לכל תצפית בהרכב (b882b2)
• הסרה של הקצאת איטרטורים בטעות ב-snapshotFlow (231e56)
• הפעלת nonSkippingGroupOptimization בספריות של כתיבת קוד. כתוצאה מכך, הקוד שנוצר לכל הפונקציות הניתנות להרכבה שאי אפשר להפעיל מחדש ב-androidx יהיה יעיל יותר. בעתיד אנחנו מתכננים להפעיל את האפשרות הזו כברירת מחדל. I(acbc08)

גרסה ‎1.7.0-alpha03

‫21 בפברואר 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha03 מופץ. גרסה ‎1.7.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• הוספת קבוצות החלפה כדי לשפר את זיהוי השינויים (0941b5)

שיפורים בביצועים

• שיפור הקצאת הזיכרון בזיהוי שינויים (53e7fd)
• תיקון דליפת זיכרון בכלי ההלחנה (0e097d)
• הוספת האפשרות להשתמש ב-ScopeMap כדי להעביר ביטולים כשמרכיבים מחדש (e19a7e)
• אופטימיזציה של מפת ביטולי התוקף כדי לשמור רק מצבים נגזרים (f11c44)
• החלפת השימוש ב-IdentityArraySet ב-ScatterSet (db572e)
• אופטימיזציה של removeScope ב-ScopeMap (bb0530)

גרסה ‎1.7.0-alpha02

‫7 בפברואר 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha02 מופץ. גרסה ‎1.7.0-alpha02 מכילה את השמירות האלה.

תיקוני באגים

• ביטול תוקף של ביטויי למדה שאפשר להרכיב בהרכבות משנה באותו פריים. (98301c)
• הפעלת קריאה חוזרת (callback) של onRelease באותו סדר כמו onForgotten. (2cd790)
• שינוי המסנן לא משתקף ב-snapshotFlow. (796b80)

שיפורים בביצועים

• שינוי של snapshot observer במקום כשהוא כבר שקוף. (f60f30)
• אופטימיזציה של SnapshotIdSet.lowest(). (7ae149)
• שימוש ב-fold() ב-SnapshotIdSet ללא הקצאה. (532b7d)
• הסרת הקצאה של איטרטור (83f96b)

גרסה ‎1.7.0-alpha01

‫24 בינואר 2024

‫androidx.compose.runtime:runtime-*:1.7.0-alpha01 מופץ. גרסה ‎1.7.0-alpha01 מכילה את השמירות האלה.

אופטימיזציה של הביצועים

• הוספת האפשרות ליצור משבצות אחרי הוספה של קבוצת צאצא (b5960c)
• אופטימיזציה של שינויים בתיעוד של מצבי תמונת מצב (28c3fe)
• הפעלת מצב דילוג חזק (ed1766)

תיקוני באגים

• התחשבות במטא של פרמטר ברירת המחדל בזיכרון המובנה (096665)
• שיפורים בשיטת הבידינג currentCompoundHashKey (d4a872)
• הבנה של קבוצות כשיוצאים מקריאה של פונקציה מוטבעת (2a90fc)

גרסה 1.6

גרסה 1.6.8

‫12 ביוני 2024

‫androidx.compose.runtime:runtime-*:1.6.8 מופץ. גרסה 1.6.8 מכילה את השמירות האלה.

גרסה 1.6.7

‫1 במאי 2024

‫androidx.compose.runtime:runtime-*:1.6.7 מופץ. גרסה 1.6.7 מכילה את השמירות האלה.

גרסה 1.6.6

‫17 באפריל 2024

‫androidx.compose.runtime:runtime-*:1.6.6 מופץ. לא בוצעו שינויים מאז הגרסה האחרונה.

גרסה 1.6.5

‫3 באפריל 2024

‫androidx.compose.runtime:runtime-*:1.6.5 מופץ. גרסה 1.6.5 מכילה את השמירות האלה.

גרסה 1.6.4

‫20 במרץ 2024

‫androidx.compose.runtime:runtime-*:1.6.4 מופץ. גרסה 1.6.4 מכילה את השמירות האלה.

גרסה 1.6.3

6 במרץ 2024

‫androidx.compose.runtime:runtime-*:1.6.3 מופץ. גרסה 1.6.3 מכילה את השמירות האלה.

גרסה 1.6.2

‫21 בפברואר 2024

‫androidx.compose.runtime:runtime-*:1.6.2 מופץ. גרסה 1.6.2 מכילה את השמירות האלה.

גרסה 1.6.1

‫7 בפברואר 2024

‫androidx.compose.runtime:runtime-*:1.6.1 מופץ. גרסה 1.6.1 מכילה את השמירות האלה.

תיקוני באגים

• הפעלת קריאה חוזרת (callback) של onRelease באותו סדר כמו onForgotten. (2cd790)
• שינוי המסנן לא משתקף ב-snapshotFlow. (796b80)

גרסה 1.6.0

‫24 בינואר 2024

‫androidx.compose.runtime:runtime-*:1.6.0 מופץ. גרסה 1.6.0 מכילה את השמירות האלה.

שינויים חשובים מאז גרסה 1.5.0

תכונות חדשות

• העברה מחדש של חריגים שמוסתרים במהלך לולאת הרה-קומפוזיציה (4dff9a)

אופטימיזציה של הביצועים

• אופטימיזציה של שינויים בתיעוד של מצבי תמונת מצב (28c3fe)
• אופטימיזציה rememberSaveable (f01d79)
• דחיית קריאה חוזרת של מצבים נגזרים עד לתיעוד השינויים (f38099)
• שיפור האופן שבו מספקים ערכים מקומיים של קומפוזיציה (a337ea)

תיקוני באגים

• תיקון דליפת זיכרון בטבלת המשבצות (73fcfe)
• דילוג על הרכבה מחדש של קומפוזיציות משנה שיוסרו. (Ieeb99, ‏ b/254645321)
• מחזורי החיים של RememberObserver מופעלים רק כשהוא מאוחסן בחישוב הזיכרון. (f6b4dc)
• הגבלת הלכידה של $dirty לביטויי למדה מוטמעים. (acfca0)
• תוקנה בעיה שבה תוכן שאפשר להזיז קיבל לפעמים את הלוקאלים הלא נכונים של הקומפוזיציה. (035cd6)

גרסה ‎1.6.0-rc01

‫10 בינואר 2024

‫androidx.compose.runtime:runtime-*:1.6.0-rc01 מופץ. גרסה ‎1.6.0-rc01 מכילה את השמירות האלה.

גרסה ‎1.6.0-beta03

‫13 בדצמבר 2023

‫androidx.compose.runtime:runtime-*:1.6.0-beta03 מופץ. גרסה ‎1.6.0-beta03 מכילה את השמירות האלה.

גרסה ‎1.6.0-beta02

‫29 בנובמבר 2023

‫androidx.compose.runtime:runtime-*:1.6.0-beta02 מופץ. גרסה ‎1.6.0-beta02 מכילה את השמירות האלה.

גרסה ‎1.6.0-beta01

‫15 בנובמבר 2023

‫androidx.compose.runtime:runtime-*:1.6.0-beta01 מופץ. גרסה ‎1.6.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• הפצת ערכים מסוימים של יציבות בהערה. (274a4c)

תיקוני באגים

• שימוש במדיניות הפניה למצב של היקף מקומי של קומפוזיציה בהקשר. (83361c)
• הגבלת השימוש ב-‎ $dirty capture לביטויי למדה מוטמעים. (acfca0)
• תוקנה בעיה שבה תוכן שאפשר להזיז קיבל לפעמים את הלוקאלים הלא נכונים של הקומפוזיציה. (035cd6)
• שימוש במיפויי hash מהירים יותר שלא מקצים זיכרון ב-RecomposeScopeImpl. (d79494)
• שימוש בחשבון ObjectIntMap ב-DerivedState. (21862e)
• משתמשים ב-IntRef עבור int SnapshotThreadLocal ב-DerivedState. (04eaf4)

גרסה ‎1.6.0-alpha08

‫18 באוקטובר 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha08 מופץ. גרסה ‎1.6.0-alpha08 מכילה את השמירות האלה.

תיקוני באגים

• מחזורי החיים של RememberObserver מופעלים רק כשהוא מאוחסן בחישוב הזיכרון. (f6b4dc)
• שיפור ההקצאות במיון של רשימת הפסילות. (954d63)
• שימוש במפות חדשות שלא מקצות זיכרון ב-SnapshotStateObserver. (4303ce)
• מחיקת ביטולים כשהיצירה מושבתת. (e001be)

גרסה ‎1.6.0-alpha07

‫4 באוקטובר 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha07 מופץ. גרסה ‎1.6.0-alpha07 מכילה את השמירות האלה.

שינויים ב-API

• התג SnapshotStateList מסומן עכשיו כ-RandomAccess כדי לאפשר שימוש בגרסת האינדוקס הישיר של רכיבי העזרה לרשימות. ‫(I5210c, ‏ b/219554654)

גרסה ‎1.6.0-alpha06

‫20 בספטמבר 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha06 מופץ. גרסה ‎1.6.0-alpha06 מכילה את השמירות האלה.

גרסה ‎1.6.0-alpha05

‫6 בספטמבר 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha05 מופץ. גרסה ‎1.6.0-alpha05 מכילה את השמירות האלה.

גרסה ‎1.6.0-alpha04

‫23 באוגוסט 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha04 מופץ. גרסה ‎1.6.0-alpha04 מכילה את השמירות האלה.

תכונות חדשות

• העברה מחדש של חריגים שמוסתרים במהלך לולאת הרה-קומפוזיציה (4dff9a)

שינויים ב-API

• נוספה שיטה להשבתה של ReusableComposition, שמאפשרת להסיר תצפיות אבל לשמור את הצמתים במקומם. אפשר להפעיל מחדש את הקומפוזיציה שהושבתה על ידי התקשרות אל setContent. (Ib7f31)
• הוספנו ממשק ReusableComposition לניהול מחזור החיים של קומפוזיציות משנה ולשימוש חוזר בהן. (I812d1, b/252846775)

גרסה ‎1.6.0-alpha03

‫9 באוגוסט 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha03 מופץ. גרסה ‎1.6.0-alpha03 מכילה את השמירות האלה.

תיקוני באגים

• תיקון אופטימיזציה חדשה של CompositionLocalProvider (3118e88)
• תיקון האופן שבו מפורקים צמתי תוכן ניידים. (5e3d59b)

גרסה ‎1.6.0-alpha02

26 ביולי 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha02 מופץ. גרסה ‎1.6.0-alpha02 מכילה את השמירות האלה.

תכונות חדשות ושיפורים בביצועים

• אופטימיזציה rememberSaveable (f01d79)
• דחיית קריאה חוזרת של מצבים נגזרים עד לתיעוד השינויים (f38099)
• שיפור האופן שבו מספקים ערכים מקומיים של קומפוזיציה (a337ea)
• ‫SideEffect מסומן כ-@ExplicitGroupsComposable כדי למנוע יצירה של קבוצה. (I74815)
• אל תשוו מפות מקומיות של קומפוזיציה בשימוש חוזר (782071)

שינויים ב-API

• נוסף עומס יתר של מקרה מיוחד ל-CompositionLocalProviders שמונע את התקורה שמשמשת להעברת כמה ערכים כדי להאיץ את התהליך, אבל הוא תקורה כשמעבירים ערך יחיד. (I6d640, b/288169379)

תיקוני באגים

• תיקון דליפת זיכרון בטבלת המשבצות (73fcfe)
• תיקון אופן השחזור של rememberSaveable כש-stateSaver מחזירה null ‏ (90748c)

גרסה ‎1.6.0-alpha01

‫21 ביוני 2023

‫androidx.compose.runtime:runtime-*:1.6.0-alpha01 מופץ. גרסה ‎1.6.0-alpha01 מכילה את השמירות האלה.

תיקוני באגים

• דילוג על הרכבה מחדש של קומפוזיציות משנה שיוסרו. (Ieeb99, ‏ b/254645321)
• הקצאות מופחתות כשמחילים תמונות מצב. (I65c09)
• לא לחשב את readableHash ב-DerivedState אם התמונה לא שונתה (68c565)

גירסה 1.5

גרסה 1.5.4

‫18 באוקטובר 2023

‫androidx.compose.runtime:runtime-*:1.5.4 מופץ. גרסה 1.5.4 מכילה את השמירות האלה.

גרסה 1.5.3

‫4 באוקטובר 2023

‫androidx.compose.runtime:runtime-*:1.5.3 מופץ. גרסה 1.5.3 מכילה את השמירות האלה.

גרסה 1.5.2

‫27 בספטמבר 2023

‫androidx.compose.runtime:runtime-*:1.5.2 מופץ. גרסה 1.5.2 מכילה את השמירות האלה.

גירסה 1.5.1

‫6 בספטמבר 2023

‫androidx.compose.runtime:runtime-*:1.5.1 מופץ. גרסה 1.5.1 מכילה את השמירות האלה.

גרסה 1.5.0

‫9 באוגוסט 2023

‫androidx.compose.runtime:runtime-*:1.5.0 מופץ. גרסה 1.5.0 מכילה את השמירות האלה.

שינויים ב-API

• הוסרו הקצאות בשינוי קומפוזיציה, באנימציות של צבעים וב-AndroidComposeView. (Ib2bfa)
• נוספה הערה @StateFactoryMarker כדי לסמן פונקציות שיוצרות מצבים וחייבות להיות עטופות בקריאה remember. (I64550)
• הוספה של גרסאות פרימיטיביות של State ו-MutableState (fb3d89)
• נוסף Snapshot.isApplyObserverNotificationPending (I672a5)
• נוספו גרסאות פרימיטיביות של State API, שמאפשרות לעקוב אחרי ערכים מסוג Int,‏ Long,‏ Float ו-Double באובייקטים מסוג State בלי לקבל עונשים על המרה אוטומטית של טיפוסים. כדי להשתמש בהן, צריך להשתמש בשיטות החדשות ליצירת אובייקטים mutableIntState(Int), mutableFloatStateOf(Float) וכו'. (I48e43)

תיקוני באגים

• דילוג על הרכבה מחדש של קומפוזיציות משנה שיוסרו. (Ieeb99, ‏ b/254645321)
• לא לשמור הפניה ל-snapshot ב-ComposerImpl (0206f7)
• לא להחיל קומפוזיציה פעמיים (f5791b)
• הבטחת ביטול תוקף לערכי מצב נגזר שלא אותחלו (aa2a92)
• התקשרות אל onEndChanges במהלך סילוק הקומפוזיציה. (62cc8c)
• תיקון העברת תוכן להרכב משנה (4beb41)
• תיקון פוטנציאלי של מצבי קיפאון (c1a425 ו-8edce0)
• הכלי ליצירת קומפוזיציה שנוצר לחלון ב-Android יחסום עכשיו רק שיחות אל withFrameNanos במקום את כל הקומפוזיציה, כשהוא יקבל התראה מסוג ON_STOP. המשמעות היא שחלונות שמשויכים לפעילויות שהופסקו ימשיכו להרכיב מחדש שינויים בנתונים, אבל האנימציות או כל קריאה אחרת של withFrameNanos ייחסמו. (Id9e7f, b/240975572)
• הפעלת קריאות חוזרות לביטול ההפעלה של LayoutNode לפני השבתת האפקטים 3784073
• Fix changed flags for restarted lambdas ea81df9
• תיקון באג שקשור לעריכה בזמן אמת של רכיבים עם צמתים 73fd4d8
• ‫ON_STOP צריך להשהות את השידורים של שעון הפריימים במקום את הקומפוזיציה ae276f1
• Invalidate SnapshotStateObserver scopes for unchanged derived states 84d9b1c
• תיקון פוטנציאל לקיפאון כשמבטלים קומפוזיציות 28761fc
• תיקון של העברת תוכן להרכב משנה 92d4156
• תיקון שינויים בהתראות על שינויים עבור פונקציות Lambda שהופעלו מחדש (8a03e9)
• הפעלת קריאות חוזרות לביטול ההפעלה של LayoutNode לפני סילוק האפקטים (8b0fa4)
• תיקון endToMarker() כשמפסיקים קבוצות של צמתים. (d71d980)
• שימוש בקבוצה הנוכחית SlotWriter לבדיקה בהשבתה (a0b518b)
• הסרת fill ב-SlotTable.moveSlotGapTo() והעברה לסגירה (81f9935)
• תיקון בעיה שגורמת להשבתה של תוכן שניתן להעברה בזמן ההעברה (1d7c024)
• פתרון בעיות שקשורות לביטולים מיידיים של תוכן שאפשר להעביר (8676618)

שיפורים בביצועים

• אם התמונה לא שונתה, לא כדאי לחשב את readableHash ב-DerivedState. (307102)
• הקצאות מופחתות (I65c09,‏ d7ea77,‏ 727974 ו-445808 )
• ביטול מהיר של כתיבת הודעה CoroutineScopes (a55362 ו-bd382f)
• החלפת רשומות של אובייקטים של מדינה ברשומות של מדינה שלא ניתן לגשת אליהן (c986960)
• שימוש בכלי ההלחנה בהיקף הנכון כשמממשים קבוצות (9a5e5b6)
• שימוש ב-IdentityArraySet לאחסון ביטולי תוקף של snapshot ‏ (7f60cca)
• הקטנת ההקצאות לתצפיות של תמונת מצב (5bc535f)

גרסה ‎1.5.0-rc01

26 ביולי 2023

‫androidx.compose.runtime:runtime-*:1.5.0-rc01 מופץ. גרסה ‎1.5.0-rc01 מכילה את השמירות האלה.

תיקוני באגים

• דחיית קריאה חוזרת של מצבים נגזרים עד לתיעוד השינויים (f38099)

• אפשר לבצע בדיקה אופציונלית כדי להמליץ על העברת mutableStateOf() קריאות לסוגים המקבילים והמיוחדים שלהן עבור פרימיטיבים. מזהה ה-lint הוא AutoboxingStateCreation. בעבר, הבדיקה הזו הופעלה כברירת מחדל לכל הפרויקטים. כדי לראות את האזהרה הזו בעורך של Android Studio ובפלט של lint בפרויקט, צריך לשנות את רמת החומרה שלה ממידע לאזהרה (או לרמה גבוהה יותר) על ידי הצהרה על warning "AutoboxingStateCreation" בהגדרות של build.gradle או build.gradle.kts של המודול, כמו שמוצג (I34f7e):

      android {
          lint {
              warning "AutoboxingStateCreation"
          }
          ...
      }
  

גרסה ‎1.5.0-beta03

‫28 ביוני 2023

‫androidx.compose.runtime:runtime-*:1.5.0-beta03 מופץ. גרסה ‎1.5.0-beta03 מכילה את השמירות האלה.

תיקוני באגים

• דילוג על הרכבה מחדש של קומפוזיציות משנה שיוסרו. (Ieeb99, ‏ b/254645321)

גרסה ‎1.5.0-beta02

‫7 ביוני 2023

‫androidx.compose.runtime:runtime-*:1.5.0-beta02 מופץ. גרסה ‎1.5.0-beta02 מכילה את השמירות האלה.

שיפורים בביצועים

• אם התמונה לא שונתה, לא כדאי לחשב את readableHash ב-DerivedState. (307102)

גרסה ‎1.5.0-beta01

‫24 במאי 2023

‫androidx.compose.runtime:runtime-*:1.5.0-beta01 מופץ. גרסה ‎1.5.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• הסרנו הקצאות ברה-קומפוזיציה, באנימציות של צבעים וב-AndroidComposeView (Ib2bfa)
• נוספה הערה @StateFactoryMarker כדי לסמן פונקציות שיוצרות מצבים וחייבות להיות עטופות בקריאה remember. (I64550)
• הוספה של גרסאות פרימיטיביות של State ו-MutableState (fb3d89)
• נוסף Snapshot.isApplyObserverNotificationPending (I672a5)

תיקוני באגים

• הקצאות מופחתות (I65c09,‏ d7ea77,‏ 727974 ו-445808 )
• לא לשמור הפניה ל-snapshot ב-ComposerImpl (0206f7)
• ביטול מהיר של כתיבת הודעה CoroutineScopes (a55362 ו-bd382f)
• לא להחיל קומפוזיציה פעמיים (f5791b)
• הבטחת ביטול תוקף לערכי מצב נגזר שלא אותחלו (aa2a92)
• התקשרות אל onEndChanges במהלך סילוק הקומפוזיציה. (62cc8c)
• תיקון העברת תוכן להרכב משנה (4beb41)
• תיקון פוטנציאלי של מצבי קיפאון (c1a425
• הפונקציה ON_STOP צריכה להשהות את השידורים של שעון המסגרת במקום את הקומפוזיציה (f4a2d1)
• תיקון שינויים בהתראות על שינויים עבור פונקציות Lambda שהופעלו מחדש (8a03e9)
• הפעלת קריאות חוזרות לביטול ההפעלה של LayoutNode לפני סילוק האפקטים (8b0fa4)

External Contribution

• נוסף Snapshot.isApplyObserverNotificationPending (I672a5)

גרסה ‎1.5.0-alpha04

‫10 במאי 2023

‫androidx.compose.runtime:runtime-*:1.5.0-alpha04 מופץ. גרסה ‎1.5.0-alpha04 מכילה את השמירות האלה.

שינויים ב-API

• נוספו גרסאות פרימיטיביות של State API, שמאפשרות לעקוב אחרי ערכים מסוג Int,‏ Long,‏ Float ו-Double באובייקטים מסוג State בלי לקבל עונשים על המרה אוטומטית של טיפוסים. כדי להשתמש בהן, צריך להשתמש בשיטות החדשות ליצירת אובייקטים mutableIntState(Int), mutableFloatStateOf(Float) וכו'. (I48e43)

תיקוני באגים

• התקשרות אל onEndChanges במהלך סילוק הקומפוזיציה. צמתי מיקוד שהוסרו במהלך Composition.dispose נרשמים ל-onEndChanges כדי לאפס את המיקוד.(03d4a47)

• מוודאים שהערכים של מצב נגזר שלא אותחל לא תקפים. כל מצב נגזר משויך לרשימה של התלויות שלו ב-SnapshotStateObserver. הרשימה הזו משמשת לביטול תוקף של היקפים שמשויכים למצב נגזר בכל פעם שמתבצע שינוי בתלות. השינוי בתלות נרשם בהתקדמות של התמונה, שיכולה לקרות אחרי קריאה של מצב נגזר (בגלל הקריאה ל-Snapshot.notifyObjectsInitialized()).

  הלוגיקה הקודמת של תצפית על מצב נגזר ב-SnapshotStateObserver ניקתה תלות ישנה, ואז קראה ערך חדש. התוצאה הייתה מרוץ תהליכים שבו הביטול קורה במצב נקי, שבו ביטול התלות לא נרשם.

  השינוי הזה משנה את הסדר של קריאת המצב הנגזר וניקוי התלות, כדי להבטיח שהביטול תמיד יקרה במצב תקין. (c472be6)

גרסה ‎1.5.0-alpha03

‫19 באפריל 2023

‫androidx.compose.runtime:runtime-*:1.5.0-alpha03 מופץ. גרסה ‎1.5.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• הכלי ליצירת קומפוזיציה שנוצר לחלון ב-Android יחסום עכשיו רק שיחות אל withFrameNanos במקום את כל הקומפוזיציה, כשהוא יקבל התראה מסוג ON_STOP. המשמעות היא שחלונות שמשויכים לפעילויות שהופסקו ימשיכו להרכיב מחדש שינויים בנתונים, אבל האנימציות או כל קריאה אחרת של withFrameNanos ייחסמו. (Id9e7f, b/240975572)

תיקוני באגים

• תיקון פוטנציאלי של מצב קיפאון ברשימת תמונות המצב ובמפה 5c1a425
• הפעלת קריאות חוזרות לביטול ההפעלה של LayoutNode לפני השבתת האפקטים 3784073
• Fix changed flags for restarted lambdas ea81df9
• תיקון באג שקשור לעריכה בזמן אמת של רכיבים עם צמתים 73fd4d8
• ‫ON_STOP צריך להשהות את השידורים של שעון הפריימים במקום את הקומפוזיציה ae276f1
• Invalidate SnapshotStateObserver scopes for unchanged derived states 84d9b1c
• תיקון פוטנציאלי של מצב קיפאון (deadlock) במהלך סילוק של קומפוזיציות 28761fc
• תיקון של העברת תוכן להרכב משנה 92d4156

גרסה ‎1.5.0-alpha02

‫5 באפריל 2023

‫androidx.compose.runtime:runtime-*:1.5.0-alpha02 מופץ. גרסה ‎1.5.0-alpha02 מכילה את השמירות האלה.

תכונות חדשות

• אפשר עכשיו להשתמש באופרטור getValue של Kotlin כפונקציה שניתנת להרכבה (f174f6e)

תיקוני באגים ושיפורי ביצועים

• החלפת רשומות של אובייקטים של מדינה ברשומות של מדינה שלא ניתן לגשת אליהן (c986960)
• שימוש בכלי ההלחנה בהיקף הנכון כשמממשים קבוצות (9a5e5b6)
• תיקון endToMarker() כשמפסיקים קבוצות של צמתים. (d71d980)
• שימוש בקבוצה הנוכחית SlotWriter לבדיקה בהשבתה (a0b518b)
• שימוש ב-IdentityArraySet לאחסון ביטולי תוקף של snapshot ‏ (7f60cca)
• הסרת fill ב-SlotTable.moveSlotGapTo() והעברה לסגירה (81f9935)
• תיקון בעיה שגורמת להשבתה של תוכן שניתן להעברה בזמן ההעברה (1d7c024)
• פתרון בעיות שקשורות לביטולים מיידיים של תוכן שאפשר להעביר (8676618)
• הקטנת ההקצאות לתצפיות של תמונת מצב (5bc535f)

גרסה ‎1.5.0-alpha01

‫22 במרץ 2023

‫androidx.compose.runtime:runtime-*:1.5.0-alpha01 מופץ. גרסה ‎1.5.0-alpha01 מכילה את השמירות האלה.

תכונות חדשות

• נוספה Modifier.Node#coroutineScope כדי לאפשר ל-Modifier.Nodes להפעיל קורוטינות (I76ef9)
• כדי לאפשר לאפליקציה Modifier.Nodes לקרוא את CompositionLocals, צריך להטמיע את הממשק CompositionLocalConsumerModifierNode. (Ib44df)

גרסה 1.4

גרסה 1.4.3

‫3 במאי 2023

הגרסה androidx.compose.runtime:runtime-*:1.4.3 יוצאת ללא שינויים.

גרסה 1.4.2

‫19 באפריל 2023

‫androidx.compose.runtime:runtime-*:1.4.2 מופץ. גרסה 1.4.2 מכילה את השמירות האלה.

תיקוני באגים

• תיקון פוטנציאלי של מצב קיפאון ברשימת תמונות המצב ובמפה 2eb6570

• יכול להיות שתוספת תוכן ל-SnapshotStateList או ל-SnapshotStateMap תיתקל בקיפאון (deadlock) אם השינוי מתבצע במקביל לכתיבה ישירה לרשומת המצב. הסיכוי להיתקל בבעיה הזו גדל משמעותית בעקבות השינויים שהוצגו ב-93fcae828b, שמשתמש בכתיבות ישירות כדי לשחרר רשומות שלא נעשה בהן שימוש.

• הנעילות מסודרות כך שלעולם לא תתבצע נעילת תמונת מצב בזמן שנעילת מפה או רשימה מוחזקת.

גרסה 1.4.1

‫5 באפריל 2023

‫androidx.compose.runtime:runtime-*:1.4.1 מופץ. גרסה 1.4.1 מכילה את השמירות האלה.

תיקוני באגים

• תיקון endToMarker() כשמפסיקים קבוצות של צמתים. d71d980

גרסה 1.4.0

‫22 במרץ 2023

‫androidx.compose.runtime:runtime-*:1.4.0 מופץ. גרסה 1.4.0 מכילה את השמירות האלה.

שינויים חשובים מאז גרסה 1.3.0

• שימוש בערך מאותחל מ-LiveData להרכב הראשון 3680e25
• מוסיפים את ComposeNodeLifecycleCallback כדי לצפות במחזור החיים של צמתי יצירה. 8b6a258
• הוספת נכס parameterTypes אל ComposableMethod 7b6c7ad

תיקוני באגים ושיפורי ביצועים

• ניקוי שני אינדקסים של היקף ההרשאות ב-SnapshotStateObserver 29f4a3e
• Add groups needed in the body of unskippable lambdas 7d06752
• שיפור מאפייני ההפניה לזיכרון של מצב תמונת המצב 93fcae8
• הסרה של boxing בחיפושים מקומיים של קומפוזיציה 0875717
• שימוש במפתח הנכון לקבוצות צמתים שאי אפשר לעשות בהן שימוש חוזר 6388d8d
• הגנה על SnapshotStateObserver מפני הפעלות חוזרות והפעלות בו-זמניות 98cb6ba
• נוסף אימות של גבולות האינדקס בשיטה IdentityArraySet get 35a77d3
• עדכון מודול הכתיבה כדי להשתמש בתוספים של ViewTreeLifecycleOwner 21c2122
• שליחת התראות על החלת שינויים אחרי שהרכיב Recomposer מסיים את המסגרת. 98f2641
• תיקון קריסה של חריגה מטווח האינדקסים כשמבטלים את Recomposer 8f8656f
• תמיד לאלץ הרכבה מחדש אם ספקי ההורה של Composition השתנו 9526fcc
• Recomposer tolerance for cancelled Jobs a55f7ed
• שיפור הטיפול בביטולים במספר גדול של רכיבי Composer 9b7ed67
• תיקון של יצירת קבוצות סגירה להחזרות של מוצרים שלא נרכשו באופן מקומי b6f590c

גרסה ‎1.4.0-rc01

‫8 במרץ 2023

‫androidx.compose.runtime:runtime-*:1.4.0-rc01 מופץ. גרסה ‎1.4.0-rc01 מכילה את השמירות האלה.

תיקוני באגים

• מחיקת שני מדדי ההיקף ב-SnapshotStateObserver

גרסה ‎1.4.0-beta02

‫22 בפברואר 2023

‫androidx.compose.runtime:runtime:1.4.0-beta02 וגם androidx.compose.runtime:runtime-saveable:1.4.0-beta02 מופצים. גרסה ‎1.4.0-beta02 מכילה את השמירות האלה.

גרסה ‎1.4.0-beta01

‫8 בפברואר 2023

‫androidx.compose.runtime:runtime-*:1.4.0-beta01 מופץ. גרסה ‎1.4.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• נוספה האפשרות ComposeNodeLifecycleCallback שמאפשרת מעקב אחרי מחזור החיים של צמתי Compose‏ (I3731b)
• הוספנו את @TestOnly ל-Composer.disableSourceInformation() כי אפשר להפעיל את הפונקציה הזו רק בבדיקה. (I896c8)

תיקוני באגים

• הסרת תיבות חיפוש בחיפושים מקומיים בהרכבה (62f66a)
• שיפור מאפייני ההפניה לזיכרון של מצב Snapshot ‏ (dfb451)

גרסה ‎1.4.0-alpha05

‫25 בינואר 2023

‫androidx.compose.runtime:runtime:1.4.0-alpha05 וגם androidx.compose.runtime:runtime-saveable:1.4.0-alpha05 מופצים. גרסה ‎1.4.0-alpha05 מכילה את השמירות האלה.

שינויים ב-API

• שינויים נוספים בסוגים ובערכי null של פונקציות מוטמעות או פונקציות שהוצאו משימוש (I24f91)

גרסה ‎1.4.0-alpha04

‫11 בינואר 2023

‫androidx.compose.runtime:runtime-*:1.4.0-alpha04 מופץ. גרסה ‎1.4.0-alpha04 מכילה את השמירות האלה.

שינויים ב-API

• בקמפיין TestMonotonicFrameClock נעשה עכשיו שימוש בהערה הנכונה לגבי ניסוי. (I95c9e)

תיקוני באגים

• הגנה על SnapshotStateObserver מפני הפעלות חוזרות והפעלות מקבילות (d902fb)

גרסה ‎1.4.0-alpha03

‫7 בדצמבר 2022

‫androidx.compose.runtime:runtime-*:1.4.0-alpha03 מופץ. גרסה ‎1.4.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• הוספת שיטה ציבורית חדשה למחלקה ComposableMethod שדומה ל-java.lang.reflect.Method#getParameterTypes() (Iab0c3)

תיקוני באגים

• ההתראות על החלת תמונת המצב נשלחות עכשיו אחרי ש-Recomposer מסיים להחיל את השינויים. ‫(Iad6c0, ‏ b/222093277)

גרסה ‎1.4.0-alpha02

9 בנובמבר 2022

‫androidx.compose.runtime:runtime-*:1.4.0-alpha02 מופץ. גרסה ‎1.4.0-alpha02 מכילה את השמירות האלה.

גרסה ‎1.4.0-alpha01

24 באוקטובר 2022

‫androidx.compose.runtime:runtime-*:1.4.0-alpha01 מופץ. גרסה ‎1.4.0-alpha01 מכילה את השמירות האלה.

שינויים ב-API

• ל-SnapshotStateList ול-SnapshotStateMap יש עכשיו הטמעות מפורשות של toList() ושל toMap(), בהתאמה. השיטות האלה מחזירות את התוכן הנוכחי שלהן בלי לבצע העתקה, כי הן מחזירות את הנתונים הפנימיים הבלתי ניתנים לשינוי שמשמשים לאחסון התוכן שלהן. אפשר להשתמש בערך הזה, למשל, כדי ליצור רצף של ערכים באמצעות snapshotFlow בלי להעתיק את הנתונים. (Ica2bd)

גרסה 1.3

גרסה 1.3.3

‫11 בינואר 2023

‫androidx.compose.runtime:runtime-*:1.3.3 מופץ. גרסה 1.3.3 מכילה את השמירות האלה.

• אין שינויים מאז גרסה 1.3.2

גרסה 1.3.2

‫7 בדצמבר 2022

‫androidx.compose.runtime:runtime-*:1.3.2 מופץ. גרסה 1.3.2 מכילה את השמירות האלה.

תיקוני באגים

• העדכון כולל תמיכה ב-androidx.compose.ui 1.3.2

גרסה 1.3.1

9 בנובמבר 2022

‫androidx.compose.runtime:runtime-*:1.3.1 מופץ. גרסה 1.3.1 מכילה את השמירות האלה.

גרסה 1.3.0

24 באוקטובר 2022

‫androidx.compose.runtime:runtime-*:1.3.0 מופץ. גרסה 1.3.0 מכילה את השמירות האלה.

שינויים חשובים מאז גרסה 1.2.0

טיפול בחריגים / תמיכה ב-Live Edit

• כדי לשפר את התמיכה בעריכה בזמן אמת, הוספנו ממשקי API שמאפשרים לטפל בחריגים במהלך ההרכבה
• טיפול בשגיאות בהרכב לצורך Hot Reload
• טיפול בשגיאות של עריכה בזמן אמת בשמירה או בשחזור

מעקב אחר הרכב

• נוספו ממשקי API למעקב בזמן ריצה כדי לתמוך בכלים חדשים למעקב אחר קומפוזיציה
• יצירת קריאות להפעלה/סיום של אירועי מעקב שאפשר להרכיב
• נוספה מחדש הפונקציה ComposerKt.traceEventStart(Int, String)‎

Composable Reflection APIs

• הוספנו ComposableMethod API חדש כדי לאפשר הפעלות אמינות יותר של ממשקי API שניתנים להרכבה, שמבוססות על רפלקציה.
• העברה של invokeComposable לזמן הריצה של Compose
• שינוי של ה-API כדי להפעיל שיטה שאפשר להרכיב

תיקונים בזמן ריצה

• תיקון של בדיקת טווח פגומה לבדיקת סמנים בטבלת משבצות
• מתן אפשרות להעברת תוכן לתוך SubcomposeLayout וממנו
• תיקון של העברת תוכן לתוכן חדש של קומפוזיציה משנית

מערכת תמונת המצב

• בוצעו שיפורים שונים במערכת תמונת המצב בנוגע לניהול הזיכרון, לביצועים ולדיוק.
• אופטימיזציה של הסרת היקף ב-SnapshotStateObserver
• הסרת תמונות מצב מוטמעות שנוצרו מתמונות מצב שקופות
• תוקנה בעיית מרוץ תהליכים בקריאת מצב מהתמונה הגלובלית
• Support DerivedState in SnapshotStateObserver
• מניעת הסרה של מצב נגזר מקומפוזיציה כשקוראים אותו בהיקפים אחרים
• Use IdentityArrayMap instead of HashMap inside DerivedState
• עדכון של observers של מצב נגזר לשימוש בווקטור ניתן לשינוי
• עדכון של ניקוי המצב של SnapshotStateObserver
• החלפת SnapshotStateObserver.invalidated ב-ArraySet
• תוקנה בעיית מרוץ תהליכים בקריאת מצב מהתמונה הגלובלית
• תיקון השימוש ברשומה לא עדכנית בחישוב הגיבוב (hash) של DerivedState
• תיקון מרוץ התהליכים כשמעבירים את התמונה הגלובלית
• האצת ניקוי התצפיות על היקף הפעולה ב-SnapshotStateObserver

גרסה ‎1.3.0-rc01

‫5 באוקטובר 2022

‫androidx.compose.runtime:runtime-*:1.3.0-rc01 מופץ. גרסה ‎1.3.0-rc01 מכילה את השמירות האלה.

תיקוני באגים

• תוקן ArrayIndexOutOfBoundsException שמגיע מטבלת החריצים (b/249076084)

גרסה ‎1.3.0-beta03

‫21 בספטמבר 2022

‫androidx.compose.runtime:runtime-*:1.3.0-beta03 מופץ. גרסה ‎1.3.0-beta03 מכילה את השמירות האלה.

שינוי בהתנהגות שעלול לגרום לכשלים

• הפרמטרים remember ו-rememberCoroutineScope שונו ל-crossinline. במקום לאפשר החזרה מוקדמת, המערכת תדווח על שגיאה בהחזרות מוקדמות, וכך תמנע שגיאה פנימית מאוחרת יותר.
• השינוי הזה עלול לגרום לדיווח על שגיאות חדשות בקומפיילר, ולדרוש הסרה של החזרות לא מקומיות מהביטויים של Lambda שעוברים לפונקציות האלה. (Ibea62)

גרסה ‎1.3.0-beta02

‫7 בספטמבר 2022

‫androidx.compose.runtime:runtime-*:1.3.0-beta02 מופץ. גרסה ‎1.3.0-beta02 מכילה את השמירות האלה.

תיקוני באגים

• ‫API מעודכן (I64ca0)

גרסה ‎1.3.0-beta01

‫24 באוגוסט 2022

‫androidx.compose.runtime:runtime-*:1.3.0-beta01 מופץ. גרסה ‎1.3.0-beta01 מכילה את השמירות האלה.

שינויים ב-API

• נוספה שיטה find ל-CompositionData כדי לאפשר לכלי פיתוח שמשתמשים ב-API הזה למצוא במהירות קבוצת משנה של קומפוזיציה באמצעות הזהות שלה. (I5794f)

גרסה ‎1.3.0-alpha03

‫10 באוגוסט 2022

‫androidx.compose.runtime:runtime-*:1.3.0-alpha03 מופץ. גרסה ‎1.3.0-alpha03 מכילה את השמירות האלה.

גרסה ‎1.3.0-alpha02

‫27 ביולי 2022

‫androidx.compose.runtime:runtime-*:1.3.0-alpha02 מופץ. גרסה ‎1.3.0-alpha02 מכילה את השמירות האלה.

שינויים ב-API

• נוסף מחדש ComposerKt.traceEventStart(Int, String) לצורך תאימות לאחור (I6e6de)

גרסה ‎1.3.0-alpha01

29 ביוני 2022

‫androidx.compose.runtime:runtime-*:1.3.0-alpha01 מופץ. גרסה ‎1.3.0-alpha01 מכילה את השמירות האלה.

שינויים ב-API

• העברת פונקציונליות של כלי עזר לזמן ריצה (I4f729)

גרסה 1.2

גרסה 1.2.1

‫10 באוגוסט 2022

‫androidx.compose.runtime:runtime-*:1.2.1 מופץ. גרסה 1.2.1 מכילה את השמירות האלה.

תיקוני באגים

• תוקנה דליפת זיכרון: בוצעה סילוק של קובצי snapshot מוטמעים שנוצרו מקובצי snapshot שקופים b/239603305

גרסה 1.2.0

‫27 ביולי 2022

‫androidx.compose.runtime:runtime-*:1.2.0 מופץ. גרסה 1.2.0 מכילה את השמירות האלה.

שינויים חשובים מאז 1.1.0

• ב-Compose Runtime נוספו כמה תכונות בגרסה 1.2.0, וגם בוצעו תיקוני באגים רבים לשיפור היציבות. התכונה החדשה המשמעותית ביותר הייתה ההשקה של movableContentOfAPI, שאפשר להשתמש בו כדי להפעיל חוויית משתמש מורכבת, כמו מעברים של רכיבים משותפים. ה-API של movableContentOf ממיר פונקציית lambda שניתנת להרכבה לפונקציית lambda שמעבירה את המצב שלה ואת הצמתים התואמים לכל מיקום חדש שהיא נקראת אליו. כשהשיחה הקודמת יוצאת מהקומפוזיציה, המצב נשמר באופן זמני, ואם שיחה חדשה ל-Lambda נכנסת לקומפוזיציה, המצב והצמתים המשויכים מועברים למיקום של השיחה החדשה. אם לא נוספת שיחה חדשה, המצב מוסר באופן סופי והמשתמשים שרשומים לקבלת עדכונים מקבלים הודעה.

• אם קוראים ל-movableContentOf lambda כמה פעמים באותה קומפוזיציה, נוצרים מצב וצמתים חדשים לכל קריאה. כשהקריאות יוצאות מהקומפוזיציה וקריאות חדשות נכנסות, המצב מועבר מהקריאות הראשונות שיוצאות לקריאות שנכנסות, לפי סדר הקריאות. כל המידע שלא נדרש לשיחות חדשות מוסר באופן סופי.

• בנוסף לזה ולכמה תכונות חדשות אחרות, השקענו הרבה זמן בייצוב של זמן הריצה ומערכת מצב ה-Snapshot. הסרנו דליפות זיכרון שונות וביצענו אופטימיזציה של נתיבי קוד.

• למטה מופיע סיכום של השינויים:

תכונות חדשות ב-1.2

• הוספת תמונה ניסיונית של unsafeEnter/Leave
• הוספת Snapshot.asContextElement API ניסיוני
• הוספת Snapshot.withoutReadObservation
• איך מאפשרים להעביר מצב בתוך קומפוזיציה
• מעקב אחרי קומפוזיציות מחדש ב-Compose

ביצועים ב1.2

• שיפור הביצועים המקומיים של הקומפוזיציה
• פרופילים של Baseline ל-Compose צריכים להיגזר באמצעות נקודות השוואה

תיקוני באגים ב-1.2

• הסרת פרטי מעקב מהיקפי ההגדרה מחדש של מהדורות
• מניעת הסרה של מצב נגזר מקומפוזיציה כשקוראים אותו בהיקפים אחרים
• שימוש ב-removeScope() יעיל יותר ב-SnapshotStateObserver
• ניקוי יחסי תלות במצב הנגזר בקומפוזיציה
• תיקון של שינוי ב-currentCompositeKeyHash אחרי רה-קומפוזיציה פנימית בתוך תוכן שניתן להזזה
• ניקוי של קומפוזיציות שנפסלו במהלך הסילוק
• תיקון קריאה של מצב נגזר במהלך הרכבה מחדש
• תיקון של דליפת זיכרון כשמבצעים מעקב אחרי אובייקטים של מצב נגזר
• תוקן מפתח הגיבוב המורכב של movableContent כדי שיהיה עקבי
• תיקון מקרה שבו הכלי ליצירת מוזיקה קורס
• מוודאים שביטול תוקף של קבוצה גורם להרכבה מחדש
• תיקון באג שבו הפונקציה rememberSaveable עם קלט משוחזרת בסדר שגוי

גרסה ‎1.2.0-rc03

29 ביוני 2022

‫androidx.compose.runtime:runtime-*:1.2.0-rc03 מופץ. גרסה ‎1.2.0-rc03 מכילה את השמירות האלה.

תיקוני באגים

• בעבר, תצפיות על מצב נגזר הוסרו ללא תנאי מההיקף של ההרכבה ומההרכבה עצמה, מה שגרם לבעיות בהיקפים אחרים שאולי עדיין צופים במצב הנגזר. השינוי הזה מסיר רק מופעים של מצב נגזר אם הם לא נצפים יותר על ידי היקפים אחרים. (b/236618362)

גרסה ‎1.2.0-rc02

‫22 ביוני 2022

‫androidx.compose.runtime:runtime-*:1.2.0-rc02 מופץ. גרסה ‎1.2.0-rc02 מכילה את השמירות האלה.

גרסה ‎1.2.0-rc01

‫15 ביוני 2022

‫androidx.compose.runtime:runtime-*:1.2.0-rc01 מופץ. גרסה ‎1.2.0-rc01 מכילה את השמירות האלה.

שינויים ב-API

• ממשקים בספריות של Compose נוצרים עכשיו באמצעות שיטות ממשק שמוגדרות כברירת מחדל ב-jdk8 ‏ (I5bcf1)

גרסה ‎1.2.0-beta03

‫1 ביוני 2022

‫androidx.compose.runtime:runtime-*:1.2.0-beta03 מופץ. גרסה ‎1.2.0-beta03 מכילה את השמירות האלה.

גרסה ‎1.2.0-beta02

‫18 במאי 2022

‫androidx.compose.runtime:runtime-*:1.2.0-beta02 מופץ. גרסה ‎1.2.0-beta02 מכילה את השמירות האלה.

גרסה ‎1.2.0-beta01

‫11 במאי 2022

‫androidx.compose.runtime:runtime-*:1.2.0-beta01 מופץ. גרסה ‎1.2.0-beta01 מכילה את השמירות האלה.

תכונות חדשות

• זו גרסת הבטא הראשונה של 1.2!

שינויים ב-API

• נוספה תכונה ניסיונית Snapshot.unsafeEnter/unsafeLeave (I108f3)
• נוסף API ניסיוני Snapshot.asContextElement() ‏ (Iff072)
• עכשיו אפשר להשתמש בהערה @ComposableTarget ובהערות שמסומנות ב-@ComposableTargetMarker בהיקף הקובץ באמצעות הקידומת @file. שימוש באנוטציית יעד בהיקף הקובץ יגרום לקומפיילר להניח שכל הפונקציות הקומפוזביליות בקובץ מיועדות להיות היעד של ממשק ההחלה המשויך. לדוגמה, השימוש ב-@file:UiComposable מצהיר שכל הפונקציות של @Composable מטרגטות את כלי ההחלה של ממשק המשתמש של Compose. פונקציה שצריכה לטרגט ממשק החלה אחר חייבת לספק במפורש את הערת הסמן של היעד עבור ממשק ההחלה הרצוי. (I40804)

גרסה ‎1.2.0-alpha08

‫20 באפריל 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha08 מופץ. גרסה ‎1.2.0-alpha08 מכילה את השמירות האלה.

שינויים ב-API

• הוספנו את TracingInProgress לממשק CompositionTracer. (Ic6f12)
• הוספת recomposeScopeIdentity ל-Composer‏ (I0c873)
• ממשקי API מוגבלים למעקב (Composer.setTracer) אל OptIn(InternalComposeTracingApi). (I9187f)
• נוסף ResuableContentHost שמאפשר שליטה טובה יותר במשך החיים של מצב שנוצר לתוכן שאפשר לעשות בו שימוש חוזר. לדוגמה, אם קומפוזיציה משנית לא נמצאת בשימוש באופן זמני, אפשר להשבית את התוכן שלה וכך לגרום למערכת לשכוח את כל המצב שנשמר בקומפוזיציה, מה שיפעיל, למשל, את כל האפקטים שניתנים להסרה. (I2c0f2, b/220322704)

גרסה ‎1.2.0-alpha07

‫6 באפריל 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha07 מופץ. גרסה ‎1.2.0-alpha07 מכילה את השמירות האלה.

שינויים ב-API

• נוספה פונקציה חדשה Snapshot.withoutReadObservation { ... }. היא מאפשרת למשתמשים להפעיל את ה-lambda שהועבר בלי להירשם לשינויים של ערכי המצב שנקראו במהלך הבלוק הזה. השימוש ב-Snapshot יכול להיות שימושי בתרחישי שימוש שבהם רוצים ליהנות מהיתרונות של כתיבה וקריאה thread-safe שמבוססים על Snapshot, אבל רוצים לקרוא את הערך בלי לגרום לרה-קומפוזיציה או למדידה מחדש מיותרות. (I9f365, b/214054486)

גרסה ‎1.2.0-alpha06

‫23 במרץ 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha06 מופץ. גרסה ‎1.2.0-alpha06 מכילה את השמירות האלה.

גרסה ‎1.2.0-alpha05

9 במרץ 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha05 מופץ. גרסה ‎1.2.0-alpha05 מכילה את השמירות האלה.

External Contribution

• העדכון כולל שימוש בשגרות משנה (coroutines) של Kotlinx בגרסה 1.6.0‏ (I3366d)

גרסה ‎1.2.0-alpha04

23 בפברואר 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha04 מופץ. גרסה ‎1.2.0-alpha04 מכילה את השמירות האלה.

שינויים ב-API

• נוספו הפונקציות ComposableTarget, ComposableTargetMarker ו-ComposableOpenTarget שמאפשרות דיווח בזמן משך הזמן לקימפול על מצב שבו פונקציה קומפוזבילית מופעלת בטירגוט של ממשק החלה שלא נועד להשתמש בה.

  ברוב המקרים, אפשר להסיק את ההערות האלה באמצעות התוסף של מהדר Compose, ולכן השימוש בהערות האלה ישירות צריך להיות נדיר . המקרים שלא ניתן להסיק לגביהם כוללים יצירה ושימוש בפונקציית החלה מותאמת אישית, פונקציות מופשטות שניתנות להרכבה (כמו שיטות ממשק), שדות או משתנים גלובליים שהם ביטויי למדה שניתנים להרכבה (משתנים מקומיים ופרמטרים נגזרים), או כשמשתמשים ב- ComposeNode או בפונקציות קשורות שניתנות להרכבה.

  במקרה של פונקציות מותאמות אישית, הפונקציות המורכבות שקוראות ל-ComposeNode או ל-ReusableComposeNode צריכות להוסיף הערה CompoableTarget לפונקציה ולכל סוגי הפרמטרים של פונקציות ה-lambda המורכבות. עם זאת, מומלץ ליצור הערה עם התג ComposableTargetMarker ואז להשתמש בהערה המסומנת במקום בתג ComposableTarget ישירות. הערה שאפשר להוסיף לה הערות אחרות, שמסומנת ב-ComposableTargetMarker, שווה ל-ComposbleTarget עם השם המלא של מחלקת המאפיינים כפרמטר של ה-applier. דוגמה לשימוש ב-ComposableTargetMarker מופיעה במאמר anroidx.compose.ui.UiComposable. (I38f11)

גרסה ‎1.2.0-alpha03

‫9 בפברואר 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha03 מופץ. גרסה ‎1.2.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• נוספה הפונקציה movableContentOf שממירה lambda קומפוזבילי ל-lambda שמעביר את המצב שלה ואת הצמתים התואמים לכל מיקום חדש שהיא נקראת אליו. כשהשיחה הקודמת יוצאת מהקומפוזיציה, המצב נשמר באופן זמני, ואם שיחה חדשה ל-Lambda נכנסת לקומפוזיציה, המצב והצמתים המשויכים מועברים למיקום של השיחה החדשה. אם לא נוספת שיחה חדשה, המצב מוסר באופן סופי והתראות נשלחות למאזינים.

  אם קוראים ל-movableContentOf lambda כמה פעמים באותה קומפוזיציה, נוצרים מצב וצמתים חדשים לכל קריאה. כשהקריאות יוצאות מהקומפוזיציה ונכנסות קריאות חדשות, המצב מועבר מהקריאות הראשונות שיוצאות לקריאות שנכנסות, לפי הסדר שבו הן נקראות. כל המידע שלא נדרש לשיחות חדשות מוסר באופן סופי. (Ib4850)

• הוספנו ל-composition‏ API למעקב, כדי לאפשר לכלים לספק מעקב מפורט יותר של פונקציות הניתנות להגדרה. הקומפיילר יוצר עכשיו קריאות ל-Tracing API שכוללות מידע על המקור. (Ib0eb5)

  כדי להסיר את הקריאות האלה ואת פרטי המקור המשויכים מגרסת build להפצה, מוסיפים את כלל Proguard הבא:

    -assumenosideeffects public class androidx.compose.runtime.ComposerKt {
        boolean isTraceInProgress();
        void traceEventStart(int,java.lang.String);
        void traceEventEnd();
    }
  

• מוסיפים את InternalComposeScope כדי שהכלים יוכלו לזהות רכיב שאפשר להרכיב מחדש במהלך הרכבות מחדש. (I07a3f)

גרסה ‎1.2.0-alpha02

‫26 בינואר 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha02 מופץ. גרסה ‎1.2.0-alpha02 מכילה את השמירות האלה.

גרסה ‎1.2.0-alpha01

‫12 בינואר 2022

‫androidx.compose.runtime:runtime-*:1.2.0-alpha01 מופץ. גרסה ‎1.2.0-alpha01 מכילה את השמירות האלה.

שינויים ב-API

• נוסף השדה identity ל-CompositionData כדי ליצור מזהים קבועים ב-Layout Inspector. (Ic116e)

עדכונים של תלות

• עכשיו תלוי ב-Kotlin 1.6.10.

גרסה 1.1

גרסה 1.1.1

23 בפברואר 2022

‫androidx.compose.runtime:runtime-*:1.1.1 מופץ. גרסה 1.1.1 מכילה את השמירות האלה.

תיקוני באגים

• תיקון NullPointerException ב-androidx.compose.ui.platform.RenderNodeLayer.updateDisplayList (aosp/1947059, ‏ b/206677462)
• תוקנה קריסה שנגרמה בגלל תוכן הלוח בזמן קריאה מהלוח ב-Android. (I06020, ‏ b/197769306)
• תוקנה פריסה מימין לשמאל ב-LazyVerticalGrid (aosp/1931080, ‏ b/207510535)

גרסה 1.1.0

‫9 בפברואר 2022

‫androidx.compose.runtime:runtime-*:1.1.0 מופץ. גרסה 1.1.0 מכילה את השמירות האלה.

שינויים חשובים מאז גרסה 1.0.0

• תמיכה יציבה באפקט הגלילה מעבר לקצה ב-Android 12
• שיפורים בגודל משטח המגע
• שימו לב: ב-Compose 1.0, רכיבי Material ירחיבו את שטח הפריסה שלהם כדי לעמוד בהנחיות הנגישות של Material בנוגע לגודל משטח המגע. לדוגמה, משטח המגע של לחצן יתרחב לגודל מינימלי של 48x48dp, גם אם הגדרתם שהלחצן יהיה קטן יותר. כך, התנהגות של Compose Material תהיה זהה להתנהגות של רכיבי Material Design, ותוכלו לקבל התנהגות עקבית אם תשלבו בין Views ו-Compose. השינוי הזה גם מבטיח שכשתצרו את ממשק המשתמש באמצעות רכיבי Compose Material, הדרישות המינימליות לנגישות של משטחי מגע יתקיימו.
• תמיכה יציבה בפס ניווט
• העברנו מספר ממשקי API שהיו ניסיוניים בעבר למצב יציב
• תמיכה בגרסאות חדשות יותר של Kotlin

גרסה ‎1.1.0-rc03

‫26 בינואר 2022

‫androidx.compose.runtime:runtime-*:1.1.0-rc03 מופץ. גרסה ‎1.1.0-rc03 מכילה את השמירות האלה.

תיקוני באגים

• העדכון כולל תמיכה ב-Compose Material 1.1.0-rc03

גרסה ‎1.1.0-rc01

15 בדצמבר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-rc01 מופץ. גרסה ‎1.1.0-rc01 מכילה את השמירות האלה.

גרסה ‎1.1.0-beta04

1 בדצמבר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-beta04 מופץ. גרסה ‎1.1.0-beta04 מכילה את השמירות האלה.

תכונות חדשות

• העדכון בוצע כדי שתהיה תאימות ל-Kotlin 1.6.0

גרסה ‎1.1.0-beta03

17 בנובמבר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-beta03 מופץ. גרסה ‎1.1.0-beta03 מכילה את השמירות האלה.

גרסה ‎1.1.0-beta02

3 בנובמבר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-beta02 מופץ. גרסה ‎1.1.0-beta02 מכילה את השמירות האלה.

שינויים ב-API

• קוד ה-Snapshot פוצל למספר קבצים, אבל כולם עדיין נמצאים באותה מחלקת JVM. (Ic6c98)

גרסה ‎1.1.0-beta01

‫27 באוקטובר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-beta01 מופץ. גרסה ‎1.1.0-beta01 מכילה את השמירות האלה.

גרסה ‎1.1.0-alpha06

‫13 באוקטובר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-alpha06 מופץ. גרסה ‎1.1.0-alpha06 מכילה את השמירות האלה.

שינויים ב-API

• הוסר InternalCompilerApi משיטות Composer שנדרשות לקריאה בין מודולים (I1aa0b)
• הפונקציה Recomposer.state הוצאה משימוש והוחלפה בפונקציה Recomposer.currentState כדי לשנות את הסוג שלה ל-StateFlow ‏ (Ic2ab3, ‏ b/197773820)

גרסה ‎1.1.0-alpha05

‫29 בספטמבר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-alpha05 מופץ. גרסה ‎1.1.0-alpha05 מכילה את השמירות האלה.

גרסה ‎1.1.0-alpha04

‫15 בספטמבר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-alpha04 מופץ. גרסה ‎1.1.0-alpha04 מכילה את השמירות האלה.

גרסה ‎1.1.0-alpha03

‫1 בספטמבר 2021

‫androidx.compose.runtime:runtime-*:1.1.0-alpha03 מופץ. גרסה ‎1.1.0-alpha03 מכילה את השמירות האלה.

תכונות חדשות

• הקומפיילר של Compose תומך עכשיו בגרסאות ישנות יותר של Compose Runtime‏ (1.0). לפני השינוי הזה, מהדר Compose היה תואם רק ל-Compose Runtime מאותה גרסה או מגרסה מאוחרת יותר. אחרי השינוי הזה, מהדר Compose תואם לגרסה ישנה יותר של Compose Runtime‏ (1.0). (aosp/1796968)
• עדכנו את Compose 1.1.0-alpha03 כך שיהיה תלוי ב-Kotlin 1.5.30. (I74545)

גרסה ‎1.1.0-alpha02

‫18 באוגוסט 2021

‫androidx.compose.runtime:runtime-*:1.1.0-alpha02 מופץ. גרסה ‎1.1.0-alpha02 מכילה את השמירות האלה.

גרסה ‎1.1.0-alpha01

4 באוגוסט 2021

‫androidx.compose.runtime:runtime-*:1.1.0-alpha01 מופץ. גרסה ‎1.1.0-alpha01 מכילה את השמירות האלה.

גירסה 1.0

גרסה 1.0.5

3 בנובמבר 2021

‫androidx.compose.runtime:runtime-*:1.0.5 מופץ. גרסה 1.0.5 מכילה את השמירות האלה.

תיקוני באגים

• תוקנה קריסה במעקב אחר מופעים של derivedStateOf. (aosp/1792247)

גרסה 1.0.4

‫13 באוקטובר 2021

‫androidx.compose.runtime:runtime-*:1.0.4 מופץ. גרסה 1.0.4 מכילה את השמירות האלה.

עדכונים של תלות

• העדכון כולל תלות ב-Kotlin 1.5.31

גרסה 1.0.3

‫29 בספטמבר 2021

‫androidx.compose.runtime:runtime-*:1.0.3 מופץ. גרסה 1.0.3 מכילה את השמירות האלה.

עדכונים של תלות

• העדכון כולל תלות ב-Kotlin 1.5.30

גרסה 1.0.2

‫1 בספטמבר 2021

‫androidx.compose.runtime:runtime-*:1.0.2 מופץ. גרסה 1.0.2 מכילה את השמירות האלה.

העדכון תומך בגרסת Compose 1.0.2. ‫Compose 1.0.2 עדיין תואם ל-Kotlin 1.5.21.

גרסה 1.0.1

4 באוגוסט 2021

‫androidx.compose.runtime:runtime-*:1.0.1 מופץ. גרסה 1.0.1 מכילה את השמירות האלה.

עדכונים של תלות

• העדכון כולל תלות ב-Kotlin 1.5.21.

גרסה 1.0.0

28 ביולי 2021

‫androidx.compose.runtime:runtime-*:1.0.0 מופץ. גרסה 1.0.0 מכילה את השמירות האלה.

התכונות העיקריות בגרסה 1.0.0

זו הגרסה היציבה הראשונה של Compose. פרטים נוספים זמינים בבלוג הרשמי של Compose.

בעיות מוכרות

• אם אתם משתמשים ב-Android Studio Bumblebee Canary 4 או ב-AGP‏ 7.1.0-alpha04/7.1.0-alpha05, יכול להיות שתיתקלו בקריסה הבאה:

    java.lang.AbstractMethodError: abstract method "void androidx.lifecycle.DefaultLifecycleObserver.onCreate(androidx.lifecycle.LifecycleOwner)"
  

  כדי לפתור את הבעיה, צריך להגדיל באופן זמני את minSdkVersion ל-24 ומעלה בקובץ build.gradle. הבעיה הזו תיפתר בגרסה הבאה של Android Studio Bumblebee וב-AGP 7.1. (b/194289155)

גרסה ‎1.0.0-rc02

‫14 ביולי 2021

‫androidx.compose.runtime:runtime-*:1.0.0-rc02 מופץ. גרסה ‎1.0.0-rc02 מכילה את השמירות האלה.

• תוקנו תנאי מירוץ ב-SnapshotStateObserver שגרמו ל-NullPointerExceptions לא סדירים. ‫(aosp/1763445, ‏ aosp/1758105, ‏ b/192677711)
• תוקנו בעיות שקשורות לתמונות מצב של זמן ריצה שגרמו לקריסות של java.lang.IllegalStateException: Reading a state that was created after the snapshot was taken or in a snapshot that has not yet been applied. (b/193006595, b/192570897)

גרסה ‎1.0.0-rc01

‫1 ביולי 2021

‫androidx.compose.runtime:runtime-*:1.0.0-rc01 מופץ. גרסה ‎1.0.0-rc01 מכילה את השמירות האלה.

גרסה ‎1.0.0-beta09

‫16 ביוני 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta09 מופץ. גרסה ‎1.0.0-beta09 מכילה את השמירות האלה.

נוספו כללי פרופיל

בגרסה הזו נוספו כללי פרופיל למודולים הבאים של כתיבת הודעות (I14ed6):

• androidx.compose.animation
• androidx.compose.animation-core
• androidx.compose.foundation
• androidx.compose.foundation-layout
• androidx.compose.material
• androidx.compose.material-ripple
• androidx.compose.runtime
• androidx.compose.ui
• androidx.compose.ui.geometry
• androidx.compose.ui.graphics
• androidx.compose.ui.text
• androidx.compose.ui.text
• androidx.compose.ui.unit
• androidx.compose.ui.util

מהם כללי פרופיל?

• כללי הפרופיל של ספרייה מצוינים בקובץ טקסט baseline-prof.txt שנמצא בספרייה src/main או בספרייה מקבילה. בכל שורה בקובץ מצוין כלל, ובמקרה הזה כלל הוא תבנית להתאמה לשיטות או למחלקות בספרייה. התחביר של הכללים האלה הוא קבוצת-על של פורמט הפרופיל של ART שקריא לבני אדם, שמשמש כשמשתמשים ב-adb shell profman --dump-classes-and-methods .... הכללים האלה מופיעים באחת משתי צורות, כדי להתמקד בשיטות או במחלקות.

• כלל של method ייראה כך:

  <FLAGS><CLASS_DESCRIPTOR>-><METHOD_SIGNATURE>
  

• כלל כיתה יכלול את התבנית הבאה:

  <CLASS_DESCRIPTOR>
  

• כאן <FLAGS> הוא אחד או יותר מהתווים H, S ו-P כדי לציין אם לסמן את השיטה הזו כ'פופולרית', 'הפעלה' או 'אחרי הפעלה'.

• השדה <CLASS_DESCRIPTOR> הוא המתאר של המחלקה שאליה שייכת המתודה המטורגטת. לדוגמה, למחלקה androidx.compose.runtime.SlotTable יהיה דסקריפטור של Landroidx/compose/runtime/SlotTable;.

• ‫<METHOD_SIGNATURE> הוא החתימה של ה-method, והוא כולל את השם, סוגי הפרמטרים וסוגי הערכים המוחזרים של ה-method. לדוגמה, לשיטה fun isPlaced(): Boolean ב-LayoutNode יש חתימה isPlaced()Z.

• התבניות האלה יכולות לכלול תווים כלליים (**,‏ * ו-?) כדי שכלל יחיד יכלול כמה שיטות או מחלקות.

מה עושים הכללים?

• שיטה עם הדגל H מציינת שהשיטה הזו היא שיטה 'פעילה' וצריך לקמפל אותה מראש.

• שיטה עם הדגל S היא שיטה שמופעלת בזמן ההפעלה, ולכן צריך לבצע קומפילציה שלה מראש כדי להימנע מהעלות של קומפילציה ופרשנות של השיטה בזמן ההפעלה.

• מתודה עם הדגל P מציינת שהיא מתודה שמופעלת אחרי ההפעלה.

• אם מחלקה מופיעה בקובץ הזה, המשמעות היא שהיא נמצאת בשימוש במהלך ההפעלה וצריך להקצות לה מראש מקום ב-heap כדי להימנע מעלות הטעינה של המחלקה.

איך זה עובד?

• ספריות יכולות להגדיר את הכללים האלה, שייארזו בפריטי מידע שנוצרו בתהליך של פיתוח (Artifact) מסוג AAR. כשיוצרים אפליקציה שכוללת את הארטיפקטים האלה, הכללים האלה משולבים יחד, והכללים המשולבים משמשים ליצירת פרופיל ART בינארי קומפקטי שספציפי לאפליקציה. לאחר מכן, מערכת ART יכולה להשתמש בפרופיל הזה כשהאפליקציה מותקנת במכשירים כדי לבצע קומפילציה מראש של קבוצת משנה ספציפית של האפליקציה, וכך לשפר את הביצועים של האפליקציה, במיוחד בהפעלה הראשונה. הערה: הפעולה הזו לא תשפיע על אפליקציות שאפשר לבצע בהן ניפוי באגים.

גרסה ‎1.0.0-beta08

‫2 ביוני 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta08 מופץ. גרסה ‎1.0.0-beta08 מכילה את השמירות האלה.

שינויים ב-API

• ‫State<T> נקרא עכשיו State<out T> (I69049)
• ControlledComposition שינוי ב-API כדי לאפשר הרכבה מחדש של שינויים במעבר יחיד של הרכבה מחדש. (Iaafd1, b/184173932)

גרסה ‎1.0.0-beta07

‫18 במאי 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta07 מופץ. גרסה ‎1.0.0-beta07 מכילה את השמירות האלה.

שינויים ב-API

• נוספו ממשקי API חדשים של מהדר Compose שמאפשרים להסיר את פרטי המקור שנוצרו על ידי המהדר במהלך מזעור המקור. (Ia34e6)

• הוספנו את ReusableContent, שמנסה לעשות שימוש חוזר בצמתים בתוכן במקום להחליף אותם כשמשנים את המפתח. כשמשנים את המפתח, המערכת מתעלמת מהערכים הקודמים בטבלת המשבצות של התוכן, למעט הצמתים שנוצרו והערכים ששימשו לעדכון הצמתים.

  הוספנו את ReusableComposeNode, שמשתמש מחדש בצומת שנפלט במקום להחליף אותו כמו שקורה ב-ComposeNode. (I1dd86)

• @ComposeCompilerApi כבר לא @RequiresOptIn (Iab690)

תיקוני באגים

• הקומפוננטות LazyColumn/Row ישמרו עכשיו עד 2 פריטים שהיו גלויים בעבר כפעילים (לא יוסרו), גם אם הם כבר לא גלויים בגלל גלילה. כך הרכיב יכול לעשות שימוש חוזר בתתי-הקומפוזיציות הפעילות כשצריך ליצור פריט חדש, וכך לשפר את ביצועי הגלילה. (Ie5555)

גרסה ‎1.0.0-beta06

‫5 במאי 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta06 מופץ. גרסה ‎1.0.0-beta06 מכילה את השמירות האלה.

שינויים ב-API

• @ComposeCompilerApi כבר לא @RequiresOptIn (Iab690)

גרסה ‎1.0.0-beta05

21 באפריל 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta05 מופץ. גרסה ‎1.0.0-beta05 מכילה את השמירות האלה.

שינויים ב-API

• הוסרה@InternalComposeApi האפשרות לקריאה וכתיבה של תמונת מצב של הקלטה (Id134d)

תיקוני באגים

• קבצי AndroidManifest מ-ui-test-manifest ומ-ui-tooling-data תואמים עכשיו ל-Android 12‏ (I6f9de, ‏ b/184718994)

גרסה ‎1.0.0-beta04

‫7 באפריל 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta04 מופץ. גרסה ‎1.0.0-beta04 מכילה את השמירות האלה.

תיקוני באגים

• לפני השינוי הזה, אפשר היה לדלג על פונקציות מקומיות שניתנות להגדרה על סמך הפרמטרים שלהן. אחרי השינוי הזה, אף פונקציה מקומית שניתנת להרכבה לא תדלג. השינוי הזה נעשה כי נפוץ ומצופה שפונקציות מקומיות יתעדו פרמטרים מההורה, והדילוג עליהם הוא מקור נפוץ לבאגים.

  לסיכום, כדאי לעיין בדוגמה הבאה:

  @Composable fun Counter(count: Int, onCountChange: (Int) -> Unit) {
    @Composable fun ShowCount() { Text("Count: $count") }
    ShowCount()
    Button(onClick={ onCountChange(count + 1) }) {
      Text("Increment")
    }
  }
  

  לפני השינוי הזה, הפונקציה הניתנת להרכבה ShowCount תמיד דילגה, גם אחרי שהפרמטר count עודכן. הם לא נספרים כך יותר. (I5648a)

• תוקנה הבעיה שבה הפונקציה rememberSaveable() שחזרה את הערך הישן כשנעשה בה שימוש עם פרמטרים של קלט (I1b110, ‏ b/182403380)

גרסה ‎1.0.0-beta03

‫24 במרץ 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta03 מופץ. גרסה ‎1.0.0-beta03 מכילה את השמירות האלה.

שינויים ב-API

• האפשרות DefaultMonotonicFrameClock הוצאה משימוש. התקשרות אל withFrameNanos או אל Recomposer.runRecomposeAndApplyChanges ללא MonotonicFrameClock תגרום עכשיו ל-IllegalStateException. (I4eb0d)

גרסה ‎1.0.0-beta02

10 במרץ 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta02 מופץ. גרסה ‎1.0.0-beta02 מכילה את השמירות האלה.

תיקוני באגים

• החלת הגבלות על שימוש ציבורי בממשקי API ניסיוניים (I6aa29, ‏ b/174531520)
• תיקון של rememberSaveable { mutableStateOf(0) } פגום כשמשתמשים בו בתוך יעד של navigation-compose. (I1312b, ‏ b/180042685, ‏ b/180701630)

גרסה ‎1.0.0-beta01

24 בפברואר 2021

‫androidx.compose.runtime:runtime-*:1.0.0-beta01 מופץ. גרסה ‎1.0.0-beta01 מכילה את השמירות האלה.

זו הגרסה הראשונה של Compose 1.0.0 Beta.

שינויים ב-API

• ‫Recomposer.runRecomposeConcurrentlyAndApplyChanges experimental API for recomposing invalidated compositions off the main frame loop. (I342d0)
• כל הרכיבים הקומפוזביליים שמסומנים ב-‎ @ReadOnlyComposable עוברים עכשיו אימות בזמן ההידור כדי לוודא שהם מבצעים רק קריאות לרכיבים אחרים מסוג ‎ @ReadOnlyComposables (I58961)

• השדה defaultFactory עבור compositionLocalOf ועבור staticCompositionLocalOf הוא עכשיו חובה במקום אופציונלי.

  השינוי הזה מסיר שגיאת סוג פוטנציאלית עבור סוגים שאי אפשר להגדיר כ-nullable, שלא סופקה להם ברירת מחדל של היצרן. בעבר, הפעולה הזו הייתה מספקת הפניה לערך null עבור סוג שלא יכול להיות null.

  בסוגים שניתן להגדיר להם ערך null, כדאי לספק את { null } כברירת המחדל של factory.

  אנחנו לא ממליצים להשתמש ב-locals עם סוגים שלא מאפשרים ערך null, אלא אם אפשר לספק ברירת מחדל הגיונית. אם אין ברירת מחדל הגיונית, פונקציית ה-lambda‏ defaultFactory צריכה להחזיר חריגה. עם זאת, אם מתרחשת חריגה, הצרכנים של הלוקאל יסתמכו באופן מרומז על כך שהוא יסופק, והדבר לא נאכף על ידי מערכת הטיפוסים. (Ifbd2a)

• סמלים שהוצאו משימוש הוסרו מסביבת זמן הריצה של הכתיבה (I3252c)

• המאפיין emptyContent() שהוצא משימוש הוסר. במקומה צריך להשתמש במדיניות {}. (Idb33f, ‏ b/179432510)

• השם של Providers השתנה ל-CompositionLocalProvider

  • הקונסטרוקטור Composition לא מקבל יותר פרמטר מפתח, והוא הוצא משימוש.
  • הפונקציה currentCompositeKeyHash הפכה למאפיין הניתן להגדרה ברמה העליונה, במקום להיות פונקציה הניתנת להגדרה ברמה העליונה.
  • המחלקות CompositionData ו-CompositionGroup הועברו למרחב השמות androidx.compose.runtime.tooling
  • הפכנו את ComposableLambda לממשק במקום למחלקה קונקרטית, והוא כבר לא כולל פרמטרים של סוג.
  • הפכנו את ComposableLambdaN לממשק במקום למחלקה קונקרטית, והוא כבר לא כולל פרמטרים של סוג.
  • הפונקציה snapshotFlow הועברה למרחב השמות androidx.compose.runtime
  • שיטת המיזוג של SnapshotMutationPolicy כבר לא ניסיונית
  • הפונקציה clearRoots ברמה העליונה @TestOnly הוסרה. היא כבר לא נחוצה.
  • הפונקציות keySourceInfoOf ו-resetSourceInfo הוסרו. הם כבר לא נחוצים.
  • הפונקציה Composer.collectKeySourceInformation הוסרה. היא כבר לא נחוצה.
  • השיטות isJoinedKey,‏ joinedKeyLeft ו-joinedKeyRight הוסרו. הם כבר לא נחוצים.
  • ממשקי API שונים ברמה העליונה הועברו ואורגנו מחדש בקבצים שונים. בגלל הסמנטיקה של מחלקת הקבצים ב-Kotlin, הפעולה הזו תשבור את התאימות הבינארית אבל לא את תאימות המקור, ולכן לא אמורה להיות בעיה עבור רוב המשתמשים.
  • (I99b7d, ‏ b/177245490)

• ‫SnapshotStateObserver כבר לא ניסיוני (Id2e6a)

• נמחקו כמה ממשקי API שהוצאו משימוש בעבר (Ice5da, ‏ b/178633932)

• ביצענו את השינויים הבאים ב-Material API:

  • הוספנו את הפרמטר contentPadding לרכיב Top/BottomAppBar כדי לאפשר התאמה אישית של הריווח שמוגדר כברירת מחדל.
  • הפרמטרים ב-BackdropScaffold סודרו מחדש כך שהפרמטרים הנדרשים יופיעו לפני הפרמטרים האופציונליים, בהתאם להנחיות ה-API.
  • הפרמטר icon ב-BottomNavigationItem הועבר כך שהוא מופיע אחרי selected ו-onClick.
  • השם של הפרמטר alwaysShowLabels ב-BottomNavigationItem השתנה ל-alwaysShowLabel.
  • השם של הפרמטרים bodyContent בכמה רכיבים השתנה ל-content.
  • הפרמטרים ב-ButtonDefaults.buttonColors() סודרו מחדש. חשוב לשים לב: מכיוון שסוג הפרמטרים לא השתנה, לא תהיה שגיאה בקוד. צריך לוודא שאתם משתמשים בפרמטרים עם שמות או לעדכן את הסדר באופן ידני, אחרת הקוד לא יפעל כמו קודם.
  • הפרמטר secondaryVariant נוסף אל darkColors(). הצבע הזה בדרך כלל זהה לצבע secondary בעיצוב הכהה, אבל אנחנו מוסיפים אותו כדי לשמור על עקביות ולאפשר התאמה אישית נוספת.
  • הוסרו ElevationDefaults ו-animateElevation() מממשק ה-API הציבורי כי לא היה בהם שימוש נפוץ והם לא היו שימושיים.
  • השם של onValueChangeEnd ב-Slider שונה ל-onValueChangeFinished והוגדר כ-nullable.
  • כדי לשמור על עקביות, שינינו את השם של הפרמטר text ב-Snackbar ל-content.
  • נוסף הפרמטר contentPadding ל-DropdownMenuItem כדי לאפשר התאמה אישית של שולי ברירת המחדל, והוגדר ש-content יהיה תוסף ל-RowScope.
  • השם של ModalDrawerLayout שונה ל-ModalDrawer.
  • השם של BottomDrawerLayout שונה ל-BottomDrawer.
  • (I1cc66)

גרסה ‎1.0.0-alpha12

‫10 בפברואר 2021

‫androidx.compose.runtime:runtime-*:1.0.0-alpha12 מופץ. גרסה ‎1.0.0-alpha12 מכילה את השמירות האלה.

שינויים ב-API

• התמיכה ב-ViewGroups הוסרה מ-UiApplier. הפונקציות הניתנות להרכבה emitView שהוצאו משימוש הוסרו. (Ifb214)
• השם של CompositionReference שונה ל-CompositionContext ‏ (I53fcb)
• הפונקציה ComponentActivity.setContent הועברה אל androidx.activity.compose.setContent במודול androidx.activity:activity-compose. (Icf416)
• ‫Snapshot API עודכן כדי להיות עקבי יותר עם הנחיות ה-API, וכדי להסתיר מחלקות הטמעה פנימיות מ-API ציבורי. (Id9e32)
• שונה השם של Ambients כדי להתאים לשינוי השם של Ambient -> CompositionLocal. בעבר, השם של Ambients היה AmbientFoo, ועכשיו השם של CompositionLocals הוא LocalFoo. (I2d55d)
• השם של Ambient שונה ל-CompositionLocal, והשמות של ambientOf / staticAmbientOf שונו ל-compositionLocalOf / staticCompositionLocalOf בהתאמה. השינוי הזה עוזר להבהיר את המטרה של CompositionLocal: מנגנון לאספקת ערכים מקומיים לקומפוזיציה או לאחזור שלהם. צריך להוסיף למופעים של CompositionLocal את הקידומת Local, למשל val LocalFoo = compositionLocalOf { Foo() }. (Ia55b6)
• הפונקציות takeMutableSnapshot ו-takeSnapshot הועברו להיות פונקציות נלוות של Snapshot. (I91f19)

• התג @ComposableContract הוצא משימוש לטובת שלוש הערות ספציפיות יותר.

  @ComposableContract(restartable = false) הפך ל@NonRestartableComposable @ComposableContract(readonly = true) הפך ל@ReadOnlyComposable @ComposableContract(preventCapture = true) הפך ל@DisallowComposableCalls @ComposableContract(tracked = true) הוסר. (I60a9d)

• הוצאנו משימוש את כלי השירות emptyContent()‎ ו-(@Composable () -> Unit).orEmpty()‎ כי הם כבר לא משפיעים לטובה על הביצועים או על הערך (I0484d).

• ‫snapshotFlow ו-withMutableSnapshot כבר לא ניסיוניים (I6a45f)

• עכשיו אפשר לסגור את כלי ההלחנה מחדש. רכיבי recomposition סגורים ימשיכו את ה-recomposition עד שקורוטינות הצאצא של ה-composition יושלמו. השם של הפונקציה Recomposer.shutDown שונה ל-cancel כדי ליצור ניגוד לפונקציה close. (Ib6d76)

• הוצאנו משימוש את פריט המידע שנוצר בתהליך פיתוח compose:runtime-dispatch. המחלקות MonotonicFrameClock נמצאת עכשיו ב-compose:runtime, והמחלקות AndroidUiDispatcher נמצאת ב-compose:ui. (Ib5c36)

• ה-API שאליו מכוון פלאגין הקומפיילר של Compose עבר רפקטורינג כדי להשתמש בממשק במקום במחלקה קונקרטית. בנוסף, הממשק לא משתמש יותר בפרמטר מסוג.

  זהו שינוי פנימי שלא אמור להשפיע על התאימות של קוד המקור, אבל הוא שינוי בינארי שעלול לגרום לבעיות. (I3b922, b/169406779)

• הוצג SnapshotMutableState‏ (Icfd03)

• השם של DisposableEffectDisposable שונה ל-DisposaleEffectResult ‏ (Ica7c6)

• הוסר Recomposer.current(). [Abstract]ComposeView now default to lazily created, window-scoped Recomposers driven by the ViewTreeLifecycleOwner for the window. רה-קומפוזיציה וטיקים של אנימציה מבוססת-withFrameNanos מושהים בזמן שמחזור החיים של המארח מושהה. (I38e11)

• ‫Recomposer.runningRecomposers כולל עכשיו StateFlow גלובלי של RecomposerInfo לקריאה בלבד, כדי לעקוב אחרי מצב הקומפוזיציה בתהליך. עדיף להשתמש ב-API הזה במקום ב-Recomposer.current(), שהוצא משימוש. (If8ebe)

• השם של DisposableEffectDisposable שונה ל-DisposaleEffectResult ‏ (I3ea68)

גרסה ‎1.0.0-alpha11

‫28 בינואר 2021

‫androidx.compose.runtime:runtime-*:1.0.0-alpha11 מופץ. גרסה ‎1.0.0-alpha11 מכילה את השמירות האלה.

שינויים ב-API

• הפונקציות onCommit,‏ onDispose ו-onActive הוצאו משימוש לטובת ממשקי ה-API‏ SideEffect ו-DisposableEffect ‏ (If760e)
• הוצאנו משימוש את ה-API‏ emit() ואת כל העומסים העודפים שלו, ושינינו את השם שלו ל-ComposeNode. ממשקי ה-API זהים, רק השם שונה כדי לפעול בהתאם למוסכמות מתן השמות של Compose (I4137b)
• הפונקציות invalidate ו-compositionReference() הוצאו משימוש, ועכשיו משתמשים בפונקציות currentRecomposeScope ו-rememberCompositionReference בהתאמה. (I583a8)

• הפונקציה RememberObserver מחליפה את CompositionLifecycleObserver, והפונקציה CompositionLifecycleObserver הוצאה משימוש.

  ‫RememberObserver הוא תחליף ל-CompositionLifecycleObserver עם סמנטיקה שונה ושיטות ששמן שונה. אפשר לעבור ל-API החדש באופן מכני לאובייקטים שזוכרים רק פעם אחת, וזו גם ההמלצה שלנו. עם זאת, אם הפניה נשמרה יותר מפעם אחת ברכיב, הפונקציה onRemembered נקראת לכל הפניה, והפונקציה onEnter נקראת רק פעם אחת. הייתה קריאה לפונקציה onEnter כמה פעמים אם האובייקט היה בשימוש בקומפוזיציות משנה, כמו WithConstraints ו-Scaffold, ולכן אי אפשר היה להסתמך על קריאה יחידה לפונקציה onEnter, והיא הוסרה ב-RememberObserver.

  ‫RememberObserver מוסיף את onAbandoned שנקרא אם מופע RememberObserver מוחזר מהקריאה החוזרת שהועברה אל remember אבל לא נשמר במצב הקומפוזיציה, ולכן אף פעם לא תתבצע קריאה אל onRemembered. זה יכול לקרות אם חריגה מסיימת את ההרכבה לפני שהיא מסתיימת, או אם ההרכבה נפסלת כי המצב שהיא יצרה עבורו הרכבה כבר לא עדכני או כבר לא נחוץ. אם המופע של RememberObserver שמופיע אחרי ההמלצה שלמעלה לגבי הפניה יחידה עוקב אחרי משאב חיצוני, גם onForgotten וגם onAbandoned מציינים שהמשאב כבר לא נחוץ. אם האובייקט עוקב אחרי עבודה שהתחילה או משאבים שהוקצו ב-onRemembered, אפשר להתעלם מ-onAbandoned כי הוא לא יופעל אם onRemembered יופעל. (I02c36)

• אל תסמנו פונקציות collectAsState() כפונקציות מוטבעות (Ia73e4)

תיקוני באגים

• הקומפוזיציה WithConstraints עברה שינוי משמעותי, שונה לשם BoxWithConstraints והועברה אל foundation.layout. ‫(I9420b, ‏ b/173387208)
• שימוש ב-TestCoroutineDispatcher בבדיקות (I532b6)

גרסה ‎1.0.0-alpha10

‫13 בינואר 2021

‫androidx.compose.runtime:runtime-*:1.0.0-alpha10 מופץ. גרסה ‎1.0.0-alpha10 מכילה את השמירות האלה.

שינוי שעלול לגרום לכשלים

• שינוי המבנה של ה-API הפנימי של הקומפיילר מאפשר לאגד שינויים בצמתים שנוצרו כתוצאה מקומפוזיציה לשלב 'החלת שינויים' בקומפוזיציה, אחרי שכל הפונקציות @Composable הושלמו.

  זהו שינוי שעלול לשבור את ההתנהגות שעלול להשפיע על קוד אפליקציה, כי הצמתים לא זמינים יותר מממשקי API פנימיים וניסיוניים עד שהשינויים יחולו. בדרך כלל אפשר לפתור את הבעיה הזו על ידי הוספת קוד עם תלויות כאלה ל-SideEffect composable כדי לדחות את ההרצה של הקוד עד אחרי שהצמתים נוצרו ואותחלו. (I018da)

שינויים ב-API

• הוספנו דרך לעקוב אחרי השינויים שבוצעו על ידי ה-recomposer. (I1b3e2)

• הרחבת ממשקי ה-API של [Abstract]ComposeView כדי לאפשר מיחזור של תצוגות מבוססות-Compose, השבתת הקומפוזיציה שלהן כדי ליצור אותן מחדש מאוחר יותר. הוספת ממשקי API להתקנה ולגילוי של Recomposers בהיקף חלון ושל CompositionReferences ליצירת קומפוזיציות צאצא.

  מוסיפים ViewCompositionStrategy כדי להגדיר את אסטרטגיית הסילוק של [Abstract]ComposeViews; התנהגות ברירת המחדל היא סילוק בהסרת החלון. (I860ab)

תיקוני באגים

• ה-Recomposer חושף עכשיו Flow של המצב הנוכחי שלו, ומאפשר מעקב אחרי הפעילות שלו והפעילות של אפקטים משויכים. (Ifb2b9)
• עכשיו אפשר לגשת לאירוע המקורי של מקש באמצעות keyEvent.nativeKeyEvent ‏ (I87c57, ‏ b/173086397)

גרסה ‎1.0.0-alpha09

‫16 בדצמבר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha09 מופץ. גרסה ‎1.0.0-alpha09 מכילה את השמירות האלה.

שינויים ב-API

• הוסרו SlotTable, ‏ SlotReader ו-SlotWriter מה-API הציבורי. בעבר הם סומנו כ-InternalComposeAPI. עכשיו הם פנימיים למודול הכתיבה.

  הוספנו את CompositionData ו-CompositionGroup כתחליף ל-API של ui-tooling, כדי להשתמש בו לחילוץ מידע על קומפוזיציה. ממשקי ה-API האלה הם ציבוריים, אבל הם לא מיועדים לשימוש מחוץ ל-ui-tooling API, כי הם מספקים את המידע הגולמי ש-ui-tooling API מפרש (I31a9c).

• הסיווג Applier לא נחשב יותר ל-Id85b0

• ממשק Applier השתנה כדי לפשט את בניית העצים מלמטה למעלה במקום מלמעלה למטה.

  השם של ה-method‏ insert() השתנה ל-insertTopDown().

  נוספה שיטה חדשה: insertBottomUp()

  הכלי להחלת מדיניות מוסיף צמתים לעץ שהוא עורך באמצעות insertTopDown() או insertBottomUp(), בהתאם למה שפועל טוב יותר.

  יותר יעיל לבנות חלק מהעצים, כמו LayoutNode ו-View, מלמטה למעלה מאשר מלמעלה למטה. לפני השינוי הזה, היה צריך להשתמש במערך של תוספים כדי להטמיע את השיטה מלמטה למעלה, והיה צריך להעתיק את המערך לכל כלי שנדרש לבנייה מלמטה למעלה כדי לשפר את הביצועים. בעקבות השינוי הזה, Applier overrides insertBottomUp() כדי לבנות עץ מלמטה למעלה ו-insertTopDown() כדי לבנות את העץ מלמעלה למטה. (Icbdc2)

• ‫Compose תומך בשיטות getter של מאפיינים שיכולות לבצע קריאות לרכיבים קומפוזביליים. התמיכה בזה לא תבוטל, אבל התחביר להצהרה על מאפיין getter כ-@Composable ישתנה.

  התחביר שהוצא משימוש לביצוע הפעולה הזו היה באמצעות הוספת הערה לנכס עצמו:

      @Composable val someProperty: Int get() = ...
  

  התחביר הנכון לביצוע הפעולה הזו הוא באמצעות הערה של שיטת ה-getter של המאפיין:

     val someProperty: Int @Composable get() = ...
  

  שני סוגי התחביר יפעלו למשך זמן מסוים, אבל בסופו של דבר התחביר הישן שהוצא משימוש יהפוך לשגיאת קומפילציה. (Id9197)

תיקוני באגים

• AndroidOwner made internal (Ibcad0, b/170296980)
• הפונקציה subcomposeInto(LayoutNode) הפכה לפנימית (Id724a)

גרסה ‎1.0.0-alpha08

‫2 בדצמבר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha08 מופץ. גרסה ‎1.0.0-alpha08 מכילה את השמירות האלה.

שינויים ב-API

• נוספה בדיקת Lint לשמות ולמיקום של פרמטרים של lambda שאפשר להרכיב, כדי לבדוק אם יש התאמה להנחיות של Compose. בנוסף, העברנו חלק מממשקי ה-API באמצעות children כשם של פונקציית ה-lambda האחרונה שלהם אל content, בהתאם לבדיקת ה-lint ולהנחיות. (Iec48e)
• ‫Recomposer לא מקבל יותר EmbeddingContext. יחסי התלות הנדרשים בתזמון מתקבלים מ-effectCoroutineContext. ה-API ‏FrameManager הוצא משימוש. שילובים של פלטפורמות צריכים לאתחל טיפול גלובלי משלהם בתמונת מצב. (I02369)
• הפונקציה RestorableStateHolder.withRestorableState קיבלה את השם החדש RestorableStateProvider (I66640)

תיקוני באגים

• הסביבות שהוצאו משימוש נקראות עם Ambient כסיומת, והוחלפו במאפיינים חדשים עם הקידומת Ambient, בהתאם להנחיות של סביבות אחרות ושל Compose API. (I33440)
• הסרת המודול הישן ui-test וה-stubs שלו (I3a7cb)

גרסה ‎1.0.0-alpha07

11 בנובמבר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha07 מופץ. גרסה ‎1.0.0-alpha07 מכילה את השמירות האלה.

תכונות חדשות

שינויים ב-API

• ההערה @UnionType הוצאה משימוש (I57cde)
• הפונקציה provideDefault נוספה כחלופה לפונקציה provide כדי לספק ערכים של משתנים סביבתיים. אפשר להשתמש בה כדי לציין ערכים של משתנים סביבתיים שיוגדרו רק אם לא סופק כבר ערך של משתנה סביבתי. (Id6635, ‏ b/171024925)
• השם של LaunchedTask שונה ל-LaunchedEffect כדי לשמור על עקביות עם ממשקי ה-API של SideEffect ו-DisposableEffect. כדי לעודד שימוש בשיטות מומלצות, אסור להשתמש ב-LaunchedEffect ללא פרמטרים של נושא. (Ifd3d4)
• ל-Applier יש עכשיו קריאות חוזרות (callback) מסוג onBeginChanges/onEndChanges שמופעלות כש-Composer מתחיל להחיל שינויים על העץ או מסיים להחיל אותם. אפשר להשתמש בהם לניהול משאבים בקבוצות, אם צריך. (Icf476)
• החל מגרסה Recomposer, נדרש CoroutineContext בזמן יצירה (Ic4610)
• שינויים בהטמעה הפנימית של SlotTable שלא אמורים להשפיע על ה-API הציבורי. (If9828)
• הוסרו מתאמי rxjava2 שהוצאו משימוש ולא מקבלים את הערך ההתחלתי (Idb72f)

תיקוני באגים

• המאפיין foundation.Text הוצא משימוש והוחלף במאפיין material.Text. ל-API בסיסי לטקסט שלא צורך ערכים מעיצוב, אפשר לעיין ב-androidx.compose.foundation.BasicText. ‫(If64cb)
• ה-BaseTextField הוצא משימוש. במקום זאת, משתמשים ב-BasicTextField. (I896eb)
• כמה סמלים שקשורים לפריסה הועברו מ-androidx.compose.ui אל androidx.compose.layout.ui. (I0fa98, b/170475424)

External Contribution

• נוסף מודול runtime-rxjava3 לכתיבת הודעות. דומה ל-runtime-rxjava2 (I02cbf)

גרסה ‎1.0.0-alpha06

28 באוקטובר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha06 מופץ. גרסה ‎1.0.0-alpha06 מכילה את השמירות האלה.

שינויים ב-API

• הקומפוזיציה מחדש היא עכשיו CompositionReference והורה תקף של קומפוזיציה. השימוש ב-Explicit Recomposer נדרש עכשיו בפחות מקומות. (I4036f)
• נוסף API מקביל של DisposableEffect ל-SideEffect, שממלא את התפקיד של onCommit-with-params אבל עם onDispose נדרש.
  • נוסף rememberUpdatedState API לפרסום נתונים מ-רה-קומפוזיציה לתהליכים מתמשכים או ארוכי טווח, כמו DisposableEffects או LaunchedTasks.
  • (Id50b9)
• המחלקות MutableVector מיישמות עכשיו את RandomAccess ‏ (I85d73, ‏ b/170461551)
• נוסף קומפוזיציה SideEffect להחלת תופעות לוואי של קומפוזיציה על אובייקטים שמנוהלים על ידי הקומפוזיציה. הקומפוזבל SideEffect נועד להחליף את הקומפוזבל onCommit. (Ia77c2)
• ‫API ניסיוני חדש: RestorableStateHolder. הפונקציה מאפשרת לשמור את המצב שהוגדר באמצעות [savedInstanceState] ו-[rememberSavedInstanceState] עבור עץ המשנה לפני השמדת העץ, כדי לאפשר את הרכבתו מחדש בפעם הבאה עם המצב המשוחזר. ‫(I66884, ‏ b/166586419)

תיקוני באגים

• מפעילים מעברים ב-ComposeTestRule ומסירים את האפשרות להפעיל את הסמן המהבהב מ-ComposeTestRule. (If0de3)

גרסה ‎1.0.0-alpha05

‫14 באוקטובר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha05 מופץ. גרסה ‎1.0.0-alpha05 מכילה את השמירות האלה.

שינויים ב-API

• שינוי ניסיוני.שינוי קלט להשהיית קלט של מצביע (Ia77d2)
• הביצועים של LazyColumn/Row משתפרים כי מתבצעת פחות עבודה בהרכב משנה בכל גלילה. הוספנו את השיטה החדשה hasInvalidations()‎ למחלקה Composition. השיטה hasPendingChanges()‎ מ-Recomposer שונתה ל-hasInvalidations()‎ (Ib2f32, ‏ b/168293643, ‏ b/167972292, ‏ b/165028371)
• הוספנו את produceState API להפעלת קורוטינות מקומפוזיציה שמעדכנות ערך יחיד של State<T> לאורך זמן (Id4a57)
• הפונקציה launchInComposition שונתה ל-LaunchedTask כדי להתאים להנחיות של Compose API (I99a8e)
• הסדר של קריאות place() בפריסות מותאמות אישית מגדיר עכשיו את סדר הציור של הצאצאים (Ibc9f6)

גרסה ‎1.0.0-alpha04

‫1 באוקטובר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha04 מופץ. גרסה ‎1.0.0-alpha04 מכילה את השמירות האלה.

שינויים ב-API

• הוספנו את OwnerScope כדי לאפשר איסוף של היקפי תצפית על פריסות וציורים אחרי שהם כבר לא תקפים. (Ic4cf8)
• נוסף API של derivedStateOf כדי ליצור אובייקטים של State על סמך חישוב שיכול לקרוא (ולגזור) אובייקטים אחרים של State ‏ (If758b)
• נוסף TestOnly API ל-SnapshotStateObserver ‏ (I6e2a9)

תיקוני באגים

• הפונקציה foundation.Box הוצאה משימוש. במקומה צריך להשתמש ב-foundation.layout.Box. (Ie5950, ‏ b/167680279)

גרסה ‎1.0.0-alpha03

16 בספטמבר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha03 מופץ. גרסה ‎1.0.0-alpha03 מכילה את השמירות האלה.

שינויים ב-API

• CompositionCoroutineScope לא מטמיע יותר את MonotonicFrameClock. מי שמתקשר אל withFrameNanos צריך לייבא את הפונקציה ברמה העליונה באופן מפורש. (Icb642, ‏ b/166778123)

תיקוני באגים

• הפונקציות הגלובליות לבדיקה, כמו onNode או waitForIdle, הוצאו משימוש. צריך לעבור לגרסאות החדשות שלהן שמוגדרות ב-ComposeTestRule ‏ (I7f45a).
• ‫launchInComposition כבר לא מפעיל פונקציות Coroutine שלא נשלחו (Ief6af, ‏ b/166486000)

גרסה ‎1.0.0-alpha02

‫2 בספטמבר 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha02 מופץ. גרסה ‎1.0.0-alpha02 מכילה את השמירות האלה.

שינויים ב-API

• הוספת ממשקי API‏ snapshotFlow ו-withMutableSnapshot לצריכה וליצירה של שינויים בנתוני תמונת המצב. (I3e722)

• המוסכמה לקריאה לפונקציות שניתנות להרכבה השתנתה. זהו שינוי בינארי שעלול לגרום לכשל. צריך לקמפל מחדש את כל הספריות כדי שהן יפעלו עם הגרסה הזו של תוסף הקומפיילר של Compose.

  השינוי הזה לא יוצר שינוי שובר תאימות ברמת המקור, כי ממשקי ה-API היחידים שהשתנו הם ממשקי API של קומפיילר שנדרשת הסכמה מפורשת לשימוש בהם. ‫(I7afd2, ‏ b/158123185)

• הוסרו שיטות תזמון מ-EmbeddingContext ‏ (I7b9be)

• הפונקציה onPreCommit הוצאה משימוש. עכשיו הפונקציה onCommit כוללת את ההתנהגות של onPreCommit.

  הפונקציות onCommit ו-onActive פועלות עכשיו באותו פריים של Choreographer שבו השינויים בהרכב בוצעו, ולא בתחילת הפריים הבא של Choreographer. (I70403)

גרסה ‎1.0.0-alpha01

‫26 באוגוסט 2020

‫androidx.compose.runtime:runtime-*:1.0.0-alpha01 מופץ. גרסה 1.0.0-alpha01 מכילה את השמירות האלה.

גרסה ‎0.1.0-dev

גרסה ‎0.1.0-dev17

‫19 באוגוסט 2020

‫androidx.compose.runtime:runtime-*:0.1.0-dev17 מופץ. גרסה ‎0.1.0-dev17 מכילה את השמירות האלה.

שינויים ב-API

• עכשיו אפשר להצהיר בפונקציות emit מותאמות אישית שאפשר לדלג על אחת או יותר מהפונקציות setter שלהן ולבצע קומפוזיציה מחדש באופן עצמאי. (Ibbd13)

• הוסרו קריאות ל-FrameManager שיצאו משימוש.

  בוצעו שינויים בממשקי API פנימיים של Compose כדי לצמצם את התקורה של מעקב אחרי אובייקטים של מצב כמו mutableStateof() (I80ba6)

• הקומפוזיציה state { ... } הוצאה משימוש, ועכשיו נעשה שימוש בקריאות מפורשות ל-remember { mutableStateOf(...) } לשם הבהרה. השינוי הזה מצמצם את שטח הפנים הכולל של ה-API ואת מספר המושגים לניהול מצב, והוא תואם לתבנית by mutableStateOf() של הקצאת מאפייני מחלקה. (Ia5727)

• הפונקציה Flow.collectAsState קובעת עכשיו את ברירת המחדל של ה-dispatcher מתוך הקומפוזיציה עצמה, במקום להשתמש ב-Dispatchers.Main כברירת מחדל. (I9c1d9)

• תוקנה קריסה שמתרחשת כשמשתמשים בלולאת for במשהו ששומר את המצב. עכשיו מותר להשתמש באותו מפתח ב-savedInstanceState(),‏ ה-API של UiSavedStateRegistry מותאם עכשיו לדרישה החדשה הזו (I4ab76, ‏ b/160042650, ‏ b/156853976, ‏ b/159026663, ‏ b/154920561)

תיקוני באגים

• האפשרות emitView הוצאה משימוש. אם אפשר, משתמשים ב-AndroidView כדי להוציא Views בתוך Compose. שימו לב: בעתיד לא תהיה תמיכה בהוספה ישירה של רכיבי Views ו-ViewGroups, אלא אם הם רכיבי עלים בעץ ההרכב. במקרה כזה, אפשר להשתמש ב-AndroidView. (I29b1e, ‏ b/163871221)

גרסה 0.1.0-dev16

‫5 באוגוסט 2020

‫androidx.compose.runtime:runtime-*:0.1.0-dev16 מופץ. גרסה ‎0.1.0-dev16 מכילה את השמירות האלה.

שינויים ב-API

• מדיניות השינוי שמוגדרת כברירת מחדל ב-mutableStateOf(),‏ ambientOf() ו-savedInstanceStateOf() השתנתה מ-referentialEqualityPolicy() ל-structuralEqualityPolicy().

  ברירת המחדל להחלטה אם ערך חדש שמוקצה למופע mutableStateOf() נחשב לשינוי היא עכשיו שימוש ב-== במקום ב-===.

  פרטים נוספים זמינים בכתובת https://kotlinlang.org/docs/reference/equality.html

  ‫ambientOf() ו-savedInstanceStateOf() משתמשים ב-mutableStateOf() בהטמעות שלהם, ולכן הם שונו כדי להיות עקביים עם mutableStateOf().

  שימוש בשוויון מבני תואם יותר לציפיות של המפתחים.

  לדוגמה,

  val state = mutableStateOf(1f)
  

  ואחריו

  state.value = 1f
  

  לא ייחשב יותר כשינוי ב-state, ולא יהיה צורך יותר ליצור מחדש את השימוש ב-state במהלך הכתיבה.

  זהו שינוי שעלול לשבור את התאימות, אבל ברוב המקרים (למשל כשמשתמשים במחלקות שלא מבטלות את equals()), לא תהיה לו השפעה ניכרת על האפליקציה.

  בכיתות שמבצעות שינוי של equals(), כמו כיתות data, יכול להיות שתהיה ירידה בביצועים כי ה-methods של equals() נקראים עכשיו כברירת מחדל כשהם מוקצים ל-mutableStateOf().

  כדי לשחזר את ההתנהגות הקודמת, צריך להוסיף את פרמטר המדיניות policy = referentialEqualityPolicy() לקריאות אל mutableStateOf(), ambientOf() ו-savedInstanceStateOf(). (Ic21a7)

• הפונקציות Row ו-Column הן עכשיו פונקציות מוטבעות, מה שמפחית באופן משמעותי את התקורה של השימוש בהן. (I75c10)

תיקוני באגים

• הפונקציה setViewContent הוצאה משימוש. במקומה צריך להשתמש בפונקציה setContent. ‫(I7e497, ‏ b/160335130)

• נוסף MonotonicFrameAnimationClock שמאפשר להשתמש ב-MonotonicFrameClock כ-AnimationClockObservable כדי לגשר על הפער בין השעונים החדשים שמבוססים על קורוטינות לבין ממשקי API שעדיין משתמשים בשעונים הישנים שמבוססים על קריאות חוזרות (callback).

  הגרסה המקבילה של ManualAnimationClock ל-MonotonicFrameClock היא עכשיו ManualFrameClock. (I111c7, b/161247083)

• הפונקציה Modifier.stateDraggable עברה שינוי משמעותי ושמה שונה ל-Modifier.swipeable. נוספה מחלקה חדשה בשם SwipeableState, והמחלקה DrawerState והמחלקה BottomDrawerState עברו רפקטורינג כדי לרשת ממנה. [Modal/Bottom]DrawerLayout לא מקבל יותר פרמטר onStateChange. (I72332, ‏ b/148023068)

• ה-API‏ Modifier.plus הוצא משימוש. במקומו צריך להשתמש ב-Modifier.then. השימוש במילה 'אז' מספק אות חזק יותר לגבי הסדר, ובנוסף אוסר על הקלדת Modifier.padding().background() + anotherModifier, מה ששובר את הרצף ומקשה על הקריאה (Iedd58, ‏ b/161529964)

• הקומפוננטה SubcomposeLayout נוספה. זהו פרימיטיב ברמה נמוכה שמאפשר להרכיב את רכיבי הצאצא במהלך המדידה, אם רוצים להשתמש בערכים שזמינים רק מאוחר יותר במהלך המדידה להרכבת עץ המשנה. לדוגמה, WithConstraints לא מיושם באמצעות SubcomposeLayout. (I25cc8)

• השם של Material FilledTextField שונה ל-TextField, והשם של TextField הבסיסי שונה ל-BaseTextField, כדי שיהיה קל יותר לגלות את ה-API הרצוי הפשוט ביותר ולהשתמש בו (Ia6242, b/155482676).

• השם של Modifier.drawBackground שונה ל-Modifier.background (I13677)

גרסה 0.1.0-dev15

22 ביולי 2020

‫androidx.compose.runtime:runtime-*:0.1.0-dev15 מופץ. גרסה ‎0.1.0-dev15 מכילה את השמירות האלה.

עדכון התלות

• כדי להשתמש בגרסה 0.1.0-dev15 של Compose, צריך לעדכן את התלויות בהתאם לקטעי הקוד החדשים שמוצגים למעלה בקטע הצהרה על תלויות.

שינויים ב-API

• ההערה @Model הוצאה משימוש. אפשר להשתמש ב-state וב-mutableStateOf כחלופות. ההחלטה להוציא משימוש את התכונה הזו התקבלה אחרי דיונים מעמיקים.

  הצדקה

  ההסבר כולל, בין היתר:

  • מצמצם את שטח הפנים של ה-API ואת המושגים שאנחנו צריכים ללמד
  • התאמה טובה יותר לערכות כלים דומות אחרות (Swift UI, ‏ React, ‏ Flutter)
  • החלטה שניתן לבטל. תמיד אפשר להפעיל את @Model מחדש מאוחר יותר.
  • הסרת מקרים מיוחדים של שימוש ושאלות קשות לענות עליהן לגבי הגדרת @Model כדברים שאנחנו צריכים לטפל בהם
  • מחלקות נתונים @Model, equals,‏ hashcode וכו'.
  • איך אפשר להגדיר שחלק מהנכסים יהיו במעקב וחלק לא?
  • איך מציינים אם להשתמש בשוויון מבני או בשוויון של הפניה בתצפית?
  • מפחיתים את ה'קסם' במערכת. השינוי יקטין את הסיכוי שמישהו יניח שהמערכת חכמה יותר ממה שהיא (כלומר, שהיא יודעת להשוות בין רשימות)
  • הופך את רמת הפירוט של התצפית לאינטואיטיבית יותר.
  • משפר את האפשרות לבצע רפקטורינג ממשתנה -> מאפיין במחלקה
  • יכול להיות שיהיו אפשרויות לאופטימיזציות ספציפיות למדינה
  • ההגדרה הזו תואמת יותר לשאר המערכת האקולוגית ומפחיתה את אי הבהירות לגבי מצב בלתי משתנה או לגבי 'אימוץ מצב משתנה'

  הערות לגבי העברה

  כמעט כל השימושים הקיימים ב-@Model ניתנים לשינוי בקלות יחסית באחת משתי דרכים. בדוגמה שלמטה יש מחלקה @Model עם שני מאפיינים רק לצורך הדוגמה, והיא נמצאת בשימוש בקומפוזיציה.

  @Model class Position(
   var x: Int,
   var y: Int
  )
  
  @Composable fun Example() {
   var p = remember { Position(0, 0) }
   PositionChanger(
     position=p,
     onXChange={ p.x = it }
     onYChange={ p.y = it }
   )
  }
  

  חלופה 1: משתמשים בפקודה State<OriginalClass> ויוצרים עותקים.

  הגישה הזו קלה יותר לשימוש בזכות מחלקות הנתונים של Kotlin. בעצם, צריך להפוך את כל מאפייני var הקודמים למאפייני val של מחלקת נתונים, ואז להשתמש ב-state במקום ב-remember, ולהקצות את ערך המצב לעותקים משוכפלים של המקור באמצעות שיטת הנוחות copy(...) של מחלקת הנתונים.

  חשוב לציין שהגישה הזו פועלת רק אם כל השינויים שבוצעו במחלקה הזו נעשו באותו היקף שבו נוצר המופע State. אם המחלקה משנה את עצמה באופן פנימי מחוץ להיקף השימוש, ואתם מסתמכים על התצפית הזו, כדאי להשתמש בגישה הבאה.

  data class Position(
   val x: Int,
   val y: Int
  )
  
  @Composable fun Example() {
   var p by state { Position(0, 0) }
   PositionChanger(
     position=p,
     onXChange={ p = p.copy(x=it) }
     onYChange={ p = p.copy(y=it) }
   )
  }
  

  חלופה 2: שימוש ב-mutableStateOf וב-property delegates

  הגישה הזו פשוטה יותר בזכות נציגי המאפיינים של Kotlin ו-mutableStateOf API, שמאפשרים ליצור מופעים של MutableState מחוץ לקומפוזיציה. בעצם, מחליפים את כל המאפיינים var של המחלקה המקורית במאפיינים var עם mutableStateOf כנציג המאפיין שלהם. היתרון הוא שהשימוש בכיתה לא ישתנה בכלל, רק ההטמעה הפנימית שלה. ההתנהגות לא זהה לחלוטין לדוגמה המקורית, כי כל נכס נצפה או נרשם בנפרד, ולכן יכול להיות שהקומפוזיציות מחדש שיוצגו אחרי השינוי הזה יהיו מצומצמות יותר (וזה טוב).

  class Position(x: Int, y: Int) {
   var x by mutableStateOf(x)
   var y by mutableStateOf(y)
  }
  
  // source of Example is identical to original
  @Composable fun Example() {
   var p = remember { Position(0, 0) }
   PositionChanger(
     position=p,
     onXChange={ p.x = it }
     onYChange={ p.y = it }
   )
  }
  

  (I409e8, b/152050010, b/146362815, b/146342522, b/143413369, b/135715219, b/143263925, b/139653744)

• שינוי אסטרטגיית יצירת הקוד של מהדר Compose. לפני השינוי, מהדר ה-Compose היה משנה קריאות לפונקציות שניתנות להרכבה. בעקבות השינוי הזה, אנחנו משנים את הגוף של פונקציה קומפוזבילית, ומשאירים את מיקום הקריאה ללא שינוי (ברוב המקרים).

  המשמעות היא שרוב הלוגיקה שמתקשרת עם זמן הריצה של הכתיבה מתרחשת בתחילת גוף הפונקציה, במקום במיקום הקריאה.

  השינוי הזה אמור להיות תואם למקור בכל השימושים ב-Compose. רוב המשתמשים ב-Compose לא צריכים לעדכן קוד כתוצאה מהשינוי הזה.

  כדי לתמוך בעבודה הזו, חתימת ה-JVM של כל הפונקציות שניתנות להרכבה השתנתה. פונקציה קומפוזבילית שמקבלת פרמטר יחיד, הופכת לפונקציה שמקבלת 3 פרמטרים. הפרמטרים הנוספים הם Composer ומספר שלם מסוג 'key'. מספר שלם מסוג bitmask משמש להעברת מטא-נתונים דרך קריאות.

  Compose הופכת עכשיו גם ארגומנטים שמוגדרים כברירת מחדל לפונקציה קומפוזבילית. השינוי הזה מתבצע בלי להוסיף עומס יתר של ברירת מחדל סינתטית לפונקציה עצמה, ולכן יוגדרו פחות פונקציות.

  אלה שינויים התנהגותיים מכוונים שידועים לנו כתוצאה מהעדכון הזה:

  1. חלק מהשיחות ידלגו על מקומות שבהם הן לא דילגו בעבר
  2. ביטויים שניתנים להרכבה בביטויי ארגומנטים שמוגדרים כברירת מחדל נרשמים עכשיו למינוי ומטופלים בצורה נכונה

  העבודה הזו כללה כמה אופטימיזציות: ‫1. התוצאה של השוואות בין פרמטרים מועברת דרך תרשים הקריאות לפונקציות אחרות שאפשר להרכיב. התוצאה תהיה פחות השוואות בזמן הריצה, הקטנה של גודל טבלת המשבצות ודילוג על יותר פונקציות שאפשר להרכיב שלא דולגו קודם. ‫2. פרמטרים שנקבע שהם 'סטטיים' בזמן ההידור לא מושווים יותר ולא מאוחסנים בזמן הריצה. כך מקטינים את מספר ההשוואות ואת גודל טבלת המשבצות. 3. מבנה בקרת הזרימה של גוף הפונקציות משמש לצמצום מספר הקבוצות שנוצרות. כך מקטינים את גודל טבלת המשבצות ומפחיתים את העבודה של זמן הריצה 4. פרמטרים של שליחה וקבלה שלא נעשה בהם שימוש בפונקציות לא נכללים בקביעת האפשרות לדלג על הפונקציה אם לא נעשה בהם שימוש בגוף הפונקציה.

  רוב השינויים שגורמים לבעיות תאימות היו ב-API שהקומפיילר מכוון אליו ישירות, והשימוש הרגיל ב-Compose לא יושפע: ‫1. הפונקציה Composer::startExpr הוסרה ‫2. ‫Composer::endExpr הוסר ‫3. ‫Composer::call הוצא משימוש ‫4. העומסים העודפים שאינם varargs של key הוסרו. להשתמש בגרסה vararg מעכשיו והלאה. 5. ההערה Pivotal הוצאה משימוש. אפשר להשתמש ב-key במקום. 6. הפונקציה ScopeUpdateScope::updateScope שונתה כך שהיא מצפה ל-Function3 במקום ל-Function1 7. הפונקציות restartableFunction ו-restartableFunctionN עודכנו כך שיכללו פרמטרים נוספים של זמן קומפילציה (I60756, ‏ b/143464846)

• נוספו sortWith ו-removeRange ל-MutableVector ‏ (Icccf7)

• נוספו הטמעות של שיטות ברירת מחדל עבור CompositionLifecycleObserver (I24289)

• הכלי Applier דורש עכשיו שימוש בשיטה clear()‎ כדי להשמיד קומפוזיציות (Ibe697)

• הפונקציה asMutableList() נוספה ל-MutableVector כדי לאפשר לה לעבור ל-API ציבורי בלי להעתיק את כל הרשימה. (I298df)

• נוספה הפונקציה rememberCoroutineScope()‎ כדי לקבל CoroutineScope מנוהל בקומפוזיציה להפעלת משימות בתגובה לאירועים. (I0e264)

• ‫MutableVector הוא אוסף חדש שלא מיישם אף אחד מממשקי האוסף הרגילים. האוסף הזה מציע מהירות מעל הדרישות האחרות, והוא מיועד לשימוש רק בהטמעות פנימיות. (I8ebd6)

• הסרנו באופן זמני את StableMutableList ואת StableMutableMap כדי למנוע בעיה בגרסה של Kotlin Compose שנדרשת. הממשקים האלה יחזרו אחרי ש-Compose יעודכן לגרסה של Kotlin שבה הבעיה לא קיימת.

  הפונקציות SnapshotStateList ו-SnapshotStateMap גלויות לכולם עכשיו, אבל הן יוצאו משימוש אחרי שחזור הפונקציות StableMutableList ו-StableMutableMap. (Ia7769)

• הוספת פונקציה ברמה העליונה עם frameNanos לתזמון אנימציה (Ie34c5)

• ההערה @Untracked הוצאה משימוש. Replace with @ComposableContract(tracked=false) (Id211e)

• השמות של RestartableFunction וממשקי ה-API שקשורים אליו שונו ל-ComposableLambda וכו'. ממשקי ה-API האלה טירגטו רק את הקומפיילר, ולכן השינוי הזה לא אמור להשפיע על התאימות ברמת המקור בדרך כלל. השינוי בשם נעשה בעיקר כדי להבהיר טוב יותר מהו המחלקה הזו כשהיא מופיעה במעקב אחר מחסנית (I7eb25)

• ההערה @Composable כבר לא תקפה לגבי מחלקות (Ia5f02)

• ‫Ambient<T> is now @Stable instead of @Immutable (I0b4bb)

• לפני השינוי הזה, התוסף של מהדר Compose היה מיירט באופן לא טריוויאלי קריאות ל-constructors בתוך פונקציה עם הערה @Composable אם הייתה (I5205a, b/158123804)

• הקומפוזיציה Recompose כבר לא מהווה הפשטה שימושית. רוב הרה-קומפוזיציה צריכה לקרות כתוצאה מהקצאות של MutableState. לכל דבר אחר, מומלץ להשתמש בפונקציה invalidate כדי להפעיל יצירה מחדש של ההיקף הנוכחי. (Ifc992)

• ההפשטה Observe כבר לא שימושית. אם אתם צריכים לשכפל אותה, אפשר לשכפל את ההטמעה שלה פשוט על ידי יצירת פונקציה הניתנת להגדרה שמבצעת פרמטר lambda הניתן להגדרה. לדוגמה, @Composable fun Observe(body: @Composable () -> Unit) = body() (I40d37)

• ההערה @Direct הוצאה משימוש לטובת @ComposableContract(restartable=false) (If4708)

• נוסף מתאם ל-StateFlow שהוצג לאחרונה, שמאפשר לאכלס מראש את הערך הראשוני כך שהמצב שמוחזר לא יכול להיות null ‏ (I61dd8,‏ b/156233789)

• נוסף מתאם ל-Flow. דוגמה לשימוש: val value by flow.collectAsState() (If2198, b/153375923)

• [ניתן לשינוי]אופרטורים של נציגי מאפיינים של מצב הועברו לתוספים כדי לתמוך באופטימיזציות של נציגי מאפיינים ב-Kotlin 1.4. כדי להמשיך להשתמש ב-by state { ... } או ב-by mutableStateOf(...), המתקשרים צריכים להוסיף ייבוא. (I5312c)

• ‫androidx.compose.ViewComposer הועבר אל androidx.ui.node.UiComposer ‫androidx.compose.Emittable הוסר. הוא היה מיותר עם ComponentNode. הספרייה androidx.compose.ViewAdapters הוסרה. הם כבר לא נתמכים. הפונקציה Compose.composeInto הוצאה משימוש. במקומה, צריך להשתמש ב-setContent או ב-setViewContent. השימוש ב-Compose.disposeComposition הוצא משימוש. במקום זאת, משתמשים בשיטה dispose באובייקט Composition שמוחזר על ידי setContent. הפונקציה androidx.compose.Compose.subcomposeInto הועברה אל androidx.ui.core.subcomposeInto השם של הפונקציה ComponentNode#emitInsertAt שונה ל-ComponentNode#insertAt השם של הפונקציה ComponentNode#emitRemoveAt שונה ל-ComponentNode#removeAt השם של הפונקציה ComponentNode#emitMode שונה ל-ComponentNode#move (Idef00)

• הדגל ComposeFlags.COMPOSER_PARAM עודכן ל-true, וכתוצאה מכך ישתנה אופן יצירת הקוד בתוסף לכתיבת הודעות. ברמה גבוהה, הפעולה הזו גורמת ליצירה של פונקציות עם הערה @Composable עם פרמטר סינתטי נוסף, שמועבר לקריאות הבאות עם הערה @Composable כדי שסביבת זמן הריצה תוכל לנהל את הביצוע בצורה תקינה. זהו שינוי משמעותי שגורם לשבירת תאימות בינארית, אבל הוא אמור לשמור על תאימות ברמת המקור בכל השימושים המאושרים ב-Compose. (I7971c)

• שינויי תוכנה שעלולים לגרום לכשל ב-API של מצב אווירה. פרטים נוספים מופיעים ביומן ובמסמכי התיעוד של Ambient<T> (I4c7ee, b/143769776)

• נוסף ui-livedata – ארטיפקט חדש עם מתאם ל-LiveData. דוגמה לשימוש: val value by liveData.observeAsState() (Ie9e8c, b/150465596)

• השימוש במתאמי Rx ללא ערך התחלתי מפורש הוצא משימוש. שימוש בערך null לא תמיד מומלץ כברירת מחדל. לדוגמה, אם יש לכם רשימה, עדיף להתחיל עם emptyList()‎ או עם ברירת מחדל סבירה אחרת (I00025,‏ b/161348384)

• נוסף ui-rxjava2 – ארטיפקט חדש עם מתאמים ל-RxJava2. דוגמה לשימוש: val value by observable.subscribeAsState() (Ifab4b, b/153369097)

• אפשר עכשיו להשתמש ב-savedInstanceState() עם סוגים שניתן להגדיר כ-nullable (I6847f, ‏ b/153532190)

• פונקציות חדשות listSaver()‎ ו-mapSaver()‎ כדי להקל על כתיבת אובייקטים מותאמים אישית של Saver (I8cf68, ‏ b/152331508)

• פונקציות חדשות: savedInstanceState()‎ ו-rememberSavedInstanceState()‎. הן דומות לפונקציות state()‎ ו-remember()‎, אבל יש להן תמיכה מובנית במצב של מופע שנשמר (If1987,‏ b/152025209)

תיקוני באגים

• השם של runOnIdleCompose שונה לrunOnIdle (I83607)
• ‫API ניסיוני של LayoutNode (I4f2e9)
• השימוש ב-androidx.ui.foundation.TextFieldValue וב-androidx.ui.input.EditorValue הוצא משימוש. גם רכיבי ה-TextField,‏ FilledTextField ו-CoreTextField הניתנים להרכבה שמשתמשים בסוג הזה הוצאו משימוש. במקום זאת, צריך להשתמש ב-androidx.ui.input.TextFieldValue ‏ (I4066d,‏ b/155211005)
• הוסר ה-API ‏DrawBackground שיצא משימוש לטובת ממשקי API של תוסף drawBackground ב-Modifier. בוצע רפקטורינג של ההטמעות של color,‏ brush ו-paint drawBackground כדי לצמצם את נתיבי הקוד, וגם כדי להסיר את הדרישה ליצירת Modifier כחלק מהקומפוזיציה. (I0343a)
• ממשקי API ברמה גבוהה יותר של Compose עודכנו כך שבמקום Canvas הם חושפים CanvasScope. כך הצרכנים לא צריכים לתחזק אובייקטים משלהם של Paint. צרכנים שעדיין צריכים גישה ל-Canvas יכולים להשתמש בשיטה drawCanvas של התוסף, שמספקת קריאה חוזרת להנפקת פקודות ציור עם ה-Canvas הבסיסי. (I80afd)
• בוצע שינוי ב-API של lambda עם Constraints trailing. עכשיו, במקום שני פרמטרים, יש לו היקף של מקבל, שבנוסף למגבלות ול-layoutDirection, מספק את המאפיינים minWidth,‏ maxWidth,‏ minHeight ו-maxHeight ב-Dp ‏ (I91b9a,‏ b/149979702)
• נוסף משנה של מרווח פנימי סימטרי. (I39840)
• הפונקציות wrapContentWidth ו-wrapContentHeight עודכנו כך שהן מצפות ליישור אנכי או אופקי ולא ליישור כלשהו. המשנה של המאפיין gravity עודכן כך שיקבל יישור אנכי או אופקי. העדכנו את הרכיבים Row, ‏ Column ו-Stack כדי לתמוך ביישור רציף בהתאמה אישית. (Ib0728)
• המודול ui-text משנה את השם ל-ui-text-core (I57dec)
• שיפור של DrawModifier API:
  • הגדרנו את היקף המקבל של draw()‎ כ-ContentDrawScope
  • הסרה של כל הפרמטרים ב-draw()
  • ל-DrawScope יש את אותו ממשק כמו ל-CanvasScope הקודם
  • ל-ContentDrawScope יש שיטה drawContent()‎‏ (Ibaced, ‏ b/152919067)
• התכונה ColoredRect הוצאה משימוש. במקומה, צריך להשתמש ב-method‏ Box(Modifier.preferredSize(width, height).drawBackground(color)). (I499fa, b/152753731)
• הוחלף Modifier plus operator בפונקציות של תוסף factory ‏ (I225e4)
• מעכשיו אפשר לגשת לחברים ב-RowScope וב-ColumnScope מחוץ ל-Row ול-Column. (I3a641)
• השם של LayoutFlexible שונה ל-LayoutWeight. השם של הפרמטר tight שונה ל-fill. (If4738)
• הפרמטר LayoutDirection נוסף ל-WithConstraints ‏ (I6d6f7)
• שינוי השם של הרקע ל-DrawBackground והגדרתו כברירת מחדל (Ia0bd3)
• החלפנו את ButtonStyle בפונקציות נפרדות והסרנו את העומס של הטקסט (מחרוזת). אפשר לעיין בדוגמאות מעודכנות של פרטי השימוש. (If63ab, b/146478620, b/146482131)
• ‫runOnIdleCompose ו-runOnUiThread הן עכשיו פונקציות גלובליות במקום שיטות ב-ComposeTestRule. (Icbe8f)

External Contribution

• הסרה של API מיותר כמו Looper ו-Handler משכבת ההעברה של Compose Runtime (I6847d)
• הוצאה משימוש של Flow<T>.collectAsState() ללא ערך ראשוני. במקום זאת, אפשר להשתמש ב-StateFlow<T> או להעביר ערך התחלתי מפורש. ‫(I63f98, ‏ b/157674865)