מחזור חיים

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

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

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

הספרייה הזו עודכנה לאחרונה ב-19 בנובמבר 2025

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

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

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

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

Kotlin

Groovy

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

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

Java

Groovy

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

משוב

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

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

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

גרסה 2.10

גרסה 2.10.0

‫19 בנובמבר 2025

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

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

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

@Composable
fun MyComposable() {
    // This LifecycleOwner is automatically moved to DESTROYED when
    // it leaves composition and its maxLifecycle is the maximum of either
    // the maxLifecycle you set or the Lifecycle.State of the parentLifecycleOwner
    val lifecycleOwner = rememberLifecycleOwner(
        maxLifecycle = RESUMED,
        parentLifecycleOwner = LocalLifecycleOwner.current,
    )
    CompositionLocalProvider(LocalLifecycleOwner provides lifecycleOwner) {
        val childLifecycleOwner = LocalLifecycleOwner.current
    }
}

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

@Composable
fun MyComposable() {
    NavDisplay(
        backStack = backStack,
        entryDecorators =
            listOf(
                rememberSaveableStateHolderNavEntryDecorator(),
                // Add this line to automatically scope ViewModels to each entry
                rememberViewModelStoreNavEntryDecorator(),
            ),
        entryProvider = entryProvider {
            // Add your entries here
        }
    }
}

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

override val defaultViewModelCreationExtras: CreationExtras
    // Use the CreationExtras builder to add in a custom value to the default
    // CreationExtras in your Activity or Fragment
    get() = super.defaultViewModelCreationExtras + CreationExtras {
        this[CustomKey] = "customValue"
   }

הוספנו תמיכה מקורית בסוגים שניתנים לאיפוס ב-SavedStateHandle.saved, כדי לפשט את השמירה והשחזור של מאפיינים שניתנים לאיפוס.
סימון של בנאי SavedStateHandle כ-@VisibleForTesting.
הערך של minSdk השתנה מ-API 21 ל-API 23.

גרסה ‎2.10.0-rc01

‫5 בנובמבר 2025

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

גרסה ‎2.10.0-beta01

‫22 באוקטובר 2025

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.10.0-alpha05

‫8 באוקטובר 2025

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

שינויים ב-API

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

גרסה ‎2.10.0-alpha04

‫24 בספטמבר 2025

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

שינויים ב-API

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

גרסה ‎2.10.0-alpha03

‫27 באוגוסט 2025

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

שינויים ב-API

עדכון של Compose לגרסה 1.9.0. (I2b9de)

גרסה ‎2.10.0-alpha02

‫13 באוגוסט 2025

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

תכונות חדשות

הקומפוננטה LifecycleOwner יכולה ליצור עכשיו מחזור חיים עצמאי של רכיב הבסיס. אם מגדירים את parent = null באופן מפורש, מחזור החיים החדש פועל באופן עצמאי ללא קשר למארח (כמו Activity,‏ Fragment או NavBackStackEntry). הוא מתחיל ברגע שהרכיב הניתן להרכבה נכנס לקומפוזיציה, ונהרס אוטומטית כשהוא יוצא ממנה. (I8dfbe, ‏ b/433659048)
```
@Composable
fun IndependentComponent() {
    // Create a standalone lifecycle, not tied to the parent Activity/Fragment.
    LifecycleOwner(parent = null) {
        val rootLifecycle = LocalLifecycleOwner.current.lifecycle
    }
}
```

שינויים ב-API

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

תיקוני באגים

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

External Contribution

הסרת שדות גיבוי פנימיים מיותרים מ-LifecycleOwner. תודה ל-Jake Wharton על התרומה. (Ideddb)

גרסה ‎2.10.0-alpha01

‫30 ביולי 2025

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

תכונות חדשות

מוסיפים LifecycleOwner composable כדי לאפשר יצירת מחזורי חיים בהיקף ישירות בממשק המשתמש. האפשרות הזו שימושית לרכיבים שצריכים לנהל את מחזור החיים שלהם באופן עצמאי. דוגמה לאופן שבו רכיב חדש שאפשר להרכיב משולב ב-Navigation3 זמינה בכתובת aosp/3708610. (76cbf7)
```
@Composable
fun MyComposable() {
    LifecycleOwner(
        maxLifecycle = RESUMED,
        parentLifecycleOwner = LocalLifecycleOwner.current,
    ) {
        val childLifecycleOwner = LocalLifecycleOwner.current
    }
}
```

שינויים ב-API

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

גרסה 2.9

גרסה 2.9.4

‫17 בספטמבר 2025

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

תיקוני באגים

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

גרסה 2.9.3

‫27 באוגוסט 2025

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

