מחזור חיים

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

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

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

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

Kotlin

    dependencies {
        def lifecycle_version = "2.9.1"
        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:1.0.0-alpha03"

        // 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.9.1"
        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:1.0.0-alpha03")

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

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

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

‫Lifecycle ViewModel Navigation3 Version 1.0.0

גרסה 1.0.0-alpha03

‫2 ביולי 2025

הגרסאות androidx.lifecycle:lifecycle-viewmodel-navigation3:1.0.0-alpha03 ו-androidx.lifecycle:lifecycle-viewmodel-navigation3-android:1.0.0-alpha03 יוצאות לאור. גרסה 1.0.0-alpha03 מכילה את הקומטים האלה.

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

• ‫Lifecycle ViewModel Navigation 3 תלוי עכשיו ב-Navigation3 Alpha05

גרסה 1.0.0-alpha02

‫18 ביוני 2025

הגרסאות androidx.lifecycle:lifecycle-viewmodel-navigation3:1.0.0-alpha02 ו-androidx.lifecycle:lifecycle-viewmodel-navigation3-android:1.0.0-alpha02 יוצאות לאור. גרסה 1.0.0-alpha02 מכילה את ההתחייבויות האלה.

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

• ‫Lifecycle ViewModel Navigation3 1.0.0-alpha02 תלוי בשינויים ב-Navigation3 1.0.0-alpha04. (Icd0fd, ‏ b/420991203)

גרסה 1.0.0-alpha01

‫23 במאי 2025

androidx.lifecycle:lifecycle-viewmodel-navigation3:1.0.0-alpha01 משוחרר. גרסה 1.0.0-alpha01 מכילה את הקומטים האלה.

תכונות חדשות

• ‫Lifecycle ViewModel Navigation3 היא ספרייה חדשה שנבנתה לצד Navigation3 כדי לספק שילובים עם ViewModels. ‫androidx.lifecycle:lifecycle-viewmodel-navigation3 artifact מספק את ViewModelStoreNavEntryDecorator, שמספק ViewModelStoreOwner ייחודי לתוכן של כל NavEntry. הוא גם מספק rememberViewModelStoreNavEntryDecorator() כדי לוודא שהשינויים בהגדרות מטופלים בצורה נכונה.

val viewModelDecorator = rememberViewModelStoreNavEntryDecorator()

NavDisplay(
  …,
  entryDecorators =
  listOf(
    rememberSceneSetupNavEntryDecorator(),
    rememberSavedStateNavEntryDecorator(),
    viewModelDecorator
  )
)

גרסה 2.9

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

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

שינויים ב-API

• הוספת עקביות רבה יותר לשמות ולסדר החבילות בהתאם ל-SavedStateRegistryOwnerDelegate (I8c135, b/376026744)

תיקוני באגים

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

גרסה 2.9.0-alpha07

‫13 בנובמבר 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha07 משוחרר. גרסה 2.9.0-alpha07 מכילה את הקומטים האלה.

תאימות ל-Kotlin Multiplatform

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

תמיכה ב-KotlinX Serialization

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

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

שינויים ב-API

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

גרסה 2.9.0-alpha06

‫30 באוקטובר 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha06 משוחרר. גרסה 2.9.0-alpha06 מכילה את הקומטים האלה.

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

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

תיקוני באגים

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

גרסה 2.9.0-alpha05

‫16 באוקטובר 2024

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

גרסה 2.9.0-alpha04

‫2 באוקטובר 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha04 משוחרר. גרסה 2.9.0-alpha04 מכילה את הקומטים האלה.

Kotlin Multiplatform

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

גרסה 2.9.0-alpha03

‫18 בספטמבר 2024

androidx.lifecycle:lifecycle-*:2.9.0-alpha03 משוחרר. גרסה 2.9.0-alpha03 מכילה את ההתחייבויות האלה.

תיקוני באגים

• מתוך Lifecycle 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)
• הוספת תמיכה ביעד מרובה פלטפורמות של Kotlin‏ (linuxArm64 kotlin‏) (I139d3, ‏ b/338268719)

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.8

גרסה 2.8.7

‫30 באוקטובר 2024

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

שינויים ב-API

• ‫androidx.compose.ui.platform.LocalLifecycleOwner זמין עכשיו בערכת המקור המשותפת (KMP). (6a3f5b3)
• ‫lifecycle-runtime-compose: הוסרו desktop פריטי מידע שנוצרו בתהליך פיתוח (Artifact) והוספו -jvmStubs ו--linuxx64Stubs פריטי מידע שנוצרו בתהליך פיתוח (Artifact). היעדים האלה לא מיועדים לשימוש, אלא הם משמשים כ-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 תומך עכשיו בערכים שניתן להגדיר כ-null. תודה ל-Roman Kalukiewicz על התרומה. (0d78ea6)

