מחזור חיים

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

בטבלה הזו מפורטים כל פריטי המידע בקבוצה androidx.lifecycle.

פריט מידע שנוצר בתהליך פיתוח (Artifact) גרסה יציבה גרסה מועמדת להפצה גרסת בטא גרסת אלפא
lifecycle-*‎ 2.11.1 - - 2.12.0-alpha06
lifecycle-viewmodel-navigation3 2.11.1 - - 2.12.0-alpha06
הספרייה הזו עודכנה לאחרונה ב-18 בנובמבר 2026

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

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

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

Kotlin

Groovy

    dependencies {
        def lifecycle_version = "2.11.0"
        def arch_version = "2.2.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
        // ViewModel utilities for Compose
        implementation "androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
        // Lifecycle utilities for Compose
        implementation "androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // ViewModel integration with Navigation3
        implementation "androidx.lifecycle:lifecycle-viewmodel-navigation3:2.12.0-alpha04"

        // Annotation processor
        kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"

        // optional - Test helpers for Lifecycle runtime
        testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version"
    }
    

Kotlin

    dependencies {
        val lifecycle_version = "2.11.0"
        val arch_version = "2.2.0"

        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
        // ViewModel utilities for Compose
        implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
        // Lifecycles only (without ViewModel or LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")
        // Lifecycle utilities for Compose
        implementation("androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version")

        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")

        // ViewModel integration with Navigation3
        implementation("androidx.lifecycle:lifecycle-viewmodel-navigation3:2.12.0-alpha04")

        // Annotation processor
        kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")

        // optional - ReactiveStreams support for LiveData
        implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version")

        // optional - Test helpers for LiveData
        testImplementation("androidx.arch.core:core-testing:$arch_version")

        // optional - Test helpers for Lifecycle runtime
        testImplementation ("androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version")
    }
    

Java

Groovy

    dependencies {
        def lifecycle_version = "2.11.0"
        def arch_version = "2.2.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"

        // optional - Test helpers for Lifecycle runtime
        testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version"
    }
    

Kotlin

    dependencies {
        val lifecycle_version = "2.11.0"
        val arch_version = "2.2.0"

        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata:$lifecycle_version")
        // Lifecycles only (without ViewModel or LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime:$lifecycle_version")

        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")

        // Annotation processor
        annotationProcessor("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")

        // optional - ReactiveStreams support for LiveData
        implementation("androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version")

        // optional - Test helpers for LiveData
        testImplementation("androidx.arch.core:core-testing:$arch_version")

        // optional - Test helpers for Lifecycle runtime
        testImplementation("androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version")
    }
    

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

משוב

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

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

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

גרסה 2.12

גרסה ‎2.12.0-alpha06

‫18 בנובמבר 2026

‫androidx.lifecycle:lifecycle-*:2.12.0-alpha06 מופץ. גרסה ‎2.12.0-alpha06 מכילה את ה-commits האלה.

שינויים ב-API

  • מעבירים את LocalLifecycleOwner לשימוש ב-compositionLocalWithHostDefaultOf וב-LifecycleOwnerHostDefaultKey, ומנתקים אותו מהאחזור הישיר כחלק מעץ התצוגה מחוץ ל-Android. (I7c265)

תיקוני באגים

  • מגרסה Lifecycle 2.11.1: המאפיין currentStateFlow של LifecycleRegistry מחזיר עכשיו את אותו מופע בכל הפעלה, במקום ליצור מופע חדש בכל פעם. (I1ae01, b/579057749)

גרסה ‎2.12.0-alpha05

‫21 באוקטובר 2026

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

שינויים ב-API

  • עכשיו SavedStateHandle מספק פונקציות לשילוב עם SavedStateContainer. יש את asContainer() כדי להפוך את SavedStateHandle ל-SavedStateContainer, את getOrCreateContainer() כדי ליצור מאגר צאצא בתוך נקודת האחיזה, ואת getOrCreateSavedStateHandle() שיוצר SavedStateHandle צאצא בתוך ה-SavedStateHandle הנוכחי. כחלק מהמעבר אל SavedStateContainer, אי אפשר יותר להשתמש ב-getStateFlow וב-getLiveData ביחד ב-SavedStateHandle. אם תנסו לעשות את זה, תופיע השגיאה IllegalArgumentException (I62f36)

גרסה ‎2.12.0-alpha04

‫23 בספטמבר 2026

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

גרסה ‎2.12.0-alpha03

‫9 בספטמבר 2026

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

תיקוני באגים

  • ‫compileSdk לספריות Compose עודכנו לגרסה 37.1. כדי לעשות את זה, צריך לעדכן באופן טרנזיטיבי את compileSdk בכל האפליקציות והספריות שמשתמשות ב-Compose. (I05b0f)

גרסה ‎2.12.0-alpha02

‫26 באוגוסט 2026

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

שינויים ב-API

  • המאפיינים AutoRecreated ו-runOnNextRecreation הוצאו משימוש והוחלפו במאפיינים SavedStateProvider ו-SavedStateRestorer. (Iadc00)

גרסה ‎2.12.0-alpha01

‫12 באוגוסט 2026

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

תיקוני באגים

  • הוצאה משימוש של פריט המידע שנוצר על ידי מעבד האנוטציות (Annotation processor) של lifecycle-compiler. צריך לעבור ל-DefaultLifecycleObserver או ל-LifecycleEventObserver במקום להשתמש במעבד האנוטציות. (Ibf571,‏ b/541926513)
  • הפונקציות SavedStateViewModelFactory ו-AbstractSavedStateViewModelFactory עוצרות עכשיו באופן מיידי אם ה-SavedStateRegistryOwner שסופק לא מטמיע את ViewModelStoreOwner, וכך מונעות קריסות מאוחרות יותר במהלך יצירה מחדש של רכיבים. (Icf317)
  • הוספת תיעוד עקבות המערכת ל-LifecycleRegistry שליחות של אירועים. (Ie1f92, b/112161409)

גרסה 2.11

גרסה 2.11.1

‫18 בנובמבר 2026

‫androidx.lifecycle:lifecycle-*:2.11.1 מופץ. גרסה 2.11.1 מכילה את ה-commits האלה.

תיקוני באגים

  • המאפיין currentStateFlow של LifecycleRegistry מחזיר עכשיו את אותו מופע בכל הפעלה, במקום ליצור מופע חדש בכל פעם. (I1ae01, b/579057749)

גרסה 2.11.0

‫17 ביוני 2026

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

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

מודלים של תצוגה ברמת היקף ב-Compose – הוספנו את ViewModelStoreProvider,‏ rememberViewModelStoreProvider ו-rememberViewModelStoreOwner כדי לקשר מודלים של תצוגה להיקפים ספציפיים של ממשק המשתמש (כמו דפים של כלי לדפדוף). הם נשמרים גם אחרי שינויים בהגדרות, ונמחקים אוטומטית כשה-Composable מוסר מההיררכיה.

תמיכה ב-KMP – ViewModel-Compose ו-ViewModel-Navigation3 תומכים עכשיו בכל היעדים של Kotlin Multiplatform.

שילוב של Navigation3 – עכשיו ViewModelStoreNavEntryDecorator מקבל ViewModelStoreOwner כדי להפיץ את CreationExtras ואת ה-factories ל-ViewModels בתצוגת עץ. אפשר גם להעביר ספקים באמצעות עומס היתר החדש של rememberViewModelStoreNavEntryDecorator כדי לתמוך בכמה מקבצי פעילויות קודמות. השדה removeViewModelStoreOnPop הוצא משימוש.

‫Lifecycle Utilities – הוספנו תוסף ViewModelProvider.get<VM>(key) מוגדר, Lifecycle.addObserver מבוסס-למבדה ותוספי ברירת מחדל של פונקציית מפעל ל-ViewModelStoreOwner. הערה @EmptySuper נוספה ל-ViewModel.onCleared.

שינויים אחרים – עכשיו נדרש ממשק משתמש של Compose בגרסה 1.7.0+ כדי ש-LocalLifecycleOwner יסיר את החלופות של ההשתקפות. כדי לעדכן את "פיתוח נייטיב" compileSdk, נדרשת גרסת AGP מינימלית של 9.2.0.

גרסה ‎2.11.0-rc01

‫3 ביוני 2026

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

גרסה ‎2.11.0-beta02

‫19 במאי 2026

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

שינויים ב-API

  • מוסיפים עומס יתר של rememberViewModelStoreNavEntryDecorator שמקבל ViewModelStoreProvider. כך המפתחים יכולים להרים את הספק מעל להיקף הקומפוזיציה של ה-decorator, וכך לאפשר תרחישי שימוש כמו תמיכה בכמה מקבצי פעילויות קודמות (back stack) שבהם אותו רכיב קיים בשניהם אבל דורש מצב נפרד. (Ibbbfe,‏ b/503420425)
  • מניעת פינוי מוקדם של ViewModels משותף כשספק אחים מוסר מהקומפוזיציה. (Ib321a)

תיקוני באגים

  • כדי להשתמש ב-LocalLifecycleOwner, צריך את Compose UI בגרסה 1.7.0 ואילך. הפעולה הזו מסירה את ברירות המחדל של ההשתקפות הפנימית, משפרת את הביצועים אבל אוכפת שדרוג תלות קפדני ללקוחות. (I48e65)
  • מניעת שכפול סמלים עם גרסאות ישנות יותר של JetBrains fork כשמשדרגים ל-Compose Multiplatform 1.11.0. (Iccd64)
  • תוקנה בעיה שבה ViewModels נמחקו בטעות במהלך הרכבה מחדש כשמשתמשים ב-rememberViewModelStoreProvider עם פרמטרים לא יציבים של ברירת מחדל. עכשיו הספק יוצר מחדש רק כשהבעלים הראשי או המפתח המפורש משתנים. (Ibe296, b/501792448)

גרסה ‎2.11.0-beta01

‫22 באפריל 2026

‫androidx.lifecycle:lifecycle-*:2.11.0-beta01 מופץ. גרסה ‎2.11.0-beta01 מכילה את ה-commits האלה.

שינויים ב-API

  • פיצול של rememberViewModelStoreOwner ו-rememberViewModelStoreProvider לפונקציות נפרדות לתרחישים לדוגמה עם מפתח ובלי מפתח. (Ifd154,‏ b/500802788)

תיקוני באגים

  • עדכון של Compose compileSdk ל-API 37. כלומר, כשמשתמשים ב-Compose, נדרשת גרסת AGP מינימלית של 9.2.0. (Id45cd, b/413674743)

גרסה ‎2.11.0-alpha03

‫25 במרץ 2026

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

שינויים ב-API

  • הופכים את parentKey לפרמטר אופציונלי בבנאים של ViewModelStoreProvider, עם ברירת המחדל null, ומעבירים אותו אחרי parentStore או parentOwner. כך קל יותר ליצור מופע כשלא צריך מפתח היקף משותף. (I66b67)
  • הפרמטר ViewModelStoreNavEntryDecorator מקבל עכשיו ViewModelStoreOwner במקום ViewModelStore. כך Navigation3 יכול להפיץ את ברירת המחדל של ההורה CreationExtras ו-ViewModelProvider.Factory ל-ViewModels בתצוגת עץ, וכך להבטיח תמיכה ביחסי תלות ברמת האפליקציה. (Ia6018, b/434651920)
  • בידוד המצב של ViewModelStoreProvider באמצעות מפתח ייחודי. כך ספקים אחים לא ימחקו בטעות את ה-ViewModels אחד של השני במהלך ההסרה. (I59c0b, b/434651920)
  • הוספת פונקציית תוסף אחת (ViewModelProvider.get<VM>(key: String)). כך המפתחים יכולים לאחזר מודלים של תצוגה בצורה נקייה יותר באמצעות key בהתאמה אישית עם פרמטרים של סוגים מוגדרים ב-Kotlin, בלי צורך להעביר באופן מפורש את סוג המחלקה. (Ic1f59)
  • הוספת תמיכה ב-defaultArgs ל-ViewModelStoreProvider כדי לאפשר אתחול של ViewModels עם ערכי ברירת מחדל של SavedState. (I1e933, b/434651920, b/165642391)
  • הוצאה משימוש של removeViewModelStoreOnPop ושל ViewModelStoreNavEntryDecoratorDefaults שמשויך אליו. ה-API הזה היה פתרון עקיף לשינויים בהגדרות, שעכשיו מטופלים באופן פנימי. עכשיו צריך לנקות את כל המצבים של ה-decorator, כולל ViewModels, באותו זמן שבו מנקים את ה-pop. כדי לשמור על מצב ה-decorator מחוץ לזמן שבו מקבץ הפעילויות הקודמות מועבר ל-NavDisplay, צריך להשתמש ב-API של rememberDecoratedNavEntries. (I852d9)

תיקוני באגים

  • מוסיפים את toString() ל-CreationExtras.Key כדי להציג את שם הכיתה. (I5de52)

גרסה ‎2.11.0-alpha02

‫11 במרץ 2026

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

מודלים של תצוגה מוגדרת היקף

  • בגרסה הזו הוספנו ממשקי API ליצירת מכונות ViewModelStore ברמת ההיקף ב-Compose. כך אפשר לקשר את ViewModels להיקפים ספציפיים של ממשק המשתמש (כמו דפים ספציפיים של Pager או פריטים ספציפיים של LazyList). האובייקטים האלה מסוג ViewModels נשמרים גם כשמשנים את ההגדרות, והם נמחקים אוטומטית כשהרכיב ה-Composable התואם שלהם מוסר באופן סופי מההיררכיה.

    // Hoist the parent provider outside the Pager.
    val provider = rememberViewModelStoreProvider()
    val pagerState = rememberPagerState(pageCount = { 5 })
    
    HorizontalPager(state = pagerState) { page ->
        // Create an owner scoped to the current page.
        val storeOwner = rememberViewModelStoreOwner(provider, key = page)
    
        // Provide the scoped owner to this composition.
        CompositionLocalProvider(LocalViewModelStoreOwner provides storeOwner) {
            // ViewModel is now scoped specifically to this page.
            val viewModel: PageViewModel = viewModel()
        }
    }
    

חשוב לזכור ש-ViewModelStoreProvider זמין מחוץ ל-Compose ואפשר להשתמש בו עם Activities, ‏ Fragments ו/או Views.

תכונות חדשות

  • הוספת תמיכה לכל יעדי KMP ב-ViewModel Navigation3. (I60fa5)
  • הוספת פונקציות של מפעל ל-LifecycleOwner, ל-ViewModelStoreOwner ול-SavedStateRegistryOwner כדי לצמצם את הקוד החוזר כשיוצרים רכיבים מותאמים אישית של בעלים. (I9682c)
  • מוסיפים פונקציית הרחבה של Lifecycle.addObserver שמבוססת על lambda כדי לאפשר מעקב אחרי אירועים במחזור החיים בלי ליצור אובייקט אנונימי. (I94f38)
  • הוספת תוספי defaultViewModelProviderFactory וdefaultViewModelCreationExtras אל ViewModelStoreOwner. הם מספקים גישה בטוחה לברירות המחדל בלי שצריך לבדוק ידנית את הסוגים מול HasDefaultViewModelProviderFactory. (Ifa83d)

שינויים ב-API

  • מוסיפים את rememberViewModelStoreOwner כדי ליצור בקלות ViewModelStoreOwner ברמת ההיקף ב-Compose. הפונקציה הזו מחזירה בעלים שקשור למחזור החיים של הפונקציה הקומפוזבילית, ומנקה באופן אוטומטי את ה-ViewModels שלה כשהפונקציה הקומפוזבילית מוסרת מממשק המשתמש. (I2a15b, b/165642391)
  • מוסיפים את rememberViewModelStoreProvider כדי לאפשר יצירת מכונות ViewModelStore ברמת ההיקף ב-Compose. הפונקציה הזו מקשרת בין מאגר צאצא לבעלים הורה, וכך מבטיחה ש-ViewModels ישרדו שינויים בהגדרות, תוך ניקוי אוטומטי שלהם כשה-Composable יוסר מההיררכיה. (I0f57a,‏ b/165642391)
  • צריך להוסיף את ViewModelStoreProvider כדי לנהל מכונות ViewModelStore ברמת ההיקף. הכיתה הזו מאפשרת ליצור היקפים צאצאים ששורדים שינויים בהגדרות, אבל אפשר לנקות אותם בנפרד. הוא גם מספק מעטפות של ViewModelStoreOwner שיורשות את ברירות המחדל של ה-factory והתוספות ליצירה מההורה. (I87f4f,‏ b/434651920)

גרסה ‎2.11.0-alpha01

‫25 בפברואר 2026

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

תכונות חדשות

  • תמיכה בכל היעדים של Kotlin Multiplatform‏ (KMP) ב-ViewModel-Compose. הפרדת זיהוי הבעלים מ-LocalView כדי לאפשר למארחי הפלטפורמה לספק ViewModelStoreOwner כברירת מחדל, תוך שמירה על LocalView כגיבוי בטוח ב-Android. (I09fab,‏ b/434940570,‏ Ic8526,‏ b/478146897)

שינויים ב-API

  • מוסיפים הטמעה של toString ל-ViewModelStore שמפרטת את כל המפתחות השמורים כדי לייעל את ניפוי הבאגים. (I0a6f4)
  • הוספת הטמעה כברירת מחדל ל-HasDefaultViewModelProviderFactory.defaultViewModelProviderFactory, כלומר אין יותר צורך לשנות את המאפיין הזה באופן מפורש כשמטמיעים את הממשק. (Ia7095)
  • צריך להוסיף הערה ל-ViewModel.onCleared עם @EmptySuper כדי לציין במפורש ששיטות שיש להן עדיפות לא צריכות להפעיל את super.onCleared(). (I8c226)

גרסה 2.10

גרסה 2.10.0