תכונות חדשות

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

תיקוני באגים

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

גרסה 2.9.2

‫16 ביולי 2025

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

תיקוני באגים

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

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

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

גרסה 2.9.1

‫4 ביוני 2025

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

תיקוני באגים

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

גרסה 2.9.0

‫7 במאי 2025

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

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

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

תמיכה ב-KotlinX Serialization

הוספנו תמיכה ב-KotlinX Serialization ב-SavedState 1.3.0, והשקנו את saved, נציג מאפיינים עצלן, כדי לאפשר לכם לאחסן בקלות מחלקות @Serializable ב-SavedStateHandle ולשחזר את המחלקות האלה באופן אוטומטי אחרי שהתהליך נסגר ונוצר מחדש. חשוב לזכור שהנציג saved הוא עצלן ולא יפעיל את פונקציית ה-lambda‏ init או ישמור משהו ב-SavedStateHandle עד שתהיה אליו גישה.
```
@Serializable
data class Person(val firstName: String, val lastName: String)

class MyViewModel(handle: SavedStateHandle) : ViewModel() {
    var person by handle.saved { Person("John", "Doe") }

    fun onPersonChanged(person: Person) {
        this.person = person
    }
}
```

Kotlin Multiplatform

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

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

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

גרסה ‎2.9.0-rc01

‫23 באפריל 2025

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

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

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

גרסה ‎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 כדי לוודא ששינויים במצב מחזור החיים גורמים להרכבה מחדש בצורה נכונה. תודה, סטיבן שון! (Iad484)

גרסה ‎2.9.0-alpha09

‫29 בינואר 2025

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

תכונות חדשות

הוספת MutableStateSerializer לסדרת androidx.compose.runtime.MutableState. (Idfc48, ‏ b/378895074)

שינויים ב-API

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

גרסה ‎2.9.0-alpha08

‫11 בדצמבר 2024

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

תכונות חדשות

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

תיקוני באגים

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

תיקוני באגים

בקטע מחזור חיים 2.8.5: מעדכנים את כללי ProGuard‏ androidx.lifecycle.ReportFragment כדי לאפשר טשטוש . (ff898e1)

External Contribution

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

גרסה ‎2.9.0-alpha01

‫7 באוגוסט 2024

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

Kotlin Multiplatform

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.8

גרסה 2.8.7

‫30 באוקטובר 2024

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

שינויים ב-API

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

גרסה 2.8.6

‫18 בספטמבר 2024

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

תיקוני באגים

התמיכה ב-NullSafeMutableLiveData Lint error השתפרה, ועכשיו היא כוללת smart casts כדי למנוע תוצאות חיוביות מטעות. (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 ומטה כשמשתמשים בהקטנת קוד. ‫(aosp/3133056, b/346808608)

גרסה 2.8.2

‫12 ביוני 2024

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

תיקוני באגים

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

גרסה 2.8.1

‫29 במאי 2024

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

תיקוני באגים

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

גרסה 2.8.0

‫14 במאי 2024

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

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

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

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

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

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

הפונקציה ViewModel נכתבה מחדש ב-Kotlin ועכשיו היא משתמשת ב-AutoClosable במקום ב-Closeable. מעכשיו יש תמיכה בהוספת אובייקטים של AutoCloseable עם key שמאפשר לאחזר אותם באמצעות getCloseable().
קריאה ל-API של LifecycleStartEffect ול-API של LifecycleResumeEffect ללא מפתח היא עכשיו שגיאה, בהתאם לאותה קונבנציה כמו ב-API של DisposableEffect, שהממשקים האלה משקפים.
המאפיין LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) הוצא משימוש לטובת LiveData.toPublisher(lifecycleOwner).
התוספים של lifecycle-livedata-core-ktx kotlin הועברו עכשיו למודול lifecycle-livedata-core.
בוצע refactoring ב-NullSafeMutableLiveData כדי למנוע הרבה תוצאות חיוביות כוזבות.

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

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

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

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

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

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

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

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

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

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

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

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

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

בעיות מוכרות

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

גרסה 2.8.0-rc01

‫1 במאי 2024

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

תיקוני באגים

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

תיקוני באגים

בוצע refactoring ב-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 מכילה את הקומטים האלה.

תכונות חדשות

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

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

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

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

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

תיקוני באגים

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

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 extensions למודול מחזור החיים הבסיסי. (Id787b, ‏ b/274800183)
העברנו את lifecycle-runtime-ktx kotlin extensions למודול מחזור החיים הבסיסי. (Ic3686, b/274800183)
העברנו את lifecycle-livedata-core-ktx kotlin extensions למודול מחזור החיים הבסיסי. (I54a3d, b/274800183)

