מחזור חיים

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

בטבלה הזו מפורטים כל פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) בקבוצה androidx.lifecycle.

פריט מידע שנוצר בתהליך פיתוח (Artifact) גרסה יציבה מועמד לגרסה גרסת בטא גרסת אלפא
מחזור חיים-* 2.8.4 - - -
הרכבה של מודל צפייה במחזור חיים 2.8.4 - - -
הספרייה הזו עודכנה לאחרונה ב-24 ביולי 2024

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

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

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

Kotlin

מגניב

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

Java

מגניב

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

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

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

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

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

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

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

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

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

Kotlin

    dependencies {
        val lifecycle_version = "2.8.4"
        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.8

גרסה 2.8.4

24 ביולי 2024

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

תיקוני באגים

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

גרסה 2.8.3

1 ביולי 2024

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

תיקוני באגים

  • תוקנה בעיה בתאימות לאחור של מחזור חיים 2.8 עם 'כתיבה' בגרסה 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 שגיאות במחזור חיים 2.8.X עם 'כתיבה' בגרסה 1.6.X ומטה. עכשיו אפשר להשתמש במחזור חיים 2.8.2 בכל גרסה של 'כתיבה' ללא צורך בפתרונות עקיפים. (aosp/3105647, b/336842920)
  • ViewModelProvider לא תקרוס יותר במהלך שילוב גרסאות קודמות של יחסי תלות של compileOnly במחזור החיים עם גרסאות 2.8 ואילך, ופתרון בעיות בספריות כמו LeakCanary. (I80383, b/341792251)

גרסה 2.8.1

29 במאי 2024

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

תיקוני באגים

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

גרסה 2.8.0

14 במאי 2024

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

שינויים חשובים מאז 2.7.0

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

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

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

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

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

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

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

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

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

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

ממשקי ה-API העיקריים של מחזור החיים ב-Lifecycle, ב-LifecycleOwner, ב-LifecycleObserver, ב-Lifecycle.State, ב-Lifecycle.Event וב-LifecycleRegistry נשלחים עכשיו בפריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שתואמים ל-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 ושולח פריט מידע שנוצר בתהליך הפיתוח (Artifact) של Android, שתואם לתמיכה בפלטפורמות מרובות של androidx.compose.

תאימות ל-ViewModel Kotlin לריבוי פלטפורמות

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

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

תאימות בינארית ב-Android נשמרה, אבל יש כמה שינויים חשובים כשמשווים את פלטפורמת Android API לפלטפורמה המשותפת של ה-API:

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

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

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

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

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

בעיות מוכרות

גרסה 2.8.0-rc01

1 במאי 2024

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

תיקוני באגים

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

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

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

גרסה 2.8.0-beta01

17 באפריל 2024

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

תכונות חדשות

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

גרסה 2.8.0-alpha04

3 באפריל 2024

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

תכונות חדשות

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

תיקוני באגים

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

עדכון בנושא תלות

  • פריט המידע שנוצר בתהליך הפיתוח (Artifact) מסוג lifecycle-viewmodel-compose תלוי עכשיו ב-Compose 1.6.0.
  • מחזור החיים תלוי עכשיו בגרסה 1.3.1 של מנהל ההתקנה של הפרופיל.

גרסה 2.8.0-alpha03

20 במרץ 2024

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

תכונות חדשות

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

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

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

תאימות ל-Kotlin בריבוי פלטפורמות

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

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

תאימות בינארית ב-Android נשמרה, אבל יש כמה שינויים חשובים כשמשווים את פלטפורמת Android API לפלטפורמה המשותפת של ה-API:

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

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

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

תיקוני באגים

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

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

  • LocalLifecycleOwner עבר מממשק המשתמש של כתיבת הודעה לכתיבה בזמן הרצה של מחזור החיים, כדי שאפשר יהיה להשתמש בממשקי ה-API לעזרה שמבוססים על הכתיבה מחוץ לממשק המשתמש של הכתיבה. תודה על התרומה, 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 הנתון. לדוגמה, אפשר להשתמש באפשרות הזו בשילוב עם 'כתיבה' כדי להימנע מטיפול באירועי קליקים אחרי שמעבר למסך אחר כבר התחיל: onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) } (Icba83, b/317230685)