‫19 בנובמבר 2025

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

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

  • מוסיפים רכיב קומפוזבילי של rememberLifecycleOwner כדי לאפשר יצירה של מחזורי חיים ברמת ההיקף ישירות בממשק המשתמש. האפשרות הזו שימושית לרכיבים שצריכים לנהל את מחזורי החיים שלהם באופן עצמאי, כמו HorizontalPager שרוצה להפוך רק את הדף הנוכחי ל-RESUMED או ספריות כמו Navigation3:

    @Composable
    fun MyComposable() {
        // This LifecycleOwner is automatically moved to DESTROYED when
        // it leaves composition and its maxLifecycle is the maximum of either
        // the maxLifecycle you set or the Lifecycle.State of the parentLifecycleOwner
        val lifecycleOwner = rememberLifecycleOwner(
            maxLifecycle = RESUMED,
            parentLifecycleOwner = LocalLifecycleOwner.current,
        )
        CompositionLocalProvider(LocalLifecycleOwner provides lifecycleOwner) {
            val childLifecycleOwner = LocalLifecycleOwner.current
        }
    }
    
  • רכיב ה-artifact של lifecycle-viewmodel-navigation3 מספק שילוב מובנה מראש ל-Navigation3, שמאפשר להפעיל מופעי ViewModel ברמת ההיקף למסכים ספציפיים ("רשומות") באמצעות ה-API של rememberViewModelStoreNavEntryDecorator():

    @Composable
    fun MyComposable() {
        NavDisplay(
            backStack = backStack,
            entryDecorators =
                listOf(
                    rememberSaveableStateHolderNavEntryDecorator(),
                    // Add this line to automatically scope ViewModels to each entry
                    rememberViewModelStoreNavEntryDecorator(),
                ),
            entryProvider = entryProvider {
                // Add your entries here
            }
        }
    }
    
  • הוספת פונקציית מפעל של בונה ל-CreationExtras, שמספקת API נוח ואידיומטי יותר של Kotlin.

    override val defaultViewModelCreationExtras: CreationExtras
        // Use the CreationExtras builder to add in a custom value to the default
        // CreationExtras in your Activity or Fragment
        get() = super.defaultViewModelCreationExtras + CreationExtras {
            this[CustomKey] = "customValue"
       }
    
  • הוספת תמיכה מובנית בסוגים שניתנים לביטול ב-SavedStateHandle.saved, כדי לפשט את השמירה והשחזור של מאפיינים שניתנים לביטול.

  • סימון SavedStateHandle יצרנים בתור @VisibleForTesting.

  • ה-minSdk השתנה מ-API 21 ל-API 23.

גרסה ‎2.10.0-rc01

‫5 בנובמבר 2025

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

גרסה ‎2.10.0-beta01

‫22 באוקטובר 2025

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

שינויים ב-API

  • השם של ViewModelStoreNavEntryDecoratorDefault השתנה לשם ViewModelStoreNavEntryDecoratorDefaults, עם האות s. (I6d27b,‏ b/444447434)

תיקוני באגים

  • rememberLifecycleOwner לא קורס יותר אם הבעלים מקבל אירוע Lifecycle.Event.ON_DESTROY לפני המעבר אל Lifeycle.State.CREATED. (I6f98e, b/444594991)

גרסה ‎2.10.0-alpha05

‫8 באוקטובר 2025

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

שינויים ב-API

  • ה-removeViewModelStoreOnPopCallback() הוא עכשיו חלק מאובייקט ViewModelStoreNavEntryDecoratorDefault, שבו פלטפורמות והטמעות אחרות יכולות לקרוא לברירת המחדל. (Ia1f23, b/444447434)
  • שינינו את המבנה של ViewModelStoreNavEntryDecorator מפונקציה למחלקה כדי לשקף טוב יותר את הפונקציונליות שלה כ-factory של NavEntryDecorator, ושינינו את השם של הפרמטר shouldRemoveViewModelStore של ה-decorator ל-removeViewModelStoreOnPop כדי להבהיר שהקריאה החוזרת הזו מופעלת רק כשערך נשלף מה-backStack. (Iefdc5,‏ b/444447434)

גרסה ‎2.10.0-alpha04

‫24 בספטמבר 2025

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

שינויים ב-API

  • משנים את הרכיב הקומפוזבילי LifecycleOwner ל-rememberLifecycleOwner. עכשיו הפונקציה מחזירה את LifecycleOwner ישירות. כדי לספק את הבעלים הזה לקומפוזיציית משנה, צריך להשתמש ב-CompositionLocalProvider. (Ic57f0, b/444446629)
  • הוספת רכיבי Stub של KMP ל-lifecycle-viewmodel-navigation3 כדי לאפשר ל-JetBrains לספק פיצולים שממלאים את היעדים האלה, וכך לתמוך ב-CMP. (I44a4c)

גרסה ‎2.10.0-alpha03

‫27 באוגוסט 2025

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

שינויים ב-API

  • מעדכנים את Compose לגרסה 1.9.0. (I2b9de)

גרסה ‎2.10.0-alpha02

‫13 באוגוסט 2025

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

תכונות חדשות

  • הרכיב הקומפוזבילי LifecycleOwner יכול עכשיו ליצור מחזור חיים בסיסי נפרד. כשמגדירים את parent = null (באופן מפורש), מחזור החיים החדש פועל באופן עצמאי מכל מארח (כמו Activity,‏ Fragment או NavBackStackEntry). הוא מתחיל ברגע שהרכיב הניתן לשילוב נכנס לקומפוזיציה ומושמד באופן אוטומטי כשהוא יוצא ממנה. (I8dfbe,‏ b/433659048)

    @Composable
    fun IndependentComponent() {
        // Create a standalone lifecycle, not tied to the parent Activity/Fragment.
        LifecycleOwner(parent = null) {
            val rootLifecycle = LocalLifecycleOwner.current.lifecycle
        }
    }
    

שינויים ב-API

  • בפונקציה הקומפוזבילית LifecycleOwner, השם של הפרמטר parentLifecycleOwner השתנה ל-parent. (I080bc)

תיקוני באגים

  • עכשיו, כשמסירים את הרכיב הניתן לקישור LifecycleOwner, מחזור החיים שלו עובר בצורה תקינה למצב DESTROYED. כך אפשר למנוע דליפות פוטנציאליות של קוד חיצוני שמכיל הפניה למחזור החיים. (I9e5b7, b/433659048)
  • ‫minSdk שמוגדר כברירת מחדל הועבר מ-API 21 ל-API 23‏ (Ibdfca,‏ b/380448311,‏ b/435705964,‏ b/435705223)

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

  • הסרת שדות גיבוי פנימיים מיותרים מ-LifecycleOwner. תודה לג'ייק וורטון על התרומה. (Ideddb)

גרסה ‎2.10.0-alpha01

‫30 ביולי 2025

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

תכונות חדשות

  • מוסיפים רכיב קומפוזבילי של LifecycleOwner כדי לאפשר יצירה של מחזורי חיים ברמת ההיקף ישירות בממשק המשתמש. האפשרות הזו שימושית לרכיבים שצריכים לנהל את מחזורי החיים שלהם באופן עצמאי. דוגמה לאופן שבו Navigation3 משלב את הפונקציה הקומפוזבילית החדשה הזו זמינה ב-aosp/3708610. (76cbf7)

    @Composable
    fun MyComposable() {
        LifecycleOwner(
            maxLifecycle = RESUMED,
            parentLifecycleOwner = LocalLifecycleOwner.current,
        ) {
            val childLifecycleOwner = LocalLifecycleOwner.current
        }
    }
    

שינויים ב-API

  • הוספת פונקציית מפעל של בונה ל-CreationExtras, שמספקת API נוח ואידיומטי יותר של Kotlin. (Iab2bd)
  • הוספת תמיכה מובנית בסוגים שניתנים לביטול ב-SavedStateHandle.saved, כדי לפשט את השמירה והשחזור של מאפיינים שניתנים לביטול. (I54d69,‏ b/421325690)
  • סימון SavedStateHandle יצרנים בתור @VisibleForTesting. (Iff0e0,‏ b/408002794)

גרסה 2.9

גרסה 2.9.4

‫17 בספטמבר 2025

‫androidx.lifecycle:lifecycle-*:2.9.4 מופץ. גרסה 2.9.4 מכילה את ה-commits האלה.

תיקוני באגים

  • תוקנה שגיאה שבה הפלאגין של Compose Compiler לא הוחל, וכתוצאה מכך פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) של Lifecycle KMP לא פעלו. (Ie95bc,‏ b/443096483,‏ b/443965665)

גרסה 2.9.3

‫27 באוגוסט 2025

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

תכונות חדשות

  • הוספת יעדים חדשים של Kotlin Multiplatform ‏(KMP) לרכיבי Lifecycle *-compose. עכשיו Lifecycle תומך בפלטפורמות הבאות: JVM (Android ו-Desktop), Native (Linux, iOS, watchOS, macOS, MinGW) ו-Web (JavaScript, WasmJS). (I0a0e4)

תיקוני באגים

גרסה 2.9.2

‫16 ביולי 2025

‫androidx.lifecycle:lifecycle-*:2.9.2 מופץ. גרסה 2.9.2 מכילה את ה-commits האלה.

תיקוני באגים

  • נוספו יעדים חדשים של Kotlin Multiplatform‏ (KMP) לרכיבי Lifecycle. עכשיו Lifecycle תומך בפלטפורמות הבאות: JVM (Android ו-Desktop), Native (Linux, iOS, watchOS, macOS, MinGW) ו-Web (JavaScript, WasmJS). חשוב לציין שלא נוספו יעדי KMP חדשים לקובצי ה-Artifact של *-compose, כי זה תלוי בגרסה היציבה של Compose 1.9. (I01cb8).

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

גרסה 2.9.1

‫4 ביוני 2025

‫androidx.lifecycle:lifecycle-*:2.9.1 מופץ. גרסה 2.9.1 מכילה את ה-commits האלה.

תיקוני באגים

  • תיקון: SavedStateHandle.remove(key) לא מנקה את המצבים של SavedStateHandle.getMutableStateFlow(key). (d5f939, b/418746333)

גרסה 2.9.0

‫7 במאי 2025

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

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

  • יש ארטיפקט KMP חדש של androidx.lifecycle:lifecycle-viewmodel-testing שמספק מחלקה של ViewModelScenario לבדיקת ViewModels בנפרד, עם תמיכה ב-onCleared וב-SavedStateHandle, וגם לבדיקת השבתת תהליך ויצירה מחדש באמצעות recreate().
  • מוסיפים את getMutableStateFlow אל SavedStateHandle כדי להחזיר MutableStateFlow. הפונקציה החדשה הזו היא בלעדית למפתח ולא ניתן להשתמש בה עם getLiveData. אם תנסו להשתמש בשניהם כדי לגשת לאותו מצב, תופיע הודעת חריגה.
  • ‫CreationExtras כולל עכשיו עומסי יתר של אופרטורים דמויי מפה כדי לאפשר מניפולציה אידיומטית של תוכן ב-Kotlin. הוא מאפשר להשתמש ב-in, ב-+= וב-+ עם CreationExtras.

תמיכה ב-KotlinX Serialization

  • הוספנו תמיכה ב-KotlinX Serialization ב-SavedState 1.3.0, והשקנו את saved, נציג של מאפיין lazy, כדי שיהיה קל לאחסן מחלקות @Serializable ב-SavedStateHandle ולשחזר את המחלקות האלה באופן אוטומטי במקרה של השבתת תהליך ויצירה מחדש. חשוב לשים לב שהנציג saved הוא עצלן ולא יקרא ל-lambda init או ישמור משהו ב-SavedStateHandle עד שתיגשו אליו.

    @Serializable
    data class Person(val firstName: String, val lastName: String)
    
    class MyViewModel(handle: SavedStateHandle) : ViewModel() {
        var person by handle.saved { Person("John", "Doe") }
    
        fun onPersonChanged(person: Person) {
            this.person = person
        }
    }
    

Kotlin Multiplatform

  • המודול lifecycle-testing תואם עכשיו ל-KMP, כולל ממשקי API כמו TestLifecycleOwner.
  • המודול lifecycle-viewmodel-savedstate תואם עכשיו ל-KMP, כולל ממשקי API כמו SavedStateHandle.
  • ה-androidx.compose.ui.platform.LocalLifecycleOwner זמין עכשיו בקבוצת המקורות הנפוצה.
  • ‫NewInstanceFactory זמין עכשיו ביעדי JVM למחשב ול-Android.

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

  • המצב Lifecycle.DESTROYED הוא סופי, וכל ניסיון להעביר Lifecycle ממנו למצב אחר יגרום עכשיו ל-IllegalStateException.
  • השדה SavedStateHandle לא כולל יותר ערכים של SavedStateProvider.saveState() שבהם הערך המוחזר של Bundle ריק.

גרסה ‎2.9.0-rc01

‫23 באפריל 2025

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

אזהרה לגבי תאימות של Lint API

  • חברת JetBrains שינתה את KaCallableMemberCall ממחלקה לממשק, וזה פוגע בתאימות הבינארית. זה יכול לגרום לקריסות אם גרסת ה-AGP של הפרויקט שונה מהגרסה ששימשה להרצת בדיקות ה-lint. העדכון הזה בוצע ב-aosp/3577172 אבל לא הופיע בהערות המוצר – אנחנו מבהירים אותו כאן. התיקון המומלץ: מעדכנים לגרסה היציבה האחרונה של AGP. אם אתם לא יכולים לעדכן באופן מלא, השתמשו ב-android.experimental.lint.version כדי להתאים את בדיקות ה-lint לגרסת ה-AGP שלכם – פרטים נוספים זמינים בקטע שינויים בהתנהגות של Compose Runtime.

גרסה ‎2.9.0-beta01

‫9 באפריל 2025

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

שינויים ב-API

  • ‫Lifecycle ViewModel Compose משתמש עכשיו באותה הגדרה של Kotlin Multiplatform כמו Compose Runtime 1.7.1 ואילך – פריטי המידע שנוצרו בתהליך הפיתוח (artifacts) של -desktop הוסרו, ונוספו פריטי המידע שנוצרו בתהליך הפיתוח (artifacts) של -jvmStubs ו--linuxx64Stubs. אף אחד מהיעדים האלה לא מיועד לשימוש, הם פלייסהולדרים שנועדו לעזור למאמצים של Jetbrains Compose. (I5cb14, b/406592090)

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

  • הספרייה הזו מטרגטת עכשיו את רמת השפה של Kotlin 2.0 ודורשת KGP 2.0.0 ואילך. (Idb6b5)
  • ‫Lifecycle ViewModel Compose תלוי עכשיו ב-Compose 1.7.8. (I5cb14, b/406592090)

גרסה ‎2.9.0-alpha13

‫26 במרץ 2025

גרסה androidx.lifecycle:lifecycle-*:2.9.0-alpha13 הושקה בלי שינויים ציבוריים משמעותיים. גרסה ‎2.9.0-alpha13 מכילה את השמירות האלה.

גרסה ‎2.9.0-alpha12

‫12 במרץ 2025

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

שינויים ב-API

  • מוסיפים את ההערה @MainThread ל-ViewModelProvider.get בכל הפלטפורמות הנתמכות של KMP. (I7e8dd, b/397736115)
  • משנים את השם של SavedState*Delegates לשם SavedState*Delegate. (I8589b, b/399629301)

גרסה ‎2.9.0-alpha11

‫26 בפברואר 2025

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

שינויים ב-API

  • הוספת הפרמטר SavedStateConfig ל-saved() נציגים (I39b3a)

גרסה ‎2.9.0-alpha10

‫12 בפברואר 2025

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

שינויים ב-API

  • העברת MutableStateSerializer אל savedstate-compose מ-lifecycle-viewmodel-compose. (I4f690, b/378895074)

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

  • נוספה בעיית Lint חדשה כשקוראים ל-Lifecycle::currentState בקומפוזיציה, ובמקום זאת מוצע להשתמש ב-currentStateAsalue().value כדי לוודא ששינויים במצב מחזור החיים גורמים לקומפוזיציה מחדש בצורה נכונה. תודה, סטיבן שון! (Iad484)

גרסה ‎2.9.0-alpha09

‫29 בינואר 2025

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

תכונות חדשות

  • צריך להוסיף את MutableStateSerializer כדי להפוך את androidx.compose.runtime.MutableState לסדרה. (Idfc48, b/378895074)

שינויים ב-API

  • החלפת פונקציות נציג (delegate) של SavedStateHandle.saved() שמועמסות יתר על המידה בפרמטרים שמוגדרים כברירת מחדל (Icd1c1)
  • האפשרות AbstractSavedStateViewModelFactory הוצאה משימוש כי היא יוצרת SavedStateHandle לכל ViewModel, וזה גורם לתקורה מיותרת. כדי ליצור ViewModel בצורה יעילה יותר, צריך להשתמש ב-ViewModelProvider.Factory עם CreationExtras.createSavedStateHandle. (Ia920b, b/388590327)

גרסה ‎2.9.0-alpha08

‫11 בדצמבר 2024

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

תכונות חדשות

  • מוסיפים את ViewModelScenario.recreate כדי לדמות השבתת תהליך של המערכת שיוצרת מחדש את ViewModel בבדיקה ואת כל הרכיבים המשויכים. (Id6a69, b/381063087)
  • עכשיו אפשר לפתור מופעים של LifecycleOwner ו-ViewModelStoreOwner שאוחזרו דרך ממשקי ה-API המתאימים של findViewTree באמצעות הורים נפרדים של תצוגה, כמו ViewOverlay. מידע נוסף על תצוגות הורה לא רציפות זמין בהערות הגרסה של הליבה או במסמכי התיעוד בכתובת ViewTree.setViewTreeDisjointParent. (I800f4)

שינויים ב-API

  • השמות והארגון של החבילות עקביים יותר עם SavedStateRegistryOwnerDelegate (I8c135,‏ b/376026744)

תיקוני באגים

  • הספרייה הזו משתמשת עכשיו באנוטציות של JSpecify nullness, שהן מסוג type-use. מפתחים ב-Kotlin צריכים להשתמש בארגומנט המהדר הבא כדי לאכוף שימוש נכון: -Xjspecify-annotations=strict (זוהי ברירת המחדל החל מגרסה 2.1.0 של מהדר Kotlin). (Ie4340, b/326456246)
  • רצף הניקוי של מסמך ViewModel.onCleared. ‫(I586c7,‏ b/363984116)

גרסה ‎2.9.0-alpha07

‫13 בנובמבר 2024

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

תאימות ל-Kotlin Multiplatform

  • עכשיו Lifecycle ViewModel SavedState תואם ל-KMP. כך אפשר להשתמש ב-SavedStateHandle בקוד נפוץ. (Ib6394, b/334076622)

תמיכה ב-KotlinX Serialization

  • הוספנו תמיכה ב-KotlinX Serialization ב-SavedState 1.3.0-alpha05, והשקנו את saved, נציג של מאפיין lazy, כדי שיהיה קל לאחסן מחלקות @Serializable ב-SavedStateHandle ולשחזר את המחלקות האלה באופן אוטומטי במקרה של השבתת תהליך ויצירה מחדש. חשוב לשים לב שהנציג saved הוא עצלן ולא יקרא ל-lambda init או ישמור משהו ב-SavedStateHandle עד שתיגשו אליו. (I47a88,‏ b/376026744)

    @Serializable
    data class Person(val firstName: String, val lastName: String)
    
    class MyViewModel(handle: SavedStateHandle) : ViewModel() {
        var person by handle.saved { Person("John", "Doe") }
    
        fun onPersonChanged(person: Person) {
            this.person = person
        }
    }
    

