מחזור חיים

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

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

פריט מידע שנוצר בתהליך פיתוח (Artifact) גרסה יציבה גרסה מועמדת להפצה גרסת בטא גרסה אלפא
lifecycle-* 2.8.7 - - 2.9.0-alpha07
lifecycle-viewmodel-compose 2.8.7 - - 2.9.0-alpha07
הספרייה עודכנה לאחרונה ב-13 בנובמבר 2024

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

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

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

Kotlin

מגניב

    dependencies {
        def lifecycle_version = "2.8.7"
        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"

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

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

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

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

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

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

Kotlin

    dependencies {
        val lifecycle_version = "2.8.7"
        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")

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

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

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

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

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

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

Java

Groovy

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

משוב

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

דיווח על בעיה חדשה

מידע נוסף זמין במסמכי התיעוד של Issue Tracker.

גרסה 2.9

גרסה 2.9.0-alpha07

13 בנובמבר 2024

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

תאימות של Kotlin למספר פלטפורמות

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

תמיכה בסריאליזציה של KotlinX

  • בעזרת התמיכה ב-KotlinX Serialization שנוספה ב-SavedState 1.3.0-alpha05, הוספנו את saved, נציג נכס עצלן, כדי שיהיה קל לאחסן כיתות @Serializable ב-SavedStateHandle ולשחזר אותן באופן אוטומטי לאחר מוות התהליך ויצירתו מחדש. חשוב לזכור שהממשק הנציג saved הוא עצלן, והוא לא יבצע קריאה לפונקציית הלמה 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 ב-Common Source Set (קבוצת המקור המשותפת) בגרסה עתידית. (I503ed, ‏ I48764, ‏ b/334076622)

גרסה 2.9.0-alpha03

18 בספטמבר 2024

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

תיקוני באגים

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

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

גרסה 2.9.0-alpha02

4 בספטמבר 2024

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

תיקוני באגים

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

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

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

גרסה 2.9.0-alpha01

7 באוגוסט 2024

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

Kotlin Multiplatform

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

  • הסרנו את התיאור הידני של הגישה לממשקי API חדשים של פלטפורמות, כי זה קורה באופן אוטומטי באמצעות בניית מודלים של API כשמשתמשים ב-R8 עם AGP 7.3 ואילך (למשל, R8 גרסה 3.3) ובכל גרסאות ה-build כשמשתמשים ב-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: פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) מסוג desktop הוסרו, ופריטי המידע שנוצרו בתהליך הפיתוח מסוג -jvmStubs ו--linuxx64Stubs נוספו. אין להשתמש באף אחד מהיעדים האלה. הם משמשים כסמנים לעזרה במאמצים של Jetbrains Compose. (6a3f5b3)

גרסה 2.8.6

18 בספטמבר 2024

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

תיקוני באגים

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

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

גרסה 2.8.5

4 בספטמבר 2024

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

תיקוני באגים

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

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

  • עכשיו יש תמיכה בערכים nullable במתווך התוסף SavedStateHandle.saveable. תודה לרומן קלוצ'יוויצ' על התרומה. (0d78ea6)

גרסה 2.8.4

24 ביולי 2024

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

תיקוני באגים

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

גרסה 2.8.3

1 ביולי 2024

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

תיקוני באגים

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

גרסה 2.8.2

‫12 ביוני 2024

androidx.lifecycle:lifecycle-*:2.8.2 משוחרר. גרסה 2.8.2 כוללת את ההוספות האלה.

תיקוני באגים

  • תוקנו שגיאות מסוג CompositionLocal LocalLifecycleOwner not present בשימוש ב-Lifecycle 2.8.X עם Compose 1.6.X או גרסה ישנה יותר – עכשיו אפשר להשתמש ב-Lifecycle 2.8.2 עם כל גרסה של Compose בלי צורך לפתרונות חלופיים. (aosp/3105647, ‏ b/336842920)
  • ViewModelProvider לא יתקרוס יותר כשמשלבים גרסאות קודמות של יחסי התלות של compileOnly במחזור החיים עם גרסאות 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 כדי שאפשר יהיה להשתמש בממשקי ה-API העוזרים שמבוססים על Compose מחוץ לממשק המשתמש של Compose.
  • הארטיפקט lifecycle-runtime-compose מכיל עכשיו את ממשקי ה-API dropUnlessResumed ו-dropUnlessStarted, שמאפשרים להשמיט אירועי קליקים או אירועים אחרים שמתרחשים גם אחרי שהערך של LifecycleOwner ירד מתחת ל-Lifecycle.State שצוין. לדוגמה, אפשר להשתמש בזה עם Navigation Compose כדי להימנע משימוש באירועי קליקים אחרי שהמעבר למסך אחר כבר התחיל: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }

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

    class MyViewModel(
  // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate
  viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob()
) : ViewModel(viewModelScope) {
  // Use viewModelScope as before, without any code changes
}