המרות של קוטלין

  • ViewModel כתוב עכשיו ב-Kotlin (I16f26, b/214568825)
  • תוספי Kotlin עם lifecycle-viewmodel-ktx הועברו למודול של מחזור החיים הבסיסי. (Id787b, b/274800183)
  • תוספי Kotlin עם lifecycle-runtime-ktx הועברו למודול של מחזור החיים הבסיסי. (Ic3686, b/274800183)
  • תוספי Kotlin עם lifecycle-livedata-core-ktx הועברו למודול של מחזור החיים הבסיסי. (I54a3d, b/274800183)

תאימות ל-Kotlin בריבוי פלטפורמות

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

שינויים ב-API

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

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

  • תודה לאבן מטקוב מ-Jetbrains על העזרה בהעברת מחזור החיים ל-Kotlin Multiplatform. (aosp/2926690, I0c5ac, If445d)

גרסה 2.8.0-alpha01

24 בינואר 2024

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

תכונות חדשות

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

גרסה 2.7

גרסה 2.7.0

10 בינואר 2024

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

שינויים חשובים מאז 2.6.0

  • TestLifecycleOwner כולל עכשיו פונקציית השעיה setCurrentState() שמבטיחה ששינוי המצב וכל הקריאות החוזרות (callback) של LifecycleObserver הושלמו לפני החזרה. חשוב לציין שבניגוד להגדרה ישירה של המאפיין currentState, השיטה הזו לא משתמשת ב-runBlocking, כך שבטוח להשתמש בה בתוך קורוטין, כמו למשל שסופק על ידי runTest.
  • התוספים LiveData של map ו-switchMap משקפים עכשיו את ההתנהגות של distinctUntilChanged. אם ל-LiveData מוגדר value, תתבצע קריאה לפונקציה map/switchMap מיד כדי לאכלס את ה-value של הערכים המוחזרים LiveData. הפעולה הזו מבטיחה שהערך הראשוני יוגדר כחלק מההרכב הראשון (כשמשתמשים בו עם observeAsState()), אבל הוא לא ישנה את התנהגות התצפית. עדכוני ערכים מהמקור LiveData עדיין יחולו רק לאחר שתתחילו לצפות ב-LiveData.
  • בגרסה הזו מתקנת בעיה שגרמה לכך ש-SavedStateHandle לא ישחזר באופן תקין מחלקות Parcelable בהתאמה אישית אחרי מוות ויצירה של תהליך מחדש. בגלל מידע על סוגים שאבד על ידי מסגרת Android, מערכים של מגרשים בהתאמה אישית מחייבים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון). בנוסף, במסמכים ב-get, ב-getLiveData וב-getStateFlow מוסברת עכשיו המגבלה הזו באופן ספציפי.
  • כללי השמירה במסגרת ההגנה המשויכים אל LifecycleObserver הוסרו. כלומר, קוד מוגן שרוצה להשתמש בממשקי API דרך הרפליקציה (למשל, באמצעות ההערה @OnLifecycleEvent שהוצאה משימוש) יצטרך לספק כללי שמירה משלו לתרחיש הספציפי לדוגמה שלו.

ניראות של אירועים במחזור החיים

  • במקום להשתמש ב-LifecycleEventObserver, עכשיו אפשר לצפות ב-Flow של Lifecycle.Event באמצעות שיטת התוסף Lifecycle.asFlow().
  • מעכשיו, משתמשי Jetpack Compose יכולים להשתמש ב-LifecycleEventEffect כדי להריץ תופעות לוואי של 'כתיבה' על סמך Lifecycle.Event.
