Compose Runtime

Compose Runtime

מדריך למשתמש  דוגמה לקוד

מסמכי עזרה של API
androidx.compose.runtime
androidx.compose.runtime.rxjava2
androidx.compose.runtime.rxjava3
androidx.compose.runtime.saveable
androidx.compose.runtime.snapshots
(מידע נוסף זמין במסמכי העזרה של כל החבילות של Compose)

אבני בניין בסיסיות של מודל התכנות ושל ניהול המצב ב-Compose, וזמן ריצה ליבה שאליו פונה הפלאגין של Compose Compiler.

העדכון האחרון	גרסה יציבה	גרסה מועמדת להפצה	גרסת בטא	גרסה אלפא
13 בנובמבר 2024	1.7.5	-	-	1.8.0-alpha06

מבנה

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

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

קיבוץ	תיאור
compose.animation	פיתוח אנימציות באפליקציות שלהם ב-Jetpack Compose כדי להעשיר את חוויית המשתמש.
compose.compiler	שינוי פונקציות עם @Composable והפעלת אופטימיזציות באמצעות פלאגין של קומפילר Kotlin.
compose.foundation	כתיבת אפליקציות ב-Jetpack Compose באמצעות אבני בניין מוכנות לשימוש והרחבת הבסיס כדי ליצור רכיבים משלכם של מערכת עיצוב.
compose.material	פיתוח ממשקי משתמש של Jetpack Compose באמצעות רכיבי Material Design מוכנים לשימוש. זוהי נקודת הכניסה ברמה הגבוהה יותר של Compose, שנועדה לספק רכיבים שתואמים לאלה שמתוארים בכתובת www.material.io.
compose.material3	פיתוח ממשקי משתמש של Jetpack Compose באמצעות רכיבי Material Design 3, הגרסה הבאה של Material Design. Material 3 כולל רכיבים ועיצוב נושאים מעודכנים ותכונות של התאמה אישית של Material You, כמו צבעים דינמיים. הוא תוכנן כך שיהיה עקבי עם הסגנון החזותי החדש של Android 12 וממשק המשתמש של המערכת.
compose.runtime	אבני בניין בסיסיות של מודל התכנות ושל ניהול המצב ב-Compose, וזמן ריצה ליבה שאליו פונה הפלאגין של Compose Compiler.
compose.ui	רכיבים בסיסיים של ממשק המשתמש של Compose שנדרשים כדי לקיים אינטראקציה עם המכשיר, כולל פריסה, ציור והזנה.

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

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

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

Groovy

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

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Kotlin

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