// Allows overriding the viewModelScope in a test
fun Test() = runTest {
  val viewModel = MyViewModel(backgroundScope)
}

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

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

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

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

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

תאימות של Kotlin למולטי-פלטפורמות במחזור החיים

ממשקי ה-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 לפלטפורמות מרובות

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

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

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

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

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

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

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

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

בעיות מוכרות

גרסה 2.8.0-rc01

1 במאי 2024

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

תיקוני באגים

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

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

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

גרסה 2.8.0-beta01

17 באפריל 2024

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

תכונות חדשות

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

גרסה 2.8.0-alpha04

3 באפריל 2024

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

תכונות חדשות

  • הארטיפקט lifecycle-viewmodel-compose תואם עכשיו ל-Kotlin Multiplatform, הקוד שלו הועבר ל-common והוא כולל ארטיפקט ל-Android, בהתאם לתמיכה בפלטפורמות מרובות של androidx.compose. כדי להתאים את השינוי הזה, השיטה 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 שאפשר לשנות, ומאפשר להחדיר את המפנה ואת 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 למספר פלטפורמות

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

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

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

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

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

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

תיקוני באגים

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

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

  • LocalLifecycleOwner הועבר מ-Compose UI אל lifecycle-runtime-compose כדי שניתן יהיה להשתמש בממשקי ה-API העוזרים שמבוססים על Compose מחוץ לממשק המשתמש של Compose. תודה ל-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 למספר פלטפורמות

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

שינויים ב-API

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

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

  • תודה לאיוון מטקוב (Ivan Matkov) מ-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

גרסה

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, מערכים של Parcelables מותאמים אישית דורשים עבודה נוספת (יצירה ידנית של מערך ממוין מהסוג הנכון), והמגבלה הזו מצוינת עכשיו במפורש במסמכי התיעוד של get, ‏ getLiveData ו-getStateFlow.
  • כללי השמירה של Proguard שמשויכים ל-LifecycleObserver הוסרו. המשמעות היא שקוד מוגן שרוצים להשתמש בו בממשקי 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 כדי לטפל בזוגות של אירועים – התחלה לעצירה והמשך להשהיה, בהתאמה. ה-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, מערכים של 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 בתהליך ה-composition הראשוני. (I91d2b, ‏ b/269479952)
  • עכשיו, ה-addCloseable() של ViewModel סוגר את ה-Closeable באופן מיידי אם ה-ViewModel כבר קיבל קריאה ל-onCleared(). (I4712e, ‏ b/280294730)

תיקוני באגים

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

גרסה 2.7.0-alpha01

26 ביולי 2023

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.6

גרסה 2.6.2

6 בספטמבר 2023

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

תיקוני באגים

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

גרסה 2.6.1

22 במרץ 2023

androidx.lifecycle:lifecycle-*:2.6.1 משוחרר. גרסה 2.6.1 כוללת את ההצהרות האלה.

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

גרסה 2.6.0

8 במרץ 2023

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

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

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

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

Lifecycle 2.5 Lifecycle 2.5‏ (KTX) Lifecycle 2.6
Transformations.switchMap(liveData) {...} liveData.switchMap {...} liveData.switchMap {...}
Transformations.map(liveData) {...} liveData.map {...} liveData.map {...}
Transformations.distinctUntilChanged(liveData) {...} liveData.distinctUntilChanged{...} liveData.distinctUntilChanged{...}
LiveDataReactiveStreams.fromPublisher(publisher) publisher.toLiveData() publisher.toLiveData()
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) liveData.toPublisher(lifecycleOwner) liveData.toPublisher(lifecycleOwner)
override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory override val defaultViewModelProviderFactory = factory
override fun getDefaultViewModelCreationExtras(): CreationExtras = extras override fun getDefaultViewModelCreationExtras(): CreationExtras = extras override val defaultViewModelProviderCreationExtras = extras
ViewTreeLifecycleOwner.set(view, owner) ViewTreeLifecycleOwner.set(view, owner) view.setViewTreeLifecycleOwner(owner)
ViewTreeLifecycleOwner.get(view) view.findViewTreeLifecycleOwner() view.findViewTreeLifecycleOwner()
override fun getViewModelStore(): ViewModelStore = store override fun getViewModelStore(): ViewModelStore = store override val viewModelStore: ViewModelStore = store
override fun getLifecycle(): Lifecycle = registry override fun getLifecycle(): Lifecycle = registry override val lifecycle: Lifecycle get() = registry
  • עכשיו, האפשרות של השיטה onChanged של Observer שנוצרה ב-Kotlin להיות null תואמת לאפשרות של הסוג הכללי להיות null. אם רוצים ש-Observer.onChanged() יקבל סוג nullable, צריך ליצור את Observer עם סוג nullable.
  • גם הכיתות האלה הומרו ל-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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

