מחזור חיים

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Java

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

    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-alpha04

‫23 בספטמבר 2026

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

גרסה ‎2.12.0-alpha03

‫9 בספטמבר 2026

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

תיקוני באגים

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

תיקוני באגים

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

גרסה ‎2.11.0-beta01

‫22 באפריל 2026

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

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

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

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

תכונות חדשות

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

שינויים ב-API

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

External Contribution

• מסירים שדות גיבוי פנימיים מיותרים מ-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) ואינטרנט (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) לארטיפקטים של Lifecycle. מעכשיו יש תמיכה במחזור החיים בפלטפורמות הבאות: JVM (Android ומחשבים), Native (Linux,‏ iOS,‏ watchOS,‏ macOS,‏ MinGW) ואינטרנט (JavaScript,‏ WasmJS). שימו לב שלא נוספו יעדי KMP חדשים לארטיפקטים של *-compose, כי זה תלוי בגרסה היציבה של Compose 1.9. ‫(I01cb8).

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

• המחזור תלוי עכשיו ב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

• חברת 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)

External Contribution

• נוספה בעיה חדשה ב-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 שאוחזרו באמצעות ממשקי ה-API המתאימים שלהם findViewTree דרך הורים לא רציפים של תצוגה, כמו ViewOverlay. מידע נוסף על הורים של תצוגות מנותקות מופיע בהערות הגרסה של Core או במסמכי התיעוד בכתובת 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 delegate היא עצלה ולא תפעיל את פונקציית ה-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: מעדכנים את כללי ProGuard androidx.lifecycle.ReportFragment כדי לאפשר טשטוש . (ff898e1)

External Contribution

• מעבירים את 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)

תכונות חדשות

• זמין ארטיפקט חדש של androidx.lifecycle:lifecycle-viewmodel-testing KMP שמספק מחלקה של 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)
• מאפיין הרחבה מוטבע לחשיפת האפליקציה הבסיסית בצורה בטוחה ב-Kotlin בגרסה 2.0 (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: הוסרו פריטי Artifact‏ 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)

External Contribution

• הפונקציה SavedStateHandle.saveable extension delegate תומכת עכשיו בערכים שניתן להגדיר כ-nullable. תודה ל-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)
• השילוב של ViewModelsaveable באמצעות נציגי מאפיינים (property delegates) משתמש עכשיו בשם המחלקה כחלק מהמפתח שנוצר אוטומטית, וכך נמנעות התנגשויות אם כמה מחלקות משתמשות באותו 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 שצוין. לדוגמה, אפשר להשתמש בזה עם Navigation Compose כדי להימנע מטיפול באירועי קליקים אחרי שכבר התחילה העברה למסך אחר: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }

• ‫ViewModel.viewModelScope הוא עכשיו פרמטר של בנאי שאפשר לשנות, וכך להוסיף משגר משלכם ו-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.

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

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

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

External Contribution

• תודה ל-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, בהתאם לתמיכה ב-multiplatform של 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 artifact תלוי עכשיו ב-Compose 1.6.0.
• מחזור החיים תלוי עכשיו בכלי להתקנת פרופילים 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)

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

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

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

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

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

תיקוני באגים

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

External Contribution

• ‫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

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

External Contribution

• תודה לאיוון מטקוב מ-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, מערכים של Parcelable מותאמים אישית דורשים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון), ובמסמכי התיעוד בנושא get, getLiveData ו-getStateFlow מצוינת עכשיו המגבלה הזו באופן ספציפי.
• הוסרו כללי השמירה של proguard שמשויכים ל-LifecycleObserver. המשמעות היא שקוד שעבר ProGuard ורוצה להשתמש בממשקי API באמצעות רפלקציה (למשל באמצעות ההערה @OnLifecycleEvent שיצאה משימוש לפני זמן רב), יצטרך לספק כללי שמירה משלו לתרחיש השימוש הספציפי שלו.

Lifecycle Event Observability