@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
    viewModel.refreshData()
  }
  // …
}
  • משתמשי Jetpack Compose יכולים להשתמש ב-LifecycleStartEffect וב-LifecycleResumeEffect כדי לטפל בצמדים של אירועים – שהתחילו לפעול והושהו בהשהיה, בהתאמה. ה-API הזה משקף את ה-API שנמצא ב-DisposableEffect, והוא מתאים למקרים שבהם צריך לבצע את השינוי כשמופיע חזרה למצב הקודם.
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleStartEffect(viewModel) {
    val timeTracking = viewModel.startTrackingTimeOnScreen()
    onStopOrDispose {
      timeTracking.stopTrackingTimeOnScreen()
    }
  }
  // …
}

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

ניראות (observability) המצב של מחזור החיים

  • עכשיו אפשר לראות את הערך הנוכחי של Lifecycle.State דרך הנכס Lifecycle.currentStateFlow, שמחזיר StateFlow כאשר value הוא Lifecycle.State הנוכחי.
  • משתמשי 'Jetpack פיתוח נייטיב' יכולים להשתמש בתוסף Lifecycle.currentStateAsState() כדי לחשוף את Lifecycle.State ישירות כ'כתיבה' State. היא מקבילה (וחלופה קצרה יותר) ל-lifecycle.currentStateFlow.collectAsState().

מידע נוסף מופיע במאמר איסוף מצב מחזור חיים באמצעות תהליכים.

גרסה 2.7.0-rc02

13 בדצמבר 2023

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

תיקוני באגים

  • תוקנה בעיה שגרמה לכך ש-SavedStateHandle לא הצליח לשחזר באופן תקין כיתות Parcelable בהתאמה אישית אחרי מוות של תהליך ויצירה של נכס מחדש. בגלל מידע על סוגים שאבד על ידי מסגרת Android, מערכים של מגרשים בהתאמה אישית מחייבים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון). בנוסף, במסמכים ב-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 כשנמצאים בקורוטין. בדיקת השגיאות בקוד מציעה עכשיו את האפשרות 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 פיתוח נייטיב מאפשר את המצב הנכון עבור היצירה הראשונית. (I91d2b, b/269479952)
  • המכשיר addCloseable() של ViewModel סוגר עכשיו את Closeable אם ViewModel כבר קיבל שיחה למספר onCleared(). (I4712e, b/280294730)

תיקוני באגים

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

גרסה 2.7.0-alpha01

26 ביולי 2023

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.6

גרסה 2.6.2

6 בספטמבר 2023

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

תיקוני באגים

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

גרסה 2.6.1

22 במרץ 2023

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

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

גרסה 2.6.0

8 במרץ 2023

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

שינויים חשובים מאז 2.5.0

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

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

מחזור חיים 2.5 Lifecycle 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 מכילה את התחייבויות אלה.

המרות של קוטלין

  • 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 מכילה את התחייבויות אלה.

