מחזור חיים

מחזור חיים

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

הפניית API
androidx.lifecycle

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

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

פריט מידע שנוצר בתהליך פיתוח (Artifact)	גרסה יציבה	גרסה מועמדת להפצה	גרסת בטא	גרסת אלפא
lifecycle-*	2.11.0	-	-	‎2.12.0-alpha03
lifecycle-viewmodel-navigation3	2.11.0	-	-	‎2.12.0-alpha03

הספרייה הזו עודכנה לאחרונה בתאריך: 9 בספטמבר 2026

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

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

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

הוצאנו משימוש את ממשקי ה-API ב-lifecycle-extensions. במקום זאת, מוסיפים תלויות של ארטיפקטים ספציפיים של מחזור החיים שדרושים לכם.

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.11.0"

        // 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.11.0")

        // 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-alpha03

‫9 בספטמבר 2026

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

תיקוני באגים

• ‫compileSdk Compose libraries updated to 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 מכילה את השמירות האלה.

תיקוני באגים

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

גרסה 2.11

גרסה ‎2.11.0

‫17 ביוני 2026

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

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

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

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

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

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

שינויים אחרים – כדי להסיר את הגיבויים של השתקפות, צריך עכשיו להשתמש בממשק המשתמש של כתיבת ההודעה 1.7.0+ ב-LocalLifecycleOwner. כדי לעדכן את Compose 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, נדרשת גרסה 1.7.0 ואילך של Compose UI. הפעולה הזו מסירה חלופות פנימיות של השתקפות, משפרת את הביצועים אבל מחייבת לקוחות לשדרג את התלות שלהם. (I48e65)
• כשמשדרגים ל-Compose Multiplatform 1.11.0, אפשר למנוע כפילות של סמלים בגרסאות ישנות יותר של הסתעפות JetBrains. (Iccd64)
• תוקנה בעיה שבה ViewModels נוקו בצורה שגויה במהלך רה-קומפוזיציה כשמשתמשים ב-rememberViewModelStoreProvider עם פרמטרים לא יציבים שמוגדרים כברירת מחדל. הספק יוצר מחדש רק כשהבעלים של ההורה או המפתח המפורש משתנים. (Ibe296, ‏ b/501792448)

גרסה ‎2.11.0-beta01

‫22 באפריל 2026

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

שינויים ב-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). כך המפתחים יכולים לאחזר ViewModels בצורה נקייה יותר באמצעות key מותאם אישית עם פרמטרים של סוג מאומת ב-Kotlin, בלי הצורך להעביר במפורש את סוג המחלקה. (Ic1f59)
• מוסיפים defaultArgs תמיכה ב-ViewModelStoreProvider כדי לאפשר הפעלה של ViewModels עם ערכי SavedState ברירת מחדל. (I1e933, b/434651920, b/165642391)
• הוצאה משימוש של removeViewModelStoreOnPop ושל ViewModelStoreNavEntryDecoratorDefaults שמשויך אליו. ה-API הזה היה פתרון עקיף לשינויים בהגדרות, שמעכשיו מטופלים באופן פנימי. כל מצב המעצב, כולל ViewModels, חייב להימחק עכשיו בו-זמנית בהצגת חלון קופץ. כדי לשמור את מצב ה-decorator מחוץ למצב שבו מקבץ הפעילויות הקודמות (back stack) מועבר ל-NavDisplay, צריך להשתמש ב-rememberDecoratedNavEntries API. (I852d9)

תיקוני באגים

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

גרסה ‎2.11.0-alpha02

‫11 במרץ 2026

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

Scoped ViewModels

• בגרסה הזו מוצגים ממשקי 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)
• כדי לצמצם את קוד ה-boilerplate כשמרכיבים רכיבי בעלים בהתאמה אישית, מוסיפים פונקציות factory ל-LifecycleOwner, ל-ViewModelStoreOwner ול-SavedStateRegistryOwner. (I9682c)
• מוסיפים פונקציית הרחבה מבוססת-lambda‏ Lifecycle.addObserver כדי לאפשר צפייה באירועים של מחזור החיים בלי ליצור מופע של אובייקט אנונימי. (I94f38)
• הוספת התוספים defaultViewModelProviderFactory ו-defaultViewModelCreationExtras אל ViewModelStoreOwner. הם מספקים גישה בטוחה לברירות מחדל בלי לדרוש בדיקות ידניות של סוגים מול HasDefaultViewModelProviderFactory. (Ifa83d)

שינויים ב-API

• מוסיפים את rememberViewModelStoreOwner כדי ליצור בקלות ViewModelStoreOwnerים עם היקף מוגדר בכלי הכתיבה. הפונקציה הזו מחזירה בעלים שקשור למחזור החיים של רכיב ה-Composable, ומנקה אוטומטית את ה-ViewModels שלו כשרכיב ה-Composable מוסר מממשק המשתמש. (I2a15b, b/165642391)
• מוסיפים את rememberViewModelStoreProvider כדי לאפשר יצירת מופעים של ViewModelStore בהיקף מוגבל ב-Compose. הפונקציה הזו מקשרת מאגר צאצא לבעלים של מאגר אב, וכך מוודאת ש-ViewModels ממשיכים להתקיים שינויים בהגדרות, תוך ניקוי אוטומטי שלהם כשמסירים את ה-Composable מההיררכיה. ‫(I0f57a, ‏ b/165642391)
• מוסיפים ViewModelStoreProvider כדי לנהל מופעים ViewModelStore בהיקף מוגבל. המחלקות האלה מאפשרות ליצור היקפים משניים ששורדים שינויים בהגדרות, אבל אפשר לנקות אותם בנפרד. הוא מספק גם ViewModelStoreOwner wrappers שמקבלים בירושה את הגדרות ברירת המחדל של המפעלים ואת תוספות היצירה מההורה. (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() בשיטות שמוגדרות כ-override. (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
      }
  }
  