• במקום להשתמש ב-LifecycleEventObserver, אפשר עכשיו להשתמש בשיטת ההרחבה Lifecycle.asFlow() כדי לראות Flow של Lifecycle.Event.
• משתמשים ב-Jetpack Compose יכולים עכשיו להשתמש ב-LifecycleEventEffect כדי להפעיל תופעות לוואי של Compose על סמך Lifecycle.Event.

@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
    viewModel.refreshData()
  }
  // …
}

• משתמשי Jetpack Compose יכולים להשתמש ב-LifecycleStartEffect וב-LifecycleResumeEffect כדי לטפל בצמדי אירועים – started עד stopped ו-resumed עד paused, בהתאמה. ה-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 ישירות כ-Compose State. הערך הזה זהה לערך שמתקבל מהנוסחה 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 addCloseable() סוגר עכשיו מיידית את Closeable אם ViewModel כבר קיבל שיחה אל onCleared(). ‫(I4712e, ‏ b/280294730)

תיקוני באגים

• מתוך מחזור החיים 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 יכולים עכשיו להיות Flow עם Lifecycle.asFlow(). (If2c0f, ‏ b/176311030)
• LifecycleResumeEffect נוסף API להרצת רכיב ה-Compose SideEffect על סמך קריאות חוזרות (callback) של אירועים מסוג Lifecycle.Event.ON_RESUME ו-Lifecycle.Event.ON_PAUSE. (I60386, ‏ b/235529345)
• נוסף API להרצת רכיבי Compose SideEffect על סמך קריאות חוזרות (callback) של אירועים Lifecycle.Event.ON_START ו-Lifecycle.Event.ON_STOP.LifecycleStartEffect (I5a8d1, b/235529345)
• LifecycleEventEffect נוסף API להפעלת Compose SideEffects על סמך Lifecycle.Event. (Ic9794, ‏ b/235529345)
• התוסף Lifecycle.collectAsState() נוסף כדי לחשוף ישירות את Lifecycle.State כ-Compose 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

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

• המאפיין המציין אם ערך יכול להיות ריק (nullability) של שיטת onChanged של Observer שנוצר ב-Kotlin תואם עכשיו למאפיין המציין אם ערך יכול להיות ריק של הסוג הגנרי. אם רוצים ש-Observer.onChanged() יקבל סוג שניתן לאתחול ל-null, צריך ליצור מופע של Observer עם סוג שניתן לאתחול ל-null.
• המחלקות האלה הומרו גם ל-Kotlin, אבל הן עדיין תואמות למקור: DefaultLifecycleObserver,‏ LifecycleEventObserver,‏ Lifecycle,‏ LifecycleRegistry,‏ LifecycleObserver,‏ ViewModelStore,‏ AndroidViewModel,‏ AbstractSavedStateViewModelFactory,‏ LifecycleService,‏ ServiceLifecycleDispatcher ו-ProcessLifecycleOwner

גרסה ‎2.6.0-rc01

‫22 בפברואר 2023

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

תיקוני באגים

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

גרסה ‎2.6.0-beta01

‫8 בפברואר 2023

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

המרות ב-Kotlin