גרסה 2.8.4

‫24 ביולי 2024

androidx.lifecycle:lifecycle-*:2.8.4 משוחרר. גרסה 2.8.4 מכילה את התחייבויות האלה.

תיקוני באגים

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

גרסה 2.8.3

‫1 ביולי 2024

androidx.lifecycle:lifecycle-*:2.8.3 משוחרר. גרסה 2.8.3 מכילה את ההתחייבויות האלה.

תיקוני באגים

• תוקנה בעיה בתאימות לאחור של Lifecycle 2.8 עם Compose 1.6.0 ומטה כשמשתמשים ב-code shrinking. (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 dependencies עם גרסאות 2.8 ומעלה, וכך נפתרות בעיות בספריות כמו LeakCanary. ‫(I80383, ‏ b/341792251)

גרסה 2.8.1

‫29 במאי 2024

androidx.lifecycle:lifecycle-*:2.8.1 משוחרר. גרסה 2.8.1 מכילה את ההתחייבויות האלה.

תיקוני באגים

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

גרסה 2.8.0

‫14 במאי 2024

androidx.lifecycle:lifecycle-*:2.8.0 משוחרר. גרסה 2.8.0 מכילה את ההתחייבויות האלה.

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

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

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

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

• הפונקציה ViewModel נכתבה מחדש ב-Kotlin ועכשיו היא משתמשת ב-AutoClosable במקום ב-Closeable. מעכשיו יש תמיכה בהוספה של אובייקטים AutoCloseable עם key שמאפשר לאחזר אותם באמצעות getCloseable().

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

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

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

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

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

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

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

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

תאימות של ViewModel Kotlin Multiplatform

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

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

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

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

תיקוני באגים

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

External Contribution

• תודה ל-Victor Kropp על שיפור הבדיקה של ה-thread הראשי ב-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, בהתאם לתמיכה ב-Multiplatform של androidx.compose. כדי להתאים את השינוי הזה, השיטה Composable viewModel מקבלת עכשיו KClass בנוסף ל-java.lang.Class. (b/330323282)

תיקוני באגים

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

עדכון תלות

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

גרסה 2.8.0-alpha03

‫20 במרץ 2024

androidx.lifecycle:lifecycle-*:2.8.0-alpha03 משוחרר. גרסה 2.8.0-alpha03 מכילה את הקומטים האלה.

תכונות חדשות

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

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

תאימות ל-Kotlin Multiplatform

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

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

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

• יצירת מופע של ViewModelProvider מתבצעת עכשיו באמצעות השיטות 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

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

מעקב אחרי אירועים במחזור החיים

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

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

• משתמשי Jetpack Compose יכולים להשתמש ב-LifecycleStartEffect וב-LifecycleResumeEffect כדי לטפל בצמדי אירועים – 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, מערכים של Parcelables מותאמים אישית דורשים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון). במסמכי העזרה בנושא get, getLiveData ו-getStateFlow מצוינת עכשיו המגבלה הזו באופן ספציפי. (I0b55a)

גרסה 2.7.0-rc01

‫15 בנובמבר 2023

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

תיקוני באגים

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

גרסה 2.7.0-beta01

‫1 בנובמבר 2023

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

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

גרסה 2.7.0-alpha03

‫18 באוקטובר 2023

androidx.lifecycle:lifecycle-*:2.7.0-alpha03 משוחרר. גרסה 2.7.0-alpha03 מכילה את הקומיטים האלה.

תכונות חדשות

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

תיקוני באגים

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

גרסה 2.7.0-alpha02

‫6 בספטמבר 2023

androidx.lifecycle:lifecycle-*:2.7.0-alpha02 משוחרר. גרסה 2.7.0-alpha02 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

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

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

• התוספים LiveData.map() ו-LiveData.switchMap() מגדירים עכשיו את value של LiveData שמוחזר אם הוגדר ערך ל-LiveData הקודם, וכך מוודאים של-LiveData שמתקבל יש את המצב הנכון בקומפוזיציה הראשונית ב-Jetpack Compose. (I91d2b, ‏ b/269479952)
• ‫ViewModel's addCloseable() now immediately closes the Closeable if the ViewModel has already received a call to onCleared(). (I4712e, ‏ b/280294730)

תיקוני באגים

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

גרסה 2.7.0-alpha01

‫26 ביולי 2023

androidx.lifecycle:lifecycle-*:2.7.0-alpha01 משוחרר. גרסה 2.7.0-alpha01 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