android {
    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

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

משוב

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

דיווח על בעיה חדשה

מידע נוסף זמין במסמכי התיעוד של Issue Tracker.

Runtime Tracing גרסה 1.7

גרסה 1.7.0-rc01

18 בספטמבר 2024

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

Runtime Tracing גרסה 1.0

גרסה 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 הוסיפה לאפליקציה גרסה חדשה יותר של compose-runtime.

גרסה 1.0.0-alpha04

23 באוגוסט 2023

androidx.compose.runtime:runtime-tracing:1.0.0-alpha04 משוחרר. גרסה 1.0.0-alpha04 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

תכונות חדשות

• התכונה תואמת לגרסאות האחרונות של Benchmark ו-Tracing Perfetto, ומאפשרת תמיכה ב-Composition Tracing בזמן הפעלת האפליקציה (הפעלה קרה), למשל ב-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.8

גרסה 1.8.0-alpha06

13 בנובמבר 2024

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

שינויים ב-API

• שינויים ב-API של PausableComposition. השינויים האלה משבשים את הגרסאות הקודמות של 1.8.0-alpha (החל מ-1.8.0-alpha02), אבל מכיוון שאלה ממשקי API חדשים ב-1.8.0, אין תאימות לאחור כי ממשקי ה-API עדיין נמצאים בגרסת אלפא. (I39819)
• הוספת ממשקי API של כלים כדי לעקוב אחרי יצירת קומפוזיציות חדשות ב-Recomposer‏ (Iaeb7e)
• הוספת snapshotId מסוג Long אל Snapshot והוצאה משימוש של id. המזהה של קובץ snapshot השתנה מ-Int ל-Long כדי למנוע מצב של חריגה ממכסת המזהים של קובץ snapshot במערכות עם קצב פריימים גבוה מאוד ואנימציות ארוכות. הסוג הוגדר כ-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 לחזרה חוזרת (iterative) במקום לחזרה חזרה (recursive) (I5817f)

תרומה חיצונית

• הטמעת סטאקים עם רשימות אוספים (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 כוללת את ההוספות האלה.

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

• יצירת הקשר צאצא בזִהירות עבור rememberCoroutineScope‏ (f61464)
  • בדרך כלל משתמשים ב-rememberCoroutineScope כדי להפעיל פונקציות רפיטיביות בתגובה לאירועים שמתרחשים אחרי ה-composition. בתרחישים מסוימים, יכול להיות שהאירועים האלה לא יתרחשו אף פעם, וכתוצאה מכך יהיו עלויות נוספות של יצירת משימות וביטול שלהן ללא תועלת.
  • אפשר להגדיר שההיקף שמוחזר על ידי rememberCoroutineScope ייצור את coroutineContext שלו באופן עצל (lazy) כשמתבצעת גישה אליו, וכך למנוע לחלוטין את יצירת המשימה וביטולה אם אף פעם לא משתמשים בהיקף.

גרסה 1.8.0-alpha02

18 בספטמבר 2024

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

תכונות חדשות

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

גרסה 1.8.0-alpha01

4 בספטמבר 2024

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

גרסה 1.7

גרסה 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

• אין שינויים בפריטי המידע שנוצרו בתהליך פיתוח (artifacts) של Android. הוסרו ארטיפקטים מסוג -desktop והתווספו ארטיפקטים מסוג -jvmStubs ו--linuxx64Stubs. אין להשתמש באף אחד מהיעדים האלה. הם משמשים כסמנים לעזרה במאמצים של Jetbrains Compose.

גרסה 1.7.0

4 בספטמבר 2024

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

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

• נוספה האפשרות לספק משתנה מקומי של קומפוזיציה שמחושב על סמך הערכים של משתנים מקומיים אחרים של קומפוזיציה, כברירת מחדל, באמצעות compositionLocalWithComputedDefault() או על ידי הצגת פונקציית lambda לשימוש בחישוב הערך באמצעות providesComputed במקום provides.
• אפשר לקבל את הערך של רכיב מקומי בתוך קומפוזיציה באמצעות המאפיין currentValue של הרכיב המקומי בתוך קומפוזיציה, שאפשר לגשת אליו מתוך פונקציית ה-lambda שמחשבת את הערך. משתמשים ב-current במקום ב-current, שאפשר לגשת אליו רק בפונקציות @Composable. (Iadbc0)
• אפשר לגשת מיד לאובייקטים חדשים של מצב מ-snapshots אחרים, כולל ה-snapshot הגלובלי, עם המצב הראשוני שלהם. שינויים נוספים לא יהיו גלויים עד להחלה של קובץ ה-snapshot שבו נוצר האובייקט.
• המצב הראשוני של mutableStateOf(), וגם הגרסאות הפרימיטיביות שלו, הוא הערך שמוענק כפרמטר ל-mutableStateOf(). המצב הראשוני של mutableStateListOf() ו-mutableStateMapOf() הוא ריק.
• נוספו Snapshot.isInSnapshot ו-Snapshot.PreexistingSnapshotId, שמשמשים לאפשרות של אובייקט מצב לתמוך בגישה מיידית מ-snapshot הגלובלי בזמן היצירה שלו.
• כדי לאפשר גישה מיידית לאובייקטים של מצב בהתאמה אישית, צריך לפעול לפי התבנית של השינויים שבוצעו באובייקטים המובנים של קובצי snapshot. (I84a17)
• מפעילים את nonSkippingGroupOptimization בספריות ליצירת תוכן. כך הקוד שנוצר לכל הפונקציות הניתנות לקיבוץ שלא ניתן להפעיל מחדש ב-androidx יעיל יותר. בעתיד אנחנו מתכננים להפעיל את התכונה הזו כברירת מחדל. I(acbc08)
• ביטול התוקף של פונקציות lambda שניתנות ליצירה מחדש בתוך קומפוזיציות משנה באותו פריים. (98301c)
• קוראים ל-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() או על ידי הצגת פונקציית lambda לשימוש בחישוב הערך באמצעות providesComputed במקום provides.
• אפשר לקבל את הערך של רכיב מקומי בתוך קומפוזיציה באמצעות המאפיין currentValue של הרכיב המקומי בתוך קומפוזיציה, שאפשר לגשת אליו מתוך פונקציית ה-lambda שמחשבת את הערך. משתמשים ב-current במקום ב-current, שאפשר לגשת אליו רק בפונקציות @Composable. (Iadbc0)

שינויים ב-API

• אפשר לגשת מיד לאובייקטים חדשים של מצב מ-snapshots אחרים, כולל ה-snapshot הגלובלי, עם המצב הראשוני שלהם. שינויים נוספים לא יהיו גלויים עד להחלה של קובץ ה-snapshot שבו נוצר האובייקט.
• המצב הראשוני של mutableStateOf(), וגם הגרסאות הפרימיטיביות שלו, הוא הערך שמוענק כפרמטר ל-mutableStateOf(). המצב הראשוני של mutableStateListOf() ו-mutableStateMapOf() הוא ריק.
• נוספו Snapshot.isInSnapshot ו-Snapshot.PreexistingSnapshotId, שמשמשים לאפשרות של אובייקט מצב לתמוך בגישה מיידית מ-snapshot הגלובלי בזמן היצירה שלו.
• כדי לאפשר גישה מיידית לאובייקטים של מצב בהתאמה אישית, צריך לפעול לפי התבנית של השינויים שבוצעו באובייקטים המובנים של קובצי 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)
• הימנעות מנעילה גורפת (deadlock) ב-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)
• תיקון של דליפת זיכרון ב-Composer (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 מכילה את ההצהרות האלה.

תיקוני באגים

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

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

• שינוי של משתמש שמתבונן בתמונה מצבירה כשהיא כבר שקופה. (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)
• אופטימיזציה של התיעוד של שינויים במצבים של קובצי snapshot (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 כוללת את ההצהרות האלה על ביצוע שינויים (commits).

תיקוני באגים

• קוראים ל-onRelease באותו סדר כמו onForgotten. (2cd790)
• מסננים מצבים שהשתנו ולא זוהו ב-snapshotFlow. (796b80)

גרסה 1.6.0

24 בינואר 2024

androidx.compose.runtime:runtime-*:1.6.0 משוחרר. גרסה 1.6.0 כוללת את ההצהרות האלה.

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

תכונות חדשות

• השלכת חריגות מחדש שנבלעות במהלך לולאת הרכבת מחדש (4dff9a)

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

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

תיקוני באגים

• תיקון של דליפת זיכרון בטבלת חריצי זיכרון (73fcfe)
• דילוג על הרכבת מחדש של קומפוזיציות משנה שיוסרו. (Ieeb99, ‏ b/254645321)
• מפעילים את מחזורי החיים של RememberObserver רק כשהוא מאוחסן בחישוב של remember. (f6b4dc)
• הגבלת הצילום של $dirty ל-lambdas מוטמעים. (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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-API

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

תיקוני באגים

• שימוש במדיניות עזרה למצב של היקף מקומי בהרכבה בהקשר. (83361c)
• הגבלת התיעוד של $dirty ל-lambdas בשורה. (acfca0)
• תיקון תוכן שניתן להזיז, שלפעמים מקבל את המיקומים המקומיים הלא נכונים של הקומפוזיציה. (035cd6)
• שימוש במפות גיבוב מהירות יותר ללא הקצאה ב-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 רק כשהוא מאוחסן בחישוב של remember. (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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

גרסה 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 מכילה את ההוספות האלה.

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

• Optimize 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)
• הקצאות מופחתות כשמחילים קובצי snapshot. (I65c09)
• הימנעות מחישובו של readableHash ב-DerivedState אם קובץ snapshot לא השתנה (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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

גרסה 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 במהלך ה-dispose של הקומפוזיציה. (62cc8c)
• תיקון העברת תוכן לקומפוזיציה משנית (4beb41)
• תיקון נעילה מרובת משתמשים פוטנציאלית (c1a425 ו-8edce0)
• מעכשיו, ה-recomposer שנוצר לחלון ב-Android ייחסום רק את הקריאות ל-withFrameNanos במקום את כל ההרכבה, כשהוא יקבל התראה מסוג ON_STOP. המשמעות היא שחלונות המשויכים לפעילויות שהופסקו ימשיכו לבצע עיבוד מחדש של הנתונים, אבל האנימציות או כל גורם אחר שמפעיל את withFrameNanos ייחסמו. (Id9e7f, ‏ b/240975572)
• ביצוע קריאות חזרה לאחר השבתה עבור LayoutNode לפני מחיקת האפקטים 3784073
• תיקון דגלים שהשתנו ב-Lambdas שהופעלו מחדש ea81df9
• תיקון רגרסיה בעריכה בזמן אמת של Composable עם צמתים 73fd4d8
• ON_STOP צריך להשהות את השידורים של שעון המסגרות במקום את ההרכבה ae276f1
• ביטול תוקף של היקפי SnapshotStateObserver למצבים נגזרים שלא השתנו 84d9b1c
• תיקון נעילה חזקה פוטנציאלית במהלך ביטול הקצאה של קומפוזיציות 28761fc
• תיקון העברת תוכן לקומפוזיציה משנית 92d4156
• תיקון דגלים שהשתנו ב-Lambdas שהופעלו מחדש (8a03e9)
• ביצוע קריאות חזרה (callbacks) להשבתה של LayoutNode לפני מחיקת האפקטים (8b0fa4)
• תיקון של endToMarker() בסיום קבוצות צמתים. (d71d980)
• שימוש בקבוצה הנוכחית SlotWriter לבדיקת השבתה (a0b518b)
• מסירים את fill ב-SlotTable.moveSlotGapTo() ומעבירים אותו לסגירה (81f9935)
• תיקון של ביטולי תוקף חסרים בזמן העברת תוכן שניתן להעברה (1d7c024)
• תיקון של ביטולים מיידיים של תוכן שניתן להעביר (8676618)

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

• אם קובץ ה-snapshot לא השתנה, מומלץ להימנע מחישובו של 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() לסוגי פרימיטיבים מתאימים. מזהה האיתור של השגיאות בקוד הוא 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 כוללת את ההצהרות האלה.

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

• אם קובץ ה-snapshot לא השתנה, מומלץ להימנע מחישובו של 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 במהלך ה-dispose של הקומפוזיציה. (62cc8c)
• תיקון העברת תוכן לקומפוזיציה משנית (4beb41)
• תיקון נעילה מרובת משתמשים פוטנציאלית (c1a425
• ON_STOP צריך להשהות את השידורים של שעון המסגרות במקום את ההרכבה (f4a2d1)
• תיקון דגלים שהשתנו ב-Lambdas שהופעלו מחדש (8a03e9)
• ביצוע קריאות חזרה (callbacks) להשבתה של LayoutNode לפני מחיקת האפקטים (8b0fa4)

תרומה חיצונית

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

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

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

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

גרסה 1.5.0-alpha03

19 באפריל 2023

androidx.compose.runtime:runtime-*:1.5.0-alpha03 משוחרר. גרסה 1.5.0-alpha03 מכילה את ההצהרות האלה.

שינויים ב-API

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

תיקוני באגים

• תיקון נעילה מרומזת פוטנציאלית ברשימת קובצי snapshot ובמפה 5c1a425
• ביצוע קריאות חזרה לאחר השבתה עבור LayoutNode לפני מחיקת האפקטים 3784073
• תיקון דגלים שהשתנו ב-Lambdas שהופעלו מחדש ea81df9
• תיקון רגרסיה בעריכה בזמן אמת של Composable עם צמתים 73fd4d8
• ON_STOP צריך להשהות את השידורים של שעון המסגרות במקום את ההרכבה ae276f1
• ביטול תוקף של היקפי SnapshotStateObserver למצבים נגזרים שלא השתנו 84d9b1c
• תיקון נעילה חזקה פוטנציאלית במהלך ביטול הקצאה של קומפוזיציות 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 כוללת את השמירות האלה.

תיקוני באגים

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

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

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

גרסה 1.4.1

5 באפריל 2023

androidx.compose.runtime:runtime-*:1.4.1 משוחרר. גרסה 1.4.1 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

תיקוני באגים

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

גרסה 1.4.0

22 במרץ 2023

androidx.compose.runtime:runtime-*:1.4.0 משוחרר. גרסה 1.4.0 כוללת את ההצהרות האלה.

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

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

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

• ניקוי שני אינדקסי ההיקף בקובץ SnapshotStateObserver 29f4a3e
• מוסיפים את הקבוצות הנדרשות לגוף של פונקציות lambda שלא ניתן לדלג עליהן 7d06752
• שיפור המאפיינים של הפניה לזיכרון במצב Snapshot‏ 93fcae8
• הסרת תיבות בחיפוש מקומי מורכב 0875717
• שימוש במפתח הנכון לקבוצות של צמתים שלא ניתן לעשות בהם שימוש חוזר 6388d8d
• הגנה על SnapshotStateObserver מפני החלות רפיקטיבית וסמולטנית 98cb6ba
• הוספנו בדיקה של גבולות האינדקס בשיטת ה-'get' של IdentityArraySet 35a77d3
• עדכון מודול הכתיבה כך שישתמש בתוספים של ViewTreeLifecycleOwner 21c2122
• שליחת התראות על החלה אחרי ש-Recomposer מסיים את הפריימים. 98f2641
• תיקון קריסה כתוצאה מאינדקס מחוץ לטווח כשמבטלים את Recomposer 8f8656f
• תמיד לאלץ יצירת קומפוזיציה מחדש אם ספקי ההורה של Composition השתנו 9526fcc
• טווח הזמן המקובל ליצירת קובץ מחדש של משימות שבוטלו a55f7ed
• שיפור הטיפול בביטולי תוקף למספר גדול של מלחינים 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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-API

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

גרסה 1.4.0-alpha04

11 בינואר 2023

androidx.compose.runtime:runtime-*:1.4.0-alpha04 משוחרר. גרסה 1.4.0-alpha04 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-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)

תיקוני באגים

• התראות על החלת קובץ snapshot נשלחות עכשיו אחרי ש-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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-API

• עכשיו יש להטמעות מפורשות של toList() ו-toMap() ב-SnapshotStateList וב-SnapshotStateMap, בהתאמה. השיטות האלה מחזירות את התוכן הנוכחי שלהן בלי לבצע העתקה, כי הן מחזירות את הנתונים הפנימיים הבלתי משתנים שמשמשים לאחסון התוכן שלהן. אפשר להשתמש בערך הזה, למשל, כדי ליצור זרימת ערכים באמצעות 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

טיפול בחריגות / תמיכה בעריכה בזמן אמת

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

מעקב אחר הרכב

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

Composable Reflection APIs

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

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

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

Snapshot System

• מערכת קובצי ה-snapshot עברה שיפורים שונים בנושאי ניהול זיכרון, ביצועים ותיקוף.
• אופטימיזציה של הסרת ההיקף ב-SnapshotStateObserver
• ניפוי קובצי snapshot בתצוגת עץ שנוצרו מקובצי snapshot שקופים
• תוקנה בעיית מרוץ (race condition) בקריאת המצב מהקובץ הממוזער הגלובלי
• תמיכה ב-DerivedState ב-SnapshotStateObserver
• מניעת הסרה של מצב נגזר מהרכבה כשקוראים אותו בהיקפים אחרים
• שימוש ב-IdentityArrayMap במקום ב-HashMap בתוך DerivedState
• עדכון של משגיחי המצב המשניים כך שישתמשו בוקטור שניתן לשינוי
• עדכון של ניקוי המצב של SnapshotStateObserver
• החלפת SnapshotStateObserver.invalidated ב-ArraySet
• תוקנה בעיית מרוץ (race condition) בקריאת המצב מהקובץ הממוזער הגלובלי
• תיקון השימוש ברשומה לא עדכנית בחישוב גיבוב של DerivedState
• תיקון של מרוץ תהליכים בזמן ההתקדמות של קובץ ה-snapshot הגלובלי
• האצת הניקוי של תצפיות ההיקף ב-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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

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

• הפרמטר ל-remember ול-rememberCoroutineScope השתנה ל-crossinline. כך תופיע שגיאה לגבי החזרות מוקדמות במקום לאפשר החזרה מוקדמת, שתוביל לדיווח על שגיאה פנימית בשלב מאוחר יותר.
• השינוי הזה עלול לגרום לדיווח על שגיאות חדשות של המהדר, שיחייבו הסרה של חזרות לא מקומיות מהפונקציות הלמבדה שמועברות לפונקציות האלה. (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

• נוספה ל-CompositionData שיטת find כדי לאפשר לכלים למפתחים שמשתמשים ב-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 מכילה את השמירות האלה.

תיקוני באגים

• תוקן דליפת זיכרון: טיפול ב-snapshots בתצוגת עץ שנוצרו מ-snapshots שקופים 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, יחד עם תיקוני באגים רבים לשיפור היציבות. התכונה החדשה המשמעותית ביותר הייתה השקת ה-API של movableContentOf, שאפשר להשתמש בו כדי לאפשר חוויית משתמש מורכבת, כמו מעברים של רכיבים משותפים. ה-API של movableContentOf ממיר פונקציית lambda שניתנת להרכבה לפונקציית lambda שמעבירה את המצב שלה ואת הצמתים התואמים לכל מיקום חדש שבו היא נקראת. כשהקריאה הקודמת יוצאת מההרכב, המצב נשמר באופן זמני. אם קריאה חדשה ל-lambda נכנסת להרכב, המצב והצמתים המשויכים מועברים למיקום של הקריאה החדשה. אם לא תתווסף קריאה חדשה, המצב יוסר באופן סופי והצופים יקבלו הודעה.

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

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

• בהמשך מופיעה רשימה של השינויים:

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

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

הביצועים ב-1.2

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

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

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

גרסה 1.2.0-rc03

29 ביוני 2022

androidx.compose.runtime:runtime-*:1.2.0-rc03 משוחרר. גרסה 1.2.0-rc03 כוללת את ההצהרות האלה.

תיקוני באגים

• בעבר, תצפיות של מצב נגזר הוסרו ללא תנאי מהיקף ה-recompose ומההרכב ביחד, מה שגרם לשיבושים בהיקפים אחרים שעדיין עשויים לצפות במצב נגזר. השינוי הזה מסיר את המופעים של המצב המשויך רק אם הוא לא נצפה יותר בהיקפים אחרים. (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 מטרגטות את ה-applier של Compose UI. פונקציה שצריכה לטרגט מחבר אחר צריכה לספק במפורש את ההערה של סמן היעד למחבר הרצוי. (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 כזה בתרחישי שימוש שבהם רוצים ליהנות מהיתרונות של קריאה/כתיבה מבוססת-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 מכילה את ההוספות האלה.

תרומה חיצונית

• העדכון כולל שימוש ב-Kotlinx coroutines 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 שמאפשרים לדווח בזמן הידור על קריאה של פונקציה הניתנת להגדרה שמטרגטת מחולל שמטרגט אחר לא תוכנן להשתמש בו.

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

  למפעילים מותאמים אישית, הפונקציות הניתנות לקיפול שמפעילות את ComposeNode או את ReusableComposeNode צריכות להוסיף הערה CompoableTarget לפונקציה ולסוגי הפרמטרים של lambda שניתן לקיפול. עם זאת, מומלץ ליצור הערה עם הערה ComposableTargetMarker, ואז להשתמש בהערה המסומנת במקום ב-ComposableTarget ישירות. הערה שניתנת ליצירה ולשימוש מחדש שמסומנת ב-ComposableTargetMarker זהה ל-ComposbleTarget עם השם המלא של סיווג המאפיין כפרמטר של הגורם המפעיל. דוגמה לשימוש ב-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 נכנסת לקומפוזיציה, המצב והצמתים המשויכים מועברים למיקום של הקריאה החדשה. אם לא תתווסף קריאה חדשה, המצב יוסר לתמיד, ותישלח התראה למשתמשי הצפייה.

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

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

  כדי להסיר את הקריאות האלה ואת פרטי המקור המשויכים מהגרסה היציבה, מוסיפים את הכלל הבא של 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 ליצירת מזהי invariants ב-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)
• תוקנה בעיית RTL ב-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
• שיפורים בגודל של משטח המגע
• שימו לב שבגרסה 1.0 של Compose, רכיבי Material ירחיבו את שטח הפריסה שלהם כדי לעמוד בהנחיות הנגישות של Material לגבי גודל יעד המגע. לדוגמה, יעד המגע של הלחצן יתרחב לגודל מינימלי של 48x48dp, גם אם תגדירו את הגודל של הלחצן לגודל קטן יותר. כך Compose Material תואם לאותו התנהגות של רכיבי Material Design, ומספק התנהגות עקבית אם משלבים בין Views לבין Compose. השינוי הזה גם מבטיח שכשיוצרים את ממשק המשתמש באמצעות רכיבי Material של Compose, מתקיימים הדרישות המינימליות לנגישות של יעדי מגע.
• תמיכה יציבה בפס ניווט
• מספר ממשקי 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 Compiler תומך עכשיו בגרסאות ישנות יותר של Compose Runtime‏ (1.0). לפני השינוי הזה, ה-Compose Compiler היה תואם רק ל-Compose Runtime מאותה גרסה ואילך. אחרי השינוי הזה, ה-Compose Compiler תואם לגרסה ישנה יותר של 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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

תיקוני באגים

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

גרסה 1.0.4

13 באוקטובר 2021

androidx.compose.runtime:runtime-*:1.0.4 משוחרר. גרסה 1.0.4 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

עדכוני יחסי תלות

• העדכון נעשה כך שיהיה תלוי ב-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 כוללת את השמירות האלה.

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

גרסה 1.0.1

4 באוגוסט 2021

androidx.compose.runtime:runtime-*:1.0.1 משוחרר. גרסה 1.0.1 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

עדכוני יחסי תלות

• העדכון נעשה כך שיהיה תלוי ב-Kotlin 1.5.21.

גרסה 1.0.0

28 ביולי 2021

androidx.compose.runtime:runtime-*:1.0.0 משוחרר. גרסה 1.0.0 כוללת את ההצהרות האלה.

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

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

בעיות מוכרות

• אם אתם משתמשים ב-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 מכילה את ההתחייבויות האלה.

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

בגרסה הזו נוספו כללי פרופיל למודול ה-Compose הבאים (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> הוא התיאור של המחלקה שאליה שייך ה-method המטורגט. לדוגמה, למחלקה androidx.compose.runtime.SlotTable יהיה מתאר של Landroidx/compose/runtime/SlotTable;.

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

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

מה המטרה של הכללים?

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

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

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

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

איך זה עובד?

• בספריות אפשר להגדיר את הכללים האלה, שיארזו בארטיפקטים של 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 שמאפשר לבצע שינויים ב-recompose במעבר יחיד. (Iaafd1, ‏ b/184173932)

גרסה 1.0.0-beta07

18 במאי 2021

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

הערה: ספריות שתלויות ב-Compose יצטרכו להיערך מחדש בגרסה 1.0.0-beta07. אחרת, יכול להיות שספריות ייתקלו ב-NoSuchMethodError, למשל:
java.lang.NoSuchMethodError: No interface method startReplaceableGroup(ILjava/lang/String;)V in class Landroidx/compose/runtime/Composer; or its super classes. (Ia34e6)

שינויים ב-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 להקלטת קריאות וכתוביות של קובצי snapshot (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

• הוספת API ניסיוני מסוג Recomposer.runRecomposeConcurrentlyAndApplyChanges ליצירה מחדש של קומפוזיציות שבוטלו מחוץ ללולאת המסגרת הראשית. (I342d0)
• כל רכיבי ה-Composable שסומנו ב-‎ @ReadOnlyComposable מאומתים עכשיו בזמן הידור כדי לוודא שהם מבצעים רק קריאות לרכיבי ‎ @ReadOnlyComposable אחרים (I58961)

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

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

  לסוגי nullable, כדאי לספק את { null } כמפעל ברירת המחדל.

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

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

• הממשק הוצא משימוש emptyContent() הוסר. במקום זאת, אתם צריכים להשתמש ב-{}. (Idb33f, ‏ b/179432510)

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

  • ה-constructor של 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() מפני שהן לא היו שימושיות או נפוצות.
  • שינית את השם של 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 rename. בעבר, השם של סביבות האווירה היה AmbientFoo, עכשיו השם של CompositionLocals הוא LocalFoo. (I2d55d)
• השם של Ambient השתנה ל-CompositionLocal, והשמות של ambientOf / staticAmbientOf השתנו ל-compositionLocalOf / staticCompositionLocalOf, בהתאמה. השינוי הזה עוזר להבהיר את המטרה של CompositionLocal: מנגנון למתן או אחזור ערכים מקומיים ליצירה. יש להוסיף את הקידומת Local למופעים של CompositionLocal, למשל 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)

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

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

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

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

• הוספה של SnapshotMutableState (Icfd03)

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

• הוסר Recomposer.current().‏ [Abstract]ComposeView מוגדר עכשיו כברירת מחדל ל-Recomposers ברמת החלון שנוצרים בזמנם, ומנוהלים על ידי ViewTreeLifecycleOwner של החלון. הטיקים של האנימציה המבוססת על Recomposition ו-withFrameNanos מושהים בזמן שה-Lifecycle של המארח מושהה. (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 מוחזר מהקריאה החוזרת (callback) שהועברה אל remember אבל לא נשמר במצב ההרכבה, ולכן אף פעם לא תתבצע קריאה ל-onRemembered. המצב הזה יכול להתרחש אם חריגה מסתיימת לפני השלמת היצירה, או אם היצירה נמחקת כי המצב שהיא יוצרת כבר לא רלוונטי או מסיבה אחרת. אם המופע של RememberObserver, בהתאם להמלצה שלמעלה לגבי הפניה יחידה, עוקב אחרי משאב חיצוני, הערכים של onForgotten ושל onAbandoned מציינים שהמשאב כבר לא נדרש. אם האובייקט עוקב אחרי עבודה שהתחילה או משאבים שהוקצו ב-onRemembered, אפשר להתעלם מ-onAbandoned כי הוא לא יקרא אם יקראו ל-onRemembered. (I02c36)

• אין לסמן פונקציות collectAsState() כפונקציות מוטמעות (inline) (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

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

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

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

תיקוני באגים

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

גרסה 1.0.0-alpha09

16 בדצמבר 2020

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

שינויים ב-API

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

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

• הכיתה Applier כבר לא נחשבת ל-(Id85b0)

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

  השם של השיטה insert() השתנה ל-insertTopDown().

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

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

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

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

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

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

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

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

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

תיקוני באגים

• AndroidOwner הפך את הבעיה לבעיה פנימית (Ibcad0, ‏ b/170296980)
• הפונקציה subcomposeInto(LayoutNode) הפכה לפונקציה פנימית (Id724a)

גרסה 1.0.0-alpha08

2 בדצמבר 2020

androidx.compose.runtime:runtime-*:1.0.0-alpha08 משוחרר. גרסה 1.0.0-alpha08 מכילה את ההצהרות האלה.

הערה: הגרסה הזו תואמת רק ל-Kotlin 1.4.20, לכן תצטרכו לעדכן את גרסת Kotlin.

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.0.0-alpha07

11 בנובמבר 2020

androidx.compose.runtime:runtime-*:1.0.0-alpha07 משוחרר. גרסה 1.0.0-alpha07 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

תכונות חדשות

שינויים ב-API

• ההערה @UnionType הוצאה משימוש (I57cde)
• האפשרות provideDefault נוספה כחלופה ל-provide לצורך מתן נתונים סטטיים, וניתן להשתמש בה כדי לציין ערכים סטטיים שייקבעו רק אם לא צוין כבר ערך סטטי. (Id6635, ‏ b/171024925)
• השם של LaunchedTask שונה ל-LaunchedEffect כדי לשמור על עקביות עם ממשקי ה-API של SideEffect ו-DisposableEffect. כדי לעודד שימוש בשיטות מומלצות, אסור להשתמש ב-LaunchedEffect ללא פרמטרים של נושא. (Ifd3d4)
• ל-Applier יש עכשיו פונקציות קריאה חוזרת (callbacks) מסוג onBeginChanges/onEndChanges שמופעלות כש-Composer מתחיל או מסיים להחיל שינויים על העץ. אם צריך, אפשר להשתמש בהם לניהול משאבים באצווה. (Icf476)
• עכשיו נדרש CoroutineContext בזמן היצירה של Recomposer (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)

תרומה חיצונית

• נוספה מודול runtime-rxjava3 ליצירת אימיילים. דומה ל-runtime-rxjava2 (I02cbf)

גרסה 1.0.0-alpha06

28 באוקטובר 2020

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

שינויים ב-API

• עכשיו, Recomposer הוא CompositionReference והורה תקף של קומפוזיציה. עכשיו נדרש שימוש ב-Explicit Recomposer במקומות פחותים. (I4036f)
• הוספנו ל-SideEffect ממשק API מקביל של DisposableEffect, שממלא את התפקיד של onCommit-with-params אבל עם onDispose נדרש.
  • הוספנו את rememberUpdatedState API כדי לפרסם נתונים מהרכבה מחדש לתהליכים מתמשכים או לטווח ארוך, כמו DisposableEffects או LaunchedTasks.
  • (Id50b9)
• MutableVector מיישם עכשיו את RandomAccess (I85d73, ‏ b/170461551)
• הוספנו את הרכיב SideEffect composable כדי להחיל תופעות לוואי של קומפוזיציה על אובייקטים שמנוהלים על ידי הקומפוזיציה. ה-SideEffect נועד להחליף את ה-composable של 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

• Modifier.pointerInput‏ – שינוי מקדם קלט ניסיוני להשהיית קלט (Ia77d2)
• כדי לשפר את הביצועים של גלילה ב-LazyColumn/Row, אנחנו מבצעים פחות עבודה בהרכבה המשנית בכל גלילה. נוספה השיטה החדשה hasInvalidations()‏ ל-Composition class. השיטה hasPendingChanges()‏ מ-Recomposer נקראה עכשיו hasInvalidations()‏ (Ib2f32, ‏ b/168293643, ‏ b/167972292, ‏ b/165028371)
• הוספת API ליצירת מצב (produceState) להפעלת קורוטינים מהרכבה שמעדכנים ערך 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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

הערה: Compose בגרסה 1.0.0-alpha04 תואם רק ל-Android Studio 4.2 Canary 13 ואילך.

שינויים ב-API

• הוספנו את OwnerScope כדי לאפשר איסוף של היקפי התצפית של פריסה ותרשימים אחרי שהם כבר לא תקפים. (Ic4cf8)
• הוספנו את ממשק ה-API derivedStateOf כדי ליצור אובייקטים של State על סמך חישוב שעשוי לקרוא (ולנגזר) מאובייקטים אחרים של State (If758b)
• נוספה ממשק 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 לא מפעיל יותר פונקציות קורוטין שלא הועברו (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 לצורך שימוש בשינויים בנתוני קובצי snapshot וליצור שינויים כאלה. (I3e722)

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

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

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

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

  הפונקציות onCommit ו-onActive פועלות עכשיו באותו פריים של מנהל התנועה שבו בוצעו השינויים בהרכב, ולא בתחילת הפריים הבא של מנהל התנועה. (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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-API

• עכשיו אפשר להצהיר על אירועים מותאמים אישית שאפשר לדלג על אחד או יותר מה-setters שלהם ולבנות אותם מחדש בנפרד מהאירוע. (Ibbd13)

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

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

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

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

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

תיקוני באגים

• האפשרות emitView הוצאה משימוש. אם אפשר, השתמשו ב-AndroidView במקום זאת כדי להפיק תצוגות בתוך 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() השתנתה ל-structuralEqualityPolicy() במקום ל-referentialEqualityPolicy().

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

  מידע נוסף זמין בכתובת https://kotlinlang.org/docs/reference/equality.html

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

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

  לדוגמה,

  val state = mutableStateOf(1f)
  

  ולאחר מכן

  state.value = 1f
  

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

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

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

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

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

תיקוני באגים

• השיטה setViewContent הוצאה משימוש. במקום זאת, צריך להשתמש ב-setContent. (I7e497, ‏ b/160335130)

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

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

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

• ה-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 data classes, equals, hashcode וכו'
  • איך אפשר להגדיר נכסים מסוימים כ'במעקב' ונכסים אחרים לא?
  • איך מציינים שוויון מבני לעומת שוויון עקיף לשימוש בתצפית?
  • הפחתת ה'קסם' במערכת. תפחית את הסבירות שמישהו יחשוב שהמערכת חכמה יותר ממה שהיא (כלומר, שהיא יודעת איך לבצע השוואה בין שתי רשימות)
  • הניתוח המפורט יותר של התצפיות הוא אינטואיטיבי יותר.
  • שיפור היכולת לבצע רפרסטורציה ממשתנה לנכס בכיתה
  • יכולה לאפשר לבצע אופטימיזציה ידנית ספציפית למדינה
  • התאמה טובה יותר לשאר הסביבה העסקית, והפחתת הערפול לגבי נתונים שלא משתנים או לגבי העובדה שאנחנו 'מקבלים את המצב המשתנה'

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

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

  @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 כדי להפוך את הגישה הזו לקלילה יותר, באמצעות מנהלי הנכסים (delegates) של Kotlin ו-mutableStateOf API שמאפשר ליצור מכונות של MutableState מחוץ ל-composition. בעיקרון, צריך להחליף את כל נכסי ה-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. רוב המשתמשים ב-Compose לא יצטרכו לעדכן קוד בעקבות השינוי הזה.

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

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

  שינויים התנהגותיים ידועים ומכוונים כתוצאה מכך:

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

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

  רוב השינויים המשמעותיים היו בממשקי API שהמקודד מטרגט ישירות, והשימוש הרגיל ב-compose לא יושפע: 1. Composer::startExpr הוסר 2. Composer::endExpr הוסר 3. השיטה Composer::call הוצאה משימוש ב-4. הוסר הטעינה יתר של key ללא vararg. מעכשיו והלאה, צריך להשתמש בגרסה 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 הוא אוסף חדש שלא מטמיע אף אחד מממשקי Collection הרגילים. האוסף הזה מספק מהירות גבוהה יותר מהדרישות האחרות, והוא מיועד לשימוש רק בהטמעות פנימיות. (I8ebd6)

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

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

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

• ההערה ‎@Untracked הוצאה משימוש. החלפה ב-@ComposableContract(tracked=false)‏ (Id211e)

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

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

• Ambient<T> עכשיו הוא @Stable במקום @Immutable (I0b4bb)

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

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

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

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

• הוספנו מתאם ל-StateFlow שהוצג לאחרונה, שמאפשר לאכלס מראש את הערך הראשוני כך שהמצב המוחזר לא יהיה nullable (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, שיגרום לשינוי בשיטת יצירת הקוד של הפלאגין compose. ברמה גבוהה, הפעולה הזו גורמת ליצירת פונקציות @Composable עם פרמטר סינתטי נוסף, שמוענק לקריאות הבאות של @Composable כדי שסביבת זמן הריצה תוכל לנהל את הביצועים בצורה תקינה. זהו שינוי בינארי משמעותי שעלול לשבור את התאימות, אבל הוא אמור לשמור על תאימות ברמת המקור בכל שימוש מורשה ב-compose. (I7971c)

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

תרומה חיצונית

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