סביבת זמן הריצה של Compose

מבנה

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

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

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

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

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

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

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

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

android {
    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.15"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

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

משוב

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

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

מידע נוסף זמין במאמרי העזרה בנושא הכלי למעקב אחר בעיות.

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

גרסה 1.7.0-rc01

‫18 בספטמבר 2024

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

גרסה 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-perfetto) – כך נפתרה בעיה שבה compose-runtime-tracing הביא גרסה חדשה יותר של compose-runtime לאפליקציה.

גרסה ‎1.0.0-alpha04

‫23 באוגוסט 2023

androidx.compose.runtime:runtime-tracing:1.0.0-alpha04 משוחרר. גרסה ‎1.0.0-alpha04 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

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

גרסה 1.0.0-alpha02

‫8 בפברואר 2023

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

תכונות חדשות

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

גרסה ‎1.0.0-alpha01

‫7 בספטמבר 2022

androidx.compose.runtime:runtime-tracing:1.0.0-alpha01 משוחרר. גרסה ‎1.0.0-alpha01 מכילה את הקומיטים האלה.

תכונות חדשות

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

גרסה 1.10

גרסה ‎1.10.0-rc01

‫19 בנובמבר 2025

androidx.compose.runtime:runtime-*:1.10.0-rc01 משוחרר. גרסה ‎1.10.0-rc01 מכילה את הקומטים האלה.

תיקוני באגים

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

גרסה ‎1.10.0-beta02

‫5 בנובמבר 2025

androidx.compose.runtime:runtime-*:1.10.0-beta02 משוחרר. גרסה 1.10.0-beta02 מכילה את הקומטים האלה.

שינויים ב-API

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

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

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

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

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

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

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

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

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

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

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

תיקוני באגים

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

גרסה ‎1.10.0-beta01

‫22 באוקטובר 2025

androidx.compose.runtime:runtime-*:1.10.0-beta01 משוחרר. גרסה 1.10.0-beta01 מכילה את הקומטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.10.0-alpha05

‫8 באוקטובר 2025

androidx.compose.runtime:runtime-*:1.10.0-alpha05 משוחרר. גרסה ‎1.10.0-alpha05 מכילה את הקומטים האלה.

תיקוני באגים

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

גרסה ‎1.10.0-alpha04

‫24 בספטמבר 2025

androidx.compose.runtime:runtime-*:1.10.0-alpha04 משוחרר. גרסה ‎1.10.0-alpha04 מכילה את הקומטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.10.0-alpha03

‫10 בספטמבר 2025

androidx.compose.runtime:runtime-*:1.10.0-alpha03 משוחרר. גרסה ‎1.10.0-alpha03 מכילה את הקומטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.10.0-alpha02

‫27 באוגוסט 2025

androidx.compose.runtime:runtime-*:1.10.0-alpha02 משוחרר. גרסה ‎1.10.0-alpha02 מכילה את הקומטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.10.0-alpha01

‫13 באוגוסט 2025

androidx.compose.runtime:runtime-*:1.10.0-alpha01 משוחרר. גרסה ‎1.10.0-alpha01 מכילה את הקומטים האלה.

שינויים ב-API

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

תיקוני באגים

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

External Contribution

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

גרסה 1.9

גרסה 1.9.5

‫19 בנובמבר 2025

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

תיקוני באגים

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

גרסה 1.9.4

‫22 באוקטובר 2025

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

גרסה 1.9.3

‫8 באוקטובר 2025

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

גרסה 1.9.2

‫24 בספטמבר 2025

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

גרסה 1.9.1

‫10 בספטמבר 2025

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

תיקוני באגים

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

גרסה 1.9.0

‫13 באוגוסט 2025

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

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

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

גרסה 1.9.0-rc01

‫30 ביולי 2025

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

תיקוני באגים

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

גרסה 1.9.0-beta03

‫16 ביולי 2025

androidx.compose.runtime:runtime-*:1.9.0-beta03 משוחרר. גרסה 1.9.0-beta03 מכילה את הקומטים האלה.

גרסה ‎1.9.0-beta02

‫2 ביולי 2025

androidx.compose.runtime:runtime-*:1.9.0-beta02 משוחרר. גרסה 1.9.0-beta02 מכילה את הקומטים האלה.

תיקוני באגים

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

גרסה 1.9.0-beta01

‫18 ביוני 2025

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

שינויים ב-API

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

תיקוני באגים

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

External Contribution

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

גרסה ‎1.9.0-alpha04

‫4 ביוני 2025

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

שינויים ב-API

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

תיקוני באגים

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

External Contribution

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

גרסה ‎1.9.0-alpha03

‫20 במאי 2025

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.9.0-alpha02

‫7 במאי 2025