• הערך של האפשרות לקבלת ערך null בשיטה onChanged של Observer שנוצר ב-Kotlin תואם עכשיו לערך של האפשרות לקבלת ערך null בסוג הכללי. אם רוצים ש-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-common מ-lifecycle-runtime-ktx. (Iabb91, ‏ b/240298691)

גרסה 2.6.0-alpha05

‫25 בינואר 2023

androidx.lifecycle:lifecycle-*:2.6.0-alpha05 משוחרר. גרסה 2.6.0-alpha05 מכילה את הקומיטים האלה.

המרות של Kotlin

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

גרסה 2.6.0-alpha04

‫11 בינואר 2023

androidx.lifecycle:lifecycle-*:2.6.0-alpha04 משוחרר. גרסה 2.6.0-alpha04 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

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

המרות של Kotlin

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

תיקוני באגים

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

גרסה 2.6.0-alpha03

24 באוקטובר 2022

androidx.lifecycle:lifecycle-*:2.6.0-alpha03 משוחרר. גרסה 2.6.0-alpha03 מכילה את הקומיטים האלה.

תיקוני באגים

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

גרסה 2.6.0-alpha02

‫7 בספטמבר 2022

androidx.lifecycle:lifecycle-*:2.6.0-alpha02 משוחרר. גרסה 2.6.0-alpha02 מכילה את הקומיטים האלה.

שינויים ב-API

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

תיקוני באגים

• פריטי מידע שנוצרו בתהליך פיתוח (Artifact) של Lifecycle כוללים עכשיו אילוצים שמבטיחים שכל פריטי המידע שנוצרו בתהליך פיתוח שקשורים למחזור החיים משתמשים באותה גרסה, ומשדרגים אוטומטית תלויות אחרות כשמשדרגים אחת מהן. b/242871265
• ‫FlowLiveData.asFlow() יוצר עכשיו callbackFlow במקום להשתמש בהטמעה משלו של Channel כדי להבטיח בטיחות בשרשור ושמירה על ההקשר. (I4a8b2, b/200596935)
• הפונקציה FlowLiveData's 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 נמצא לפחות ב-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() שמקבל פונקציית למדה ליצירת מופע של 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) }
  }
  

• נוספו addCloseable() API ועומס יתר חדש של בנאי שמאפשרים להוסיף אובייקט אחד או יותר של Closeable ל-ViewModel שייסגר כשה-ViewModel ינוקה, בלי שיהיה צורך לבצע פעולות ידניות ב-onCleared().

  לדוגמה, כדי ליצור היקף של קורוטינה שאפשר להוסיף ל-ViewModel, אבל לשלוט בו באמצעות בדיקה, אפשר ליצור CoroutineScope שמטמיע את Closeable:

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

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

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

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

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

גרסה 2.5.0-rc02

‫15 ביוני 2022

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

תיקוני באגים

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

גרסה 2.5.0-rc01

11 במאי 2022

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

תיקוני באגים

• ‫MediatorLiveData.addSource() throws a NullPointerException when passed a null source instead of propagating the null source to observers.(Ibd0fb, b/123085232)

גרסה 2.5.0-beta01

‫20 באפריל 2022

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.5.0-alpha06

‫6 באפריל 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha06 משוחרר. גרסה 2.5.0-alpha06 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

• המאפיין CreationExtras הוא עכשיו מופשט במקום סגור. (Ib8a7a)

תיקוני באגים

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

גרסה 2.5.0-alpha05

23 במרץ 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha05 משוחרר. גרסה 2.5.0-alpha05 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.5.0-alpha03

23 בפברואר 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha03 משוחרר. גרסה 2.5.0-alpha03 מכילה את הקומיטים האלה.

תכונות חדשות

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

שינויים ב-API

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

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

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

גרסה 2.5.0-alpha02

‫9 בפברואר 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha02 משוחרר. גרסה 2.5.0-alpha02 מכילה את הקומיטים האלה.

שינויים ב-API

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

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

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

תיקוני באגים

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

גרסה 2.5.0-alpha01

‫26 בינואר 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha01 משוחרר. גרסה 2.5.0-alpha01 מכילה את הקומיטים האלה.

ViewModel CreationExtras