תאימות ל-Kotlin Multiplatform

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

שינויים ב-API

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

Lifecycle Event Observability

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

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

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

גרסה ‎2.7.0-rc01

‫15 בנובמבר 2023

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

תיקוני באגים

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

גרסה ‎2.7.0-beta01

‫1 בנובמבר 2023

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

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

גרסה ‎2.7.0-alpha03

‫18 באוקטובר 2023

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎2.7.0-alpha02

‫6 בספטמבר 2023

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

תכונות חדשות

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

שינויים ב-API

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

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

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

תיקוני באגים

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

גרסה ‎2.7.0-alpha01

‫26 ביולי 2023

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.6

גרסה 2.6.2

‫6 בספטמבר 2023

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

תיקוני באגים

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

גרסה 2.6.1

‫22 במרץ 2023

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

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

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

גרסה 2.6.0

‫8 במרץ 2023

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

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

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

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

מחזור חיים 2.5	מחזור חיים 2.5 (KTX)	מחזור חיים 2.6
`Transformations.switchMap(liveData) {...}`	`liveData.switchMap {...}`	`liveData.switchMap {...}`
`Transformations.map(liveData) {...}`	`liveData.map {...}`	`liveData.map {...}`
`Transformations.distinctUntilChanged(liveData) {...}`	`liveData.distinctUntilChanged{...}`	`liveData.distinctUntilChanged{...}`
`LiveDataReactiveStreams.fromPublisher(publisher)`	`publisher.toLiveData()`	`publisher.toLiveData()`
`LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData)`	`liveData.toPublisher(lifecycleOwner)`	`liveData.toPublisher(lifecycleOwner)`
`override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory`	`override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory`	`override val defaultViewModelProviderFactory = factory`
`override fun getDefaultViewModelCreationExtras(): CreationExtras = extras`	`override fun getDefaultViewModelCreationExtras(): CreationExtras = extras`	`override val defaultViewModelProviderCreationExtras = extras`
`ViewTreeLifecycleOwner.set(view, owner)`	`ViewTreeLifecycleOwner.set(view, owner)`	`view.setViewTreeLifecycleOwner(owner)`
`ViewTreeLifecycleOwner.get(view)`	`view.findViewTreeLifecycleOwner()`	`view.findViewTreeLifecycleOwner()`
`override fun getViewModelStore(): ViewModelStore = store`	`override fun getViewModelStore(): ViewModelStore = store`	`override val viewModelStore: ViewModelStore = store`
`override fun getLifecycle(): Lifecycle = registry`	`override fun getLifecycle(): Lifecycle = registry`	`override val lifecycle: Lifecycle get() = registry`

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

גרסה ‎2.6.0-alpha04

‫11 בינואר 2023

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

תכונות חדשות

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

שינויים ב-API

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

המרות של Kotlin

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

תיקוני באגים

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

גרסה ‎2.6.0-alpha03

24 באוקטובר 2022

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

תיקוני באגים

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

גרסה ‎2.6.0-alpha02

‫7 בספטמבר 2022

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.6.0-alpha01

29 ביוני 2022

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

תכונות חדשות

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

גרסה 2.5

גרסה 2.5.1

‫27 ביולי 2022

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

תיקוני באגים

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

גרסה 2.5.0

29 ביוני 2022

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

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

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

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

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

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

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

‫lifecycle-viewmodel-compose מציע עכשיו API של viewModel() שמקבל פונקציית למבדה ליצירת מופע של 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 constructor תוך שמירה על אותו משך חיים כמו viewModelScope:
```
class TestScopeViewModel(
    val customScope: CloseableCoroutineScope = CloseableCoroutineScope()
) : ViewModel(customScope) {
    // You can now use customScope in the same way as viewModelScope
}
```

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

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

גרסה ‎2.5.0-rc02

‫15 ביוני 2022

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

תיקוני באגים

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

גרסה ‎2.5.0-rc01

‫11 במאי 2022

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

תיקוני באגים

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

גרסה ‎2.5.0-beta01

‫20 באפריל 2022

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha06

‫6 באפריל 2022

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

תכונות חדשות

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

תכונות חדשות

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

שינויים ב-API

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

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

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

גרסה ‎2.5.0-alpha02

‫9 בפברואר 2022

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

שינויים ב-API

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

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

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

תיקוני באגים

מתוך 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 שבו ישתמשו מעכשיו והלאה.

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

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

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

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

תיקוני באגים

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

גרסה 2.4

גרסה 2.4.1

‫9 בפברואר 2022

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

תיקוני באגים

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

גרסה 2.4.0