androidx.compose.runtime:runtime-*:1.9.0-alpha02 משוחרר. גרסה ‎1.9.0-alpha02 מכילה את הקומטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.9.0-alpha01

‫23 באפריל 2025

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

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

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

שינויים ב-API

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

תיקוני באגים

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

External Contribution

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

גרסה 1.8

גרסה 1.8.3

‫18 ביוני 2025

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

גרסה 1.8.2

‫20 במאי 2025

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

גרסה 1.8.1

‫7 במאי 2025

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

גרסה 1.8.0

‫23 באפריל 2025

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

גרסה 1.8.0-rc03

‫9 באפריל 2025

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

גרסה 1.8.0-rc02

‫26 במרץ 2025

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

גרסה 1.8.0-rc01

‫12 במרץ 2025

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

שינויים ב-API

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

גרסה 1.8.0-beta03

‫26 בפברואר 2025

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

גרסה 1.8.0-beta02

‫12 בפברואר 2025

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

תיקוני באגים

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

גרסה ‎1.8.0-beta01

‫29 בינואר 2025

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

שינויים ב-API

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

גרסה ‎1.8.0-alpha08

‫15 בינואר 2025

androidx.compose.runtime:runtime-*:1.8.0-alpha08 משוחרר. גרסה ‎1.8.0-alpha08 מכילה את הקומטים האלה.

גרסה ‎1.8.0-alpha07

‫11 בדצמבר 2024

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

שינויים ב-API

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

External Contribution

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

גרסה ‎1.8.0-alpha06

‫13 בנובמבר 2024

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.8.0-alpha05

‫30 באוקטובר 2024

androidx.compose.runtime:runtime-*:1.8.0-alpha05 משוחרר. גרסה ‎1.8.0-alpha05 מכילה את הקומטים האלה.

תיקוני באגים

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

External Contribution

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

גרסה ‎1.8.0-alpha04

‫16 באוקטובר 2024

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

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

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

גרסה 1.8.0-alpha03

‫2 באוקטובר 2024

androidx.compose.runtime:runtime-*:1.8.0-alpha03 משוחרר. גרסה ‎1.8.0-alpha03 מכילה את הקומטים האלה.

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

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

גרסה ‎1.8.0-alpha02

‫18 בספטמבר 2024

androidx.compose.runtime:runtime-*:1.8.0-alpha02 משוחרר. גרסה ‎1.8.0-alpha02 מכילה את הקומטים האלה.

תכונות חדשות

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

גרסה ‎1.8.0-alpha01

‫4 בספטמבר 2024

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

גרסה 1.7

גרסה 1.7.8

‫12 בפברואר 2025

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

גרסה 1.7.7

‫29 בינואר 2025

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

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

גרסה 1.7.5

‫30 באוקטובר 2024

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

גרסה 1.7.4

‫16 באוקטובר 2024

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

גרסה 1.7.3

‫2 באוקטובר 2024

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

גרסה 1.7.2

‫18 בספטמבר 2024

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

גרסה 1.7.1

‫10 בספטמבר 2024

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

גרסה 1.7.0

‫4 בספטמבר 2024

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

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

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

גרסה 1.7.0-rc01

‫21 באוגוסט 2024

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

גרסה 1.7.0-beta07

‫7 באוגוסט 2024

androidx.compose.runtime:runtime-*:1.7.0-beta07 משוחרר. גרסה 1.7.0-beta07 מכילה את הקומטים האלה.

גרסה 1.7.0-beta06

‫24 ביולי 2024

androidx.compose.runtime:runtime-*:1.7.0-beta06 משוחרר. גרסה 1.7.0-beta06 מכילה את הקומטים האלה.

גרסה 1.7.0-beta05

‫10 ביולי 2024

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

גרסה 1.7.0-beta04

‫26 ביוני 2024

androidx.compose.runtime:runtime-*:1.7.0-beta04 משוחרר. גרסה 1.7.0-beta04 מכילה את הקומטים האלה.

גרסה ‎1.7.0-beta03

‫12 ביוני 2024

androidx.compose.runtime:runtime-*:1.7.0-beta03 משוחרר. גרסה 1.7.0-beta03 מכילה את הקומטים האלה.

גרסה ‎1.7.0-beta02

‫29 במאי 2024

androidx.compose.runtime:runtime-*:1.7.0-beta02 משוחרר. גרסה 1.7.0-beta02 מכילה את הקומטים האלה.

גרסה ‎1.7.0-beta01

‫14 במאי 2024

androidx.compose.runtime:runtime-*:1.7.0-beta01 משוחרר. גרסה 1.7.0-beta01 מכילה את הקומטים האלה.

גרסה ‎1.7.0-alpha08

‫1 במאי 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha08 משוחרר. גרסה ‎1.7.0-alpha08 מכילה את הקומטים האלה.