• ארטיפקט lifecycle-viewmodel-navigation3 מספק שילוב מוכן מראש ל-Navigation3, ומאפשר להפעיל היקף של מופעי ViewModel למסכים בודדים ('רשומות') באמצעות rememberViewModelStoreNavEntryDecorator() API:

  @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
          }
      }
  }
  

• הוספנו פונקציית builder factory ל-CreationExtras, כדי לספק Kotlin API נוח יותר ואידיומטי יותר.

  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"
     }
  

• הוספנו תמיכה מקורית בסוגים שניתן להגדיר כ-nullable ב-SavedStateHandle.saved, כדי לפשט את השמירה והשחזור של מאפיינים שניתן להגדיר כ-nullable.

• מסמנים את הקונסטרקטורים של 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 עברה רפקטורינג והפכה ממחלקת פונקציה למחלקת מחלקה, כדי לשקף טוב יותר את הפונקציונליות שלה כמפעל של NavEntryDecorator. בנוסף, הפרמטר shouldRemoveViewModelStore של הדקורטור קיבל את השם 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)
• הוספת stubs של KMP ל-lifecycle-viewmodel-navigation3 כדי לאפשר ל-JetBrains לספק forks שממלאים את היעדים האלה וכך לתמוך ב-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 composable יכול עכשיו ליצור מחזור חיים עצמאי של רכיב הבסיס. אם מגדירים את 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

• ב-composable‏ LifecycleOwner, הפרמטר parentLifecycleOwner נקרא עכשיו parent. (I080bc)

תיקוני באגים

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

חישוב צריכת הנתונים