המרות של קוטלין

  • Transformations כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור הכיתות שנכתבו ב-Kotlin באופן ישיר שהשתמשו בתחביר כמו Transformations.map – קוד Kotlin חייב עכשיו להשתמש בתחביר שיטת התוסף Kotlin שהיה זמין בעבר רק בעת השימוש ב-lifecycle-livedata-ktx. כשמשתמשים בשפת התכנות Java, הגרסאות של השיטות האלה שמבוססות על שיטת androidx.arch.core.util.Function הוצאו משימוש ומוחלפות בגרסאות שמשתמשות ב-Kotlin Function1. השינוי הזה שומר על תאימות בינארית. (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. ה-method onChanged() משתמשת עכשיו בשם value כפרמטר. (Iffef2, I4995e, b/240298691)
  • AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher ו-ProcessLifecycleOwner נכתבים עכשיו ב-Kotlin (I2e771, Ibae40, I160d7, I08884, I1cda7, b/240298)691{/11

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

המרות של קוטלין

  • 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, I59a/23I59a23

תיקוני באגים

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

גרסה 2.6.0-alpha03

24 באוקטובר 2022

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

תיקוני באגים

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

גרסה 2.6.0-alpha02

7 בספטמבר 2022

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

שינויים ב-API

  • MediatorLiveData כולל עכשיו constructor להגדרה של ערך ראשוני. (Ib6cc5, b/151244085)

תיקוני באגים

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

גרסה 2.6.0-alpha01

29 ביוני 2022

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

תכונות חדשות

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

גרסה 2.5

גרסה 2.5.1

27 ביולי 2022

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

תיקוני באגים

  • הטמעות מותאמות אישית של AndroidViewModelFactory קוראות עכשיו לפונקציה create(modelClass) כראוי כשמשתמשים ב-constructor של AndroidViewModelFactory עם המצבים הבאים: 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). התוספות האלה מסופקות באופן אוטומטי על ידי 'הפעילות או המקטע' שלך, בעת שימוש בפעילות 1.5.0 ובמקטע 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 מספק עכשיו DSL של Kotlin מסוג viewModelFactory שמאפשר להגדיר את ViewModelProvider.Factory במונחים של מאתחל אחד או יותר של lambda, אחד לכל מחלקה ספציפית של ViewModel שנתמכת על ידי המפעל המותאם אישית שלך, תוך שימוש ב-CreationExtras כמקור הנתונים הראשי.

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

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

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

  • שילוב של מצב חיסכון בכתיבה של SavedStateHandle – פריט המידע שנוצר בתהליך הפיתוח (Artifact) מסוג lifecycle-viewmodel-compose מכיל עכשיו ממשקי API ניסיוניים חדשים ב-SavedStateHandle.saveable, שמאפשרים התנהגות דומה ל-rememberSaveable שמגובה ב-SavedStateHandle של 'ViewModel'.

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

  • נוספו API של addCloseable() ועומס יתר חדש של constructor, שמאפשר להוסיף אובייקט 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()
   }
}

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

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

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

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

גרסה 2.5.0-rc02

15 ביוני 2022

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

תיקוני באגים

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

גרסה 2.5.0-rc01

11 במאי 2022

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

תיקוני באגים

  • עכשיו MediatorLiveData.addSource() זורקת NullPointerException כשמעבירים מקור null במקום להפיץ את המקור null לתצפית.(Ibd0fb, b/123085232)

גרסה 2.5.0-beta01

20 באפריל 2022

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

שינויים ב-API

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

תיקוני באגים

  • תוקנה בעיה שבה הצבת NavHost בתוך NavHost אחר בכרטיסיית ניווט תחתונה שאינה ראשית הובילה לערך IllegalStateException כשמשתמשים במספר מקבצים של אחורה. (I11bd5, b/228865698)

גרסה 2.5.0-alpha06

6 באפריל 2022

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

תכונות חדשות

  • הוספת עומס יתר ניסיוני של MutableState ל-SavedStateHandle.saveable עבור התאמה ל-rememberSaveable (I38cfe, b/224565154)

שינויים ב-API

  • עכשיו הטקסט CreationExtras מופשט במקום בחתימה. (Ib8a7a)

תיקוני באגים

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

גרסה 2.5.0-alpha05

23 במרץ, 2022

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

  • SavedStateViewFactory תומך עכשיו בשימוש ב-CreationExtras גם כאשר הוא אותחל עם SavedStateRegistryOwner. אם תספקו תוספות, המערכת תתעלם מהארגומנטים המאתחלים. (I6c43b, b/224844583)

גרסה 2.5.0-alpha04

9 במרץ 2022

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

שינויים ב-API

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

גרסה 2.5.0-alpha03

23 בפברואר 2022

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

תכונות חדשות

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