גרסה ‎1.7.0-alpha07

‫17 באפריל 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha07 משוחרר. גרסה ‎1.7.0-alpha07 מכילה את הקומטים האלה.

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.7.0-alpha06

‫3 באפריל 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha06 משוחרר. גרסה ‎1.7.0-alpha06 מכילה את הקומטים האלה.

תיקוני באגים

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

גרסה ‎1.7.0-alpha05

‫20 במרץ 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha05 משוחרר. גרסה ‎1.7.0-alpha05 מכילה את הקומטים האלה.

תיקוני באגים

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

גרסה ‎1.7.0-alpha04

‫6 במרץ 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha04 משוחרר. גרסה ‎1.7.0-alpha04 מכילה את התחייבויות הקוד האלה.

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

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

גרסה 1.7.0-alpha03

‫21 בפברואר 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha03 משוחרר. גרסה ‎1.7.0-alpha03 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

גרסה ‎1.7.0-alpha02

‫7 בפברואר 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha02 משוחרר. גרסה ‎1.7.0-alpha02 מכילה את הקומיטים האלה.

תיקוני באגים

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

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

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

גרסה ‎1.7.0-alpha01

‫24 בינואר 2024

androidx.compose.runtime:runtime-*:1.7.0-alpha01 משוחרר. גרסה ‎1.7.0-alpha01 מכילה את הקומיטים האלה.

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

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

תיקוני באגים

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

גרסה 1.6

גרסה 1.6.8

‫12 ביוני 2024

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

גרסה 1.6.7

‫1 במאי 2024

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

גרסה 1.6.6

‫17 באפריל 2024

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

גרסה 1.6.5

‫3 באפריל 2024

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

גרסה 1.6.4

‫20 במרץ 2024

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

גרסה 1.6.3

‫6 במרץ 2024

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

גרסה 1.6.2

‫21 בפברואר 2024

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

גרסה 1.6.1

‫7 בפברואר 2024

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

תיקוני באגים

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

גרסה 1.6.0

‫24 בינואר 2024

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

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

תכונות חדשות

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

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

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

תיקוני באגים

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

גרסה ‎1.6.0-rc01

‫10 בינואר 2024

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

גרסה ‎1.6.0-beta03

‫13 בדצמבר 2023

androidx.compose.runtime:runtime-*:1.6.0-beta03 משוחרר. גרסה 1.6.0-beta03 מכילה את הקומיטים האלה.

גרסה ‎1.6.0-beta02

‫29 בנובמבר 2023

androidx.compose.runtime:runtime-*:1.6.0-beta02 משוחרר. גרסה 1.6.0-beta02 מכילה את הקומיטים האלה.

גרסה ‎1.6.0-beta01

‫15 בנובמבר 2023

androidx.compose.runtime:runtime-*:1.6.0-beta01 משוחרר. גרסה 1.6.0-beta01 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

• שימוש במדיניות הפניה להרכבת מצב של היקף מקומי בהקשר. (83361c)
• הגבלת השימוש ב-‎ $dirty capture לביטויי למדה מוטמעים. (acfca0)
• תוקנה בעיה שבה תוכן שאפשר להזיז קיבל לפעמים את הלוקאלים הלא נכונים של הקומפוזיציה. (035cd6)
• שימוש במיפוי האש מהיר יותר שלא מקצה זיכרון ב-RecomposeScopeImpl. (d79494)
• שימוש ב-ObjectIntMap ב-DerivedState. (21862e)
• משתמשים ב-IntRef עבור הערך השלם 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 מכילה את הקומיטים האלה.

גרסה ‎1.6.0-alpha05

‫6 בספטמבר 2023

androidx.compose.runtime:runtime-*:1.6.0-alpha05 משוחרר. גרסה ‎1.6.0-alpha05 מכילה את הקומיטים האלה.

גרסה ‎1.6.0-alpha04

‫23 באוגוסט 2023

androidx.compose.runtime:runtime-*:1.6.0-alpha04 משוחרר. גרסה ‎1.6.0-alpha04 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

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

גרסה 1.6.0-alpha03

‫9 באוגוסט 2023

androidx.compose.runtime:runtime-*:1.6.0-alpha03 משוחרר. גרסה ‎1.6.0-alpha03 מכילה את הקומיטים האלה.

תיקוני באגים

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

גרסה ‎1.6.0-alpha02

‫26 ביולי 2023

androidx.compose.runtime:runtime-*:1.6.0-alpha02 משוחרר. גרסה ‎1.6.0-alpha02 מכילה את הקומיטים האלה.

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

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.6.0-alpha01

‫21 ביוני 2023