המרות ב-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 הוצאו משימוש, כי השימוש במפנה משימות מושהה עלול להוביל לבזבוז משאבים במקרים מסוימים. מומלץ להשתמש ב-Lifecycle.repeatOnLifecycle. (Iafc54, ‏ b/248302832)

המרות ב-Kotlin

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

תיקוני באגים

  • SavedStateHandle לא קורס יותר עם ClassCastException כשקוראים ל-get() עם סוג הכיתה הלא נכון. (I6ae7c)

גרסה 2.6.0-alpha03

24 באוקטובר 2022

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

תיקוני באגים

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

גרסה 2.6.0-alpha02

7 בספטמבר 2022

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

שינויים ב-API

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

תיקוני באגים

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

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

  • lifecycle-viewmodel מספק עכשיו viewModelFactory Kotlin DSL שמאפשר להגדיר את ViewModelProvider.Factory במונחים של מערך אחד או יותר של פונקציות להפעלה של פונקציית הלמה (lambda), אחת לכל סוג ViewModel ספציפי שהמפעל המותאם אישית תומך בו, באמצעות CreationExtras כמקור הנתונים הראשי.

    val customFactory = viewModelFactory {
    // The return type of the lambda automatically sets what class this lambda handles
    initializer {
        // Get the Application object from extras provided to the lambda
        val application = checkNotNull(get(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY))
        HomeViewModel(application)
    }
    initializer {
        val savedStateHandle = createSavedStateHandle()
        DetailViewModel(savedStateHandle)
    }
}

  • lifecycle-viewmodel-compose מציע עכשיו ממשק API מסוג viewModel() שמשתמש במפעל lambda ליצירת מכונה של ViewModel בלי צורך ליצור ViewModelProvider.Factory מותאם אישית.

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

  • שילוב של SavedStateHandle Compose Saver – הארטיפקט lifecycle-viewmodel-compose מכיל עכשיו ממשקי API ניסיוניים חדשים ב-SavedStateHandle.saveable שמאפשרים התנהגות כמו rememberSaveable שמגובת על ידי SavedStateHandle של ViewModel.

    class ListScreenViewModel(handle: SavedStateHandle): ViewModel() {
    // This value survives both configuration changes and process death and recreation
    val editMode by handle.saveable { mutableStateOf(false) }
}

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

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

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

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

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

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

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

גרסה 2.5.0-rc02

15 ביוני 2022

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

תיקוני באגים

  • ViewModelProvider לא יתקרוס יותר כשמשתמשים בשילוב של גרסאות קודמות של יחסי תלות של Lifecycle מסוג 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() מעביר עכשיו NullPointerException כשמקבל מקור null במקום להעביר את המקור null למתבוננים.(Ibd0fb, ‏ b/123085232)

גרסה 2.5.0-beta01

20 באפריל 2022

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

שינויים ב-API

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