בגרסה הזו אנחנו מניחים את היסודות לשינוי המבנה של ViewModel. במקום קבוצה קשיחה של מחלקות משנה של ViewModelProvider.Factory שכל אחת מהן מוסיפה פונקציונליות נוספת (מאפשרת פרמטר של constructor‏ Application באמצעות AndroidViewModelFactory, מאפשרת פרמטר של constructor‏ SavedStateHandle באמצעות SavedStateViewModelFactory ו-AbstractSavedStateViewModelFactory וכו'), אנחנו עוברים לעולם של מפעלים חסרי מצב שמסתמכים על קונספט חדש, 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 שמעביר רק את המידע שצריך לכל ViewModel בלי להסתמך על היררכיה קפדנית של מחלקות משנה של Factory:ViewModelProvider.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 now depends on Androidx Startup 1.1.1 which fixed a regression in where using ProcessLifecycleInitializer would cause an 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 לא מאפשרת יותר גנריות עם ערך null.
• נוסף API חדש של קורוטינות ל-androidx.lifecycle:lifecycle-runtime-ktx:
• ‫Lifecycle.repeatOnLifecycle, API שמריץ בלוק קוד ב-Coroutine כשה-Lifecycle נמצא לפחות במצב מסוים. החסימה תבוטל ותופעל מחדש כשהמחזור יעבור למצב היעד וממנו;
• ‫Flow.flowWithLifecycle, API שפולט ערכים מ-Flow במעלה הזרם כשהמחזור החיים נמצא לפחות במצב מסוים.
• הפריט DefaultLifecycleObserver הועבר מ-lifecycle.lifecycle-common-java8 אל lifecycle.lifecycle-common. ‫lifecycle.lifecycle-common-java8 לא מספק יותר פונקציונליות נוספת מעבר ל-lifecycle.lifecycle-common, ולכן אפשר להחליף את התלות בו ב-lifecycle.lifecycle-common.
• ממשקי API שאינם קורוטינות מ-lifecycle-viewmodel-ktx הועברו למודול lifecycle-viewmodel.

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

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

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

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

  (או)

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

גרסה 2.4.0-rc01

‫29 בספטמבר 2021

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

גרסה 2.4.0-beta01

‫15 בספטמבר 2021

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

שינויים ב-API

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

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 לא מאפשרת יותר ערך Null כללי. (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

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

תיקוני באגים

• מגרסה Lifecycle 2.3.1: כלל ה-lint‏ NonNullableMutableLiveData יכול להבחין עכשיו בין משתני שדה עם ערכי null שונים. (b/169249668)

‫Lifecycle Viewmodel Compose גרסה 1.0.0

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

‫Lifecycle-Viewmodel-Compose גרסה 1.0.0-alpha02

24 בפברואר 2021

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

שינויים ב-API

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

‫Lifecycle-Viewmodel-Compose גרסה 1.0.0-alpha01

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

‫24 במרץ 2021

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

תיקוני באגים

• עכשיו אפשר להשתמש בכלל NonNullableMutableLiveData lint כדי להבחין בין משתני שדה עם ערכי null שונים. (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 או לגרסה מתקדמת יותר. תוספי Kotlin‏ findViewTreeLifecycleOwner ו-findViewTreeViewModelStoreOwner זמינים ב-lifecycle-runtime-ktx וב-lifecycle-viewmodel-ktx, בהתאמה.
• LiveData.observe() הוצאה משימוש של הרחבת Kotlin: הרחבת Kotlin שנדרשת לשימוש בתחביר lambda הוצאה משימוש, כי היא לא נדרשת כשמשתמשים ב-Kotlin 1.4.LiveData.observe()

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

תכונות חדשות

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

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

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

תיקוני באגים

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

גרסה 2.3.0-alpha05

‫24 ביוני 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha05 משוחרר. גרסה 2.3.0-alpha05 מכילה את הקומיטים האלה.

תיקוני באגים

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

גרסה 2.3.0-alpha04

‫10 ביוני 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha04 משוחרר. גרסה 2.3.0-alpha04 מכילה את הקומיטים האלה.

תיקוני באגים

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

גרסה 2.3.0-alpha03

20 במאי 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha03. גרסה 2.3.0-alpha03 מכילה את הקומיטים האלה.

תכונות חדשות

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

תיקוני באגים

• תוקנה בעיה שגרמה לכך שMutableLiveData בדיקות Lint שפורסמו במחזור החיים 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)

תיקוני באגים

• שיפרנו את הביצועים של תקופת ההרצה של הניסוי על ידי מניעת כשל באימות המחלקה במכשירים עם 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. תוסף findViewTreeLifecycleOwner Kotlin זמין ב-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 Version 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 Coroutine: ארטיפקט lifecycle-runtime-ktx החדש מוסיף שילוב בין Lifecycle לבין Kotlin coroutines. בנוסף, הרחבנו את lifecycle-livedata-ktx כדי לנצל את היתרונות של קורוטינות. פרטים נוספים זמינים במאמר שימוש ב-Kotlin coroutines עם רכיבי ארכיטקטורה.
• הוצאה משימוש של ViewModelProviders.of(): ‏ViewModelProviders.of() הוצא משימוש. אפשר להעביר את Fragment או FragmentActivity לקונסטרוקטור החדש ViewModelProvider(ViewModelStoreOwner) כדי להשיג את אותה הפונקציונליות כשמשתמשים ב-Fragment 1.2.0.
• lifecycle-extensions הוצאה משימוש של ארטיפקט: בעקבות ההוצאה משימוש של ViewModelProviders.of() שצוינה למעלה, בגרסה הזו הוצא משימוש ה-API האחרון ב-lifecycle-extensions, ולכן הארטיפקט הזה נחשב עכשיו כפריט שהוצא משימוש באופן מלא. מומלץ מאוד להסתמך על ארטיפקטים ספציפיים של מחזור החיים שאתם צריכים (למשל lifecycle-service אם אתם משתמשים ב-LifecycleService ו-lifecycle-process אם אתם משתמשים ב-ProcessLifecycleOwner) ולא על lifecycle-extensions, כי לא תהיה גרסה עתידית של 2.3.0 ל-lifecycle-extensions.
• ‫Gradle Incremental Annotation Processor: מעבד האנוטציות של Lifecycle הוא מצטבר כברירת מחדל. אם האפליקציה כתובה בשפת התכנות Java 8, אפשר להשתמש ב-DefautLifecycleObserver במקום זאת. אם היא כתובה בשפת התכנות Java 7, אפשר להשתמש ב-LifecycleEventObserver.

גרסה 2.2.0-rc03

4 בדצמבר 2019

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

תיקוני באגים

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

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

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

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

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

גרסה 2.2.0-rc02

‫7 בנובמבר 2019

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

תיקוני באגים

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

גרסה 2.2.0-rc01

‫23 באוקטובר 2019

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

תיקוני באגים

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

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

• תודה לניקלאס אנסמן על תרומתו לתיקון! (aosp/1145596)

גרסה 2.2.0-beta01

‫9 באוקטובר 2019

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

תיקוני באגים

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

תכונות חדשות

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

ViewModel-SavedState גרסה 1.0.0

גרסה 1.0.0

‫22 בינואר 2020

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

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

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

ViewModel-Savedstate גרסה 1.0.0-rc03

4 בדצמבר 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc03 משוחרר. גרסה 1.0.0-rc03 מכילה את הקומיטים האלה.

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

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

‫Viewmodel-Savedstate גרסה 1.0.0-rc02

‫7 בנובמבר 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc02 משוחרר. גרסה 1.0.0-rc02 מכילה את הקומיטים האלה.

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

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

ViewModel-SavedState Version 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 Version 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 Version 1.0.0-alpha01

‫13 במרץ 2019

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

תכונות חדשות

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

גרסה 2.1.0

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

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

שינויים ב-API

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

גרסה 2.1.0-alpha02

‫30 בינואר 2019

androidx.lifecycle 2.1.0-alpha02 משוחרר.

שינויים ב-API

• ‫LifecycleRegistry כולל עכשיו את השיטה setCurrentState() שמחליפה את השיטה setState() שהוצאה משימוש. (aosp/880715)

תיקוני באגים

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

גרסה 2.1.0-alpha01

17 בדצמבר 2018

androidx.lifecycle 2.1.0-alpha01 משוחרר.

תכונות חדשות

• נוסף LifecycleEventObserver למקרים שבהם נדרש זרם של אירועים במחזור החיים. זהו API ציבורי ולא מחלקה מוסתרת GenericLifecycleObserver.
• נוספו תוספי ktx לשיטות LiveData.observe ולשיטות Transformations.*.
• השיטה Transformations.distinctUntilChanged נוספה. הוא יוצר אובייקט LiveData חדש שלא פולט ערך עד שהערך של LiveData במקור משתנה.
• תמיכה ב-Coroutine ב-ViewModels: נוספה מאפיין ההרחבה ViewModel.viewModelScope.
• נוסף ViewModelProvider.KeyedFactory, מפעל של 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 הוצא משימוש – צריך להשתמש ישירות בשיטות הסטטיות שלו
• התכונה ViewModelProviders.DefaultFactory הוצאה משימוש. במקומה יש להשתמש ב-ViewModelProvider.AndroidViewModelFactory
• השיטה הסטטית ViewModelProvider.AndroidViewModelFactory.getInstance(Application) נוספה כדי לאחזר Factory סטטי שמתאים ליצירת מופעים של ViewModel ושל AndroidViewModel.