‫27 באוקטובר 2021

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

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

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

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

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

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

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

(או)

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

גרסה ‎2.4.0-rc01

‫29 בספטמבר 2021

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

גרסה ‎2.4.0-beta01

‫15 בספטמבר 2021

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

שינויים ב-API

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

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

תכונות חדשות

נוסף RepeatOnLifecycleWrongUsage lint check חדש ל-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)
תוקנה בעיה נוספת בבדיקת ה-lint‏ NullSafeMutableLiveData כשמשתמשים בגנריות. (מס' 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.

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

10 בפברואר 2021

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

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

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

תכונות חדשות

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

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

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha05

‫24 ביוני 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha04

‫10 ביוני 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha03

20 במאי 2020

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha02

29 באפריל 2020

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

שינויים ב-API

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

תיקוני באגים

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

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

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

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

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

גרסה ‎2.2.0-rc02

‫7 בנובמבר 2019

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

תיקוני באגים

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

גרסה ‎2.2.0-rc01

‫23 באוקטובר 2019

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

תיקוני באגים

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

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

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

גרסה ‎2.2.0-beta01

‫9 באוקטובר 2019

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

תיקוני באגים

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

גרסה ‎2.2.0-alpha05

‫18 בספטמבר 2019

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

תיקוני באגים

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

גרסה ‎2.2.0-alpha04

‫5 בספטמבר 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha04 משוחרר. כאן אפשר לראות את הקומיטים שכלולים בגרסה הזו.

תכונות חדשות

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

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

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

גרסה ‎2.2.0-alpha03

‫7 באוגוסט 2019

androidx.lifecycle:lifecycle-*:2.2.0-alpha03 משוחרר. כאן אפשר לראות את הקומיטים שכלולים בגרסה הזו.

תכונות חדשות

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

שינויים ב-API

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

גרסה ‎2.2.0-alpha02

‫2 ביולי 2019

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

שינויים ב-API

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

גרסה ‎2.2.0-alpha01

‫7 במאי 2019

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

תכונות חדשות

בגרסה הזו הוספנו תכונות חדשות שמוסיפות תמיכה ב-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 Version 1.0.0-rc03

4 בדצמבר 2019

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

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

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

‫Viewmodel-Savedstate גרסה ‎1.0.0-rc02

‫7 בנובמבר 2019

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

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

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

ViewModel-SavedState גרסה ‎1.0.0-rc01

‫23 באוקטובר 2019

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

ViewModel-Savedstate גרסה ‎1.0.0-beta01

‫9 באוקטובר 2019

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

תיקוני באגים

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

ViewModel-SavedState גרסה ‎1.0.0-alpha05

‫18 בספטמבר 2019

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

שינויים ב-API

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

‫ViewModel-SavedState גרסה ‎1.0.0-alpha03

‫7 באוגוסט 2019

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

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

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

‫ViewModel-SavedState גרסה ‎1.0.0-alpha02

‫2 ביולי 2019

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

תכונות חדשות

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

שינויים ב-API

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

‫ViewModel-Savedstate גרסה ‎1.0.0-alpha01

‫13 במרץ 2019

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

תכונות חדשות

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

גרסה 2.1.0

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

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

גרסה 2.1.0

‫5 בספטמבר 2019

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

גרסה ‎2.1.0-rc01

‫2 ביולי 2019

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

גרסה ‎2.1.0-beta01

‫7 במאי 2019

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

תכונות חדשות

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

גרסה ‎2.1.0-alpha04

‫3 באפריל 2019

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

שינויים ב-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 ל-methods‏ LiveData.observe ול-methods‏ Transformations.*.
השיטה Transformations.distinctUntilChanged נוספה. היא יוצרת אובייקט LiveData חדש שלא פולט ערך עד שערך ה-LiveData של המקור משתנה.
תמיכה ב-Coroutine ב-ViewModels: נוספה מאפיין ההרחבה ViewModel.viewModelScope.
נוספה ViewModelProvider.KeyedFactory, מחלקה ליצירת ViewModel שמקבלת את key ואת Class בשיטה create.

גרסה 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
ה-constructor ‏ViewModelProviders הוצא משימוש – צריך להשתמש ישירות בשיטות הסטטיות שלו
האפשרות ViewModelProviders.DefaultFactory הוצאה משימוש. במקומה יש להשתמש באפשרות ViewModelProvider.AndroidViewModelFactory
ה-method הסטטית ViewModelProvider.AndroidViewModelFactory.getInstance(Application) נוספה כדי לאחזר Factory סטטי שמתאים ליצירת מופעים של ViewModel ו-AndroidViewModel.