תיקוני באגים

  • תוקנה בעיה שבה הטמעת NavHost בתוך NavHost אחר בכרטיסיית ניווט תחתונה לא ראשית הובילה ל-IllegalStateException כשמשתמשים בכמה סטאקים של חזרה אחורה. (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. אם מציינים פרמטרים נוספים, המערכת תתעלם מהארגומנטים שהועברו ל-init. (I6c43b, b/224844583)

גרסה 2.5.0-alpha04

9 במרץ 2022

androidx.lifecycle:lifecycle-*:2.5.0-alpha04 משוחרר. גרסה 2.5.0-alpha04 מכילה את ההצהרות האלה.

שינויים ב-API

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

גרסה 2.5.0-alpha03

23 בפברואר 2022

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

תכונות חדשות

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

שינויים ב-API

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

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

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

גרסה 2.5.0-alpha02

9 בפברואר 2022

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

שינויים ב-API

  • הפונקציות SavedStateHandle ו-SavedStateViewModelFactory הומרו ל-Kotlin. כך שיפורה היכולת של הגנריקים בשתי הכיתות להיות ערכים null. (Ib6ce2, ‏ b/216168263,‏ I9647a, ‏ b/177667711)
  • עכשיו אפשר להגדיר לפרמטר LiveData של הפונקציה switchMap פלט nullable. (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 אפשר ליצור ViewModelProvider.Factory שמעביר רק את המידע הדרוש לכל ViewModel, בלי להסתמך על היררכיה קפדנית של תת-כיתות של Factory:

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

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

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

תיקוני באגים

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

גרסה 2.4

גרסה 2.4.1

9 בפברואר 2022

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

תיקוני באגים

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

גרסה 2.4.0

27 באוקטובר 2021

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

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

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

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

    בעבר, androidx.lifecycle.ProcessLifecycleOwnerInitializer היה אחראי על כך.

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

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

    (או)

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

גרסה 2.4.0-rc01

29 בספטמבר 2021

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

גרסה 2.4.0-beta01

15 בספטמבר 2021

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

שינויים ב-API

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

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

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

גרסה 2.4.0-alpha03

4 באוגוסט 2021

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

שינויים ב-API

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

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

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

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

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

גרסה 2.4.0-alpha02

16 ביוני 2021

androidx.lifecycle:lifecycle-*:2.4.0-alpha02 משוחרר. גרסה 2.4.0-alpha02 כוללת את ההצהרות האלה.

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

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

  • תודה ל-maxsav על שיפור בדיקת האיתור של שגיאות בקוד (lint) ב-NullSafeMutableLiveData. (#147, ‏ b/183696616)
  • תודה ל-kozaxinan על שיפור בדיקת האיתור של שגיאות בקוד (lint) ב-NullSafeMutableLiveData. (#161, ‏ b/184830263)

גרסה 2.4.0-alpha01

24 במרץ 2021

androidx.lifecycle:lifecycle-*:2.4.0-alpha01 משוחרר. גרסה 2.4.0-alpha01 מכילה את ההצהרות האלה.

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

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

    בעבר, androidx.lifecycle.ProcessLifecycleOwnerInitializer היה אחראי על כך.

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

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

    (או)

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

שינויים ב-API

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

תיקוני באגים

  • מ-Lifecycle 2.3.1: עכשיו אפשר להבדיל כראוי בין משתני שדות עם יכולת אופציונליות שונה באמצעות כלל האיתור של שגיאות בקוד (lint) NonNullableMutableLiveData. (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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

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

  • הגרסה הזו מאפשרת ל-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 שאפשר להעביר לו ערך null, כדי לקבוע טוב יותר אם 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

Lifecycle Version 2.3.1

24 במרץ 2021

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

תיקוני באגים

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

גרסה

גרסה

10 בפברואר 2021

androidx.lifecycle:lifecycle-*:2.3.0 משוחרר. גרסה 2.3.0 כוללת את ההצהרות האלה.

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

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

גרסה 2.3.0-rc01

16 בדצמבר 2020

androidx.lifecycle:lifecycle-*:2.3.0-rc01 משוחרר. גרסה 2.3.0-rc01 כוללת את ההצהרות האלה.

תיקוני באגים

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

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

גרסה 2.3.0-beta01

1 באוקטובר 2020

androidx.lifecycle:lifecycle-*:2.3.0-beta01 משוחרר. גרסה 2.3.0-beta01 מכילה את ההצהרות האלה.

שינויים ב-API

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

תיקוני באגים

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

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

גרסה 2.3.0-alpha07

19 באוגוסט 2020

androidx.lifecycle:lifecycle-*:2.3.0-alpha07 משוחרר. גרסה 2.3.0-alpha07 מכילה את ההצהרות האלה.

תיקוני באגים

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

גרסה 2.3.0-alpha06

22 ביולי 2020

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

תכונות חדשות

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

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

  • LifecycleRegistry אוכף עכשיו את DESTROYED כמצב סופי. (I00887)
  • LifecycleRegistry מאמת עכשיו שהשיטות שלו נקראות בשרשור הראשי. תמיד הייתה דרישה למחזור החיים של פעילויות, קטעי קוד וכו'. הוספת משגיחים משרשורות שאינם הראשיים הביאה לקריסות שקשה לזהות בסביבת זמן הריצה. לגבי אובייקטים מסוג 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 מטפל עכשיו טוב יותר במקרים של קריאה חוזרת (reentrant), ומונעת קריאות כפולות ל-onActive() או ל-onInactive(). (b/157840298)
  • תוקנה בעיה שבה בדיקות Lint לא היו פועלות ב-Android Studio 4.1 Canary 6 ואילך. (aosp/1331903)

גרסה 2.3.0-alpha04

10 ביוני 2020

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

תיקוני באגים

  • תוקנה קריסה בבדיקת ה-Lint של NonNullableMutableLiveData. (b/157294666)
  • בדיקת ה-Lint של NonNullableMutableLiveData מכסה עכשיו מקרים רבים יותר שבהם ערך null הוגדר ב-MutableLiveData עם פרמטר מסוג שאינו 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. נוסף תוסף findViewModelStoreOwner() Kotlin ל-lifecycle-viewmodel-ktx. (aosp/1295522)

תיקוני באגים

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

גרסה 2.3.0-alpha02

29 באפריל 2020

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.3.0-alpha01

4 במרץ 2020

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

תכונות חדשות

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

תיקוני באגים

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

גרסה 2.2.0

ViewModel-Savedstate גרסה 2.2.0

5 בפברואר 2020

androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0 משוחרר. גרסה 2.2.0 כוללת את ההצהרות האלה.

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

גרסה 2.2.0

22 בינואר 2020

androidx.lifecycle:lifecycle-*:2.2.0 משוחרר. גרסה 2.2.0 כוללת את ההצהרות האלה.

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

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

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

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

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

  • התוספים למעקב אחר מחזור חיים תלויים עכשיו ב-Fragment‏ 1.2.0-rc03.

גרסה 2.2.0-rc02

7 בנובמבר 2019

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

תיקוני באגים

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

גרסה 2.2.0-rc01

23 באוקטובר 2019

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

תיקוני באגים

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

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

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

גרסה 2.2.0-beta01

9 באוקטובר 2019

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

תיקוני באגים

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

גרסה 2.2.0-alpha05

18 בספטמבר 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha05 משוחרר. גרסה 2.2.0-alpha05 מכילה את ההצהרות האלה.

תיקוני באגים

  • תוקן מצב מרוץ ב-coroutine livedata builder. ‏ b/140249349

גרסה 2.2.0-alpha04

5 בספטמבר 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha04 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

תכונות חדשות

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

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

  • תודה ל-Nicklas Ansman על התרומה של המעבר אל Dispatchers.Main.immediate! (aosp/1106073)

גרסה 2.2.0-alpha03

7 באוגוסט 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha03 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

תכונות חדשות

שינויים ב-API

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

גרסה 2.2.0-alpha02

2 ביולי 2019

androidx.lifecycle:*:2.2.0-alpha02 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

שינויים ב-API

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

גרסה 2.2.0-alpha01

7 במאי 2019

androidx.lifecycle:*:2.2.0-alpha01 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

תכונות חדשות

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

ViewModel-SavedState גרסה 1.0.0

גרסה 1.0.0

22 בינואר 2020

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

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

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

Viewmodel-Savedstate גרסה 1.0.0-rc02

7 בנובמבר 2019

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

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

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

ViewModel-SavedState גרסה 1.0.0-rc01

23 באוקטובר 2019

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

ViewModel-Savedstate גרסה 1.0.0-beta01

9 באוקטובר 2019

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

תיקוני באגים

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

ViewModel-SavedState גרסה 1.0.0-alpha05

18 בספטמבר 2019

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

שינויים ב-API

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

גרסת ViewModel-SavedState 1.0.0-alpha03

7 באוגוסט 2019

androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha03 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

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

  • 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 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

תכונות חדשות

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

שינויים ב-API

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

ViewModel-Savedstate גרסה 1.0.0-alpha01

13 במרץ 2019

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

תכונות חדשות

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

גרסה

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

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

גרסה

5 בספטמבר 2019

androidx.lifecycle:lifecycle-*:2.1.0 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

גרסה 2.1.0-rc01

2 ביולי 2019

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

גרסה 2.1.0-beta01

7 במאי 2019

androidx.lifecycle:*:2.1.0-beta01 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

תכונות חדשות

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

גרסה 2.1.0-alpha04

3 באפריל 2019

androidx.lifecycle:*:2.1.0-alpha04 משוחרר. כאן אפשר למצוא את ההתחייבויות (commits) שכלולות בגרסה הזו.

שינויים ב-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 כדי לאפשר ערפול קוד (obfuscation) וצמצום (shrinking)

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

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

dependencies {
    def lifecycle_version = "1.1.1"

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

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

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

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

גרסה 1.1.1

21 במרץ 2018

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

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

גרסה 1.1.0

22 בינואר 2018

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

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

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

שינויים ב-API

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