androidx.compose.runtime:runtime-*:1.6.0-alpha01 משוחרר. גרסה ‎1.6.0-alpha01 מכילה את הקומיטים האלה.

תיקוני באגים

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

גירסה 1.5

גרסה 1.5.4

‫18 באוקטובר 2023

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

גרסה 1.5.3

‫4 באוקטובר 2023

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

גרסה 1.5.2

‫27 בספטמבר 2023

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

גירסה 1.5.1

‫6 בספטמבר 2023

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

גרסה 1.5.0

‫9 באוגוסט 2023

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

שינויים ב-API

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

תיקוני באגים

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

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

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

גרסה 1.5.0-rc01

‫26 ביולי 2023

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

תיקוני באגים

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

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

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

גרסה ‎1.5.0-beta03

‫28 ביוני 2023

androidx.compose.runtime:runtime-*:1.5.0-beta03 משוחרר. גרסה 1.5.0-beta03 מכילה את הקומיטים האלה.

תיקוני באגים

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

גרסה ‎1.5.0-beta02

‫7 ביוני 2023

androidx.compose.runtime:runtime-*:1.5.0-beta02 משוחרר. גרסה ‎1.5.0-beta02 מכילה את הקומיטים האלה.

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

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

גרסה ‎1.5.0-beta01

‫24 במאי 2023

androidx.compose.runtime:runtime-*:1.5.0-beta01 משוחרר. גרסה 1.5.0-beta01 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

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

External Contribution

• נוספה Snapshot.isApplyObserverNotificationPending (I672a5)

גרסה ‎1.5.0-alpha04

‫10 במאי 2023

androidx.compose.runtime:runtime-*:1.5.0-alpha04 משוחרר. גרסה ‎1.5.0-alpha04 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

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

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

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

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

גרסה ‎1.5.0-alpha03

‫19 באפריל 2023

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.5.0-alpha02

‫5 באפריל 2023

androidx.compose.runtime:runtime-*:1.5.0-alpha02 משוחרר. גרסה ‎1.5.0-alpha02 מכילה את הקומיטים האלה.

תכונות חדשות

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

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

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

גרסה ‎1.5.0-alpha01

‫22 במרץ 2023

androidx.compose.runtime:runtime-*:1.5.0-alpha01 משוחרר. גרסה ‎1.5.0-alpha01 מכילה את הקומיטים האלה.

תכונות חדשות

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

גרסה 1.4

גרסה 1.4.3

‫3 במאי 2023

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

גרסה 1.4.2

‫19 באפריל 2023

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

תיקוני באגים

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

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

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

גרסה 1.4.1

‫5 באפריל 2023

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

תיקוני באגים

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

גרסה 1.4.0

‫22 במרץ 2023

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

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

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

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

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

גרסה 1.4.0-rc01

‫8 במרץ 2023

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

תיקוני באגים

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

גרסה ‎1.4.0-beta02

‫22 בפברואר 2023

הגרסאות androidx.compose.runtime:runtime:1.4.0-beta02 ו-androidx.compose.runtime:runtime-saveable:1.4.0-beta02 יוצאות לאור. גרסה 1.4.0-beta02 מכילה את הקומיטים האלה.

גרסה ‎1.4.0-beta01

‫8 בפברואר 2023

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.4.0-alpha05

‫25 בינואר 2023

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

שינויים ב-API

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

גרסה 1.4.0-alpha04

‫11 בינואר 2023

androidx.compose.runtime:runtime-*:1.4.0-alpha04 משוחרר. גרסה ‎1.4.0-alpha04 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.4.0-alpha03

‫7 בדצמבר 2022

androidx.compose.runtime:runtime-*:1.4.0-alpha03 משוחרר. גרסה ‎1.4.0-alpha03 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎1.4.0-alpha02

9 בנובמבר 2022

androidx.compose.runtime:runtime-*:1.4.0-alpha02 משוחרר. גרסה ‎1.4.0-alpha02 מכילה את הקומיטים האלה.

גרסה ‎1.4.0-alpha01

24 באוקטובר 2022

androidx.compose.runtime:runtime-*:1.4.0-alpha01 משוחרר. גרסה ‎1.4.0-alpha01 מכילה את הקומיטים האלה.

שינויים ב-API

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

גרסה 1.3

גרסה 1.3.3

‫11 בינואר 2023

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

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

גרסה 1.3.2

‫7 בדצמבר 2022

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

תיקוני באגים

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

גרסה 1.3.1

9 בנובמבר 2022

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

גרסה 1.3.0

24 באוקטובר 2022

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

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

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

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

מעקב אחר הרכב

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

Composable Reflection APIs

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

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

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

Snapshot System

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

גרסה 1.3.0-rc01

‫5 באוקטובר 2022

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

תיקוני באגים

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

גרסה 1.3.0-beta03

