Compose Runtime

אבני בניין בסיסיות של מודל התכנות ושל ניהול המצב ב-Compose, וזמן ריצה ליבה שאליו פונה הפלאגין של Compose Compiler.
העדכון האחרון גרסה יציבה גרסה מועמדת להפצה גרסת בטא גרסה אלפא
18 ביוני 2025 1.8.3 - 1.9.0-beta01 -

מבנה

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.8.3"
    implementation "androidx.compose.runtime:runtime-livedata:1.8.3"
    implementation "androidx.compose.runtime:runtime-rxjava2:1.8.3"
}

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Kotlin

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

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

תכונות חדשות

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

שינויים ב-API

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

גרסה 1.0.0-alpha02

8 בפברואר 2023

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

תכונות חדשות

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

גרסה 1.0.0-alpha01

7 בספטמבר 2022

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

תכונות חדשות

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

גרסה 1.9

גרסה 1.9.0-beta01

18 ביוני 2025

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

שינויים ב-API

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

תיקוני באגים

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

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

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

גרסה 1.9.0-alpha04

4 ביוני 2025

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

שינויים ב-API

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

תיקוני באגים

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

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

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

גרסה 1.9.0-alpha03

20 במאי 2025

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

שינויים ב-API

  • כדי להביא בחשבון את הפיתוח העתידי של התכונה הזו, משנים את הערך של setDiagnosticStackTraceEnabled ל'ניסיוני'. (I11db3)

תיקוני באגים

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

גרסה 1.9.0-alpha02

7 במאי 2025

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.9.0-alpha01

‫23 באפריל 2025

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

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

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

שינויים ב-API

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

תיקוני באגים

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

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

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

גרסה 1.8

גרסה 1.8.3

18 ביוני 2025

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

גרסה 1.8.2

20 במאי 2025

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

גרסה 1.8.1

7 במאי 2025

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

גרסה 1.8.0

‫23 באפריל 2025

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

גרסה 1.8.0-rc03

9 באפריל 2025

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

גרסה 1.8.0-rc02

‫26 במרץ 2025

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

גרסה 1.8.0-rc01

‫12 במרץ 2025

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

שינויים ב-API

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

גרסה 1.8.0-beta03

26 בפברואר 2025

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

גרסה 1.8.0-beta02

12 בפברואר 2025

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

תיקוני באגים

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

גרסה 1.8.0-beta01

29 בינואר 2025

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

שינויים ב-API

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

גרסה 1.8.0-alpha08

15 בינואר 2025

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

גרסה 1.8.0-alpha07

11 בדצמבר 2024

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

שינויים ב-API

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

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

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

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

תיקוני באגים

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

12 בפברואר 2025

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

גרסה 1.7.7

29 בינואר 2025

androidx.compose.runtime:runtime-*:1.7.7 משוחרר. אין שינויים לעומת גרסת 1.7.6.

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

גרסה 1.7.5

30 באוקטובר 2024

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

גרסה 1.7.4

16 באוקטובר 2024

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

גרסה 1.7.3

2 באוקטובר 2024

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

גרסה 1.7.2

18 בספטמבר 2024

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

גרסה 1.7.1