• ‫LifecycleOwner נכתב עכשיו ב-Kotlin. זהו שינוי שגורם לאי-תאימות למקור בכיתות שנכתבו ב-Kotlin – עכשיו צריך לבטל את ההגדרה של המאפיין lifecycle במקום להטמיע את הפונקציה getLifecycle() הקודמת. (I75b4b, b/240298691)
• ‫ViewModelStoreOwner עכשיו ב-Kotlin. זהו שינוי שגורם לאי-תאימות למקור בכיתות שנכתבו ב-Kotlin – עכשיו צריך לבטל את ההגדרה של המאפיין viewModelStore במקום להטמיע את הפונקציה getViewModelStore() הקודמת. ‫(I86409, ‏ b/240298691)
• התוסף Kotlin ב-LifecycleOwner שמספק את השדה lifecycleScope הועבר לארטיפקט lifecycle-common מ-lifecycle-runtime-ktx. (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 חייב עכשיו להשתמש בתחביר של שיטת ההרחבה של Kotlin, שהיה זמין בעבר רק כשמשתמשים ב-lifecycle-livedata-ktx. כשמשתמשים בשפת התכנות Java, הגרסאות של השיטות האלה שמקבלות method של androidx.arch.core.util.Function יוצאות משימוש ומוחלפות בגרסאות שמקבלות Function1 של Kotlin. השינוי הזה שומר על תאימות בינארית. (I8e14f)
• ‫ViewTreeViewModelStoreOwner נכתב עכשיו ב-Kotlin. זהו שינוי שגורם לאי-תאימות למקור עבור המחלקות שנכתבו ב-Kotlin – עכשיו צריך לייבא ישירות את שיטות ההרחבה של Kotlin ב-View של androidx.lifecycle.setViewTreeViewModelStoreOwner ו-androidx.lifecycle.findViewTreeViewModelStoreOwner ולהשתמש בהן כדי להגדיר ולמצוא בעלים שהוגדרו בעבר. היא תואמת לבינאריות ונשארת תואמת למקורות להטמעות שנכתבו בשפת התכנות Java. (Ia06d8, ‏ Ib22d8, ‏ b/240298691)
• הממשק של HasDefaultViewModelProviderFactory נכתב עכשיו ב-Kotlin. זהו שינוי שגורם לאי-תאימות למקור בכיתות שנכתבו ב-Kotlin – עכשיו צריך לבטל את ההגדרה של המאפיינים defaultViewModelProviderFactory ו-defaultViewModelCreationExtras במקום להטמיע את הפונקציות התואמות הקודמות. ‫(Iaed9c, ‏ b/240298691)
• ‫Observer נכתב עכשיו ב-Kotlin. השיטה onChanged() שלו משתמשת עכשיו בשם value לפרמטר. ‫(Iffef2, ‏ I4995e, ‏ b/240298691)
• ‫AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher ו-ProcessLifecycleOwner נכתבו עכשיו ב-Kotlin (I2e771,‏ Ibae40,‏ I160d7,‏ I08884,‏ I1cda7,‏ b/240298691)

גרסה ‎2.6.0-alpha04

‫11 בינואר 2023

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

תכונות חדשות

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

שינויים ב-API

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

המרות ב-Kotlin

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

תיקוני באגים

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

גרסה ‎2.6.0-alpha03

24 באוקטובר 2022

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

תיקוני באגים

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

תיקוני באגים

• ‫Lifecycle artifacts כוללים עכשיו constraints שמבטיחים שכל ה-Lifecycle artifacts שתלויים זה בזה ישתמשו באותה גרסה, וישדרגו אוטומטית תלויות אחרות כשמשדרגים אחת מהן. 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 מציע עכשיו API של viewModel() שמקבל פונקציית lambda ליצירת מופע של ViewModel בלי לדרוש יצירה של ViewModelProvider.Factory בהתאמה אישית.

  // Within a @Composable, you can now skip writing a custom Factory
  // and instead write a lambda to do the initialization of your ViewModel
  val detailViewModel = viewModel {
    // This lambda is only called the first time the ViewModel is created
    // and all CreationExtras are available inside the lambda
    val savedStateHandle = createSavedStateHandle()
    DetailViewModel(savedStateHandle)
  }
  

• ‫SavedStateHandle Compose Saver 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 תמיד יקפיץ הודעת שגיאה (throw) IllegalStateException, בלי קשר לשאלה אם ל-Lifecycle מצורף observer.
• מעכשיו, LifecycleRegistry ינקה את רשימת הצופים שלו כשהוא יגיע למצב DESTROYED.

גרסה 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 צופה מצורף. (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)

תיקוני באגים

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

גרסה ‎2.5.0-alpha01

‫26 בינואר 2022

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

ViewModel CreationExtras

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

External Contribution

• תודה ל-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)

External Contribution

• תודה ל-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)

תיקוני באגים

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

External Contribution

• תודה ל-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

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