‫21 בספטמבר 2022

androidx.compose.runtime:runtime-*:1.3.0-beta03 משוחרר. גרסה 1.3.0-beta03 מכילה את הקומיטים האלה.

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

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

גרסה ‎1.3.0-beta02

‫7 בספטמבר 2022

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

תיקוני באגים

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

גרסה 1.3.0-beta01

‫24 באוגוסט 2022

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

שינויים ב-API

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

גרסה 1.3.0-alpha03

‫10 באוגוסט 2022

androidx.compose.runtime:runtime-*:1.3.0-alpha03 משוחרר. גרסה ‎1.3.0-alpha03 מכילה את הקומיטים האלה.

גרסה 1.3.0-alpha02

‫27 ביולי 2022

androidx.compose.runtime:runtime-*:1.3.0-alpha02 משוחרר. גרסה ‎1.3.0-alpha02 מכילה את הקומיטים האלה.

שינויים ב-API

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

גרסה ‎1.3.0-alpha01

29 ביוני 2022

androidx.compose.runtime:runtime-*:1.3.0-alpha01 משוחרר. גרסה ‎1.3.0-alpha01 מכילה את הקומיטים האלה.

שינויים ב-API

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

גרסה 1.2

גרסה 1.2.1

‫10 באוגוסט 2022

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

תיקוני באגים

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

גרסה 1.2.0

‫27 ביולי 2022

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

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

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

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

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

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

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

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

ביצועים ב1.2

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

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

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

גרסה 1.2.0-rc03

29 ביוני 2022

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

תיקוני באגים

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

גרסה 1.2.0-rc02

‫22 ביוני 2022

androidx.compose.runtime:runtime-*:1.2.0-rc02 משוחרר. גרסה 1.2.0-rc02 מכילה את הקומיטים האלה.

גרסה 1.2.0-rc01

‫15 ביוני 2022

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

שינויים ב-API

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

גרסה ‎1.2.0-beta03

‫1 ביוני 2022

androidx.compose.runtime:runtime-*:1.2.0-beta03 משוחרר. גרסה 1.2.0-beta03 מכילה את הקומיטים האלה.

גרסה 1.2.0-beta02

‫18 במאי 2022

androidx.compose.runtime:runtime-*:1.2.0-beta02 משוחרר. גרסה 1.2.0-beta02 מכילה את הקומיטים האלה.

גרסה ‎1.2.0-beta01

‫11 במאי 2022

androidx.compose.runtime:runtime-*:1.2.0-beta01 משוחרר. גרסה ‎1.2.0-beta01 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