10 בספטמבר 2024

  • אין שינויים ב-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, שאפשר לגשת אליו רק בפונקציות @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, שאפשר לגשת אליו רק בפונקציות @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 כוללת את ההצהרות האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה 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)
  • מוודאים שהערכים של המצב המשויך (derived) שלא הועברו לאינטליגנציה המלאכותית לא יהיו לא חוקיים (aa2a92)
  • קריאה ל-onEndChanges במהלך ביטול ההקצאה של הקומפוזיציה. (62cc8c)
  • תיקון העברת תוכן לקומפוזיציה משנית (4beb41)
  • תיקון נעילה מרובת משתמשים פוטנציאלית (c1a425 ו-8edce0)
  • מעכשיו, ה-recomposer שנוצר לחלון ב-Android ייחסום רק את הקריאות ל-withFrameNanos במקום את כל ההרכבה, כשהוא יקבל התראה מסוג ON_STOP. המשמעות היא שחלונות המשויכים לפעילויות שהופסקו ימשיכו לבצע עיבוד מחדש של הנתונים, אבל האנימציות או כל גורם אחר שמפעיל את withFrameNanos ייחסמו. (Id9e7f, ‏ b/240975572)
  • ביצוע קריאות חזרה (callbacks) להשבתה של 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)
  • הפחתת המכסות לתצפיות של קובצי snapshot (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)
  • מוודאים שהערכים של המצב המשויך (derived) שלא הועברו לאינטליגנציה המלאכותית לא יהיו לא חוקיים (aa2a92)
  • קריאה ל-onEndChanges במהלך ביטול ההקצאה של הקומפוזיציה. (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 במהלך ביטול ההקצאה של הקומפוזיציה. צמתים של מוקד שהוסרו במהלך 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
  • ביצוע קריאות חזרה (callbacks) להשבתה של 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)
  • הפחתת המכסות לתצפיות של קובצי snapshot (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 כוללת את ההצהרות האלה על ביצוע שינויים (commits).

תיקוני באגים

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

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

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

גרסה 1.4.1

5 באפריל 2023

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

תיקוני באגים

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

גרסה 1.4.0

22 במרץ 2023

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

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

  • שימוש בערך המאופס מ-LiveData ליצירה הראשונה 3680e25
  • מוסיפים את ComposeNodeLifecycleCallback כדי לעקוב אחרי מחזור החיים של צמתים ב-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
  • טווח הסבלנות של Recomposer למשימות שבוטלו a55f7ed
  • שיפור הטיפול בביטולי תוקף למספר גדול של מלחינים 9b7ed67
  • תיקון הבעיה ביצירת קבוצות סגירה להחזרות לא מקומיות b6f590c

גרסה 1.4.0-rc01

8 במרץ 2023

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

תיקוני באגים

גרסה 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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.4.0-alpha05

25 בינואר 2023

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

שינויים ב-API

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

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

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

מעקב אחר הרכב

Composable Reflection APIs

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

Snapshot System

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

גרסה 1.3.0-beta02

7 בספטמבר 2022

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

תיקוני באגים

  • ממשק API מעודכן (I64ca0)

גרסה 1.3.0-beta01

24 באוגוסט 2022

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

שינויים ב-API

  • נוספה ל-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

הביצועים ב-1.2

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

גרסה 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) ליצירת קומפוזיציות, כדי לאפשר לכלים לספק מעקב מפורט יותר אחרי פונקציות שאפשר ליצור מהן קומפוזיציות. מהדר ‎now generates calls to the tracing API which include source ‎information. (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 ליצירת מזהי Invariant ב-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 כוללת את ההצהרות האלה על ביצוע שינויים (commits).

שינויים חשובים מאז גרסה 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 מכילה את השמירות האלה.

תיקוני באגים

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

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

  • העדכון מותאם ל-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 כוללת את ההצהרות האלה.

שינויים ב-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)
  • ה-method‏ 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 פנימיים וממשקי API ניסיוניים עד שהשינויים יחולו. בדרך כלל אפשר לעקוף את הבעיה הזו על ידי הקפת הקוד עם יחסי התלות האלה ב-SideEffect composable כדי לדחות את ביצוע הקוד עד אחרי היצירה וההפעלה של הצמתים. (I018da)

שינויים ב-API

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

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

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

תיקוני באגים

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

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

שינויים ב-API

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

תיקוני באגים

  • הוצאנו משימוש סביבות Ambient ששמות שלהן כוללים את הסיומת Ambient, והחלפנו אותן בנכסים חדשים עם התחילית Ambient, בהתאם להנחיות אחרות לגבי סביבות Ambient ו-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 suspending input modifier (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 מכילה את ההצהרות האלה.

שינויים ב-API

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

גרסה 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 שלהם ולבצע שוב את ה-composition שלהם בנפרד מהאירוע. (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 שעדיין משתמשים בשעונים הישנים שמבוססים על פונקציות קריאה חוזרת.

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

עדכון יחסי התלות

  • כדי להשתמש בגרסה 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

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