שינויים ב-API

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

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

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

גרסה 2.5.0-alpha02

9 בפברואר 2022

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

שינויים ב-API

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

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

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

תיקוני באגים

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

גרסה 2.5.0-alpha01

26 בינואר, 2022

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

ViewModel CreationExtras

בגרסה הזו, אנחנו מניחים את היסודות לשינוי המבנה של ViewModel. במקום קבוצה קשיחה של מחלקות משנה של ViewModelProvider.Factory שכל אחת מהן מוסיפה פונקציונליות נוספת (המאפשרת פרמטר Application של constructor דרך AndroidViewModelFactory, מה שמאפשר פרמטר SavedStateHandle של constructor דרך 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.

התוספות האלה מסופקות כברירת מחדל בעת שימוש בפעילות 1.5.0-alpha01, מקטע 1.5.0-alpha01 וניווט 2.5.0-alpha01. אם משתמשים בגרסה קודמת של הספריות האלה, CreationExtras יהיה ריק – כל מחלקות המשנה הקיימות של ViewModelProvider.Factory נכתבו מחדש כדי לתמוך בנתיב היצירה מהדור הקודם ששימשו בגרסאות הקודמות של הספריות האלה, וגם בנתיב CreationExtras שבו ייעשה שימוש בעתיד.

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

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

תיקוני באגים

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

גרסה 2.4.0

27 באוקטובר 2021

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

שינויים חשובים מאז 2.3.0

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

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

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

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

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

    (או)

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

גרסה 2.4.0-rc01

29 בספטמבר 2021

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

גרסה 2.4.0-beta01

15 בספטמבר 2021

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

שינויים ב-API

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

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

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

גרסה 2.4.0-alpha03

4 באוגוסט 2021

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

שינויים ב-API

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

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

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

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

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

גרסה 2.4.0-alpha02

16 ביוני 2021

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

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

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

גרסה 2.4.0-alpha01

24 במרץ 2021

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

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

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

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

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

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

    (או)

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 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 של 'כתיבה'.

גרסה 1.0.0-alpha05

18 במאי 2021

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

תכונות חדשות

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

תיקוני באגים

  • הקבצים 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, צריך שהמהדר (compiler)' ו'סביבת זמן הריצה' יהיו תואמים.

גרסה 1.0.0-alpha03

10 במרץ 2021

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

שינויים ב-API

  • הפונקציה LocalViewModelStoreOwner.current מחזירה עכשיו ערך המאפיין ViewModelStoreOwner ריק כדי לקבוע בצורה מדויקת יותר האם ViewModelStoreOwner זמין של משפטים יחידים, ממשקי API שנדרשים להם ViewModelStoreOwner, כמו בתור viewModel() ו-NavHost, עדיין תגרום לחריגה אם לא מוגדר ViewModelStoreOwner. (Idf39a)

גרסה 1.0.0-alpha02 של מחזור חיים-Viewmodel-Compose

24 בפברואר 2021

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

שינויים ב-API

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

גרסה 1.0.0-alpha01 של מחזור חיים-Viewmodel-Compose

10 בפברואר 2021

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

תכונות חדשות

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

גרסה 2.3.1

גרסה 2.3.1 של מחזור החיים

24 במרץ 2021

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

תיקוני באגים

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

גרסה 2.3.0

גרסה 2.3.0

10 בפברואר 2021

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

שינויים משמעותיים מאז 2.2.0

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

גרסה 2.3.0-rc01

16 בדצמבר 2020

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

תיקוני באגים

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

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

גרסה 2.3.0-beta01

1 באוקטובר 2020

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

שינויים ב-API

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

תיקוני באגים

שינויים במסמכים

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

גרסה 2.3.0-alpha07

19 באוגוסט 2020

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

תיקוני באגים

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

גרסה 2.3.0-alpha06

22 ביולי 2020

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

תכונות חדשות

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

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

  • LifecycleRegistry אוכף עכשיו את DESTROYED כמצב סופי. (I00887)
  • עכשיו יתבצע אימות ל-LifecycleRegistry שה-methods שלו נקראות ב-thread הראשי. זה תמיד היה דרישה למחזורי חיים של פעילויות, מקטעים וכו'. תוספת של צופים משרשורים לא ראשיים גרמה לקריסה קשה של זמן הריצה. באובייקטים של 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)
  • תוקנה בעיה שבה בדיקות לאיתור שגיאות בקוד לא פעלו כשמשתמשים ב-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. (b/157294666)
  • עכשיו בדיקת השגיאות בקוד NonNullableMutableLiveData כוללת יותר מקרים שבהם הוגדר ערך null ב-MutableLiveData עם פרמטר מסוג שהוא לא null. (b/156002218)

גרסה 2.3.0-alpha03

20 במאי 2020

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

תכונות חדשות

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

תיקוני באגים

  • תוקנה בעיה שגרמה לפרסום הבדיקות של איתור השגיאות בקוד (lint) של MutableLiveData שפורסמו במחזור החיים 2.3.0-alpha01 לצד פריט המידע שנוצר בתהליך הפיתוח (Artifact) 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 יש עכשיו אפשרות להעביר Application אפס (null) ל-constructor שלו כדי לשפר את התמיכה במקרים שבהם אין זמינות מיידית ואין צורך בתמיכה ב-AndroidViewModel. (aosp/1285740)

תיקוני באגים

  • ביצועים משופרים להפעלה במצב התחלתי (cold start) על ידי מניעת כשל באימות המחלקה ב-API 28 ובמכשירים ישנים יותר. (aosp/1282118)

גרסה 2.3.0-alpha01

4 במרץ, 2020

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

תכונות חדשות

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

תיקוני באגים

  • לפריט המידע שנוצר בתהליך הפיתוח (Artifact) מסוג lifecycle-runtime יש עכשיו שם חבילה ייחודי. (aosp/1187196)

גרסה 2.2.0

גרסה 2.2.0 של ViewModel-Savedstate

5 בפברואר 2020

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

הגרסה של 'SavedState' בתצוגה של מחזור החיים משותפת עכשיו את אותה הגרסה כמו פריטי מידע אחרים שנוצרים בתהליך הפיתוח (Artifact) של מחזור החיים. ההתנהגות של 2.2.0 זהה להתנהגות של 1.0.0.

גרסה 2.2.0

22 בינואר, 2020

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

שינויים חשובים מאז 2.1.0

  • שילוב קורוטין במחזור החיים: ארטיפקט lifecycle-runtime-ktx החדש מוסיף שילוב בין קורוטינים של מחזור חיים ו-Kotlin. בנוסף, הרחבנו את התוקף של lifecycle-livedata-ktx כדי לנצל את הקורוטינים. למידע נוסף, ראו שימוש בקורוטינים של Kotlin עם רכיבי ארכיטקטורה.
  • הוצאה משימוש של ViewModelProviders.of(): הוצאנו משימוש את ViewModelProviders.of(). ניתן להעביר Fragment או FragmentActivity ל-constructor החדש של ViewModelProvider(ViewModelStoreOwner) כדי לקבל את אותה הפונקציונליות כשמשתמשים ב-Fragment 1.2.0.
  • lifecycle-extensions Artifact הוצאה משימוש: לאחר ההוצאה משימוש של ViewModelProviders.of(), הגרסה הזו מסמנת את הוצאה משימוש של ממשק ה-API האחרון ב-lifecycle-extensions ועכשיו יש להתייחס אל פריט המידע הזה משימוש בשלמותו. מומלץ מאוד בהתאם לפריט המידע הספציפי במחזור החיים שדרוש לך (למשל, lifecycle-service אם משתמשים ב-LifecycleService וב-lifecycle-process אם משתמשים ב-ProcessLifecycleOwner), במקום ב-lifecycle-extensions, כי לא תהיה השקה עתידית של lifecycle-extensions.2.3.0
  • מעבד הערות מצטברות של Gradle: מעבד ההערות של מחזור החיים הוא מצטבר כברירת מחדל. אם האפליקציה כתובה בשפת Java 8, אפשר להשתמש ב-DefautLifecycleObserver במקום זאת. ואם הוא כתוב בשפת התכנות Java 7 שאפשר להשתמש ב-LifecycleEventObserver.

גרסה 2.2.0-rc03

4 בדצמבר 2019

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

תיקוני באגים

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

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

  • תודה לאנדרס ירלברג (Anders Järleber) שתרמת את התיקון! (aosp/1156203)
  • תודה לווסבולוד טולסטופיאטוב מ-Jetbrains שבדק יישום של הוצאה להורג.

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

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

גרסה 2.2.0-rc02

7 בנובמבר 2019

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

תיקוני באגים

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

גרסה 2.2.0-rc01

23 באוקטובר 2019

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

תיקוני באגים

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

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

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

גרסה 2.2.0-beta01

9 באוקטובר 2019

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

תיקוני באגים

  • תוקנה רגרסיה שהושקה ב-Lifecycle 2.2.0-alpha05 בסדר של ProcessLifecycleOwner ו-LifecycleOwner של הפעילות עבר להתחלה והתחדש במכשירי Android 10. (aosp/1128132)
  • תוקנה רגרסיה חדשה במחזור החיים 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 Builder. 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)

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

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