שינויים ב-API

  • מוסיפים את getMutableStateFlow אל SavedStateHandle כדי להחזיר MutableStateFlow. הפונקציה החדשה הזו היא בלעדית למפתח ולא ניתן להשתמש בה עם getLiveData. אם תנסו להשתמש בשניהם כדי לגשת לאותו מצב, תופיע הודעת חריגה. (I04a4f,‏ b/375408415)

גרסה ‎2.9.0-alpha06

‫30 באוקטובר 2024

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

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

  • המצב Lifecycle.DESTROYED הוא סופי, וכל ניסיון להעביר Lifecycle ממנו למצב אחר יגרום עכשיו ל-IllegalStateException. (I116c4, b/370577987)
  • השדה SavedStateHandle לא כולל יותר ערכים של SavedStateProvider.saveState() שבהם הערך המוחזר של Bundle ריק. (I910b5, b/370577987)

תיקוני באגים

  • ‫Lifecycle.eventFlow מסתיים עכשיו בצורה תקינה כש-Lifecycle הוא DESTROYED (I293b2,‏ b/374043130)

גרסה ‎2.9.0-alpha05

‫16 באוקטובר 2024

גרסה androidx.lifecycle:lifecycle-*:2.9.0-alpha05 הושקה ללא שינויים משמעותיים. גרסה ‎2.9.0-alpha05 מכילה את ה-commits האלה.

גרסה ‎2.9.0-alpha04

‫2 באוקטובר 2024

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

Kotlin Multiplatform

  • המודול lifecycle-viewmodel-savedstate מוגדר עכשיו כתואם ל-KMP, כהכנה לממשקי API כמו SavedStateHandle שיהיו זמינים בקבוצת המקורות הנפוצה בגרסה עתידית. (I503ed,‏ I48764,‏ b/334076622)

גרסה ‎2.9.0-alpha03

‫18 בספטמבר 2024

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

תיקוני באגים

  • מ-Lifecycle 2.8.6: שגיאת ה-Lint של NullSafeMutableLiveData כוללת תמיכה משופרת בהמרות חכמות, כדי למנוע תוצאות חיוביות מוטעות. (85fed6, b/181042665)

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

גרסה ‎2.9.0-alpha02

‫4 בספטמבר 2024

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