• הסרת שדות גיבוי פנימיים מיותרים מ-LifecycleOwner. תודה ל-Jake Wharton על התרומה. (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

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

גרסה 2.9

גרסה 2.9.4

‫17 בספטמבר 2025

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

תיקוני באגים

• תוקנה שגיאה שגרמה לכך שהתוסף Compose Compiler לא הוחל, ולכן ארטיפקטים של 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. התכונה 'מחזור חיים' תומכת עכשיו בפלטפורמות הבאות: JVM (Android ומחשבים), Native (Linux,‏ iOS,‏ watchOS,‏ macOS,‏ MinGW) ו-Web (JavaScript,‏ WasmJS). (I0a0e4)

תיקוני באגים

• עדכון androidx.annotation לגרסה 1.9.1 (Ic9e4f, b/397701294)

גרסה 2.9.2

‫16 ביולי 2025

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

תיקוני באגים

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

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

• הספרייה Lifecycle תלויה עכשיו ב-Annotation 1.9.1 כדי לאפשר תמיכה ביעדי KMP חדשים (Ic9e4f, ‏ b/397701294).

גרסה 2.9.1

‫4 ביוני 2025

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

תיקוני באגים

• תיקון של 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

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

תמיכה ב-KotlinX Serialization

• הוספנו תמיכה ב-KotlinX Serialization ב-SavedState 1.3.0, והשקנו את saved, נציג מאפיינים עצלן, כדי לאפשר לכם לאחסן בקלות מחלקות @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 Desktop ו-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 Compatibility Warning

• חברת 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 ומעלה – הארטיפקטים של -desktop הוסרו ועכשיו יש ארטיפקטים של -jvmStubs ו--linuxx64Stubs. היעדים האלה לא מיועדים לשימוש, אלא הם משמשים כ-placeholder כדי לתמוך במאמצים של 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 כדי לוודא ששינויים במצב Lifecycle גורמים לרה-קומפוזיציה בצורה נכונה. תודה, Steven Schoen! (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

• החלפת פונקציות מואצלות בעלות עומס יתר 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 כדי לדמות את התהליך System Process Death וליצור מחדש את ViewModel שנבדק ואת כל הרכיבים המשויכים. (Id6a69, b/381063087)
• עכשיו אפשר לפתור מקרים של מופעים של LifecycleOwner ושל ViewModelStoreOwner שאוחזרו באמצעות ממשקי ה-findViewTree API המתאימים שלהם, באמצעות הורים מנותקים של תצוגה, כמו 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, נציג מאפיינים עצלן, כדי לאפשר לכם לאחסן בקלות מחלקות @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 מכילה את השמירות האלה.

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

תיקוני באגים

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

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

• ‫Lifecycle 2.8.6: ‏Lifecycle Runtime Compose תלוי עכשיו ב-Compose Runtime 1.7.1
• זמן הריצה של מחזור החיים תלוי עכשיו ב-ProfileInstaller 1.4.0

גרסה ‎2.9.0-alpha02

‫4 בספטמבר 2024

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

תיקוני באגים

• בקטע Lifecycle 2.8.5: מעדכנים את כללי androidx.lifecycle.ReportFragment ProGuard כדי לאפשר הסתרה . (ff898e1)

חישוב צריכת הנתונים

• מעבירים את androidx.compose.ui.platform.LocalLifecycleOwner אל קבוצת מקורות משותפת (KMP). תודה לאיוון מטקוב מ-JetBrains על התרומה. (8cd5d03)
• מתוך Lifecycle 2.8.5: נציג ההרחבה SavedStateHandle.saveable` תומך עכשיו בערכים שניתן להגדיר כ-nullable. תודה ל-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 target ‏ (I139d3, ‏ b/338268719)

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.8

גרסה 2.8.7

‫30 באוקטובר 2024

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

שינויים ב-API

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

גרסה 2.8.6

‫18 בספטמבר 2024

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

תיקוני באגים

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

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

• ‫Lifecycle Runtime Compose תלוי עכשיו ב-Compose Runtime 1.7.1

גרסה 2.8.5

‫4 בספטמבר 2024

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

תיקוני באגים

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

חישוב צריכת הנתונים

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

גרסה 2.8.4

‫24 ביולי 2024

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

תיקוני באגים

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

תיקוני באגים

• תוקנו שגיאות 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 מכילה את השמירות האלה.

תיקוני באגים

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

גרסה 2.8.0

‫14 במאי 2024

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

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

• ‫LocalLifecycleOwner הועבר מ-Compose UI אל lifecycle-runtime-compose כדי שאפשר יהיה להשתמש בממשקי העזר מבוססי-Compose שלו מחוץ ל-Compose UI.
• ארטיפקט lifecycle-runtime-compose מכיל עכשיו את ממשקי ה-API‏ dropUnlessResumed ו-dropUnlessStarted, שמאפשרים לכם להפסיק מעקב אחרי קליקים או אירועים אחרים שמתרחשים גם אחרי שערך LifecycleOwner יורד מתחת לערך Lifecycle.State שצוין. לדוגמה, אפשר להשתמש ב-Compose Navigation כדי להימנע מטיפול באירועי קליקים אחרי שהתחילה כבר העברה למסך אחר: 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 ללא מפתח היא עכשיו שגיאה, בהתאם לאותה קונבנציה כמו ב-DisposableEffect API, שהממשקי API האלה משקפים.

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

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

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

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

ממשקי ה-API העיקריים של מחזור החיים ב-Lifecycle,‏ LifecycleOwner,‏ LifecycleObserver,‏ Lifecycle.State,‏ Lifecycle.Event ו-LifecycleRegistry נשלחים עכשיו בארטיפקטים שתואמים ל-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

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

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

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

• הפעולה של יצירת מופע ViewModelProvider מתבצעת עכשיו באמצעות ה-methods‏ ViewModelProvider.create() ולא באמצעות קריאה ישירה ל-constructor שלו.
• ViewModelProvider.NewInstanceFactory ו-ViewModelProvider.AndroidViewModelFactory זמינים רק ב-Android.
  • מומלץ להשתמש ב-Custom Factories כדי להרחיב את ViewModelProvider.Factory ולהשתמש בשיטה create שמקבלת CreationExtras או להשתמש ב-Kotlin DSL‏ viewModelFactory.
• שימוש ב-ViewModelProvider ללא מפעל בהתאמה אישית בפלטפורמות שאינן JVM יגרום ל-UnsupportedOperationException. בפלטפורמות JVM, התאימות נשמרת באמצעות שימוש בבונה 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 (כולל פונקציית הבנייה viewModelFactory) יחזיר עכשיו IllegalArgumentException אם כבר נוסף initializer עם אותו clazz: KClass<VM : ViewModel>. (Ic3a36)

בעיות מוכרות

• לlifecycle-*:2.8.0 נדרשת גרסת מינימום של Compose‏ 1.7.0-alpha05 (b/336842920).

גרסה ‎2.8.0-rc01

‫1 במאי 2024

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

תיקוני באגים

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

חישוב צריכת הנתונים

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

גרסה ‎2.8.0-beta01

‫17 באפריל 2024

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

תכונות חדשות

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

גרסה ‎2.8.0-alpha04

‫3 באפריל 2024

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

תכונות חדשות

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

תיקוני באגים

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

עדכון תלות

• ארטיפקט lifecycle-viewmodel-compose תלוי עכשיו ב-Compose 1.6.0.
• מחזור החיים תלוי עכשיו ב-Profile Installer 1.3.1.

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

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

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

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

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

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

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

תיקוני באגים

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

חישוב צריכת הנתונים

• ‫LocalLifecycleOwner הועבר מ-Compose UI אל lifecycle-runtime-compose כדי שאפשר יהיה להשתמש בממשקי העזר מבוססי-Compose שלו מחוץ ל-Compose UI. תודה ל-Jake Wharton על התרומה. (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)
• התוספים של lifecycle-viewmodel-ktx kotlin הועברו עכשיו למודול מחזור החיים הבסיסי. (Id787b, ‏ b/274800183)
• התוספים של lifecycle-runtime-ktx kotlin הועברו עכשיו למודול מחזור החיים הבסיסי. (Ic3686, b/274800183)
• התוספים של lifecycle-livedata-core-ktx kotlin הועברו עכשיו למודול מחזור החיים הבסיסי. ‫(I54a3d, b/274800183)

תאימות ל-Kotlin Multiplatform

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

שינויים ב-API

• קריאה ל-LifecycleStartEffect ול-LifecycleResumeEffect ללא מפתח היא עכשיו שגיאה, בהתאם לאותה קונבנציה כמו ב-DisposableEffect API, שהממשקי 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() שמוודאת ששינוי המצב וכל הקריאות החוזרות (callback) של LifecycleObserver הושלמו לפני החזרה. חשוב לציין שבניגוד להגדרת המאפיין currentState ישירות, הפעולה הזו לא משתמשת ב-runBlocking, ולכן אפשר להשתמש בה בבטחה בתוך קורוטינה כמו זו שמסופקת על ידי runTest.
• התוספים LiveData של map ושל switchMap משקפים עכשיו את ההתנהגות של distinctUntilChanged – אם ל-LiveData מוגדר value, הפונקציה map/switchMap תופעל באופן מיידי כדי לאכלס את value של LiveData שמוחזר. ההגדרה הזו מבטיחה שהערך הראשוני יוגדר כחלק מהקומפוזיציה הראשונה (כשמשתמשים בה עם observeAsState()), אבל היא לא משנה את התנהגות התצפית – עדיין יחולו רק עדכונים של ערכים מהמקור LiveData אחרי שתתחילו לצפות ב-LiveData.
• בגרסה הזו תוקנה בעיה שבה SavedStateHandle לא שחזר כמו שצריך מחלקות Parcelable מותאמות אישית אחרי השבתת תהליך ויצירה מחדש. בגלל מידע על סוגים שאבד ב-Android framework, מערכים של Parcelables מותאמים אישית דורשים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון), והמסמכים בנושא get, getLiveData ו-getStateFlow מציינים עכשיו במפורש את המגבלה הזו.
• הוסרו כללי השמירה של proguard שמשויכים ל-LifecycleObserver. המשמעות היא שקוד שעבר ProGuard ורוצה להשתמש בממשקי API באמצעות רפלקציה (למשל באמצעות ההערה @OnLifecycleEvent שהוצאה משימוש לפני זמן רב) יצטרך לספק כללי שמירה משלו לתרחיש השימוש הספציפי שלו.

Lifecycle Event Observability

• במקום להשתמש ב-LifecycleEventObserver, אפשר עכשיו לצפות ב-Flow של Lifecycle.Event באמצעות שיטת ההרחבה 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 מותאמות אישית אחרי השבתת תהליך ויצירה מחדש. בגלל מידע על סוגים שאבד ב-Android framework, מערכים של Parcelable מותאמים אישית דורשים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון), ובמסמכי התיעוד בנושא 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 כשנמצאים בתוך שגרת המשך (coroutine). בדיקת 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 מתוך קורוטינה כמו זו שמסופקת על ידי 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)
• ‫ViewModel's addCloseable() now immediately closes the Closeable if the ViewModel has already received a call to 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 באמצעות Lifecycle.currentStateFlow, שמחזיר StateFlow כאשר value הוא Lifecycle.State הנוכחי. (Ib212d, b/209684871)
• Lifecycle.Events can now able to be observed as a Flow with Lifecycle.asFlow(). (If2c0f, b/176311030)
• LifecycleResumeEffect נוסף API להרצת רכיבי Compose SideEffects על סמך קריאות חוזרות (callback) של אירועים מסוג Lifecycle.Event.ON_RESUME ו-Lifecycle.Event.ON_PAUSE. (I60386, ‏ b/235529345)
• LifecycleStartEffect נוסף API להרצת רכיבי Compose SideEffects על סמך קריאות חוזרות (callback) של אירועים Lifecycle.Event.ON_START ו-Lifecycle.Event.ON_STOP. (I5a8d1, b/235529345)
• LifecycleEventEffect נוסף API להפעלת יצירת SideEffects ב-Compose על סמך Lifecycle.Event. (Ic9794, ‏ b/235529345)
• תוסף אחד (Lifecycle.collectAsState()) נוסף כדי לחשוף ישירות את Lifecycle.State כ-State בכתיבת אימייל. הפונקציה הזו שוות ערך לפונקציה 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 מכילה את השמירות האלה.

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

• ‫lifecycle-viewmodel-savedstate תלוי עכשיו ב-SavedState 1.2.1. (cd7251)
• מחזור החיים תלוי עכשיו ב-ProfileInstaller 1.3.0. (f9d30b)

גרסה 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 כולל עכשיו בנאי להגדרת ערך התחלתי.
• נוספה תוסף חדש ב-StateFlow וב-Flow של collectAsStateWithLifecycle() שאוסף נתונים מתוך תהליכים ומציג את הערך האחרון שלו כ-Compose State באופן שמתחשב במחזור החיים.
• השיטות Lifecycle.launchWhenX ו-Lifecycle.whenX הוצאו משימוש כי השימוש ב-dispatcher להשהיה עלול לגרום לבזבוז משאבים במקרים מסוימים. מומלץ להשתמש ב-Lifecycle.repeatOnLifecycle. מידע נוסף על השעיה חד-פעמית של עבודה זמין בהסבר הזה על הסיבות לכך שהפעולה הזו לא בטוחה.
• המרת Kotlin – מספר גדול של מחלקות Lifecycle הומרו ל-Kotlin. כל הכיתות שהומרו עדיין שומרות על התאימות הבינארית שלהן לגרסאות קודמות. במחלקות הבאות יש שינויים שלא תואמים למקור עבור מחלקות שנכתבו ב-Kotlin: ‏ViewTreeLifecycleOwner, ‏LiveDataReactiveStreams, ‏HasDefaultViewModelProviderFactory, ‏ViewTreeViewModelStoreOwner, ‏Transformations, ‏ViewModelStoreOwner, ‏LifecycleOwner

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

Lifecycle 2.5	מחזור חיים 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) של שיטת onChanged של Observer שנוצר ב-Kotlin תואם עכשיו למאפיין המציין אם ערך יכול להיות ריק (nullability) של הסוג הגנרי. אם רוצים ש-Observer.onChanged() יקבל סוג שניתן להקצאה, צריך ליצור מופע של Observer עם סוג שניתן להקצאה.
• גם המחלקות האלה הומרו ל-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 הועבר מ-lifecycle-runtime-ktx לארטיפקט lifecycle-common. (I41d78, b/240298691)
• התוסף Kotlin ב-Lifecycle שמספק את השדה coroutineScope הועבר מ-lifecycle-runtime-ktx לארטיפקט lifecycle-common. (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, שהיה זמין בעבר רק כשמשתמשים ב-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() עם סוג לא נכון של class. (I6ae7c)

גרסה ‎2.6.0-alpha03

24 באוקטובר 2022

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

תיקוני באגים

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

תיקוני באגים

• פריטי מידע שנוצרו בתהליך פיתוח (Artifact) של Lifecycle כוללים עכשיו אילוצים שמבטיחים שכל פריטי המידע שנוצרו בתהליך פיתוח שקשורים למחזור החיים משתמשים באותה גרסה, ומשדרגים אוטומטית תלויות אחרות כשמשדרגים אחת מהן. b/242871265
• ‫FlowLiveData.asFlow() יוצרת עכשיו callbackFlow במקום להשתמש בהטמעה משלה של Channel כדי להבטיח בטיחות בשרשור ושמירה על ההקשר. (I4a8b2, ‏ b/200596935)
• הפונקציה FlowLiveData של asLiveData תשמור עכשיו את הערך הראשוני של StateFlow כשיוצרים את האובייקט החדש LiveData. (I3f530, b/157380488)
• מתוך מחזור החיים 2.5.1: הטמעות בהתאמה אישית של AndroidViewModelFactory קוראות עכשיו בצורה נכונה לפונקציה create(modelClass) כשמשתמשים בבונה עם שמירת מצב עם 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 State באופן שמתחשב במחזור החיים. הנתונים של ה-Flow נאספים והערך של הפליטה החדשה מוגדר לערך של ה-State כשהמחזור החיים נמצא לפחות בשלב מסוים Lifecycle.State. אם מחזור החיים יורד מתחת לערך Lifecycle.State, איסוף הנתונים בתהליך מופסק והערך של המצב לא מתעדכן. ‫(I1856e, b/230557927)

גרסה 2.5

גרסה 2.5.1

‫27 ביולי 2022

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

תיקוני באגים

• הטמעות מותאמות אישית של AndroidViewModelFactory קוראות עכשיו בצורה נכונה לפונקציה create(modelClass) כשמשתמשים בבונה 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() שמחזיר Kotlin StateFlow למעקב אחרי שינויים בערכים, כחלופה לשימוש ב-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 באמצעות מאתחלי lambda אחד או יותר, אחד לכל מחלקה ספציפית של ViewModel שהמפעל המותאם אישית שלכם תומך בה, באמצעות 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 עכשיו יש viewModel() API שמקבל פונקציית למדה ליצירת מופע 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 Integration – ארטיפקט 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()
     }
  }
  

  אפשר להשתמש בו בViewModel constructor תוך שמירה על אותו משך חיים כמו 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 מצורף observer.
• מעכשיו, כשמגיעים למצב DESTROYED, המערכת תמחק את רשימת הצופים של LifecycleRegistry.

גרסה ‎2.5.0-rc02

‫15 ביוני 2022

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

תיקוני באגים

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

גרסה ‎2.5.0-rc01

‫11 במאי 2022

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

תיקוני באגים

• ‫MediatorLiveData.addSource() throws a NullPointerException when passed a null source instead of propagating the null source to observers.(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 כשמשתמשים בכמה מחסניות חזרה. (I11bd5, ‏ b/228865698)

גרסה ‎2.5.0-alpha06

‫6 באפריל 2022

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

תכונות חדשות

• ‫Add experimental MutableState overload to SavedStateHandle.saveable for parity with 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)

תיקוני באגים

• SavedStateViewFactory תומך עכשיו בשימוש ב-CreationExtras גם אם הוא אותחל באמצעות 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() שמחזיר Kotlin StateFlow למעקב אחרי שינויים בערכים כחלופה לשימוש ב-LiveData. (Iad3ab, b/178037961)

גרסה ‎2.5.0-alpha03

23 בפברואר 2022

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

תכונות חדשות

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

שינויים ב-API

• עכשיו אפשר ליצור ViewModel עם CreationExtras דרך lifecycle-viewmodel-compose. ‫(I08887, ‏ b/216688927)

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

• ניסיון להעביר את Lifecycle.State מ-INITIALIZED אל DESTROYED תמיד יחזיר עכשיו IllegalStateException, בלי קשר לשאלה אם ל-Lifecycle מצורף observer. (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. כך שיפרנו את האפשרות להגדיר ערך null לסוגים הגנריים בשתי המחלקות. (Ib6ce2, b/216168263, I9647a, b/177667711)
• הפרמטר LiveData של הפונקציה switchMap יכול עכשיו להחזיר פלט שניתן להקצאה ל-null. ‫(I40396, ‏ b/132923666)
• התוספים LiveData -ktx מסומנים עכשיו ב-@CheckResult כדי לוודא שהתוצאה תהיה בשימוש כשקוראים לפונקציות האלה. (Ia0f05, ‏ b/207325134)

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

• ‫SavedStateHandle מאחסן עכשיו את defaultValue בצורה תקינה כשלא קיים ערך למפתח שצוין. ‫(I1c6ce, ‏ b/178510877)

תיקוני באגים

• מתוך מחזור החיים 2.4.1: עודכן lifecycle-process כך שיהיה תלוי ב-Startup 1.1.1 כדי להבטיח שתיקונים שמונעים מ-ProcessLifecycleInitializer להציג את StartupException יהיו זמינים כברירת מחדל. (Ib01df, b/216490724)
• עכשיו מוצגת הודעת שגיאה משופרת אם לשיעורים מותאמים אישית מסוג AndroidViewModel יש פרמטרים בסדר שגוי, ומנסים ליצור ViewModel. (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 שכל אחת מהן מוסיפה פונקציונליות נוספת (מאפשרת פרמטר של constructor של Application באמצעות AndroidViewModelFactory, מאפשרת פרמטר של constructor של SavedStateHandle באמצעות SavedStateViewModelFactory ו-AbstractSavedStateViewModelFactory וכו'), אנחנו עוברים לעולם של פקטורי (factory) בלי שמירת מצב שמסתמכים על קונספט חדש, CreationExtras. (Ia7343, ‏ b/188691010, ‏ b/188541057)

בעקבות השינוי הזה, ViewModelProvider לא מבצע יותר קריאות ישירות לשיטה הקודמת 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 אחד שזקוק לו. (Ia6654, ‏ b/188541057)

אפשר לספק CreationExtras בהתאמה אישית על ידי החלפת getDefaultViewModelCreationExtras() ב-ComponentActivity או ב-Fragment, וכך להפוך אותם לזמינים ב-ViewModelProvider.Factory בהתאמה אישית כסוג מוטמע של הזרקה בעזרת AI. התוספים האלה יהיו זמינים באופן אוטומטי ל-Factory בהתאמה אישית כשמשתמשים בהם ישירות עם ViewModelProvider או כשמשתמשים בתוספי המאפיינים של Kotlin‏ by viewModels() ו-by activityViewModels(). (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 מכילה את השמירות האלה.

תיקוני באגים

• בוצעה העברה חוזרת מ-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() composable ו-LocalViewModelStoreOwner.
  • שינוי שגורם לבעיות בקוד המקור: הקוד של ViewModelProvider נכתב מחדש ב-Kotlin. השיטה ViewModelProvider.Factory.create לא מאפשרת יותר ערך גנרי שניתן לאיפוס.
• נוסף API חדש של קורוטינות ל-androidx.lifecycle:lifecycle-runtime-ktx:
• ‫Lifecycle.repeatOnLifecycle, API שמבצע בלוק קוד ב-Coroutine כשה-Lifecycle נמצא לפחות במצב מסוים. החסימה תבוטל ותופעל מחדש כשהמצב ישתנה ויחזור למצב היעד.
• ‫Flow.flowWithLifecycle, API שפולט ערכים מ-Flow במעלה הזרם כשהמחזור החיים נמצא לפחות במצב מסוים.
• הפריט 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. השיטה ViewModelProvider.Factory.create לא מאפשרת יותר ערך גנרי שניתן לאיפוס. (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 הוסר לטובת Lifecycle.repeatOnLifecycle, שמתחשב במקביליות מובנית וקל יותר להבנה. (I4a3a8)
• הופכים את ProcessLifecycleInitializer לציבורי כדי שandroidx.startup.Initializers אחרים יוכלו להשתמש בו כתלות. (I94c31)

תיקוני באגים

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

חישוב צריכת הנתונים

• תודה ל-maxsav על שיפור הבדיקה של NullSafeMutableLiveData lint. (#147, ‏ b/183696616)
• תודה ל-kozaxinan על שיפור הבדיקה של NullSafeMutableLiveData lint. (מס' 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

• נוסף Flow.flowWithLifecycle API שפולט ערכים מ-Flow במעלה הזרם כשהמחזור החיים נמצא לפחות במצב מסוים באמצעות Lifecycle.repeatOnLifecycle API. זוהי חלופה ל-LifecycleOwner.addRepeatinJob API, שהוא גם חדש. (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)

הערה: זהו שינוי בינארי שובר תאימות – אתם חייבים לשדרג ל-Hilt-Navigation-Compose 1.0.0-alpha03 ול-Navigation Compose 2.4.0-alpha03. יכול להיות שזה שינוי שובר תאימות למקור אם לא ציינתם את key = כשנעזרתם ב-viewModel(key, factory). צריך להשתמש בארגומנטים עם שם: viewModel(key = key, factory = factory).

גרסה ‎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 שניתן להגדיר כ-nullable, כדי לקבוע בצורה טובה יותר אם 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-alpha02 של Lifecycle ViewModel Compose תואמת רק לגרסה ‎1.0.0-beta01 של Compose.

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

‫10 בפברואר 2021

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

תכונות חדשות

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

הערה: גרסה 1.0.0-alpha01 של Lifecycle ViewModel Compose תואמת רק לגרסה 1.0.0-alpha12 של Compose.

גרסה 2.3.1

גרסה 2.3.1 של Lifecycle

‫24 במרץ 2021

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

תיקוני באגים

• עכשיו אפשר להשתמש בכלל 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 שיקבל קריאה חוזרת ל-saveState() כשמבקשים מ-SavedStateHandle לשמור את המצב שלו. מידע נוסף מופיע במאמר בנושא שמירת מחלקות שלא ניתן להעביר.
• אכיפה של התנהגות במחזור החיים:
  • החל מגרסה LifecycleRegistry DESTROYED היא מצב סופי.
  • ‫LifecycleRegistry מאמת עכשיו שהשיטות שלו נקראות בשרשור הראשי. הדרישה הזו תמיד הייתה קיימת במחזורי החיים של פעילויות, מקטעים וכו'. הוספה של observers משרשורים שאינם השרשור הראשי גרמה לקריסות בזמן הריצה שהיה קשה לאתר. עבור אובייקטים LifecycleRegistry שבבעלות הרכיבים שלכם, אתם יכולים לבטל את ההצטרפות לבדיקות באופן מפורש באמצעות LifecycleRegistry.createUnsafe(...), אבל אז אתם צריכים לוודא שמתבצע סנכרון תקין כשניגשים אל LifecycleRegistry משרשורים שונים.
• Lifecycle State and Event Helpers: הוספנו שיטות עזר סטטיות של downFrom(State), downTo(State), upFrom(State), upTo(State) ל-Lifecycle.Event כדי ליצור את Event בהינתן State וכיוון המעבר. נוספה השיטה getTargetState() שמספקת את State שאליו מחזור החיים יעבור ישירות אחרי Event.
• ‫withStateAtLeast: נוספו ממשקי API של Lifecycle.withStateAtLeast שממתינים למצב של מחזור חיים ומריצים בלוק קוד לא מושהה באופן סינכרוני בנקודת שינוי המצב, ואז ממשיכים עם התוצאה. ממשקי ה-API האלה שונים משיטות when* הקיימות, כי הם לא מאפשרים להריץ קוד השהיה ולא משתמשים בשיטת שליחה מותאמת אישית. (aosp/1326081)
• ‫ViewTree APIs: ממשקי 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, בהתאמה.
• LiveData.observe() הוצאה משימוש של תוסף Kotlin: תוסף LiveData.observe() Kotlin שנדרש לשימוש בתחביר 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)

חישוב צריכת הנתונים

• ממשקי ה-API להשהיית קורוטינות עם מודעות למחזור החיים מטפלים עכשיו טוב יותר בקריאות ל-yield(). תודה לניקלאס אנסמן גירץ! (aosp/1430830, b/168777346)

גרסה ‎2.3.0-beta01

‫1 באוקטובר 2020

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

שינויים ב-API

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

תיקוני באגים

• שדרוג androidx לשימוש ב-Kotlin 1.4 ‏ (Id6471, ‏ b/165307851, ‏ b/165300826)

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

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

גרסה ‎2.3.0-alpha07

‫19 באוגוסט 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha06

22 ביולי 2020

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

תכונות חדשות

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

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

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha03

20 במאי 2020

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

תכונות חדשות

• ‫SavedStateHandle תומך עכשיו בסריאליזציה עצלה. אפשר לקרוא ל-setSavedStateProvider() עבור מפתח נתון, ולספק SavedStateProvider שיקבל קריאה חוזרת ל-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)

תיקוני באגים

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

גרסה ‎2.3.0-alpha02

29 באפריל 2020

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

שינויים ב-API

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

תיקוני באגים

• שיפור הביצועים של הפעלה במצב התחלתי (cold start) על ידי מניעת כשל באימות המחלקה במכשירים עם 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 כערך שאינו null. האפשרות הזו זמינה כשמשתמשים בארטיפקטים livedata-core-ktx או livedata-ktx. (aosp/1154723, aosp/1159092)
• יש ארטיפקט חדש של lifecycle-runtime-testing שמספק TestLifecycleOwner שמטמיע את LifecycleOwner ומספק Lifecycle שניתן לשינוי ובטוח לשימוש בשרשור. (aosp/1242438)

תיקוני באגים

• לארטיפקט lifecycle-runtime יש עכשיו שם חבילה ייחודי. (aosp/1187196)

הערה: בהתאם לעדכונים של מחזור החיים 2.2.0, ארטיפקט lifecycle-extensions לא מתפרסם יותר.

גרסה 2.2.0

ViewModel-Savedstate גרסה 2.2.0

‫5 בפברואר 2020

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

‫ViewModel SavedState של מחזור החיים חולק עכשיו את אותה גרסה כמו ארטיפקטים אחרים של מחזור החיים. ההתנהגות של 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 coroutines עם רכיבי ארכיטקטורה.
• הוצאה משימוש של ViewModelProviders.of(): ViewModelProviders.of() הוצא משימוש. אפשר להעביר Fragment או FragmentActivity לקונסטרוקטור החדש ViewModelProvider(ViewModelStoreOwner) כדי להשיג את אותה הפונקציונליות כשמשתמשים ב-Fragment 1.2.0.
• lifecycle-extensions הוצאה משימוש של ארטיפקט: בעקבות ההוצאה משימוש של ViewModelProviders.of() שצוינה למעלה, בגרסה הזו אנחנו מוציאים משימוש את ה-API האחרון ב-lifecycle-extensions, ולכן הארטיפקט הזה יוצא משימוש באופן מלא. מומלץ מאוד להסתמך על ארטיפקטים ספציפיים של מחזור החיים שאתם צריכים (למשל lifecycle-service אם אתם משתמשים ב-LifecycleService ו-lifecycle-process אם אתם משתמשים ב-ProcessLifecycleOwner) ולא על lifecycle-extensions, כי לא תהיה גרסה עתידית של 2.3.0 ל-lifecycle-extensions.
• ‫Gradle Incremental Annotation Processor: כברירת מחדל, מעבד האנוטציות של 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)

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

• תודה לאנדרס יארלברג על התרומה לתיקון! (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)

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

• תודה לניקלאס אנסמן על התרומה לתיקון! (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 שעוברת למצב started ו-resumed במכשירי 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 של קורוטינה. 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 מופץ. כאן אפשר לראות את השמירות שכלולות בגרסה הזו.

תכונות חדשות

• הטמעות של ViewModelStoreOwner יכולות עכשיו להטמיע באופן אופציונלי את HasDefaultViewModelProviderFactory כדי לספק ViewModelProvider.Factory כברירת מחדל. הפעולה הזו בוצעה עבור Activity 1.1.0-alpha02,‏ Fragment 1.2.0-alpha02 ו-Navigation 2.2.0-alpha01. ‫(aosp/1092370, ‏ b/135716331)

שינויים ב-API

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

גרסה ‎2.2.0-alpha02

‫2 ביולי 2019

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

שינויים ב-API

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

גרסה ‎2.2.0-alpha01

‫7 במאי 2019

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

תכונות חדשות

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

‫ViewModel-SavedState גרסה 1.0.0

גרסה 1.0.0

‫22 בינואר 2020

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

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

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

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

• ‫Lifecycle ViewModel SavedState תלוי עכשיו ב-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 מכילה את השמירות האלה.

תיקוני באגים

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

תכונות חדשות

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

גרסה 2.1.0

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

• נוסף LifecycleEventObserver למקרים שבהם נדרש זרם של אירועים במחזור החיים. זהו API ציבורי במקום מחלקה מוסתרת של GenericLifecycleObserver.
• נוספו תוספי ktx ל-methods‏ LiveData.observe ול-methods‏ Transformations.*.
• נוספה הפונקציה Transformations.distinctUntilChanged, שיוצרת אובייקט LiveData חדש שלא פולט ערך עד שהערך של המקור LiveData משתנה.
• הוספנו תמיכה ב-coroutines ב-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 עבר לשלב בטא: ממשקי API שהוצגו בגרסאות אלפא קודמות, כמו liveData פונקציות הרחבה לטרנספורמציות ותצפיות, ViewModel אתחול עם הקצאת מאפיינים ואחרים, עברו לייצוב ולא ישתנו.

גרסה ‎2.1.0-alpha04

‫3 באפריל 2019

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

הערה: lifecycle-viewmodel-ktx לא תואם ל-Activity 1.0.0-alpha01 עד 1.0.0-alpha05 ול-Fragment 1.1.0-alpha01 עד 1.1.0-alpha05. מומלץ לשדרג לגרסה Activity 1.0.0-alpha06 ולגרסה Fragment 1.1.0-alpha06, בהתאמה.

שינויים ב-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) ליצירת ViewModel שמקבלת את key ואת Class בשיטה create.

גרסה 2.0.0

גרסה 2.0.0

‫21 בספטמבר 2018

‫Lifecycle 2.0.0 יוצא עם תיקון באג אחד מ-2.0.0-rc01 ב-ViewModel.

תיקוני באגים

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

גרסה ‎2.0.0-beta01

‫2 ביולי 2018

תיקוני באגים

• תוקן כלל LifecycleObserver proguard כדי לשמור רק על הטמעות, ולא על ממשקי משנה 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

הערה: התוסף Lifecycle Extensions 1.0.0 (android.arch.lifecycle:extensions:1.0.0) לא תואם ל-livedata:1.1.0 או ל-viewmodel:1.1.0. מומלץ לעדכן לגרסה extensions:1.1.0, שכוללת תלות טרנזיטיבית ב-livedata:1.1.0 וב-viewmodel 1.1.0.

הערה: עכשיו android.arch.lifecycle:reactivestreams:1.1.0 תלוי רק ב-android.arch.lifecycle:livedata:1.1.0, ולא בכל android.arch.lifecycle:extensions: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.