גרסה 2.2.0-alpha03

7 באוגוסט 2019

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

תכונות חדשות

שינויים ב-API

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

גרסה 2.2.0-alpha02

2 ביולי 2019

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

שינויים ב-API

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

גרסה 2.2.0-alpha01

7 במאי 2019

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

תכונות חדשות

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

ViewModel-SavedState גרסה 1.0.0

גרסה 1.0.0

22 בינואר, 2020

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

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

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

ViewModel-Savedstate גרסה 1.0.0-rc03

4 בדצמבר 2019

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

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

  • הערך 'SavedState' של תצוגת מחזור החיים תלוי עכשיו במחזור החיים 2.2.0-rc03.

Viewmodel-Savedstate גרסה 1.0.0-rc02

7 בנובמבר 2019

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

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

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

ViewModel-SavedState גרסה 1.0.0-rc01

23 באוקטובר 2019

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

ViewModel-Savedstate גרסה 1.0.0-beta01

9 באוקטובר 2019

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

תיקוני באגים

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

ViewModel-SavedState גרסה 1.0.0-alpha05

18 בספטמבר 2019

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

שינויים ב-API

  • SavedStateViewModelFactory לא נמשך יותר את הדומיין AbstractSavedStateViewModelFactory, SavedStateHandle ונוצר רק עבור ViewModels שביקשו לקבל אותו (aosp/1113593)

ViewModel-SavedState גרסה 1.0.0-alpha03

7 באוגוסט 2019

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

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

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

גרסה 2.1.0

שינויים חשובים מאז 2.0.0

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

גרסה 2.0.0

גרסה 2.0.0

21 בספטמבר 2018

מחזור החיים 2.0.0 פורסם עם תיקון באג אחד מ-2.0.0-rc01 ב-ViewModel.

תיקוני באגים

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

גרסה 2.0.0-beta01

2 ביולי 2018

תיקוני באגים

  • תוקן כלל מגן של LifecycleObserver שנועד לשמור רק הטמעות, ולא ממשקי משנה b/71389427
  • תוקנו כללי הגנה ב-ViewModel על מנת לאפשר ערפול קוד (obfuscation) וכיווץ

גרסאות טרום-AndroidX

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

גרסה 1.1.0

22 בינואר 2018

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

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

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

שינויים ב-API

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