תיקוני באגים

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

גרסה 1.0.0 של Lifecycle Viewmodel Compose

גרסה ‎1.0.0-alpha07

‫16 ביוני 2021

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

שינויים ב-API שעלולים לגרום לבעיות

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

גרסה ‎1.0.0-alpha06

‫2 ביוני 2021

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

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

גרסה ‎1.0.0-alpha05

‫18 במאי 2021

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎1.0.0-alpha04

‫7 באפריל 2021

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

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

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

גרסה ‎1.0.0-alpha03

10 במרץ 2021

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

שינויים ב-API

• ‫LocalViewModelStoreOwner.current מחזירה עכשיו ViewModelStoreOwner שניתן להגדיר כ-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-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)

גרסה 2.3.1

גרסה 2.3.1 של Lifecycle

‫24 במרץ 2021

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

תיקוני באגים

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

גרסה 2.3.0

גרסה 2.3.0

‫10 בפברואר 2021

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

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

• SavedStateHandle תמיכה במחלקות שלא ניתן להעביר כחבילה: SavedStateHandle תומך עכשיו בסריאליזציה עצלה (lazy serialization) בכך שהוא מאפשר לכם להתקשר אל setSavedStateProvider() עבור מפתח נתון, ומספק SavedStateProvider שיקבל קריאה חוזרת אל 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* כי הם לא מאפשרים להריץ קוד השעיה ולא משתמשים ב-dispatcher מותאם אישית. (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 או לגרסה מתקדמת יותר. התוספים findViewTreeLifecycleOwner ו-findViewTreeViewModelStoreOwner של Kotlin זמינים ב-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)

External Contribution

• ממשקי ה-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* הקיימות, כי הם לא מאפשרים להריץ קוד השהיה ולא משתמשים ב-dispatcher מותאם אישית. (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 now better handles reentrant cases, avoiding duplicate calls to onActive() or 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

ViewModel-Savedstate גרסה 2.2.0

‫5 בפברואר 2020

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

‫Lifecycle ViewModel SavedState חולק עכשיו את אותה גרסה כמו ארטיפקטים אחרים של Lifecycle. ההתנהגות של 2.2.0 זהה להתנהגות של 1.0.0.

גרסה 2.2.0

‫22 בינואר 2020

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

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

• שילוב של שגרות המשך של מחזור החיים: ארטיפקט lifecycle-runtime-ktx החדש מוסיף שילוב בין מחזור החיים לבין שגרות המשך של Kotlin. בנוסף, הרחבנו את lifecycle-livedata-ktx כדי לנצל את היתרונות של קורוטינות. פרטים נוספים מופיעים במאמר בנושא שימוש ב-Kotlin coroutines עם רכיבי Architecture.
• הוצאה משימוש של 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 ונשלפת אליו שאילתה מאוחר יותר עם הגדרות ברירת מחדל של פקטורי (factory).
• צריך לתקן את השימוש ב-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 שעוברת למצב התחלה והפעלה במכשירי 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. כאן אפשר למצוא תיעוד מפורט בנושא.

גרסה 1.0.0 של ViewModel-SavedState

גרסה 1.0.0

‫22 בינואר 2020

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

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

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

שינויים ב-API

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

גרסה ‎2.1.0-alpha03

‫13 במרץ 2019

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

שינויים ב-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 משתנה.
• תמיכה בקורוטינות ב-ViewModels: נוספה מאפיין ההרחבה ViewModel.viewModelScope.
• נוספה ViewModelProvider.KeyedFactory, factory של ViewModels שמקבלת 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

תיקוני באגים

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

גרסאות קודמות ל-AndroidX

בגרסאות Lifecycle שלפני AndroidX שמופיעות בהמשך, צריך לכלול את יחסי התלות הבאים:

dependencies {
    def lifecycle_version = "1.1.1"

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

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

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

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

גרסה 1.1.1

‫21 במרץ 2018

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

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

גרסה 1.1.0

‫22 בינואר 2018

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

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

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

שינויים ב-API

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