• נוספה תכונה ניסיונית Snapshot.unsafeEnter/unsafeLeave (I108f3)
• נוסף API ניסיוני Snapshot.asContextElement() ‏ (Iff072)
• עכשיו אפשר להשתמש בהערה @ComposableTarget ובהערות שמסומנות ב-@ComposableTargetMarker בהיקף הקובץ באמצעות הקידומת @file. שימוש בהערת יעד בהיקף הקובץ יגרום לקומפיילר להניח שכל הפונקציות שניתנות להרכבה בקובץ מיועדות להיות היעד של כלי ההחלה המשויך. לדוגמה, שימוש ב-@file:UiComposable מכריז שכל הפונקציות של @Composable מכוונות למרכיב Compose UI applier. פונקציה שצריכה לטרגט כלי החלה אחר חייבת לספק במפורש את הערת הסמן של היעד עבור כלי ההחלה הרצוי. (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, אבל רוצים לקרוא את הערך בלי לגרום להרכבה מחדש או למדידה מחדש מיותרות. ‫(I9f365, ‏ b/214054486)

גרסה ‎1.2.0-alpha06

‫23 במרץ 2022

androidx.compose.runtime:runtime-*:1.2.0-alpha06 משוחרר. גרסה ‎1.2.0-alpha06 מכילה את הקומיטים האלה.

גרסה ‎1.2.0-alpha05

9 במרץ 2022

androidx.compose.runtime:runtime-*:1.2.0-alpha05 משוחרר. גרסה ‎1.2.0-alpha05 מכילה את הקומיטים האלה.

External Contribution

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

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

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

גרסה ‎1.2.0-alpha03

‫9 בפברואר 2022

androidx.compose.runtime:runtime-*:1.2.0-alpha03 משוחרר. גרסה ‎1.2.0-alpha03 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

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

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

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

גרסה ‎1.2.0-alpha02

26 בינואר 2022

androidx.compose.runtime:runtime-*:1.2.0-alpha02 משוחרר. גרסה ‎1.2.0-alpha02 מכילה את הקומיטים האלה.

גרסה ‎1.2.0-alpha01

‫12 בינואר 2022

androidx.compose.runtime:runtime-*:1.2.0-alpha01 משוחרר. גרסה ‎1.2.0-alpha01 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

גרסה 1.1

גרסה 1.1.1

23 בפברואר 2022

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

תיקוני באגים

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

גרסה 1.1.0

‫9 בפברואר 2022

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

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

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

גרסה 1.1.0-rc03

26 בינואר 2022

androidx.compose.runtime:runtime-*:1.1.0-rc03 משוחרר. גרסה 1.1.0-rc03 מכילה את הקומיטים האלה.

תיקוני באגים

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

גרסה ‎1.1.0-rc01

15 בדצמבר 2021

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

גרסה 1.1.0-beta04

1 בדצמבר 2021

androidx.compose.runtime:runtime-*:1.1.0-beta04 משוחרר. גרסה 1.1.0-beta04 מכילה את הקומיטים האלה.

תכונות חדשות

• עודכן כך שיהיה תואם ל-Kotlin 1.6.0

גרסה 1.1.0-beta03

‫17 בנובמבר 2021

androidx.compose.runtime:runtime-*:1.1.0-beta03 משוחרר. גרסה 1.1.0-beta03 מכילה את הקומיטים האלה.

גרסה ‎1.1.0-beta02

‫3 בנובמבר 2021

androidx.compose.runtime:runtime-*:1.1.0-beta02 משוחרר. גרסה 1.1.0-beta02 מכילה את הקומיטים האלה.

שינויים ב-API

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

גרסה ‎1.1.0-beta01

‫27 באוקטובר 2021

androidx.compose.runtime:runtime-*:1.1.0-beta01 משוחרר. גרסה ‎1.1.0-beta01 מכילה את הקומיטים האלה.

גרסה ‎1.1.0-alpha06

‫13 באוקטובר 2021

androidx.compose.runtime:runtime-*:1.1.0-alpha06 משוחרר. גרסה ‎1.1.0-alpha06 מכילה את הקומיטים האלה.

שינויים ב-API

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

גרסה ‎1.1.0-alpha05

‫29 בספטמבר 2021

androidx.compose.runtime:runtime-*:1.1.0-alpha05 משוחרר. גרסה ‎1.1.0-alpha05 מכילה את הקומיטים האלה.

גרסה ‎1.1.0-alpha04

‫15 בספטמבר 2021

androidx.compose.runtime:runtime-*:1.1.0-alpha04 משוחרר. גרסה ‎1.1.0-alpha04 מכילה את הקומיטים האלה.

גרסה ‎1.1.0-alpha03

‫1 בספטמבר 2021

androidx.compose.runtime:runtime-*:1.1.0-alpha03 משוחרר. גרסה ‎1.1.0-alpha03 מכילה את הקומיטים האלה.

תכונות חדשות

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

גרסה ‎1.1.0-alpha02

‫18 באוגוסט 2021

androidx.compose.runtime:runtime-*:1.1.0-alpha02 משוחרר. גרסה ‎1.1.0-alpha02 מכילה את הקומיטים האלה.

גרסה ‎1.1.0-alpha01

‫4 באוגוסט 2021

androidx.compose.runtime:runtime-*:1.1.0-alpha01 משוחרר. גרסה ‎1.1.0-alpha01 מכילה את הקומיטים האלה.

גירסה 1.0

גרסה 1.0.5

‫3 בנובמבר 2021

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

תיקוני באגים

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

גרסה 1.0.4

‫13 באוקטובר 2021

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

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

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

גרסה 1.0.3

‫29 בספטמבר 2021

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

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

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

גרסה 1.0.2

‫1 בספטמבר 2021

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

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

גרסה 1.0.1

‫4 באוגוסט 2021

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

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

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

גרסה 1.0.0

‫28 ביולי 2021

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

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

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

בעיות מוכרות

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

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

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

גרסה 1.0.0-rc02

‫14 ביולי 2021

androidx.compose.runtime:runtime-*:1.0.0-rc02 משוחרר. גרסה 1.0.0-rc02 מכילה את הקומיטים האלה.

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

גרסה 1.0.0-rc01

‫1 ביולי 2021

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

גרסה 1.0.0-beta09

‫16 ביוני 2021

androidx.compose.runtime:runtime-*:1.0.0-beta09 משוחרר. גרסה 1.0.0-beta09 מכילה את הקומיטים האלה.

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

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

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

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

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

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

  <FLAGS><CLASS_DESCRIPTOR>-><METHOD_SIGNATURE>
  

• כלל מחלקה יכלול את התבנית הבאה:

  <CLASS_DESCRIPTOR>
  

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

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

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

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

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

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

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

• מתודה עם הסימון P היא מתודה שמופעלת אחרי ההפעלה.

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

איך זה עובד?

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

גרסה 1.0.0-beta08

‫2 ביוני 2021

androidx.compose.runtime:runtime-*:1.0.0-beta08 משוחרר. גרסה 1.0.0-beta08 מכילה את הקומיטים האלה.

שינויים ב-API

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

גרסה 1.0.0-beta07

‫18 במאי 2021

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

שינויים ב-API

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

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

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

• מעכשיו תמונות עם הפנים של @ComposeCompilerApi ‏@RequiresOptIn (Iab690)

תיקוני באגים

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

גרסה 1.0.0-beta06

‫5 במאי 2021

androidx.compose.runtime:runtime-*:1.0.0-beta06 משוחרר. גרסה 1.0.0-beta06 מכילה את הקומיטים האלה.

שינויים ב-API

• מעכשיו תמונות עם הפנים של @ComposeCompilerApi ‏@RequiresOptIn (Iab690)

גרסה 1.0.0-beta05

21 באפריל 2021

androidx.compose.runtime:runtime-*:1.0.0-beta05 משוחרר. גרסה 1.0.0-beta05 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.0.0-beta04

7 באפריל 2021

androidx.compose.runtime:runtime-*:1.0.0-beta04 משוחרר. גרסה 1.0.0-beta04 מכילה את הקומיטים האלה.

תיקוני באגים

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

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

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

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

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

גרסה 1.0.0-beta03

‫24 במרץ 2021

androidx.compose.runtime:runtime-*:1.0.0-beta03 משוחרר. גרסה 1.0.0-beta03 מכילה את הקומיטים האלה.

שינויים ב-API

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

גרסה 1.0.0-beta02

‫10 במרץ 2021

androidx.compose.runtime:runtime-*:1.0.0-beta02 משוחרר. גרסה ‎1.0.0-beta02 מכילה את הקומיטים האלה.

תיקוני באגים

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

גרסה ‎1.0.0-beta01

24 בפברואר 2021

androidx.compose.runtime:runtime-*:1.0.0-beta01 משוחרר. גרסה 1.0.0-beta01 מכילה את הקומיטים האלה.

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

שינויים ב-API

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

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

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

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

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

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

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

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

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

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

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

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

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

גרסה ‎1.0.0-alpha12

10 בפברואר 2021

androidx.compose.runtime:runtime-*:1.0.0-alpha12 משוחרר. גרסה ‎1.0.0-alpha12 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

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

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

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

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

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

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

• נוסף SnapshotMutableState ‏ (Icfd03)

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

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

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

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

גרסה 1.0.0-alpha11

‫28 בינואר 2021

androidx.compose.runtime:runtime-*:1.0.0-alpha11 משוחרר. גרסה ‎1.0.0-alpha11 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

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

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

תיקוני באגים

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

גרסה 1.0.0-alpha10

‫13 בינואר 2021

androidx.compose.runtime:runtime-*:1.0.0-alpha10 משוחרר. גרסה ‎1.0.0-alpha10 מכילה את הקומיטים האלה.

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

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

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

שינויים ב-API

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

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

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

תיקוני באגים

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

גרסה ‎1.0.0-alpha09

‫16 בדצמבר 2020

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

שינויים ב-API

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

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

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

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

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

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

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

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

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

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

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

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

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

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

תיקוני באגים

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

גרסה 1.0.0-alpha08

‫2 בדצמבר 2020

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.0.0-alpha07

‫11 בנובמבר 2020

androidx.compose.runtime:runtime-*:1.0.0-alpha07 משוחרר. גרסה ‎1.0.0-alpha07 מכילה את הקומיטים האלה.

תכונות חדשות

שינויים ב-API

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

תיקוני באגים

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

External Contribution

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

גרסה ‎1.0.0-alpha06

‫28 באוקטובר 2020

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

שינויים ב-API

• הקומפוזיציה מחדש היא עכשיו CompositionReference והורה קומפוזיציה תקין. השימוש ב-Explicit Recomposer נדרש עכשיו בפחות מקומות. (I4036f)
• נוסף API מקביל של DisposableEffect ל-SideEffect, שממלא את התפקיד של onCommit-with-params אבל עם onDispose נדרש.
  • הוספנו את rememberUpdatedState API כדי לפרסם נתונים מ-recomposition לתהליכים מתמשכים או ארוכי טווח, כמו 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

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

גרסה ‎1.0.0-alpha04

‫1 באוקטובר 2020

androidx.compose.runtime:runtime-*:1.0.0-alpha04 משוחרר. גרסה ‎1.0.0-alpha04 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.0.0-alpha03

‫16 בספטמבר 2020

androidx.compose.runtime:runtime-*:1.0.0-alpha03 משוחרר. גרסה ‎1.0.0-alpha03 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.0.0-alpha02

‫2 בספטמבר 2020

androidx.compose.runtime:runtime-*:1.0.0-alpha02 משוחרר. גרסה ‎1.0.0-alpha02 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

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

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

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

גרסה ‎1.0.0-alpha01

‫26 באוגוסט 2020

androidx.compose.runtime:runtime-*:1.0.0-alpha01 משוחרר. גרסה ‎1.0.0-alpha01 מכילה את הקומיטים האלה.

גרסה 0.1.0-dev

גרסה 0.1.0-dev17

‫19 באוגוסט 2020

androidx.compose.runtime:runtime-*:0.1.0-dev17 משוחרר. גרסה 0.1.0-dev17 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

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

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

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

תיקוני באגים

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

גרסה 0.1.0-dev16

‫5 באוגוסט 2020

androidx.compose.runtime:runtime-*:0.1.0-dev16 משוחרר. גרסה 0.1.0-dev16 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

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

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

  לדוגמה,

  val state = mutableStateOf(1f)
  

  ואחריו,

  state.value = 1f
  

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

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

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

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

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

תיקוני באגים

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

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

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

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

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

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

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

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

גרסה 0.1.0-dev15

‫22 ביולי 2020

androidx.compose.runtime:runtime-*:0.1.0-dev15 משוחרר. גרסה 0.1.0-dev15 מכילה את הקומיטים האלה.

עדכון לגבי תלות

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

שינויים ב-API

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

  הצדקה

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

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

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

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

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

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

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

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

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

  אפשרות חלופית 2: שימוש ב-mutableStateOf וב-property delegates

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

תיקוני באגים

• השם של runOnIdleCompose שונה לrunOnIdle (I83607)
• ‫API ניסיוני של LayoutNode (I4f2e9)
• השימוש ב-androidx.ui.foundation.TextFieldValue וב-androidx.ui.input.EditorValue הוצא משימוש. גם קומפוזיציות של TextField,‏ FilledTextField ו-CoreTextField שמשתמשות בסוג הזה הוצאו משימוש. במקומה, אפשר להשתמש ב-androidx.ui.input.TextFieldValue (‏I4066d,‏ b/155211005)
• הוסר ה-API ‏DrawBackground שיצא משימוש, ובמקומו נוספו ממשקי API של drawBackground extension ב-Modifier. בוצע רפקטורינג של ההטמעות של color, ‏ brush ו-paint drawBackground כדי לצמצם את נתיבי הקוד וגם כדי להסיר את הדרישה ליצירת Modifier כחלק מהקומפוזיציה. (I0343a)
• ממשקי API ברמה גבוהה יותר של Compose עודכנו כך שבמקום Canvas הם חושפים CanvasScope. כך הצרכנים לא צריכים לתחזק אובייקטים משלהם של Paint. צרכנים שעדיין צריכים גישה ל-Canvas יכולים להשתמש בשיטה drawCanvas של התוסף, שמספקת קריאה חוזרת להנפקת פקודות ציור עם ה-Canvas הבסיסי. (I80afd)
• בוצע שינוי ב-API של lambda עם Constraints trailing. עכשיו, במקום שני פרמטרים, יש לו היקף של מקבל, שבנוסף למגבלות ול-layoutDirection מספק את המאפיינים minWidth,‏ maxWidth,‏ minHeight ו-maxHeight ב-Dp ‏ (I91b9a,‏ b/149979702)
• נוסף משנה למרווח פנימי סימטרי. (I39840)
• הפונקציות wrapContentWidth ו-wrapContentHeight עודכנו כך שהן מצפות ליישור אנכי או אופקי ולא ליישור כלשהו. העדכון של משנה הגרביטציה מאפשר יישור אנכי או אופקי. העדכנו את הרכיבים 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)
• הוחלף Modifier plus operator בפונקציות של תוסף factory ‏ (I225e4)
• מעכשיו אפשר לגשת לחברים ב-RowScope וב-ColumnScope מחוץ לשורה ולעמודה. (I3a641)
• השם של LayoutFlexible שונה ל-LayoutWeight. השם של הפרמטר tight שונה ל-fill. (If4738)
• הפרמטר LayoutDirection נוסף ל-WithConstraints ‏ (I6d6f7)
• שינוי השם של הרקע ל-DrawBackground והגדרתו כרקע שייזכר כברירת מחדל (Ia0bd3)
• החלפנו את ButtonStyle בפונקציות נפרדות והסרנו את העומס של הטקסט (מחרוזת). אפשר לעיין בדוגמאות המעודכנות של פרטי השימוש. (If63ab, b/146478620, b/146482131)
• ‫runOnIdleCompose ו-runOnUiThread הן עכשיו פונקציות גלובליות במקום שיטות ב-ComposeTestRule. (Icbe8f)

External Contribution

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