תיקוני באגים

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

  • מעבירים את androidx.compose.ui.platform.LocalLifecycleOwner לקבוצת מקורות משותפת (KMP). תודה לאיוון מטקוב מ-JetBrains על התרומה. (8cd5d03)
  • מ-Lifecycle 2.8.5: נציג ההרחבה SavedStateHandle.saveable` תומך עכשיו בערכים שניתנים לאיפוס. תודה ל-Roman Kalukiewicz על התרומה. (0d78ea6)

גרסה ‎2.9.0-alpha01

‫7 באוגוסט 2024

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

Kotlin Multiplatform

  • ‫lifecycle-testing תואם עכשיו ל-KMP. (Iea41e)
  • הוספת תמיכה ביעד linuxArm64 של Kotlin Multiplatform‏ (I139d3,‏ b/338268719)

תכונות חדשות

  • יש פריט מידע חדש שנוצר בתהליך הפיתוח (artifact) של androidx.lifecycle:lifecycle-viewmodel-testing KMP שמספק מחלקה של ViewModelScenario לבדיקת ViewModels בנפרד, עם תמיכה ב-onCleared (כל הפלטפורמות) וב-SavedStateHandle (Android בלבד). (337f68d,‏ c9b3409,‏ 9799a95c,‏ b/264602919)
  • יצירת ViewModel עם ViewModelProvider היא עכשיו thread-safe, וההערות של @MainThread הוסרו. (Ifd978,‏ b/237006831)

שינויים ב-API

  • מוסיפים את פונקציית המפעל CreationExtras.Key() כדי לפשט את היצירה של אובייקטים אנונימיים מסוג CreationExtras.Key. (I970ee)
  • ‫CreationExtras כולל עכשיו עומסי יתר של אופרטורים דמויי מפה כדי לאפשר מניפולציה אידיומטית של תוכן ב-Kotlin. הוא מאפשר להשתמש ב-in, ב-+= וב-+ עם CreationExtras. (Ib4353)
  • ה-API של CreationExtras מטמיע עכשיו את ה-methods‏ equals,‏ hashCode ו-toString. (Ib4353)
  • ‫NewInstanceFactory זמין עכשיו ביעדי JVM למחשב ול-Android. (d3d0892)
  • מאפיין של תוסף מוטבע שחושף את האפליקציה הבסיסית באופן בטוח בגרסה 2.0 של שפת Kotlin‏ (I39df2)

תיקוני באגים

  • הוסר המתווה הידני של הגישה לממשקי API חדשים של הפלטפורמה, כי זה קורה באופן אוטומטי באמצעות בניית מודלים של API כשמשתמשים ב-R8 עם AGP 7.3 ואילך (למשל, גרסה 3.3 של R8) ובכל ה-builds כשמשתמשים ב-AGP 8.1 ואילך (למשל, גרסה 8.1 של D8). ללקוחות שלא משתמשים ב-AGP, מומלץ לעדכן לגרסה 8.1 ומעלה של D8. למידע נוסף, מומלץ לעיין במאמר הזה. (If6b4c,‏ b/345472586)

גרסה 2.8

גרסה 2.8.7

‫30 באוקטובר 2024

‫androidx.lifecycle:lifecycle-*:2.8.7 מופץ. גרסה 2.8.7 מכילה את ה-commits האלה.

שינויים ב-API

  • ‫androidx.compose.ui.platform.LocalLifecycleOwner זמין עכשיו בקבוצת המקורות הנפוצה (KMP). (6a3f5b3)
  • ‫lifecycle-runtime-compose: הוסרו desktop פריטי מידע ונוספו -jvmStubs ו--linuxx64Stubs פריטי מידע. אף אחד מהיעדים האלה לא מיועד לשימוש, הם פלייסהולדרים שנועדו לעזור למאמצים של Jetbrains Compose. (6a3f5b3)

גרסה 2.8.6

‫18 בספטמבר 2024

‫androidx.lifecycle:lifecycle-*:2.8.6 מופץ. גרסה 2.8.6 מכילה את ה-commits האלה.

תיקוני באגים

  • שגיאת ה-Lint של NullSafeMutableLiveData כוללת תמיכה משופרת בהמרות חכמות, כדי למנוע תוצאות חיוביות מוטעות. (85fed6, b/181042665)

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

גרסה 2.8.5

‫4 בספטמבר 2024

‫androidx.lifecycle:lifecycle-*:2.8.5 מופץ. גרסה 2.8.5 מכילה את ה-commits האלה.

תיקוני באגים

  • מעדכנים את כללי ProGuard של androidx.lifecycle.ReportFragment כדי לאפשר ערפול קוד . (ff898e1)

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

  • הנציג של התוסף SavedStateHandle.saveable תומך עכשיו בערכים שיכולים להיות ריקים. תודה ל-Roman Kalukiewicz על התרומה. (0d78ea6)

גרסה 2.8.4

‫24 ביולי 2024

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

תיקוני באגים

  • ‫LiveData.asFlow() מטפל עכשיו בצורה נכונה במקרים שבהם ה-Flow שמוחזר מסתיים מיד אחרי קבלת ערך שכבר מוגדר ב-LiveData (לדוגמה, כשמשתמשים ב-take(1)). (I9c566)
  • ההשלמה של Lifecycle*Effect היא עכשיו אידמפוטנטית (כלומר, אם onStopOrDispose נקרא כי מחזור החיים הופסק, הוא לא ייקרא פעם שנייה לאחר ההשלכה, אלא אם מחזור החיים יחזור שוב ל-STARTED). (I5f607,‏ b/352364595)

גרסה 2.8.3

‫1 ביולי 2024

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

תיקוני באגים

  • תוקנה בעיה בתאימות לדורות קודמים של Lifecycle 2.8 עם Compose 1.6.0 וגרסאות קודמות, כשמשתמשים בכיווץ קוד. (aosp/3133056, b/346808608)

גרסה 2.8.2

‫12 ביוני 2024

‫androidx.lifecycle:lifecycle-*:2.8.2 מופץ. גרסה 2.8.2 מכילה את ה-commits האלה.

תיקוני באגים

  • תוקנו שגיאות CompositionLocal LocalLifecycleOwner not present כשמשתמשים ב-Lifecycle 2.8.X עם Compose 1.6.X או גרסה קודמת – עכשיו אפשר להשתמש ב-Lifecycle 2.8.2 עם כל גרסה של Compose בלי צורך בפתרונות עקיפים. ‫(aosp/3105647,‏ b/336842920)
  • ‫ViewModelProvider לא יקרוס יותר כשמשלבים גרסאות קודמות של יחסי תלות של compileOnly Lifecycle עם גרסאות 2.8 ואילך, ומתקן בעיות בספריות כמו LeakCanary. (I80383, b/341792251)

גרסה 2.8.1

‫29 במאי 2024

‫androidx.lifecycle:lifecycle-*:2.8.1 מופץ. גרסה 2.8.1 מכילה את ה-commits האלה.

תיקוני באגים

  • ל-lifecycle-viewmodel-compose יש עכשיו רק תלות משותפת ב-compose-runtime, והתלות המשותפת שלו ב-compose-ui הוסרה. הארטיפקט של Android שומר על ה-compose-ui שלו לצורך תאימות. (aosp/3079334, b/339562627)
  • השילוב של saveable ב-ViewModel באמצעות נציגי נכסים משתמש עכשיו בשם המחלקה כחלק מהמפתח שנוצר אוטומטית, כדי למנוע התנגשויות אם כמה מחלקות משתמשות באותו SavedStateHandle. (aosp/3063463)

גרסה 2.8.0

‫14 במאי 2024

‫androidx.lifecycle:lifecycle-*:2.8.0 מופץ. גרסה 2.8.0 מכילה את ה-commits האלה.

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

  • ‫LocalLifecycleOwner הועבר מ-Compose UI אל lifecycle-runtime-compose כדי שיהיה אפשר להשתמש בממשקי ה-API המסייעים שלו שמבוססים על Compose מחוץ ל-Compose UI.
  • הארטיפקט lifecycle-runtime-compose מכיל עכשיו את ממשקי ה-API‏ dropUnlessResumed ו-dropUnlessStarted, שמאפשרים להשמיט קליקים או אירועים אחרים שמתרחשים גם אחרי שהערך של LifecycleOwner יורד מתחת לערך הנתון של Lifecycle.State. לדוגמה, אפשר להשתמש בזה עם Navigation Compose כדי להימנע מטיפול באירועים מסוג קליק אחרי שכבר התחיל מעבר למסך אחר: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }
  • עכשיו ViewModel.viewModelScope הוא פרמטר של constructor שאפשר לשנות, וכך להוסיף dispatcher משלכם ו-SupervisorJob() או לשנות את ברירת המחדל באמצעות backgroundScope שזמין ב-runTest. (I2817c,‏ b/264598574)

    class MyViewModel(
      // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate
      viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob()
    ) : ViewModel(viewModelScope) {
      // Use viewModelScope as before, without any code changes
    }
    
    // Allows overriding the viewModelScope in a test
    fun Test() = runTest {
      val viewModel = MyViewModel(backgroundScope)
    }
    
  • ‫ViewModel נכתב מחדש ב-Kotlin ועכשיו הוא משתמש ב-AutoClosable במקום ב-Closeable. עכשיו אפשר להוסיף אובייקטים מסוג AutoCloseable עם key שמאפשר לאחזר אותם באמצעות getCloseable().

  • קריאה ל-LifecycleStartEffect ול-LifecycleResumeEffect בלי מפתח נחשבת עכשיו לשגיאה, בהתאם לאותה מוסכמה של ה-API של DisposableEffect שממשקי ה-API האלה משקפים.

  • הוצא משימוש LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) לטובת LiveData.toPublisher(lifecycleOwner).

  • תוספי Kotlin של lifecycle-livedata-core-ktx הועברו למודול lifecycle-livedata-core.

  • ה-NullSafeMutableLiveData עבר שכתוב כדי למנוע הרבה תוצאות חיוביות כוזבות.

תאימות של מחזור החיים ל-Kotlin Multiplatform

ממשקי ה-API העיקריים של מחזור החיים ב-Lifecycle,‏ LifecycleOwner,‏ LifecycleObserver,‏ Lifecycle.State,‏ Lifecycle.Event ו-LifecycleRegistry נשלחים עכשיו ברכיבי build שתואמים ל-Kotlin Multiplatform.

פריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שהושפעו:

  • lifecycle-common מעביר את רוב ממשקי ה-API אל common ותומך ב-jvm וב-iOS בנוסף ל-Android.
  • lifecycle-runtime מעביר את רוב ממשקי ה-API אל common ותומך ב-jvm וב-iOS בנוסף ל-Android.
  • lifecycle-runtime-ktx ריק עכשיו, וכל ממשקי ה-API הועברו אל lifecycle-runtime.
  • בגרסה lifecycle-runtime-compose כל ממשקי ה-API מועברים אל common ונשלח פריט מידע שנוצר ב-Android, שתואם לתמיכה בריבוי פלטפורמות של androidx.compose.

תאימות של ViewModel ל-Kotlin Multiplatform

רכיב ה-Artifact של lifecycle-viewmodel וממשקי API כמו ViewModel,‏ ViewModelStore,‏ ViewModelStoreOwner ו-ViewModelProvider נשלחים עכשיו ברכיבי Artifact שתואמים ל-Kotlin Multiplatform.

כדי להתאים לשינוי הזה, ל-methods כמו אלה ב-ViewModelProvider שקיבלו java.lang.Class<T> יש עכשיו method מקבילה שמקבלת kotlin.reflect.KClass<T>.

התאימות הבינארית ב-Android נשמרה, אבל יש כמה שינויים בולטים כשמשווים בין ממשק ה-API של Android לממשק ה-API הנפוץ:

  • כדי ליצור מופע של ViewModelProvider, צריך להשתמש ב-methods של ViewModelProvider.create() במקום להפעיל ישירות את ה-constructor שלו.
  • התכונות ViewModelProvider.NewInstanceFactory ו-ViewModelProvider.AndroidViewModelFactory זמינות רק ב-Android.
    • מומלץ להרחיב את Custom Factories מ-ViewModelProvider.Factory ולהשתמש ב-method‏ create שמקבל CreationExtras או להשתמש ב-viewModelFactory Kotlin DSL.
  • שימוש ב-ViewModelProvider בלי פונקציית פקטורי מותאמת אישית בפלטפורמות שאינן JVM יגרום ל-UnsupportedOperationException. בפלטפורמות JVM, התאימות נשמרת באמצעות ה-constructor של ViewModel ללא ארגומנטים, אם לא סופק מפעל מותאם אישית.
  • ‫viewModelScope יחזור ל-EmptyCoroutineContext בפלטפורמות שבהן Dispatchers.Main לא זמין (למשל, Linux).

פריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שהושפעו:

  • lifecycle-viewmodel מעביר את רוב ממשקי ה-API אל common ותומך ב-jvm וב-iOS בנוסף ל-Android.
  • lifecycle-viewmodel-ktx ריק עכשיו, וכל ממשקי ה-API הועברו אל lifecycle-viewmodel.
  • בגרסה lifecycle-viewmodel-compose כל ממשקי ה-API מועברים אל common ונשלח פריט מידע שנוצר ב-Android, שתואם לתמיכה בריבוי פלטפורמות של androidx.compose.

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

  • InitializerViewModelFactory (כולל פונקציית ה-builder של viewModelFactory) תזרוק עכשיו IllegalArgumentException אם כבר נוסף initializer עם אותו clazz: KClass<VM : ViewModel>. (Ic3a36)

בעיות מוכרות

‫גרסה ‎2.8.0-rc01

‫1 במאי 2024

‫androidx.lifecycle:lifecycle-*:2.8.0-rc01 מופץ. גרסה ‎2.8.0-rc01 מכילה את ה-commits האלה.

תיקוני באגים

  • תוקנה בעיה שבה פרופיל Baseline למחלקות lifecycle-common לא נארז כראוי. הם נכללים עכשיו ב-AAR של lifecycle-runtime. ‫(aosp/3038274,‏ b/322382422)
  • תוקן שינוי לא מכוון בסדר שבו מופעי AutoCloseable שמצורפים ל-ViewModel נמחקים – הסדר הקודם של addCloseable(String, AutoCloseable), ואז addClosable(AutoCloseable), ואז onCleared() שוחזר. (aosp/3041632)
  • שיפור התנהגות ברירת המחדל של היצירה של viewModelScope בסביבות מקוריות ובסביבות JVM למחשב. (aosp/3039221)

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

  • תודה ל-Victor Kropp על שיפור הבדיקה של ה-thread הראשי ב-JVM Desktop. (aosp/3037116)

גרסה ‎2.8.0-beta01

‫17 באפריל 2024

‫androidx.lifecycle:lifecycle-*:2.8.0-beta01 מופץ. גרסה ‎2.8.0-beta01 מכילה את ה-commits האלה.

תכונות חדשות

  • רכיב ה-Artifact של lifecycle-runtime-compose תואם עכשיו ל-Kotlin Multiplatform, הקוד שלו הועבר אל common והוא כולל רכיב Artifact ל-Android, שתואם לתמיכה של androidx.compose בפלטפורמות מרובות. (If7a71,‏ I4f4a0,‏ b/331769623)

גרסה ‎2.8.0-alpha04

‫3 באפריל 2024

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

תכונות חדשות

  • רכיב ה-Artifact של lifecycle-viewmodel-compose תואם עכשיו ל-Kotlin Multiplatform, הקוד שלו הועבר אל common והוא כולל רכיב Artifact של Android, שתואם לתמיכה של androidx.compose בפלטפורמות מרובות. כדי להתאים לשינוי הזה, ה-method‏ viewModel של Composable מקבל עכשיו KClass בנוסף ל-java.lang.Class. (b/330323282)

תיקוני באגים

  • ה-NullSafeMutableLiveData עבר שכתוב כדי למנוע הרבה תוצאות חיוביות כוזבות. (I2d8c1, Iafb18, I03463, I7ecef)

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

גרסה ‎2.8.0-alpha03

‫20 במרץ 2024

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

תכונות חדשות

  • עכשיו ViewModel.viewModelScope הוא פרמטר של constructor שאפשר לשנות, וכך להוסיף dispatcher משלכם ו-SupervisorJob() או לשנות את ברירת המחדל באמצעות backgroundScope שזמין ב-runTest. (I2817c,‏ b/264598574)

    class MyViewModel(
      // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate
      viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob()
    ) : ViewModel(viewModelScope) {
      // Use viewModelScope as before, without any code changes
    }
    
    // Allows overriding the viewModelScope in a test
    fun Test() = runTest {
      val viewModel = MyViewModel(backgroundScope)
    }
    

תאימות ל-Kotlin Multiplatform

רכיב ה-Artifact של lifecycle-viewmodel וממשקי API כמו ViewModel,‏ ViewModelStore,‏ ViewModelStoreOwner ו-ViewModelProvider נשלחים עכשיו ברכיבי Artifact שתואמים ל-Kotlin Multiplatform. (b/214568825)

כדי להתאים לשינוי הזה, ל-methods כמו אלה ב-ViewModelProvider שקיבלו java.lang.Class<T> יש עכשיו method מקבילה שמקבלת kotlin.reflect.KClass<T>.

התאימות הבינארית ב-Android נשמרה, אבל יש כמה שינויים בולטים כשמשווים בין ממשק ה-API של Android לממשק ה-API הנפוץ:

  • כדי ליצור מופע של ViewModelProvider, צריך להשתמש ב-methods של ViewModelProvider.create() במקום להפעיל ישירות את ה-constructor שלו.
  • התכונות ViewModelProvider.NewInstanceFactory ו-ViewModelProvider.AndroidViewModelFactory זמינות רק ב-Android.
    • מומלץ להרחיב את Custom Factories מ-ViewModelProvider.Factory ולהשתמש ב-method‏ create שמקבל CreationExtras או להשתמש ב-viewModelFactory Kotlin DSL.
  • שימוש ב-ViewModelProvider בלי פונקציית פקטורי מותאמת אישית בפלטפורמות שאינן JVM יגרום ל-UnsupportedOperationException. בפלטפורמות JVM, התאימות נשמרת באמצעות ה-constructor של ViewModel ללא ארגומנטים, אם לא סופק מפעל מותאם אישית.
  • ‫viewModelScope יחזור ל-EmptyCoroutineContext בפלטפורמות שבהן Dispatchers.Main לא זמין (למשל, Linux).

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

  • InitializerViewModelFactory (כולל פונקציית ה-builder של viewModelFactory) תזרוק עכשיו IllegalArgumentException אם כבר נוסף initializer עם אותו clazz: KClass<VM : ViewModel>. (Ic3a36)

תיקוני באגים

  • ‫ViewModel.getCloseable מטפל עכשיו במפתחות כפולים: אם ל-key כבר יש משאב AutoCloseable שמשויך אליו, המשאב הישן יוחלף וייסגר מיד. (Ibeb67)
  • הגישה ל-viewModelScope של ViewModel היא עכשיו thread-safe. (If4766, b/322407038)

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

  • ‫LocalLifecycleOwner הועבר מ-Compose UI אל lifecycle-runtime-compose כדי שיהיה אפשר להשתמש בממשקי ה-API המסייעים שמבוססים על Compose מחוץ ל-Compose UI. תודה לג'ייק וורטון על התרומה. (I6c41b,‏ b/328263448)

גרסה ‎2.8.0-alpha02

‫21 בפברואר 2024

‫androidx.lifecycle:lifecycle-*:2.8.0-alpha02 מופץ. גרסה 2.8.0-alpha02 מכילה את השינויים האלה.

תכונות חדשות

  • נוספו ממשקי ה-API‏ dropUnlessResumed ו-dropUnlessStarted, שמאפשרים להשמיט קליקים או אירועים אחרים שמתרחשים גם אחרי שהערך של LifecycleOwner יורד מתחת לערך הנתון של Lifecycle.State. לדוגמה, אפשר להשתמש בזה עם Navigation Compose כדי להימנע מטיפול באירועים מסוג קליק אחרי שכבר התחיל מעבר למסך אחר: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) } (Icba83, b/317230685)

המרות ב-Kotlin

  • ‫ViewModel כתוב עכשיו ב-Kotlin‏ (I16f26,‏ b/214568825)
  • תוספי Kotlin של lifecycle-viewmodel-ktx הועברו עכשיו למודול מחזור החיים הבסיסי. (Id787b, b/274800183)
  • תוספי Kotlin של lifecycle-runtime-ktx הועברו עכשיו למודול מחזור החיים הבסיסי. (Ic3686, b/274800183)
  • תוספי Kotlin של lifecycle-livedata-core-ktx הועברו עכשיו למודול מחזור החיים הבסיסי. (I54a3d, b/274800183)

תאימות ל-Kotlin Multiplatform

  • ממשקי ה-API העיקריים של מחזור החיים ב-Lifecycle,‏ LifecycleOwner,‏ LifecycleObserver,‏ Lifecycle.State,‏ Lifecycle.Event ו-LifecycleRegistry נשלחים עכשיו ברכיבי build שתואמים ל-Kotlin Multiplatform. (b/317249252)

שינויים ב-API

  • קריאה ל-LifecycleStartEffect ול-LifecycleResumeEffect בלי מפתח נחשבת עכשיו לשגיאה, בהתאם לאותה מוסכמה של ה-API של DisposableEffect שממשקי ה-API האלה משקפים. (Ib0e0c, b/323518079)
  • הבית ViewModel משתמש עכשיו במינוי AutoCloseable במקום במינוי Closeable. זהו שינוי שתואם לדורות קודמים. (I27f8e,‏ b/214568825)
  • הוצא משימוש LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) לטובת LiveData.toPublisher(lifecycleOwner). (Iabe29, b/262623005)

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

  • תודה לאיוון מטקוב מ-Jetbrains על העזרה בהעברת Lifecycle ל-Kotlin Multiplatform. (aosp/2926690,‏ I0c5ac,‏ If445d)

גרסה ‎2.8.0-alpha01

‫24 בינואר 2024

‫androidx.lifecycle:lifecycle-*:2.8.0-alpha01 מופץ. גרסה 2.8.0-alpha01 מכילה את השינויים האלה.

תכונות חדשות

  • עכשיו אפשר להוסיף ל-ViewModel אובייקטים מסוג Closeable עם key שמאפשר לאחזר אותם באמצעות getCloseable(). (I3cf63)

גרסה 2.7

גרסה 2.7.0

‫10 בינואר 2024

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

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

  • TestLifecycleOwner כולל עכשיו פונקציית השהיה setCurrentState() שמוודאת ששינוי המצב וכל הקריאות החוזרות (callbacks) של LifecycleObserver הושלמו לפני החזרה. חשוב לציין שבניגוד להגדרה ישירה של המאפיין currentState, הפעולה הזו לא משתמשת ב-runBlocking, ולכן אפשר להשתמש בה בבטחה בתוך פונקציית קורוטינה, כמו זו שסופקה על ידי runTest.
  • התוספים LiveData של map ו-switchMap משקפים עכשיו את ההתנהגות של distinctUntilChanged – אם ל-LiveData מוגדר value, הפונקציה map/switchMap תיקרא באופן מיידי כדי לאכלס את ה-value של ה-LiveData שהוחזר. כך הערך הראשוני יוגדר כחלק מהקומפוזיציה הראשונה (כשמשתמשים ב-observeAsState()), אבל התנהגות התצפית לא תשתנה – עדכוני ערכים מהמקור LiveData עדיין יחולו רק אחרי שמתחילים לצפות ב-LiveData.
  • בגרסה הזו תוקנה בעיה שבה SavedStateHandle לא שחזר כראוי מחלקות Parcelable מותאמות אישית אחרי השבתת תהליך ויצירה מחדש. בגלל שמידע על סוגים אובד ב-framework של Android, מערכים של Parcelables בהתאמה אישית דורשים עבודה נוספת (יצירה ידנית של מערך עם סוג נתונים מהסוג הנכון), והמסמכים בנושא get,‏ getLiveData ו-getStateFlow מציינים עכשיו באופן ספציפי את המגבלה הזו.
  • כללי השמירה של ProGuard שמשויכים ל-LifecycleObserver הוסרו. כלומר, קוד שעבר ערפול באמצעות ProGuard ורוצה להשתמש בממשקי API באמצעות רפלקציה (למשל, שימוש בהערה @OnLifecycleEvent שהוצאה משימוש לפני זמן רב) יצטרך לספק כללי שמירה משלו לתרחיש השימוש הספציפי שלו.

תצפית על אירועים במחזור החיים

  • במקום להשתמש ב-LifecycleEventObserver, עכשיו אפשר לצפות ב-Flow של Lifecycle.Event באמצעות ה-extension method‏ Lifecycle.asFlow().
  • משתמשי Jetpack Compose יכולים עכשיו להשתמש ב-LifecycleEventEffect כדי להריץ תופעות לוואי של Compose על סמך Lifecycle.Event.
@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
    viewModel.refreshData()
  }
  // …
}
  • משתמשי Jetpack Compose יכולים להשתמש ב-LifecycleStartEffect וב-LifecycleResumeEffect כדי לטפל בצמדים של אירועים – התחלה עד עצירה והמשך עד השהיה, בהתאמה. ה-API הזה משקף את ה-API שנמצא ב-DisposableEffect, והוא מתאים למקרים שבהם צריך לבטל את השינוי שבוצע כשהמצב עולה, כשחוזרים למצב הקודם.
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleStartEffect(viewModel) {
    val timeTracking = viewModel.startTrackingTimeOnScreen()
    onStopOrDispose {
      timeTracking.stopTrackingTimeOnScreen()
    }
  }
  // …
}

מידע נוסף זמין במאמר הרצת קוד באירועים במחזור החיים.

תצפית על מצב מחזור החיים

  • עכשיו אפשר לראות את ה-Lifecycle.State הנוכחי דרך המאפיין Lifecycle.currentStateFlow, שמחזיר StateFlow שבו ה-value הוא ה-Lifecycle.State הנוכחי.
  • משתמשי Jetpack Compose יכולים להשתמש בתוסף Lifecycle.currentStateAsState() כדי לחשוף ישירות את Lifecycle.State בתור State של Compose. האפשרות הזו מקבילה ל-lifecycle.currentStateFlow.collectAsState() (וגם קצרה יותר).

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

גרסה ‎2.7.0-rc02

‫13 בדצמבר 2023

‫androidx.lifecycle:lifecycle-*:2.7.0-rc02 מופץ. גרסה 2.7.0-rc02 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה בעיה שבה SavedStateHandle לא שחזר כראוי מחלקות Parcelable מותאמות אישית אחרי השבתת תהליך ויצירה מחדש. בגלל שמידע על סוגים אובד ב-framework של Android, מערכים של Parcelables בהתאמה אישית דורשים עבודה נוספת (יצירה ידנית של מערך עם סוג נכון) והמסמכים בנושא get,‏ getLiveData ו-getStateFlow מציינים עכשיו באופן ספציפי את המגבלה הזו. (I0b55a)

גרסה ‎2.7.0-rc01

‫15 בנובמבר 2023

‫androidx.lifecycle:lifecycle-*:2.7.0-rc01 מופץ. גרסה 2.7.0-rc01 מכילה את השינויים האלה.

תיקוני באגים

  • LifecycleStartEffect ו-LifecycleResumeEffect עכשיו נפטרים מבלוק האפקט ויוצרים אותו מחדש בצורה נכונה אם LifecycleOwner משתנה. (Ia25c6)

גרסה ‎2.7.0-beta01

1 בנובמבר 2023

הגרסה androidx.lifecycle:lifecycle-*:2.7.0-beta01 פורסמה בלי שינויים. גרסה 2.7.0-beta01 כוללת את השינויים האלה.

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

גרסה ‎2.7.0-alpha03

‫18 באוקטובר 2023

‫androidx.lifecycle:lifecycle-*:2.7.0-alpha03 מופץ. גרסה 2.7.0-alpha03 מכילה את השינויים האלה.

תכונות חדשות

  • ‫lifecycle-runtime-testing מכיל עכשיו בדיקת Lint חדשה כדי למנוע הגדרה של Lifecycle.State של TestLifecycleOwner באמצעות השדה currentState בתוך פונקציית קורוטינה. בדיקת ה-Lint מציעה עכשיו להשהות את setCurrentState, מה שמאפשר להגדיר את Lifecycle.State בלי לחסום. (Icf728, b/297880630)

תיקוני באגים

  • תוקנה בעיה ב-LiveData.switchMap שבה החזרה של אותו מופע LiveData גם בקריאה הראשונית וגם בקריאה הבאה מנעה את הוספת המופע LiveData כמקור. (Ibedcba7)

גרסה ‎2.7.0-alpha02

‫6 בספטמבר 2023

‫androidx.lifecycle:lifecycle-*:2.7.0-alpha02 מופץ. גרסה 2.7.0-alpha02 מכילה את השינויים האלה.

תכונות חדשות

  • ‫TestLifecycleOwner כולל עכשיו את פונקציית ההשעיה setCurrentState() כדי לתת למשתמשים אפשרות להשתמש ב-TestLifecycleOwner מתוך פונקציית coroutine, כמו זו שסופקה על ידי runTest. (I329de, b/259344129)

שינויים ב-API

  • כל הקבצים מהמודולים של lifecycle-livedata-ktx הועברו למודול הראשי של lifecycle-livedata. (I10c6f, b/274800183)

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

  • התוספים LiveData.map() ו-LiveData.switchMap() מגדירים עכשיו את ה-value של ה-LiveData המוחזר אם הוגדר ערך ב-LiveData הקודם, כדי להבטיח שהשימוש ב-LiveData שנוצר ב-Jetpack Compose יהיה במצב הנכון בקומפוזיציה הראשונית. (I91d2b,‏ b/269479952)
  • הפונקציה addCloseable() של ViewModel סוגרת עכשיו באופן מיידי את Closeable אם ViewModel כבר קיבל קריאה ל-onCleared(). (I4712e, b/280294730)

תיקוני באגים

  • מ-Lifecycle 2.6.2: תוקנה בעיה שבה SavedStateHandle לא שוחזר בצורה נכונה אחרי השבתת תהליך אם המצב שוחזר, save() נקרא בלי לשמור בפועל את המצב ב-SavedStateRegistry ההורה, ואז המצב שוחזר שוב. הבעיה הזו תוקנה באינטראקציה בין rememberSaveable לבין NavHost של Navigation Compose. (aosp/2729289)

גרסה ‎2.7.0-alpha01

26 ביולי 2023

‫androidx.lifecycle:lifecycle-*:2.7.0-alpha01 מופץ. גרסה 2.7.0-alpha01 מכילה את השינויים האלה.

שינויים ב-API

  • עכשיו אפשר לצפות ב-Lifecycle.State ב-Compose באמצעות Lifecycle.currentStateFlow, שמחזיר StateFlow שבו value הוא ה-Lifecycle.State הנוכחי. (Ib212d,‏ b/209684871)
  • עכשיו אפשר לצפות ב-Lifecycle.Event כ-Flow עם Lifecycle.asFlow(). (If2c0f,‏ b/176311030)
  • LifecycleResumeEffect נוסף API להרצת SideEffect של Compose על סמך קריאות חוזרות (callbacks) של אירועי Lifecycle.Event.ON_RESUME ו-Lifecycle.Event.ON_PAUSE. (I60386, b/235529345)
  • נוסף ה-API של LifecycleStartEffect כדי להריץ את SideEffect של Compose על סמך קריאות חוזרות (callbacks) של האירועים Lifecycle.Event.ON_START ו-Lifecycle.Event.ON_STOP. (I5a8d1, b/235529345)
  • נוסף API של LifecycleEventEffect כדי להריץ פונקציות קומפוזביליות של SideEffect שמבוססות על Lifecycle.Event. (Ic9794, b/235529345)
  • התוסף Lifecycle.collectAsState() נוסף כדי לחשוף ישירות את Lifecycle.State בתור State של Compose. האפשרות הזו מקבילה ל-lifecycle.currentStateFlow.collectAsState() (וגם קצרה יותר). (I11015, b/235529345)

תיקוני באגים

  • התוסף LiveData.distinctUntilChanged() מגדיר עכשיו את value של LiveData שהוחזר אם הוגדר ערך ב-LiveData הקודם. הפעולה הזו לא משנה את התנהגות התצפית – ערכים מעודכנים מהמקור LiveData עדיין יחולו רק כשתתחילו לצפות ב-LiveData שהוחזר מ-distinctUntilChanged(). (Ib482f)
  • כללי השמירה של ProGuard שמשויכים ל-LifecycleObserver הוסרו. המשמעות היא שקוד שעבר ערפול באמצעות ProGuard ורוצה להשתמש בממשקי API באמצעות רפלקציה, צריך לספק כללי שמירה משלו לתרחיש השימוש הספציפי שלו. (Ia12fd)

גרסה 2.6

גרסה 2.6.2

‫6 בספטמבר 2023

‫androidx.lifecycle:lifecycle-*:2.6.2 מופץ. גרסה 2.6.2 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה בעיה שבה SavedStateHandle לא שוחזר בצורה נכונה אחרי השבתת תהליך אם המצב שוחזר, save() נקרא בלי לשמור בפועל את המצב ב-SavedStateRegistry ההורה, ואז המצב שוחזר שוב. הבעיה הזו תוקנה באינטראקציה בין rememberSaveable לבין NavHost של Navigation Compose. (aosp/2729289)

גרסה 2.6.1

‫22 במרץ 2023

‫androidx.lifecycle:lifecycle-*:2.6.1 מופץ. גרסה 2.6.1 כוללת את השינויים האלה.

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

גרסה 2.6.0

‫8 במרץ 2023

‫androidx.lifecycle:lifecycle-*:2.6.0 מופץ. גרסה 2.6.0 מכילה את השינויים האלה.

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

  • ‫LiveData כולל עכשיו מאפיין isInitialized חדש שמציין אם אי פעם הוגדר ערך מפורש ב-LiveData, וכך מאפשר להבחין בין liveData.value שמחזיר null כי לא הוגדר ערך אף פעם, לבין ערך null מפורש.
  • ‫MediatorLiveData כולל עכשיו פונקציית בנאי (constructor) להגדרת ערך ראשוני.
  • הוספנו תוסף חדש ב-StateFlow וב-Flow של collectAsStateWithLifecycle() שאוסף נתונים מתהליכים ומייצג את הערך האחרון שלו כמצב Compose באופן שמודע למחזור החיים.
  • השיטות Lifecycle.launchWhenX ו-Lifecycle.whenX הוצאו משימוש כי השימוש ב-dispatcher להשהיה עלול להוביל לבזבוז משאבים במקרים מסוימים. מומלץ להשתמש ב-Lifecycle.repeatOnLifecycle. בהסבר הזה מפורט למה השהיה חד-פעמית של העבודה לא בטוחה מטבעה.
  • המרה ל-Kotlin – מספר גדול של מחלקות Lifecycle הומרו ל-Kotlin. כל המחלקות שהומרו עדיין שומרות על התאימות הבינארית שלהן לגרסאות קודמות. במחלקות הבאות יש שינויים שלא תואמים למקור במחלקות שכתובות ב-Kotlin: ‏ViewTreeLifecycleOwner, ‏LiveDataReactiveStreams, ‏HasDefaultViewModelProviderFactory, ‏ViewTreeViewModelStoreOwner, ‏Transformations, ‏ViewModelStoreOwner, ‏LifecycleOwner

בטבלה הבאה מפורטות ההמרות המקוריות בגרסה החדשה של מחזור החיים.

מחזור חיים 2.5 ‫Lifecycle 2.5‏ (KTX) מחזור חיים 2.6
Transformations.switchMap(liveData) {...} liveData.switchMap {...} liveData.switchMap {...}
Transformations.map(liveData) {...} liveData.map {...} liveData.map {...}
Transformations.distinctUntilChanged(liveData) {...} liveData.distinctUntilChanged{...} liveData.distinctUntilChanged{...}
LiveDataReactiveStreams.fromPublisher(publisher) publisher.toLiveData() publisher.toLiveData()
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) liveData.toPublisher(lifecycleOwner) liveData.toPublisher(lifecycleOwner)
override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory override val defaultViewModelProviderFactory = factory
override fun getDefaultViewModelCreationExtras(): CreationExtras = extras override fun getDefaultViewModelCreationExtras(): CreationExtras = extras override val defaultViewModelProviderCreationExtras = extras
ViewTreeLifecycleOwner.set(view, owner) ViewTreeLifecycleOwner.set(view, owner) view.setViewTreeLifecycleOwner(owner)
ViewTreeLifecycleOwner.get(view) view.findViewTreeLifecycleOwner() view.findViewTreeLifecycleOwner()
override fun getViewModelStore(): ViewModelStore = store override fun getViewModelStore(): ViewModelStore = store override val viewModelStore: ViewModelStore = store
override fun getLifecycle(): Lifecycle = registry override fun getLifecycle(): Lifecycle = registry override val lifecycle: Lifecycle get() = registry
  • המאפיין המציין אם ערך יכול להיות ריק (nullability) של ה-method‏ onChanged של Observer שנוצר ב-Kotlin תואם עכשיו למאפיין המציין אם ערך יכול להיות ריק (nullability) של הסוג הגנרי. אם רוצים ש-Observer.onChanged() יקבל סוג שניתן להגדיר כ-null, צריך ליצור מופע של Observer עם סוג שניתן להגדיר כ-null.
  • גם המחלקות האלה הומרו ל-Kotlin, אבל הן עדיין תואמות למקור: DefaultLifecycleObserver,‏ LifecycleEventObserver,‏ Lifecycle,‏ LifecycleRegistry,‏ LifecycleObserver,‏ ViewModelStore,‏ AndroidViewModel,‏ AbstractSavedStateViewModelFactory,‏ LifecycleService,‏ ServiceLifecycleDispatcher ו-ProcessLifecycleOwner

גרסה ‎2.6.0-rc01

‫22 בפברואר 2023

‫androidx.lifecycle:lifecycle-*:2.6.0-rc01 מופץ. גרסה 2.6.0-rc01 מכילה את השינויים האלה.

תיקוני באגים

  • התוסף LiveData.distinctUntilChanged() מגדיר עכשיו את value של LiveData שהוחזר אם הוגדר ערך ב-LiveData הקודם. הפעולה הזו לא משנה את התנהגות התצפית – ערכים מעודכנים מהמקור LiveData עדיין יחולו רק כשתתחילו לצפות ב-LiveData שהוחזר מ-distinctUntilChanged(). (Ib482f)

גרסה ‎2.6.0-beta01

‫8 בפברואר 2023

‫androidx.lifecycle:lifecycle-*:2.6.0-beta01 מופץ. גרסה 2.6.0-beta01 מכילה את השינויים האלה.

המרות ב-Kotlin

  • ‫LifecycleOwner כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור מחלקות שנכתבו ב-Kotlin – עכשיו הן צריכות לשנות את המאפיין lifecycle במקום להטמיע את הפונקציה הקודמת getLifecycle(). (I75b4b, b/240298691)
  • ViewModelStoreOwner כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור מחלקות שנכתבו ב-Kotlin – עכשיו הן צריכות לשנות את המאפיין viewModelStore במקום להטמיע את הפונקציה הקודמת getViewModelStore(). (I86409,‏ b/240298691)
  • תוסף Kotlin ב-LifecycleOwner שמספק את השדה lifecycleScope הועבר אל פריט המידע שנוצר בתהליך פיתוח התוכנה (Artifact) lifecycle-common מ-lifecycle-runtime-ktx. (I41d78, b/240298691)
  • תוסף Kotlin ב-Lifecycle שמספק את השדה coroutineScope הועבר אל פריט המידע שנוצר בתהליך פיתוח התוכנה (Artifact) lifecycle-common מ-lifecycle-runtime-ktx. (Iabb91, b/240298691)

גרסה ‎2.6.0-alpha05

‫25 בינואר 2023

‫androidx.lifecycle:lifecycle-*:2.6.0-alpha05 מופץ. גרסה 2.6.0-alpha05 מכילה את השינויים האלה.

המרות של Kotlin

  • ‫Transformations כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור המחלקות האלה שנכתבו ב-Kotlin שהשתמשו ישירות בתחביר כמו Transformations.map – קוד Kotlin חייב עכשיו להשתמש בתחביר של שיטת ההרחבה של Kotlin שהיה זמין בעבר רק כשמשתמשים ב-lifecycle-livedata-ktx. כשמשתמשים בשפת התכנות Java, הגרסאות של השיטות האלה שמקבלות שיטת androidx.arch.core.util.Function הוצאו משימוש והוחלפו בגרסאות שמקבלות Function1 של Kotlin. השינוי הזה שומר על תאימות בינארית. (I8e14f)
  • ‫ViewTreeViewModelStoreOwner כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור המחלקות האלה שנכתבו ב-Kotlin – עכשיו צריך לייבא ישירות את שיטות התוספים של Kotlin ולהשתמש בהן ב-View של androidx.lifecycle.setViewTreeViewModelStoreOwner ו-androidx.lifecycle.findViewTreeViewModelStoreOwner כדי להגדיר ולמצוא בעלים שהוגדרו בעבר. הוא תואם בינארית ותואם למקור להטמעות שנכתבו בשפת התכנות Java. (Ia06d8,‏ Ib22d8,‏ b/240298691)
  • הממשק HasDefaultViewModelProviderFactory כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור מחלקות שנכתבו ב-Kotlin – עכשיו הן צריכות לשנות את המאפיינים defaultViewModelProviderFactory ו-defaultViewModelCreationExtras במקום להטמיע את הפונקציות התואמות הקודמות. (Iaed9c,‏ b/240298691)
  • ‫Observer כתוב עכשיו ב-Kotlin. השיטה onChanged() שלו משתמשת עכשיו בשם value לפרמטר שלה. (Iffef2,‏ I4995e,‏ b/240298691)
  • ‫AndroidViewModel, ‏AbstractSavedStateViewModelFactory, ‏LifecycleService, ‏ServiceLifecycleDispatcher ו-ProcessLifecycleOwner כתובים עכשיו ב-Kotlin‏ (I2e771, ‏Ibae40, ‏I160d7, ‏I08884, ‏I1cda7, ‏b/240298691)

גרסה ‎2.6.0-alpha04

‫11 בינואר 2023

‫androidx.lifecycle:lifecycle-*:2.6.0-alpha04 מופץ. גרסה 2.6.0-alpha04 מכילה את השינויים האלה.

תכונות חדשות

  • ‫LiveData כולל עכשיו מאפיין isInitialized חדש שמציין אם אי פעם הוגדר ערך מפורש ב-LiveData, וכך מאפשר להבחין בין liveData.value שמחזיר null כי לא הוגדר ערך אף פעם, לבין ערך null מפורש. (Ibd018)

שינויים ב-API

  • ממשקי ה-API של collectAsStateWithLifecycle() ב-lifecycle-runtime-compose כבר לא בסטטוס ניסיוני. (I09d42,‏ b/258835424)
  • השיטות Lifecycle.launchWhenX ו-Lifecycle.whenX הוצאו משימוש כי השימוש ב-dispatcher להשהיה עלול להוביל לבזבוז משאבים במקרים מסוימים. מומלץ להשתמש ב-Lifecycle.repeatOnLifecycle. (Iafc54,‏ b/248302832)

המרות ב-Kotlin

  • ‫ViewTreeLifecycleOwner כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור המחלקות האלה שנכתבו ב-Kotlin – עכשיו צריך לייבא ישירות את שיטות התוספים של Kotlin ולהשתמש בהן ב-View של androidx.lifecycle.setViewTreeLifecycleOwner ו-androidx.lifecycle.findViewTreeLifecycleOwner כדי להגדיר ולמצוא בעלים שהוגדרו בעבר. התוסף הזה מחליף את התוסף הקודם של Kotlin ב-lifecycle-runtime-ktx. הוא תואם בינארית ותואם למקור להטמעות שנכתבו בשפת התכנות Java. (I8a77a, I5234e, b/240298691)
  • ‫LiveDataReactiveStreams כתוב עכשיו ב-Kotlin. תוספי Kotlin שהיו בעבר ב-lifecycle-reactivestreams-ktx הועברו למודול lifecycle-reactivestreams והפכו לממשק הראשי של קוד שנכתב ב-Kotlin. זהו שינוי שלא תואם למקור בקוד שנכתב ב-Kotlin, אם עדיין לא השתמשתם בממשקי ה-API של שיטת ההרחבה של Kotlin. (I2b1b9,‏ I95d22,‏ b/240298691)
  • ‫DefaultLifecycleObserver,‏ LifecycleEventObserver,‏ Lifecycle,‏ LifecycleRegistry,‏ LifecycleObserver ו-ViewModelStore כתובים עכשיו ב-Kotlin‏ (Iadffd,‏ (I60034,‏ I8c52c,‏ I9593d,‏ I01fe1,‏ I59a23,‏ b/240298691)

תיקוני באגים

  • ‫SavedStateHandle לא קורס יותר עם ClassCastException כשמתבצעת קריאה ל-get() עם סוג המחלקה השגוי. (I6ae7c)

גרסה ‎2.6.0-alpha03

‫24 באוקטובר 2022

‫androidx.lifecycle:lifecycle-*:2.6.0-alpha03 מופץ. גרסה ‎2.6.0-alpha03 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה בעיה שבה אילוצים בין מודולים שונים של Lifecycle לא פעלו כמצופה. (I18d0d, b/249686765)
  • שגיאות שמופיעות ב-LifecycleRegistry.moveToState() כוללות עכשיו הודעות שגיאה מועילות יותר, שמיידעות את המפתחים לגבי הרכיב שגורם לשגיאה. (Idf4b2, b/244910446)

גרסה 2.6.0-alpha02

‫7 בספטמבר 2022

‫androidx.lifecycle:lifecycle-*:2.6.0-alpha02 מופץ. גרסה 2.6.0-alpha02 מכילה את השינויים האלה.

שינויים ב-API

  • ‫MediatorLiveData כולל עכשיו פונקציית בנאי (constructor) להגדרת ערך ראשוני. (Ib6cc5, b/151244085)

תיקוני באגים

  • רכיבי ה-Artifacts של Lifecycle כוללים עכשיו אילוצים שמבטיחים שכל רכיבי ה-Artifacts של מחזור החיים שתלויים זה בזה משתמשים באותה גרסה, ומשדרגים באופן אוטומטי יחסי תלות אחרים כשמשדרגים אחד מהם. b/242871265
  • עכשיו FlowLiveData.asFlow() יוצר callbackFlow במקום להשתמש בהטמעה משלו של Channel כדי להבטיח thread-safety ושמירה על ההקשר. (I4a8b2, b/200596935)
  • הפונקציה asLiveData של FlowLiveData תשמור עכשיו על הערך הראשוני של StateFlow כשיוצרים את האובייקט החדש של LiveData. (I3f530, b/157380488)
  • מ-Lifecycle 2.5.1: הטמעות בהתאמה אישית של AndroidViewModelFactory קוראות עכשיו בצורה נכונה לפונקציה create(modelClass) כשמשתמשים ב-stateful constructor עם Lifecycle 2.4 ואילך (I5b315, b/238011621)

גרסה ‎2.6.0-alpha01

29 ביוני 2022

‫androidx.lifecycle:lifecycle-*:2.6.0-alpha01 מופץ. גרסה 2.6.0-alpha01 מכילה את השינויים האלה.

תכונות חדשות

  • הוספנו תוסף חדש ב-StateFlow וב-Flow של collectAsStateWithLifecycle שאוסף נתונים מתהליכים ומייצג את הערך האחרון שלו כמצב Compose באופן שמודע למחזור החיים. ה-flow נאסף וה-emission החדש מוגדר לערך של State כשה-lifecycle נמצא לפחות ב-Lifecycle.State מסוים. כאשר מחזור החיים יורד מתחת ל-Lifecycle.State, איסוף ערכי Flow נפסק והערך של State לא מתעדכן. (I1856e, b/230557927)

גרסה 2.5

גרסה 2.5.1

‫27 ביולי 2022

‫androidx.lifecycle:lifecycle-*:2.5.1 מופץ. גרסה 2.5.1 כוללת את השינויים האלה.

תיקוני באגים

  • הטמעות בהתאמה אישית של AndroidViewModelFactory קוראות עכשיו לפונקציה create(modelClass) בצורה נכונה כשמשתמשים ב-constructor עם שמירת מצב (stateful) של AndroidViewModelFactory עם Lifecycle בגרסה 2.4 ואילך. (I5b315,‏ b/238011621)

גרסה 2.5.0

29 ביוני 2022

‫androidx.lifecycle:lifecycle-*:2.5.0 מופץ. גרסה 2.5.0 מכילה את השינויים האלה.

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

  • ב-SavedStateHandle יש עכשיו API של getStateFlow() שמחזיר StateFlow של Kotlin למעקב אחרי שינויים בערכים, כחלופה לשימוש ב-LiveData.

  • ViewModel CreationExtras – כשכותבים ViewModelProvider.Factory בהתאמה אישית, לא צריך יותר להרחיב את AndroidViewModelFactory או את AbstractSavedStateViewModelFactory כדי לקבל גישה ל-Application או ל-SavedStateHandle, בהתאמה. במקום זאת, השדות האלה מסופקים לכל מחלקת משנה של ViewModelProvider.Factory בתור CreationExtras באמצעות עומס היתר החדש של create: create(Class<T>, CreationExtras). התוספות האלה מסופקות באופן אוטומטי על ידי Activity או Fragment כשמשתמשים ב-Activity 1.5.0 וב-Fragment 1.5.0, בהתאמה.

    class CustomFactory : ViewModelProvider.Factory {
        override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
            return when (modelClass) {
                HomeViewModel::class -> {
                    // Get the Application object from extras
                    val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY])
                    // Pass it directly to HomeViewModel
                    HomeViewModel(application)
                }
                DetailViewModel::class -> {
                    // Create a SavedStateHandle for this ViewModel from extras
                    val savedStateHandle = extras.createSavedStateHandle()
                    DetailViewModel(savedStateHandle)
                }
                else -> throw IllegalArgumentException("Unknown class $modelClass")
            } as T
        }
    }
    
  • ‫lifecycle-viewmodel מספק עכשיו viewModelFactory Kotlin DSL שמאפשר להגדיר את ViewModelProvider.Factory במונחים של מאתחל למבדה אחד או יותר, אחד לכל מחלקת ViewModel מסוימת שה-factory המותאם אישית תומך בה, באמצעות CreationExtras כמקור הנתונים הראשי.

    val customFactory = viewModelFactory {
        // The return type of the lambda automatically sets what class this lambda handles
        initializer {
            // Get the Application object from extras provided to the lambda
            val application = checkNotNull(get(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY))
            HomeViewModel(application)
        }
        initializer {
            val savedStateHandle = createSavedStateHandle()
            DetailViewModel(savedStateHandle)
        }
    }
    
  • ב-lifecycle-viewmodel-compose יש עכשיו API של viewModel() שמקבל פונקציית lambda ליצירת מופע של ViewModel בלי שצריך ליצור ViewModelProvider.Factory בהתאמה אישית.

    // Within a @Composable, you can now skip writing a custom Factory
    // and instead write a lambda to do the initialization of your ViewModel
    val detailViewModel = viewModel {
      // This lambda is only called the first time the ViewModel is created
      // and all CreationExtras are available inside the lambda
      val savedStateHandle = createSavedStateHandle()
      DetailViewModel(savedStateHandle)
    }
    
  • שילוב של SavedStateHandle עם Compose Saver – פריט המידע שנוצר בתהליך פיתוח התוכנה (Artifact) של lifecycle-viewmodel-compose מכיל עכשיו ממשקי API ניסיוניים חדשים ב-SavedStateHandle.saveable שמאפשרים התנהגות כמו של rememberSaveable שמגובה על ידי SavedStateHandle של ViewModel.

    class ListScreenViewModel(handle: SavedStateHandle): ViewModel() {
        // This value survives both configuration changes and process death and recreation
        val editMode by handle.saveable { mutableStateOf(false) }
    }
    
  • הוספנו API של addCloseable() ועומס יתר חדש של בנאי שמאפשרים להוסיף אובייקט אחד או יותר של Closeable ל-ViewModel שייסגר כשה-ViewModel יימחק, בלי צורך בעבודה ידנית ב-onCleared().

    לדוגמה, כדי ליצור היקף של שגרת המשך (coroutine) שאפשר להחדיר ל-ViewModel, אבל לשלוט בו באמצעות בדיקה, אפשר ליצור CoroutineScope שמטמיע את Closeable:

    class CloseableCoroutineScope(
        context: CoroutineContext = SupervisorJob() + Dispatchers.Main.immediate
    ) : Closeable, CoroutineScope {
        override val coroutineContext: CoroutineContext = context
        override fun close() {
            coroutineContext.cancel()
       }
    }
    

    אפשר להשתמש בו ב-constructor של ViewModel תוך שמירה על אותו משך חיים כמו של viewModelScope:

    class TestScopeViewModel(
        val customScope: CloseableCoroutineScope = CloseableCoroutineScope()
    ) : ViewModel(customScope) {
        // You can now use customScope in the same way as viewModelScope
    }
    

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

  • ניסיון להעביר את Lifecycle.State מ-INITIALIZED אל DESTROYED יגרום עכשיו תמיד להצגת IllegalStateException, גם אם ל-Lifecycle יש צופה מצורף.
  • ‫LifecycleRegistry ינקה עכשיו את הצופים שלו כשהוא יגיע למצב DESTROYED.

גרסה ‎2.5.0-rc02

‫15 ביוני 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-rc02 מופץ. גרסה 2.5.0-rc02 מכילה את השינויים האלה.

תיקוני באגים

  • ‫ViewModelProvider לא יקרוס יותר כשמשלבים גרסאות קודמות של יחסי תלות של compileOnly Lifecycle עם גרסאות 2.5 ואילך. (I81a66,‏ b/230454566)

גרסה ‎2.5.0-rc01

‫11 במאי 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-rc01 מופץ. גרסה 2.5.0-rc01 מכילה את השינויים האלה.

תיקוני באגים

  • הפונקציה MediatorLiveData.addSource() זורקת עכשיו NullPointerException כשמועבר מקור null, במקום להפיץ את המקור null לצופים.(Ibd0fb,‏ b/123085232)

גרסה ‎2.5.0-beta01

‫20 באפריל 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-beta01 מופץ. גרסה 2.5.0-beta01 מכילה את השינויים האלה.

שינויים ב-API

  • נוספו נציגי מאפיינים של SavedStateHandle.saveable כדי להשתמש בשמות של מאפיינים כמפתחות לשמירת המצב ב-SavedStateHandle (I8bb86,‏ b/225014345)

תיקוני באגים

  • תוקנה בעיה שבה הטמעה של NavHost אחד בתוך NavHost אחר בכרטיסיית סרגל ניווט תחתון לא ראשי הובילה ל-IllegalStateException כשמשתמשים בכמה מקבצי פעילויות קודמות (back stack). (I11bd5, b/228865698)

גרסה ‎2.5.0-alpha06

‫6 באפריל 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-alpha06 מופץ. גרסה 2.5.0-alpha06 מכילה את השינויים האלה.

תכונות חדשות

  • הוספת עומס יתר ניסיוני של MutableState ל-SavedStateHandle.saveable כדי להשוות ל-rememberSaveable (I38cfe,‏ b/224565154)

שינויים ב-API

  • ‫CreationExtras הוא עכשיו מופשט במקום אטום. (Ib8a7a)

תיקוני באגים

  • תוקנה שגיאה מסוג IllegalStateException: Already attached to lifecycleOwner שנגרמה על ידי SavedStateHandleController. (I7ea47, b/215406268)

גרסה ‎2.5.0-alpha05

‫23 במרץ 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-alpha05 מופץ. גרסה 2.5.0-alpha05 מכילה את השינויים האלה.

תכונות חדשות

  • המודול lifecycle-viewmodel-compose מספק עכשיו את SavedStateHandleSaver, ממשק API ניסיוני שמוודא שהערכים ב-SavedStateHandle משולבים בצורה נכונה עם אותו מצב של מופע שמור שבו משתמש rememberSaveable. (Ia88b7, b/195689777)

שינויים ב-API

  • תוקנה בעיית תאימות עם Lifecycle 2.3 וגרסאות חדשות יותר של Lifecycle ב-Java. (I52c8a, b/219545060)

תיקוני באגים

  • עכשיו אפשר להשתמש ב-CreationExtras ב-SavedStateViewFactory גם אם הוא אותחל באמצעות SavedStateRegistryOwner. אם מסופקים תוספים, המערכת מתעלמת מהארגומנטים שהופעלו. (I6c43b, b/224844583)

גרסה ‎2.5.0-alpha04

9 במרץ 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-alpha04 מופץ. גרסה 2.5.0-alpha04 מכילה את השינויים האלה.

שינויים ב-API

  • ב-SavedStateHandle יש עכשיו ממשק API של getStateFlow() שמחזיר StateFlow של Kotlin למעקב אחרי שינויים בערכים, כחלופה לשימוש ב-LiveData. (Iad3ab,‏ b/178037961)

גרסה ‎2.5.0-alpha03

‫23 בפברואר 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-alpha03 מופץ. גרסה 2.5.0-alpha03 מכילה את השינויים האלה.

תכונות חדשות

  • הוספנו API של addCloseable() ועומס יתר חדש של בנאי שמאפשרים להוסיף אובייקט אחד או יותר של Closeable ל-ViewModel, שייסגר כשה-ViewModel יימחק בלי צורך בעבודה ידנית ב-onCleared(). (I55ea0)
  • ב-lifecycle-viewmodel יש עכשיו InitializerViewModelFactory שמאפשר להוסיף פונקציית lambda לטיפול במחלקות ViewModel מסוימות, באמצעות CreationExtras כמקור הנתונים הראשי. (If58fc, b/216687549)
  • ב-lifecycle-viewmodel-compose יש עכשיו API של viewModel() שמקבל פונקציית lambda ליצירת מופע של ViewModel בלי שצריך ליצור ViewModelProvider.Factory בהתאמה אישית. (I97fbb,‏ b/216688927)

שינויים ב-API

  • עכשיו אפשר ליצור ViewModel עם CreationExtras באמצעות lifecycle-viewmodel-compose. (I08887, b/216688927)

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

  • ניסיון להעביר את Lifecycle.State מ-INITIALIZED אל DESTROYED יגרום עכשיו תמיד להצגת IllegalStateException, בלי קשר לשאלה אם ל-Lifecycle יש צופה מצורף. (I7c390, b/177924329)
  • מעכשיו, LifecycleRegistry ינקה את הצופים שלו כשהוא יגיע למצב DESTROYED. (I4f8dd,‏ b/142925860)

גרסה ‎2.5.0-alpha02

‫9 בפברואר 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-alpha02 מופץ. גרסה 2.5.0-alpha02 מכילה את השינויים האלה.

שינויים ב-API

  • הקבצים SavedStateHandle ו-SavedStateViewModelFactory הומרו ל-Kotlin. זה שיפר את יכולת ה-nullability של הגנריות בשתי המחלקות. (Ib6ce2, b/216168263, I9647a, b/177667711)
  • הפרמטר switchMap של הפונקציה LiveData יכול עכשיו להחזיר פלט שניתן לאפס. (I40396,‏ b/132923666)
  • תוספי LiveData -ktx כוללים עכשיו הערות עם @CheckResult כדי לאכוף את השימוש בתוצאה כשקוראים לפונקציות האלה. (Ia0f05, b/207325134)

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

  • עכשיו SavedStateHandle מאחסן כראוי את defaultValue כשאין ערך למפתח שצוין. (I1c6ce, b/178510877)

תיקוני באגים

  • מ-Lifecycle 2.4.1: עדכנו את lifecycle-process כך שיהיה תלוי ב-Startup 1.1.1 כדי לוודא שתיקונים שמונעים מ-ProcessLifecycleInitializer להפעיל StartupException זמינים כברירת מחדל. (Ib01df, b/216490724)
  • מעכשיו מוצגת הודעת שגיאה משופרת כשמנסים ליצור ViewModel באמצעות מחלקות AndroidViewModel מותאמות אישית עם פרמטרים בסדר שגוי. (I340f7, b/177667711)
  • עכשיו אפשר ליצור מודל תצוגה דרך CreationExtras באמצעות AndroidViewModelFactory בלי להגדיר אפליקציה. (I6ebef, b/217271656)

גרסה ‎2.5.0-alpha01

‫26 בינואר 2022

‫androidx.lifecycle:lifecycle-*:2.5.0-alpha01 מופץ. גרסה 2.5.0-alpha01 מכילה את השינויים האלה.

ViewModel CreationExtras

בגרסה הזו אנחנו מניחים את היסודות לשינוי המבנה של ViewModel. במקום קבוצה קשיחה של מחלקות משנה של ViewModelProvider.Factory שכל אחת מהן מוסיפה פונקציונליות נוספת (הפעלת פרמטר של בנאי Application דרך AndroidViewModelFactory, הפעלת פרמטר של בנאי SavedStateHandle דרך SavedStateViewModelFactory ו-AbstractSavedStateViewModelFactory וכו'), אנחנו עוברים לעולם של פונקציות מפעל ללא מצב (stateless) שמסתמכות על קונספט חדש, CreationExtras. (Ia7343, b/188691010, b/188541057)

בעקבות השינוי הזה, ViewModelProvider לא מבצע יותר קריאות ישירות ל-method הקודמת create(Class<T>) של ViewModelProvider.Factory. במקום זאת, הוא קורא לעומס יתר חדש של create: create(Class<T>, CreationExtras). זה אומר שלכל הטמעה ישירה של המכונה ViewModelProvider.Factory יש עכשיו גישה לכל אחד מהערכים החדשים של CreationExtras:

  • ‫ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY: ה-String הזה מספק גישה למפתח בהתאמה אישית שהעברתם אל ViewModelProvider.get().
  • ‫ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY מספק גישה לכיתה Application.
  • ‫SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY מספק גישה אל SavedStateRegistryOwner שמשמש ליצירת ה-ViewModel הזה.
  • ‫SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY מספק גישה אל ViewModelStoreOwner שמשמש ליצירת ה-ViewModel הזה.
  • הפונקציה SavedStateHandleSupport.DEFAULT_ARGS_KEY מספקת גישה ל-Bundle של ארגומנטים שצריך להשתמש בהם כדי ליצור SavedStateHandle.

התוספות האלה מסופקות כברירת מחדל כשמשתמשים ב-Activity 1.5.0-alpha01, ב-Fragment 1.5.0-alpha01 וב-Navigation 2.5.0-alpha01. אם אתם משתמשים בגרסה קודמת של הספריות האלה, CreationExtras יהיה ריק – כל מחלקות המשנה הקיימות של ViewModelProvider.Factory נכתבו מחדש כדי לתמוך גם בנתיב היצירה הקודם ששימש את הגרסאות הקודמות של הספריות האלה וגם בנתיב CreationExtras שישמש בהמשך.

CreationExtras האלה מאפשרים לכם ליצור ViewModelProvider.Factory שמעביר רק את המידע שאתם צריכים לכל ViewModel בלי להסתמך על היררכיה קפדנית של מחלקות משנה של Factory:

class CustomFactory : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
        return when (modelClass) {
            HomeViewModel::class -> {
                // Get the Application object from extras
                val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY])
                // Pass it directly to HomeViewModel
                HomeViewModel(application)
            }
            DetailViewModel::class -> {
                // Create a SavedStateHandle for this ViewModel from extras
                val savedStateHandle = extras.createSavedStateHandle()
                DetailViewModel(savedStateHandle)
            }
            else -> throw IllegalArgumentException("Unknown class $modelClass")
        } as T
    }
}

אנחנו משתמשים בפונקציית ההרחבה createSavedStateHandle() של Kotlin ב-CreationExtras מ-SavedStateHandleSupport כדי ליצור SavedStateHandle רק ל-ViewModel שצריך אותה. thought (Ia6654,‏ b/188541057)

אפשר לספק CreationExtras בהתאמה אישית על ידי שינוי של getDefaultViewModelCreationExtras() ב-ComponentActivity או ב-Fragment, וכך להפוך אותם לזמינים ל-ViewModelProvider.Factory בהתאמה אישית כצורה מובנית של הזרקה בסיוע. התוספות האלה יהיו זמינות באופן אוטומטי ל-Factory בהתאמה אישית כשהן משמשות ישירות עם ViewModelProvider או כשמשתמשים בתוספי המאפיינים by viewModels() ו-by activityViewModels() של Kotlin. (I79f2b,‏ b/207012584,‏ b/207012585,‏ b/207012490)

תיקוני באגים

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

גרסה 2.4

גרסה 2.4.1

‫9 בפברואר 2022

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

תיקוני באגים

  • היסב בגרסאות מוקדמות יותר (backporting) מ-Lifecycle 2.5.0-alpha01: תוקנה בעיה שבה ערך ברירת המחדל שסופק ל-SavedStateHandle הופיע שוב אחרי השבתת התהליך ויצירה מחדש, גם אם הוא הוסר באופן ספציפי מ-SavedStateHandle. כתוצאה מכך, SavedStateHandle לא ימזג יותר את ערכי ברירת המחדל עם הערכים ששוחזרו, אלא ישתמש רק בערכים ששוחזרו כמקור האמת. (I53a4b)
  • lifecycle-process תלוי עכשיו ב-Androidx Startup 1.1.1, שבו תוקנה רגרסיה שבה השימוש ב-ProcessLifecycleInitializer גרם ל-StartupException. (b/216490724)

גרסה 2.4.0

‫27 באוקטובר 2021

‫androidx.lifecycle:lifecycle-*:2.4.0 מופץ. גרסה 2.4.0 מכילה את השינויים האלה.

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

  • השדה @OnLifecycleEvent הוצא משימוש. במקומה צריך להשתמש ב-LifecycleEventObserver או ב-DefaultLifecycleObserver.
  • נוספה ספרייה אחת (androidx.lifecycle:lifecycle-viewmodel-compose). הוא מספק את viewModel() הניתן להגדרה ואת LocalViewModelStoreOwner.
    • שינוי תוכנה שעלול לגרום לכשל במקור: ViewModelProvider נכתב מחדש ב-Kotlin. ה-method‏ ViewModelProvider.Factory.create לא מאפשר יותר ערך גנרי שניתן לאפס.
  • נוספו ממשקי API חדשים של פונקציות קורוטין ל-androidx.lifecycle:lifecycle-runtime-ktx:
  • ‫Lifecycle.repeatOnLifecycle, ממשק API שמפעיל בלוק של קוד ב-coroutine כשה-Lifecycle נמצא לפחות במצב מסוים. הבלוק יבוטל ויופעל מחדש כשמחזור החיים ייכנס למצב היעד וייצא ממנו.
  • ‫Flow.flowWithLifecycle, ממשק API שפולט ערכים מה-Flow במעלה הזרם כשה-Lifecycle נמצא לפחות במצב מסוים.
  • הערך DefaultLifecycleObserver הועבר מ-lifecycle.lifecycle-common-java8 אל lifecycle.lifecycle-common. lifecycle.lifecycle-common-java8 לא מספק יותר פונקציונליות נוספת מעבר ל-lifecycle.lifecycle-common, כך שאפשר להחליף את התלות בו ב-lifecycle.lifecycle-common.
  • ממשק API שאינו קורוטינה מ-lifecycle-viewmodel-ktx הועבר למודול lifecycle-viewmodel.
  • עכשיו lifecycle-process משתמש ב-androidx.startup כדי להפעיל את ProcessLifecycleOwner.

    בעבר, הפעולה הזו בוצעה על ידי androidx.lifecycle.ProcessLifecycleOwnerInitializer.

    אם השתמשתם בעבר ב-tools:node="remove", ContentProvider שמשמש לאתחול מחזור החיים של התהליך, אתם צריכים לבצע את הפעולות הבאות במקום זאת.

     <provider
        android:name="androidx.startup.InitializationProvider"
        android:authorities=\"${applicationId}.androidx-startup"
        android:exported="false"
        tools:node=\"merge">
        <!-- If you are using androidx.startup to initialize other components -->
        <meta-data
            android:name="androidx.lifecycle.ProcessLifecycleInitializer"
            android:value="androidx.startup"
            tools:node="remove" />
     </provider>
    

    (או)

     <!-- If you want to disable androidx.startup completely. -->
     <provider
        android:name="androidx.startup.InitializationProvider"
        android:authorities="${applicationId}.androidx-startup"
        tools:node="remove">
     </provider>
    

גרסה ‎2.4.0-rc01

‫29 בספטמבר 2021

גרסה androidx.lifecycle:lifecycle-*:2.4.0-rc01 הושקה ללא שינויים מ-Lifecycle 2.4.0-beta01. גרסה 2.4.0-rc01 מכילה את השינויים האלה.

גרסה ‎2.4.0-beta01

‫15 בספטמבר 2021

‫androidx.lifecycle:lifecycle-*:2.4.0-beta01 מופץ. גרסה 2.4.0-beta01 מכילה את השינויים האלה.

שינויים ב-API

  • השדה @OnLifecycleEvent הוצא משימוש. במקומה צריך להשתמש ב-LifecycleEventObserver או ב-DefaultLifecycleObserver. (I5a8fa)
  • ‫DefaultLifecycleObserver הועבר מ-androidx.lifecycle.lifecycle-common-java8 אל androidx.lifecycle.lifecycle-common. ‫androidx.lifecycle.lifecycle-common-java8 לא מספק יותר פונקציונליות נוספת מעבר ל-androidx.lifecycle.lifecycle-common, כך שאפשר להחליף את התלות בו ב-androidx.lifecycle.lifecycle-common. (I021aa)
  • ממשק API ללא קורוטינות מ-lifecycle-viewmodel-ktx הועבר למודול lifecycle-viewmodel. (I6d5b2)

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

  • תודה ל-dmitrilc על תיקון שגיאת הקלדה במסמכי התיעוד של ViewModel. (#221)

גרסה ‎2.4.0-alpha03

‫4 באוגוסט 2021

‫androidx.lifecycle:lifecycle-*:2.4.0-alpha03 מופץ. גרסה ‎2.4.0-alpha03 מכילה את השינויים האלה.

שינויים ב-API

  • שינוי תוכנה שעלול לגרום לכשל במקור: ViewModelProvider נכתב מחדש ב-Kotlin. ה-method‏ ViewModelProvider.Factory.create לא מאפשר יותר generic שניתן להגדיר כ-null. (I9b9f6)

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

  • הפונקציה Lifecycle.repeatOnLifecycle: block מופעלת עכשיו תמיד באופן סדרתי כשחוזרים על ההפעלה. (Ibab33)

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

  • תודה ל-chao2zhang על תיקון קטעי הקוד במסמכי התיעוד של repeatOnLifecycle. #205.

גרסה ‎2.4.0-alpha02

‫16 ביוני 2021

‫androidx.lifecycle:lifecycle-*:2.4.0-alpha02 מופץ. גרסה 2.4.0-alpha02 מכילה את השינויים האלה.

תכונות חדשות

  • הוספנו בדיקת איתור שגיאות בקוד (lint) חדשה של RepeatOnLifecycleWrongUsage ל-lifecycle-runtime-ktx, שמזהה שימוש שגוי ב-repeateOnLifecycle ב-onStart() או ב-onResume(). (706078, b/187887400)

שינויים ב-API

  • ה-API של LifecycleOwner.addRepeatingJob הוסר, ובמקומו נוסף ה-API של Lifecycle.repeatOnLifecycle, שמתאים לתהליכים בו-זמניים מובְנים וקל יותר להבין אותו. (I4a3a8)
  • צריך להגדיר את ProcessLifecycleInitializer כגלוי לכולם כדי שandroidx.startup.Initializerים אחרים יוכלו להשתמש בו כיחסי תלות. (I94c31)

תיקוני באגים

  • תוקנה בעיה בבדיקת ה-lint של NullSafeMutableLiveData כשהשדה כולל מגדירי גישה. (#147, b/183696616)
  • תוקנה בעיה נוספת בבדיקת ה-lint של NullSafeMutableLiveData כשמשתמשים בגנריות. (#161, b/184830263)

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

גרסה ‎2.4.0-alpha01

‫24 במרץ 2021

‫androidx.lifecycle:lifecycle-*:2.4.0-alpha01 מופץ. גרסה 2.4.0-alpha01 מכילה את השינויים האלה.

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

  • עכשיו lifecycle-process משתמש ב-androidx.startup כדי להפעיל את ProcessLifecycleOwner.

    בעבר, הפעולה הזו בוצעה על ידי androidx.lifecycle.ProcessLifecycleOwnerInitializer.

    אם השתמשתם בעבר ב-tools:node="remove", ContentProvider שמשמש לאתחול מחזור החיים של התהליך, אתם צריכים לבצע את הפעולות הבאות במקום זאת.

     <provider
        android:name="androidx.startup.InitializationProvider"
        android:authorities=\"${applicationId}.androidx-startup"
        android:exported="false"
        tools:node=\"merge">
        <!-- If you are using androidx.startup to initialize other components -->
        <meta-data
            android:name="androidx.lifecycle.ProcessLifecycleInitializer"
            android:value="androidx.startup"
            tools:node="remove" />
     </provider>
    

    (או)

     <!-- If you want to disable androidx.startup completely. -->
     <provider
        android:name="androidx.startup.InitializationProvider"
        android:authorities="${applicationId}.androidx-startup"
        tools:node="remove">
     </provider>
    

שינויים ב-API

  • הוספנו API של Flow.flowWithLifecycle שפולט ערכים מה-Flow במעלה הזרם כשהמחזור החיים נמצא לפחות במצב מסוים באמצעות ה-API של Lifecycle.repeatOnLifecycle. זוהי חלופה ל-API החדש של LifecycleOwner.addRepeatinJob. (I0f4cd)

תיקוני באגים

  • מגרסה Lifecycle 2.3.1: כלל ה-lint של NonNullableMutableLiveData יכול עכשיו להבדיל בצורה נכונה בין משתני שדה עם מאפיין שונה המציין אם ערך יכול להיות ריק (nullability). (b/169249668)

גרסה 1.0.0 של Lifecycle Viewmodel Compose

גרסה 1.0.0-alpha07

‫16 ביוני 2021

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

שינויים מהותיים ב-API

  • עכשיו אפשר להוסיף ל-viewModel() את הפרמטר האופציונלי ViewModelStoreOwner, כדי שיהיה קל יותר לעבוד עם בעלים אחרים חוץ מ-LocalViewModelStoreOwner. לדוגמה, עכשיו אפשר להשתמש ב-viewModel(navBackStackEntry) כדי לאחזר ViewModel שמשויך לתרשים ניווט מסוים. (I2628d, b/188693123)

גרסה 1.0.0-alpha06

‫2 ביוני 2021

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

עודכן כדי להתאים לגרסה 1.0.0-beta08 של Compose.

גרסה ‎1.0.0-alpha05

‫18 במאי 2021

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

תכונות חדשות

  • עודכן כדי להתאים לגרסה 1.0.0-beta07 של Compose.

תיקוני באגים

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

גרסה 1.0.0-alpha04

‫7 באפריל 2021

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

שינויים בתלויות

  • הגרסה הזו מאפשרת ל-androidx.hilt:hilt-navigation-compose ול-androidx.navigation:navigation-compose לסנכרן את יחסי התלות ב-androidx.compose.compiler:compiler:1.0.0-beta04 וב-androidx.compose.runtime:runtime:1.0.0-beta04. בגרסה 1.0.0, הקומפיילר וסביבת זמן הריצה צריכים להתאים.

גרסה 1.0.0-alpha03

10 במרץ 2021

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

שינויים ב-API

  • הפונקציה LocalViewModelStoreOwner.current מחזירה עכשיו ערך ViewModelStoreOwner שניתן לאפס, כדי לקבוע בצורה טובה יותר אם יש ViewModelStoreOwner זמין בקומפוזיציה הנוכחית. ממשקי API שנדרש בהם ViewModelStoreOwner, כמו viewModel() ו-NavHost, עדיין יזרקו חריגה אם לא מוגדר ViewModelStoreOwner. (Idf39a)

גרסה 1.0.0-alpha02 של Lifecycle-Viewmodel-Compose

‫24 בפברואר 2021

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

שינויים ב-API

  • ‫LocalViewModelStoreOwner כולל עכשיו פונקציות של provides שאפשר להשתמש בהן עם CompositionLocalProvider, במקום ה-API של asProvidableCompositionLocal(). (I45d24)

גרסה 1.0.0-alpha01 של Lifecycle-Viewmodel-Compose

‫10 בפברואר 2021

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

תכונות חדשות

  • ה-composable‏ viewModel() ו-LocalViewModelStoreOwner הועברו מ-androidx.compose.ui.viewinterop לארטיפקט הזה בחבילה androidx.lifecycle.viewmodel.compose. (I7a374)

גרסה 2.3.1

גרסה 2.3.1 של Lifecycle

‫24 במרץ 2021

‫androidx.lifecycle:lifecycle-*:2.3.1 מופץ. גרסה 2.3.1 כוללת את השינויים האלה.

תיקוני באגים

  • כלל ה-lint‏ NonNullableMutableLiveData יכול עכשיו להבדיל בצורה נכונה בין משתני שדה עם ערכי nullability שונים. (b/169249668)

גרסה 2.3.0

גרסה 2.3.0

‫10 בפברואר 2021

‫androidx.lifecycle:lifecycle-*:2.3.0 מופץ. גרסה 2.3.0 מכילה את השינויים האלה.

שינויים משמעותיים מאז גרסה 2.2.0

  • תמיכה של SavedStateHandle במחלקות שלא ניתנות להעברה: SavedStateHandle תומך עכשיו בסריאליזציה עצלה (lazy serialization) בכך שהוא מאפשר לקרוא ל-setSavedStateProvider() עבור מפתח נתון, ומספק SavedStateProvider שיקבל קריאה חוזרת (callback) ל-saveState() כאשר SavedStateHandle יתבקש לשמור את המצב שלו. אפשר לקרוא מידע נוסף במאמר שמירת מחלקות שלא ניתנות להעברה.
  • אכיפת התנהגות במחזור החיים:
    • עכשיו LifecycleRegistry אוכף את DESTROYED כמצב סופי.
    • ‫LifecycleRegistry עכשיו מאמת שהשיטות שלו נקראות בשרשור הראשי. זו תמיד הייתה דרישה למחזורי חיים של פעילויות, מקטעים וכו'. הוספה של משקיפים משרשורים שאינם ראשיים גרמה לקריסות שקשה לזהות בזמן הריצה. לאובייקטים מסוג LifecycleRegistry שבבעלות הרכיבים שלכם, אתם יכולים לבטל את ההסכמה לבדיקות באופן מפורש באמצעות LifecycleRegistry.createUnsafe(...), אבל אז אתם צריכים לוודא שמתבצע סנכרון תקין כשניגשים ל-LifecycleRegistry הזה משרשורים שונים.
  • מצבי מחזור חיים ורכיבי עזר לאירועים: הוספנו שיטות עזר סטטיות של downFrom(State),‏ downTo(State),‏ upFrom(State),‏ upTo(State) ל-Lifecycle.Event כדי ליצור את Event בהינתן State וכיוון מעבר. הוספנו את השיטה getTargetState() שמספקת את State שאליו יעבור מחזור החיים מיד אחרי Event.
  • withStateAtLeast: נוספו ממשקי API של Lifecycle.withStateAtLeast שממתינים למצב של מחזור חיים ומריצים בלוק קוד שלא מושהה באופן סינכרוני בנקודת השינוי של המצב, ואז ממשיכים עם התוצאה. ממשקי ה-API האלה שונים מהשיטות הקיימות של when* כי הם לא מאפשרים להריץ קוד מושהה ולא משתמשים ב-dispatcher מותאם אישית. (aosp/1326081)
  • ‫ממשקי API של ViewTree: ממשק API חדש של ViewTreeLifecycleOwner.get(View) ו-ViewTreeViewModelStoreOwner.get(View) מאפשר לאחזר את LifecycleOwner ו-ViewModelStoreOwner שמכילים, בהתאמה, בהינתן מופע של View. כדי לאכלס את הנתונים האלה בצורה נכונה, צריך לשדרג לגרסאות Activity 1.2.0 ו-Fragment 1.3.0, ולגרסה AppCompat 1.3.0-alpha01 ואילך. תוספי Kotlin findViewTreeLifecycleOwner ו-findViewTreeViewModelStoreOwner זמינים ב-lifecycle-runtime-ktx וב-lifecycle-viewmodel-ktx, בהתאמה.
  • הוצאה משימוש של תוסף Kotlin של LiveData.observe(): תוסף Kotlin של LiveData.observe() שנדרש כדי להשתמש בתחביר lambda הוצא משימוש כי הוא לא נחוץ כשמשתמשים ב-Kotlin 1.4.

גרסה ‎2.3.0-rc01

‫16 בדצמבר 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-rc01 מופץ. גרסה 2.3.0-rc01 מכילה את השינויים האלה.

תיקוני באגים

  • השיטה keys() של SavedStateHandle עקבית עכשיו לפני ואחרי שמירת המצב – היא כוללת עכשיו מפתחות ששימשו בעבר עם setSavedStateProvider() בנוסף למפתחות ששימשו עם set() ו-getLiveData(). (aosp/1517919, b/174713653)

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

גרסה ‎2.3.0-beta01

‫1 באוקטובר 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-beta01 מופץ. גרסה 2.3.0-beta01 מכילה את השינויים האלה.

שינויים ב-API

  • תוסף Kotlin LiveData.observe() שנדרש כדי להשתמש בתחביר lambda הוצא משימוש, כי הוא לא נחוץ כשמשתמשים ב-Kotlin 1.4. (I40d3f)

תיקוני באגים

שינויים במסמכי התיעוד

  • ה-builder של liveData והמסמכים של asLiveData() עודכנו וכוללים פרטים על שינוי ערכי הזמן הקצוב לתפוגה. (aosp/1122324)

גרסה ‎2.3.0-alpha07

‫19 באוגוסט 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-alpha07 מופץ. גרסה 2.3.0-alpha07 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה בעיה שגרמה לקריסה בבדיקת Lint של NullSafeMutableLiveData. (aosp/1395367)

גרסה ‎2.3.0-alpha06

‫22 ביולי 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-alpha06 מופץ. גרסה 2.3.0-alpha06 מכילה את השינויים האלה.

תכונות חדשות

  • נוספו שיטות עזר סטטיות של downFrom(State),‏ downTo(State),‏ upFrom(State),‏ upTo(State) ל-Lifecycle.Event כדי ליצור את Event בהינתן State וכיוון המעבר. הוספנו את השיטה getTargetState() שמספקת את State שאליו יעבור מחזור החיים מיד אחרי Event. (I00887)
  • נוספו ממשקי API מסוג Lifecycle.withStateAtLeast שממתינים למצב של מחזור חיים ומריצים בלוק קוד שלא מושהה באופן סינכרוני בנקודת השינוי של המצב, ואז ממשיכים עם התוצאה. ממשקי ה-API האלה שונים מהשיטות הקיימות של when* כי הם לא מאפשרים להריץ קוד מושהה ולא משתמשים ב-dispatcher מותאם אישית. (aosp/1326081)

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

  • עכשיו LifecycleRegistry אוכף את DESTROYED כמצב סופי. (I00887)
  • ‫LifecycleRegistry עכשיו מאמת שהשיטות שלו נקראות בשרשור הראשי. זו תמיד הייתה דרישה למחזורי חיים של פעילויות, מקטעים וכו'. הוספה של משקיפים משרשורים שאינם ראשיים גרמה לקריסות שקשה לזהות בזמן הריצה. לאובייקטים מסוג LifecycleRegistry שבבעלות הרכיבים שלכם, אתם יכולים לבטל באופן מפורש את הבדיקות באמצעות LifecycleRegistry.createUnsafe(...), אבל אז אתם צריכים לוודא שיש סנכרון תקין כשניגשים ל-LifecycleRegistry הזה משרשורים שונים (Ie7280,‏ b/137392809)

תיקוני באגים

  • תוקנה קריסה ב-NullSafeMutableLiveData. (b/159987480)
  • תוקנה בעיית ObsoleteLintCustomCheck בבדיקות Lint שכלולות ב-lifecycle-livedata-core-ktx (ובאופן ספציפי NullSafeMutableLiveData). (b/158699265)

גרסה ‎2.3.0-alpha05

‫24 ביוני 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-alpha05 מופץ. גרסה 2.3.0-alpha05 מכילה את השינויים האלה.

תיקוני באגים

  • עכשיו LiveData מטפל טוב יותר במקרים של כניסה חוזרת, ומונע קריאות כפולות אל onActive() או onInactive(). (b/157840298)
  • תוקנה בעיה שבה בדיקות Lint לא פעלו כשמשתמשים ב-Android Studio 4.1 Canary 6 ואילך. (aosp/1331903)

גרסה ‎2.3.0-alpha04

‫10 ביוני 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-alpha04 מופץ. גרסה 2.3.0-alpha04 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה קריסה בבדיקת Lint של NonNullableMutableLiveData. (b/157294666)
  • בדיקת ה-Lint של NonNullableMutableLiveData כוללת עכשיו הרבה יותר מקרים שבהם ערך null הוגדר ב-MutableLiveData עם פרמטר מסוג non-null. (b/156002218)

גרסה ‎2.3.0-alpha03

20 במאי 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-alpha03 מופצים. גרסה 2.3.0-alpha03 מכילה את השינויים האלה.

תכונות חדשות

  • ‫SavedStateHandle תומך עכשיו בסריאליזציה עצלה (lazy serialization) ומאפשר לקרוא ל-setSavedStateProvider() עבור מפתח נתון, ומספק SavedStateProvider שיקבל קריאה חוזרת (callback) ל-saveState() כש-SavedStateHandle יתבקש לשמור את המצב שלו. (b/155106862)
  • ‫API חדש של ViewTreeViewModelStoreOwner.get(View) מאפשר לאחזר את ה-ViewModelStoreOwner שמכיל את המופע של View. כדי לאכלס את הנתונים האלה בצורה נכונה, צריך לשדרג ל-Activity 1.2.0-alpha05, ל-Fragment 1.3.0-alpha05 ול-AppCompat 1.3.0-alpha01. תוסף Kotlin של findViewModelStoreOwner() נוסף אל lifecycle-viewmodel-ktx. (aosp/1295522)

תיקוני באגים

  • תוקנה בעיה שגרמה לכך שבדיקות ה-Lint של MutableLiveData שפורסמו ב-Lifecycle 2.3.0-alpha01 לא פורסמו לצד פריט המידע שנוצר בתהליך פיתוח התוכנה (artifact) של lifecycle-livedata-core-ktx. (b/155323109)

גרסה ‎2.3.0-alpha02

‫29 באפריל 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-alpha02 מופץ. גרסה 2.3.0-alpha02 מכילה את השינויים האלה.

שינויים ב-API

  • עכשיו אפשר להעביר ערך null של Application ל-constructor של SavedStateViewModelFactory כדי לתמוך טוב יותר במקרים שבהם אין ערך זמין ואין צורך בתמיכה ב-AndroidViewModel. (aosp/1285740)

תיקוני באגים

  • שיפור הביצועים של הפעלה קרה על ידי מניעת כשל באימות המחלקה במכשירים עם API 28 ומטה. (aosp/1282118)

גרסה ‎2.3.0-alpha01

‫4 במרץ 2020

‫androidx.lifecycle:lifecycle-*:2.3.0-alpha01 מופץ. גרסה 2.3.0-alpha01 מכילה את השינויים האלה.

תכונות חדשות

  • ‫API חדש של ViewTreeLifecycleOwner.get(View) מאפשר לאחזר את ה-LifecycleOwner שמכיל את המופע של View. כדי לאכלס את הנתונים האלה בצורה נכונה, צריך לשדרג ל-Activity 1.2.0-alpha01 ול-Fragment 1.3.0-alpha01. תוסף Kotlin של findViewTreeLifecycleOwner זמין ב-lifecycle-runtime-ktx. (aosp/1182361,‏ aosp/1182956)
  • הוספנו בדיקת Lint חדשה שמזהירה אתכם כשאתם מגדירים ערך null ב-MutableLiveData שהוגדר ב-Kotlin כ-non-null. האפשרות הזו זמינה כשמשתמשים ברכיבים livedata-core-ktx או livedata-ktx. (aosp/1154723,‏ aosp/1159092)
  • יש פריט מידע חדש של lifecycle-runtime-testing שמספק TestLifecycleOwner שמטמיע את LifecycleOwner ומספק Lifecycle שניתן לשינוי ושהוא thread-safe. (aosp/1242438)

תיקוני באגים

  • עכשיו לקובץ ה-App Bundle lifecycle-runtime יש שם חבילה ייחודי. (aosp/1187196)

גרסה 2.2.0

‫ViewModel-Savedstate גרסה 2.2.0

‫5 בפברואר 2020

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0 מופץ. גרסה 2.2.0 מכילה את השמירות האלה.

‫Lifecycle ViewModel SavedState משתף עכשיו את אותה גרסה כמו פריטי מידע אחרים שנוצרו בתהליך הפיתוח (artifacts) של Lifecycle. ההתנהגות של 2.2.0 זהה להתנהגות של 1.0.0.

גרסה 2.2.0

‫22 בינואר 2020

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

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

  • שילוב של שגרות המשך במחזור החיים: פריט המידע החדש שנוצר lifecycle-runtime-ktx מוסיף שילוב בין מחזור החיים לבין שגרות ההמשך של Kotlin. גם lifecycle-livedata-ktx הורחב כדי לנצל את היתרונות של פונקציות קורוטין. פרטים נוספים זמינים במאמר שימוש בקורוטינות של Kotlin עם רכיבי ארכיטקטורה.
  • הוצאה משימוש של ViewModelProviders.of(): ViewModelProviders.of() הוצא משימוש. אפשר להעביר Fragment או FragmentActivity ל-constructor החדש של ViewModelProvider(ViewModelStoreOwner) כדי להשיג את אותה פונקציונליות כשמשתמשים ב-Fragment 1.2.0.
  • הוצאה משימוש של פריט המידע שנוצר באופן אוטומטי (Artifact) של lifecycle-extensions: בעקבות ההוצאה משימוש של ViewModelProviders.of(), בגרסה הזו יוצא משימוש ה-API האחרון ב-lifecycle-extensions, ועכשיו פריט המידע שנוצר באופן אוטומטי (Artifact) נחשב ככזה שיצא משימוש באופן מלא. מומלץ מאוד להסתמך על פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) הספציפיים של מחזור החיים שאתם צריכים (כמו lifecycle-service אם אתם משתמשים ב-LifecycleService ו-lifecycle-process אם אתם משתמשים ב-ProcessLifecycleOwner) במקום ב-lifecycle-extensions, כי לא תהיה גרסה עתידית של 2.3.0 ל-lifecycle-extensions.
  • מעבד אנוטציות מצטבר של Gradle: מעבד האנוטציות של Lifecycle הוא מצטבר כברירת מחדל. אם האפליקציה כתובה בשפת התכנות Java 8, אפשר להשתמש במקום זאת ב-DefautLifecycleObserver, ואם היא כתובה בשפת התכנות Java 7, אפשר להשתמש ב-LifecycleEventObserver.

גרסה ‎2.2.0-rc03

‫4 בדצמבר 2019

‫androidx.lifecycle:lifecycle-*:2.2.0-rc03 מופץ. גרסה 2.2.0-rc03 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה תקלה שקרתה כש-ViewModel מדומה אוחסן ב-ViewModelStore ונשלחה אליו שאילתה מאוחר יותר עם ברירת המחדל של היצרן.
  • צריך לתקן את השימוש ב-Dispatchers.Main.immediate ב-launchWhenCreated ובשיטות דומות כדי שהקריאה תתבצע באופן סינכרוני במהלך אירוע במחזור חיים תואם. (aosp/1156203)

תכנים שנוספו על ידי גורמים חיצוניים

  • תודה לאנדרס יארלברג (Anders Järleberg) על התיקון. (aosp/1156203)
  • תודה ל-Vsevolod Tolstopyatov מ-Jetbrains על בדיקת ההטמעה של הרצה מוטבעת.

שינויים בתלויות

  • עכשיו Lifecycle Extensions תלוי ב-Fragment 1.2.0-rc03.

גרסה ‎2.2.0-rc02

‫7 בנובמבר 2019

‫androidx.lifecycle:lifecycle-*:2.2.0-rc02 מופץ. גרסה 2.2.0-rc02 מכילה את השינויים האלה.

תיקוני באגים

  • תוקן באג בהגדרת ה-proguard של הספרייה שהשפיע על מכשירים שפועלים עם API 28 ומעלה אם ה-API המטורגט הוא מתחת ל-29. (b/142778206)

גרסה ‎2.2.0-rc01

‫23 באוקטובר 2019

‫androidx.lifecycle:lifecycle-*:2.2.0-rc01 מופץ. גרסה 2.2.0-rc01 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה בעיה שבה launchWhenCreated ושיטות קשורות היו פועלות פריים אחד אחרי שיטת מחזור החיים המשויכת, בגלל השימוש ב-Dispatchers.Main במקום ב-Dispatchers.Main.immediate. (aosp/1145596)

תכנים שנוספו על ידי גורמים חיצוניים

  • תודה ל-Nicklas Ansman על התיקון. (aosp/1145596)

גרסה ‎2.2.0-beta01

‫9 באוקטובר 2019

‫androidx.lifecycle:lifecycle-*:2.2.0-beta01 מופץ. גרסה 2.2.0-beta01 כוללת את השינויים האלה.

תיקוני באגים

  • תוקנה רגרסיה שהוצגה ב-Lifecycle 2.2.0-alpha05 בסדר של ProcessLifecycleOwner ושל LifecycleOwner של הפעילות שעוברים למצב התחלה והמשך במכשירי Android 10. (aosp/1128132)
  • תוקנה רגרסיה שהוצגה ב-Lifecycle 2.2.0-alpha05 שגרמה ל-NullPointerException כשמשתמשים בגרסה 2.0.0 או 2.1.0 של lifecycle-process. (b/141536990)

גרסה ‎2.2.0-alpha05

‫18 בספטמבר 2019

‫androidx.lifecycle:lifecycle-*:2.2.0-alpha05 מופץ. גרסה 2.2.0-alpha05 כוללת את השינויים האלה.

תיקוני באגים

  • תוקן מרוץ תהליכים בכלי לבניית LiveData של פונקציות Coroutine. ‏b/140249349

גרסה ‎2.2.0-alpha04

‫5 בספטמבר 2019

‫androidx.lifecycle:lifecycle-*:2.2.0-alpha04 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

תכונות חדשות

  • ‫lifecycleScope,‏ whenCreated,‏ whenStarted,‏ whenResumed,‏ viewModelScope וההטמעה הבסיסית של liveData משתמשים עכשיו ב-Dispatchers.Main.immediate במקום ב-Dispatchers.Main. (b/139740492)

תכנים שנוספו על ידי גורמים חיצוניים

  • תודה לניקלאס אנסמן על תרומתו למעבר אל Dispatchers.Main.immediate! (aosp/1106073)

גרסה ‎2.2.0-alpha03

‫7 באוגוסט 2019

‫androidx.lifecycle:lifecycle-*:2.2.0-alpha03 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

תכונות חדשות

שינויים ב-API

  • השדה ViewModelProviders.of() הוצא משימוש. כדי להשיג את אותה פונקציונליות, אפשר להעביר Fragment או FragmentActivity ל-constructor החדש של ViewModelProvider(ViewModelStoreOwner). (aosp/1009889)

גרסה ‎2.2.0-alpha02

‫2 ביולי 2019

‫androidx.lifecycle:*:2.2.0-alpha02 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

שינויים ב-API

  • החלפנו את LiveDataScope.initialValue ב-LiveDataScope.latestValue, שיעקוב אחרי הערך הנוכחי שנפלט מהבלוק liveData.
  • נוספה העמסת פונקציות (overload) חדשה ל-builder של liveData שמקבלת את הפרמטר timeout כסוג Duration

גרסה ‎2.2.0-alpha01

‫7 במאי 2019

‫androidx.lifecycle:*:2.2.0-alpha01 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

תכונות חדשות

  • גרסה זו מוסיפה תכונות חדשות שמוסיפות תמיכה בשגרות המשך (coroutine) של Kotlin ל-Lifecycle ול-LiveData. כאן אפשר למצוא מסמכי תיעוד מפורטים לגביהם.

גרסה 1.0.0 של ViewModel-SavedState

גרסה 1.0.0

‫22 בינואר 2020

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0 מופץ. גרסה 1.0.0 מכילה את השינויים האלה.

תכונות חשובות בגרסה 1.0.0

  • נוספה המחלקה החדשה SavedStateHandle. הוא מאפשר למחלקות ViewModel לגשת למצב השמור ולתרום לו. אפשר לקבל את האובייקט הזה ב-constructor של המחלקה ViewModel, וה-factories שסופקו כברירת מחדל על ידי Fragments ו-AppCompatActivity יזריקו את SavedStateHandle באופן אוטומטי.
  • נוסף AbstractSavedStateViewModelFactory. הוא מאפשר ליצור מפעלים בהתאמה אישית ל-ViewModel ולתת להם גישה ל-SavedStateHandle.

‫ViewModel-Savedstate גרסה 1.0.0-rc03

‫4 בדצמבר 2019

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc03 מופץ. גרסה 1.0.0-rc03 מכילה את השינויים האלה.

שינויים בתלויות

  • ‫SavedState של Lifecycle ViewModel תלוי עכשיו ב-Lifecycle 2.2.0-rc03.

Viewmodel-Savedstate גרסה 1.0.0-rc02

‫7 בנובמבר 2019

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc02 מופץ. גרסה 1.0.0-rc02 מכילה את השינויים האלה.

שינויים בתלויות

  • עכשיו תלוי במחזור החיים 2.2.0-rc02.

‫ViewModel-SavedState גרסה 1.0.0-rc01

‫23 באוקטובר 2019

גרסה androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc01 הושקה ללא שינויים מגרסה 1.0.0-beta01. גרסה 1.0.0-rc01 מכילה את השינויים האלה.

‫ViewModel-Savedstate גרסה 1.0.0-beta01

‫9 באוקטובר 2019

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-beta01 מופץ. גרסה 1.0.0-beta01 מכילה את השינויים האלה.

תיקוני באגים

  • תוקנה בעיה שבה גישה ל-SavedState ViewModel בפעם הראשונה ב-Activity.onActivityResult() גרמה ל-IllegalStateException. (b/139093676)
  • תוקנה בעיה ב-IllegalStateException כשמשתמשים ב-AbstractSavedStateViewModelFactory. (b/141225984)

‫ViewModel-SavedState גרסה 1.0.0-alpha05

‫18 בספטמבר 2019

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha05 מופץ. גרסה 1.0.0-alpha05 מכילה את השינויים האלה.

שינויים ב-API

  • ‫SavedStateViewModelFactory כבר לא מרחיב את AbstractSavedStateViewModelFactory, ו-SavedStateHandle נוצר רק עבור ViewModels שביקשו אותו (aosp/1113593)

‫ViewModel-SavedState גרסה 1.0.0-alpha03

‫7 באוגוסט 2019

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha03 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

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

  • הספרייה lifecycle-viewmodel-savedstate לא תלויה יותר בספרייה fragment, וה-constructors הקשורים SavedStateViewModelFactory(Fragment) ו-SavedStateViewModelFactory(FragmentActivity) הוסרו. במקום זאת, SavedStateViewModelFactory הוא עכשיו ברירת המחדל של Activity 1.1.0-alpha02,‏ Fragment 1.2.0-alpha02 ו-Navigation 2.2.0-alpha01. (b/135716331)

‫ViewModel-SavedState גרסה 1.0.0-alpha02

‫2 ביולי 2019

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha02 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

תכונות חדשות

  • נוסף עומס יתר של SavedStateHandle.getLiveData() שמקבל ערך ברירת מחדל.

שינויים ב-API

  • השם של SavedStateVMFactory השתנה לשם SavedStateViewModelFactory.
  • השם של AbstractSavedStateVMFactory השתנה לשם AbstractSavedStateViewModelFactory.

‫ViewModel-Savedstate גרסה 1.0.0-alpha01

‫13 במרץ 2019

‫androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha01 מופץ. כאן אפשר למצוא את יומן ה-commit המלא של הגרסה הראשונית הזו.

תכונות חדשות

  • עכשיו ViewModels יכול לתרום ל-savedstate. כדי לעשות את זה, משתמשים ב-factory SavedStateVMFactory החדש של ViewModel, ול-ViewModel צריך להיות constructor שמקבל אובייקט SavedStateHandle כפרמטר.

גרסה 2.1.0

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

  • הוספנו את LifecycleEventObserver למקרים שבהם נדרש זרם של אירועי מחזור חיים. זהו API ציבורי במקום מחלקת GenericLifecycleObserver מוסתרת.
  • נוספו תוספי ktx ל-methods של LiveData.observe ול-methods של Transformations.*.
  • הוספנו את Transformations.distinctUntilChanged, שיוצר אובייקט LiveData חדש שלא פולט ערך עד שערך המקור LiveData משתנה.
  • הוספנו תמיכה ב-coroutine ב-ViewModels על ידי הוספת מאפיין התוסף ViewModel.viewModelScope.

גרסה 2.1.0

‫5 בספטמבר 2019

‫androidx.lifecycle:lifecycle-*:2.1.0 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

גרסה ‎2.1.0-rc01

‫2 ביולי 2019

גרסה androidx.lifecycle:*:2.1.0-rc01 הושקה ללא שינויים מגרסה androidx.lifecycle:*:2.1.0-beta01. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

גרסה ‎2.1.0-beta01

‫7 במאי 2019

‫androidx.lifecycle:*:2.1.0-beta01 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

תכונות חדשות

  • מחזורי החיים שודרגו לגרסת בטא: ממשק ה-API שהוצג בגרסאות אלפא קודמות, כמו פונקציות של תוספים מסוג liveData לטרנספורמציות ולתצפיות, אתחול של ViewModel עם הקצאת נכסים ועוד, התייצבו ולא ישתנו.

גרסה ‎2.1.0-alpha04

‫3 באפריל 2019

‫androidx.lifecycle:*:2.1.0-alpha04 מופץ. כאן אפשר למצוא את השמירות שנכללות בגרסה הזו.

שינויים ב-API

  • שינוי תוכנה שעלול לגרום לכשל: ה-API הבסיסי של by viewModels() ו-by activityViewModels() שונה כדי לתמוך ישירות ב-ViewModelStore, ולא רק ב-ViewModelStoreOwner. (aosp/932932)

גרסה ‎2.1.0-alpha03

‫13 במרץ 2019

‫androidx.lifecycle:*:2.1.0-alpha03 מופץ. כאן מופיעה הרשימה המלאה של השינויים שנכללים בגרסה הזו.

שינויים ב-API

  • המכשיר ViewModelProvider.KeyedFactory הוסר. הממשק השני, בנוסף ל-ViewModelProvider.Factory, לא התאים לתכונות חדשות כמו הקצאת נכסים ב-Kotlin by viewmodels {}. (aosp/914133)

גרסה ‎2.1.0-alpha02

30 בינואר 2019

‫androidx.lifecycle 2.1.0-alpha02 מופץ.

שינויים ב-API

  • LifecycleRegistry מכיל עכשיו את ה-method‏ setCurrentState() שמחליף את ה-method‏ setState() שהוצא משימוש. (aosp/880715)

תיקוני באגים

  • תוקנה בעיה שבה מופעים מדומים של ViewModel קרסו כש-ViewModelStore שמכיל אותם נמחק. b/122273087

גרסה ‎2.1.0-alpha01

‫17 בדצמבר 2018

‫androidx.lifecycle 2.1.0-alpha01 מופץ.

תכונות חדשות

  • הוספנו את LifecycleEventObserver למקרים שבהם נדרש זרם של אירועי מחזור חיים. זהו API ציבורי במקום מחלקת GenericLifecycleObserver מוסתרת.
  • נוספו תוספי ktx ל-methods של LiveData.observe ול-methods של Transformations.*.
  • השיטה Transformations.distinctUntilChanged נוספה. היא יוצרת אובייקט LiveData חדש שלא פולט ערך עד שערך המקור של LiveData משתנה.
  • תמיכה ב-Coroutine ב-ViewModels: נוסף מאפיין התוסף ViewModel.viewModelScope.
  • נוספה ViewModelProvider.KeyedFactory, פונקציית factory ל-ViewModels שמקבלת את key ואת Class ב-method‏ create.

גרסה 2.0.0

גרסה 2.0.0

‫21 בספטמבר 2018

גרסה 2.0.0 של Lifecycle כוללת תיקון באג אחד מגרסה 2.0.0-rc01 ב-ViewModel.

תיקוני באגים

  • תוקן כלל ProGuard של ViewModel שהסיר בנאים באופן שגוי b/112230489

‫גרסה 2.0.0-beta01

‫2 ביולי 2018

תיקוני באגים

  • תוקן כלל proguard של LifecycleObserver כדי לשמור רק הטמעות, ולא ממשקי משנה b/71389427
  • תוקנו כללי ProGuard של ViewModel כדי לאפשר ערפול קוד וצמצום

גרסאות לפני AndroidX

בגרסאות של Lifecycle שקדמו ל-AndroidX, צריך לכלול את יחסי התלות הבאים:

dependencies {
    def lifecycle_version = "1.1.1"

    // ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
    // alternatively - just LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData).
    //     Support library depends on this lightweight import
    implementation "android.arch.lifecycle:runtime:$lifecycle_version"

    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of compiler
    implementation "android.arch.lifecycle:common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"

    // optional - Test helpers for LiveData
    testImplementation "android.arch.core:core-testing:$lifecycle_version"
}

גרסה 1.1.1

‫21 במרץ 2018

יש רק שינוי קטן אחד: android.arch.core.util.Function הועבר מ-arch:runtime אל arch:common. כך אפשר להשתמש בו בלי תלות בזמן הריצה, למשל ב-paging:common שבהמשך.

‫lifecycle:common הוא תלות של lifecycle:runtime, כך שהשינוי הזה לא משפיע ישירות על lifecycle:runtime, אלא רק על מודולים שתלויים ישירות ב-lifecycle:common, כמו Paging.

גרסה 1.1.0

‫22 בינואר 2018

שינויים באריזה

עכשיו יש יחסי תלות חדשים וקטנים בהרבה:

  • android.arch.lifecycle:livedata:1.1.0
  • android.arch.lifecycle:viewmodel:1.1.0

שינויים ב-API

  • המאפיינים LifecycleActivity ו-LifecycleFragment שהוצאו משימוש הוסרו. צריך להשתמש במאפיינים FragmentActivity,‏ AppCompatActivity או לתמוך במאפיין Fragment.
  • ‫@NonNull הערות נוספו אל ViewModelProviders ואל ViewModelStores
  • ‫ה-constructor של ViewModelProviders הוצא משימוש – צריך להשתמש ישירות בשיטות הסטטיות שלו
  • האפשרות ViewModelProviders.DefaultFactory הוצאה משימוש – צריך להשתמש באפשרות ViewModelProvider.AndroidViewModelFactory
  • ה-method הסטטית ViewModelProvider.AndroidViewModelFactory.getInstance(Application) נוספה כדי לאחזר Factory סטטי שמתאים ליצירת מופעים של ViewModel ו-AndroidViewModel.