מחזור חיים

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

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

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

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

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

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

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.11.0-beta02"

        // 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.11.0-beta02")

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

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

מידע נוסף זמין במאמרי העזרה בנושא Issue Tracker.

גרסה 2.11

גרסה ‎2.11.0-beta02

‫19 במאי 2026

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

שינויים ב-API

  • מוסיפים עומס יתר של rememberViewModelStoreNavEntryDecorator שמקבל ViewModelStoreProvider. הפעולה הזו מאפשרת למפתחים להעלות את הפלאגין שמתממשק עם שירותים חיצוניים מעל היקף הקומפוזיציה של ה-decorator, וכך לתמוך בתרחישי שימוש כמו תמיכה בכמה מקבצי פעילויות קודמות (back stack) שבהן קיים אותו רשומה בשתיהן, אבל נדרש ערך דינמי נפרד. (Ibbbfe, ‏ b/503420425)
  • מניעת ניקוי מוקדם של ViewModels משותף כשמסירים ספק אח מההרכב. (Ib321a)

תיקוני באגים

  • כדי להשתמש ב-LocalLifecycleOwner, נדרשת גרסה 1.7.0 ואילך של Compose UI. הפעולה הזו מסירה חלופות פנימיות של השתקפות, משפרת את הביצועים אבל מחייבת לקוחות לשדרג את התלות שלהם. (I48e65)
  • כשמשדרגים ל-Compose Multiplatform 1.11.0, אפשר למנוע כפילות של סמלים בגרסאות ישנות יותר של JetBrains fork. (Iccd64)
  • תוקנה בעיה שבה ViewModels נוקו בצורה שגויה במהלך רה-קומפוזיציה כשמשתמשים ב-rememberViewModelStoreProvider עם פרמטרים לא יציבים שמוגדרים כברירת מחדל. הספק יוצר מחדש רק כשהבעלים של ההורה או המפתח המפורש משתנים. (Ibe296, ‏ b/501792448)

גרסה ‎2.11.0-beta01

‫22 באפריל 2026

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

שינויים ב-API

  • פיצול של rememberViewModelStoreOwner ו-rememberViewModelStoreProvider לפונקציות נפרדות לתרחישי שימוש עם מקש ולתרחישי שימוש בלי מקש. (Ifd154, ‏ b/500802788)

תיקוני באגים

  • עדכון של Compose compileSdk ל-API 37. כלומר, כשמשתמשים ב-Compose, נדרשת גרסת AGP מינימלית של 9.2.0. (Id45cd, b/413674743)

גרסה ‎2.11.0-alpha03

‫25 במרץ 2026

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

שינויים ב-API

  • הופכים את parentKey לפרמטר אופציונלי בבוני ViewModelStoreProvider, עם ערך ברירת מחדל של null, ומעבירים אותו אחרי parentStore או parentOwner. הפעולה הזו מפשטת את יצירת המופע כשלא צריך מפתח משותף של היקף. (I66b67)
  • עכשיו אפשר להשתמש ב-ViewModelStoreNavEntryDecorator עם ViewModelStoreOwner במקום ViewModelStore. כך Navigation3 יכול להעביר את ברירות המחדל של ההורה CreationExtras ו-ViewModelProvider.Factory אל ViewModels מוטמעים, כדי להבטיח תמיכה בתלות ברמת האפליקציה. ‫(Ia6018, ‏ b/434651920)
  • בידוד המצב ViewModelStoreProvider באמצעות מפתח ייחודי. כך נמנע מצב שבו ספקי אחים מוחקים בטעות את ה-ViewModels אחד של השני במהלך הסילוק. (I59c0b, ‏ b/434651920)
  • מוסיפים פונקציית תוסף ViewModelProvider.get<VM>(key: String). כך המפתחים יכולים לאחזר ViewModels בצורה נקייה יותר באמצעות key מותאם אישית עם פרמטרים של סוג מאומת ב-Kotlin, בלי הצורך להעביר במפורש את סוג המחלקה. (Ic1f59)
  • הוספת תמיכה ב-defaultArgs ל-ViewModelStoreProvider כדי לאפשר הפעלה של ViewModels עם ערכי SavedState שמוגדרים כברירת מחדל. (I1e933, ‏ b/434651920, ‏ b/165642391)
  • הוצאה משימוש של removeViewModelStoreOnPop ושל ViewModelStoreNavEntryDecoratorDefaults שמשויך אליו. ה-API הזה היה פתרון עקיף לשינויים בהגדרות, שמעכשיו מטופלים באופן פנימי. כל מצב המעצב, כולל ViewModels, חייב להימחק עכשיו בו-זמנית בהצגת חלון קופץ. כדי לשמור את מצב ה-decorator מחוץ למצב שבו מקבץ הפעילויות הקודמות (back stack) מועבר ל-NavDisplay, צריך להשתמש ב-rememberDecoratedNavEntries API. (I852d9)

תיקוני באגים

  • מוסיפים toString() ל-CreationExtras.Key כדי להציג את שם הכיתה. (I5de52)

גרסה ‎2.11.0-alpha02

‫11 במרץ 2026

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

Scoped ViewModels

  • בגרסה הזו הוספנו ממשקי API ליצירת מופעים של ViewModelStore ב-Compose עם היקף מוגדר. כך אפשר לקשר את ViewModels להיקפים ספציפיים של ממשק המשתמש (כמו דפים נפרדים של Pager או פריטים של LazyList). הם ViewModels שורדים שינויים בהגדרות, ומנוקים אוטומטית כשמסירים לצמיתות את הרכיב התואם שלהם מההיררכיה.

    // Hoist the parent provider outside the Pager.
val provider = rememberViewModelStoreProvider()
val pagerState = rememberPagerState(pageCount = { 5 })

HorizontalPager(state = pagerState) { page ->
    // Create an owner scoped to the current page.
    val storeOwner = rememberViewModelStoreOwner(provider, key = page)

    // Provide the scoped owner to this composition.
    CompositionLocalProvider(LocalViewModelStoreOwner provides storeOwner) {
        // ViewModel is now scoped specifically to this page.
        val viewModel: PageViewModel = viewModel()
    }
}

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

תכונות חדשות

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

שינויים ב-API

  • כדאי להוסיף את rememberViewModelStoreOwner כדי ליצור בקלות ViewModelStoreOwnerים עם היקף מוגדר בכלי הכתיבה. הפונקציה הזו מחזירה בעלים שקשור למחזור החיים של רכיב ה-Composable, ומנקה אוטומטית את ה-ViewModels שלו כשהרכיב מוסר מממשק המשתמש. (I2a15b, b/165642391)
  • מוסיפים את rememberViewModelStoreProvider כדי לאפשר יצירת מופעים של ViewModelStore בהיקף מוגבל ב-Compose. הפונקציה הזו מקשרת חנות צאצא לבעלים של חנות אב, וכך מוודאת ש-ViewModels שורדים שינויים בהגדרות, תוך ניקוי אוטומטי שלהם כשה-Composable מוסר מההיררכיה. ‫(I0f57a, ‏ b/165642391)
  • מוסיפים ViewModelStoreProvider כדי לנהל מופעים ViewModelStore בהיקף מסוים. המחלקות האלה מאפשרות ליצור היקפים של צאצאים ששורדים שינויים בהגדרות, אבל אפשר לנקות אותם בנפרד. הוא מספק גם ViewModelStoreOwner wrappers שמקבלים בירושה את ברירות המחדל של factories ואת התוספות ליצירה מההורה. (I87f4f, b/434651920)

גרסה ‎2.11.0-alpha01

‫25 בפברואר 2026

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

תכונות חדשות

  • תמיכה בכל יעדי Kotlin Multiplatform ‏ (KMP) ב-ViewModel-Compose. הפרדת פתרון הבעלים מ-LocalView כדי לאפשר למארחי פלטפורמות לספק ViewModelStoreOwner כברירת מחדל, תוך שמירה על LocalView כגיבוי בטוח ב-Android. (I09fab, ‏ b/434940570, ‏ Ic8526, ‏ b/478146897)

שינויים ב-API

  • כדי לפשט את תהליך הניפוי באגים, מוסיפים הטמעה של toString ל-ViewModelStore שמציגה את כל המפתחות המאוחסנים. (I0a6f4)
  • הוספת הטמעה שמוגדרת כברירת מחדל ל-HasDefaultViewModelProviderFactory.defaultViewModelProviderFactory, כלומר כבר לא צריך לבטל את ברירת המחדל של המאפיין הזה באופן מפורש כשמטמיעים את הממשק. (Ia7095)
  • מוסיפים את ההערה ViewModel.onCleared עם @EmptySuper כדי לציין במפורש שאין צורך להפעיל את super.onCleared() בשיטות שמוגדרות כ-override. (I8c226)

גרסה 2.10

גרסה 2.10.0

‫19 בנובמבר 2025

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

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

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

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

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

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

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

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

  • הוספנו תמיכה מקורית בסוגים שניתן להגדיר כ-nullable ב-SavedStateHandle.saved, כדי לפשט את השמירה והשחזור של מאפיינים שניתן להגדיר כ-nullable.

  • מסמנים את הקונסטרוקטורים של SavedStateHandle כ-@VisibleForTesting.

  • הערך של minSdk השתנה מ-API 21 ל-API 23.

גרסה ‎2.10.0-rc01

‫5 בנובמבר 2025

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

גרסה ‎2.10.0-beta01

‫22 באוקטובר 2025

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.10.0-alpha05

‫8 באוקטובר 2025

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

שינויים ב-API

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

גרסה ‎2.10.0-alpha04

‫24 בספטמבר 2025

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

שינויים ב-API

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

גרסה ‎2.10.0-alpha03

‫27 באוגוסט 2025

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

שינויים ב-API

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

גרסה ‎2.10.0-alpha02

‫13 באוגוסט 2025

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

תכונות חדשות

  • הקומפוזבילי LifecycleOwner יכול עכשיו ליצור מחזור חיים עצמאי של רכיב הבסיס. אם מגדירים את parent = null (באופן מפורש), מחזור החיים החדש פועל באופן עצמאי ללא מארח (כמו Activity, ‏ Fragment או NavBackStackEntry). הוא מתחיל ברגע שהרכיב הניתן להרכבה נכנס להרכבה ונהרס אוטומטית כשהוא יוצא ממנה. (I8dfbe, ‏ b/433659048)

    @Composable
fun IndependentComponent() {
    // Create a standalone lifecycle, not tied to the parent Activity/Fragment.
    LifecycleOwner(parent = null) {
        val rootLifecycle = LocalLifecycleOwner.current.lifecycle
    }
}

שינויים ב-API

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

תיקוני באגים

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

External Contribution

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

גרסה ‎2.10.0-alpha01

‫30 ביולי 2025

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

תכונות חדשות

  • מוסיפים LifecycleOwner רכיב קומפוזבילי כדי לאפשר יצירה של מחזורי חיים בהיקף מוגבל ישירות בממשק המשתמש. האפשרות הזו שימושית לרכיבים שצריכים לנהל את מחזור החיים שלהם באופן עצמאי. דוגמה לאופן השילוב של הרכיב החדש הזה ב-Navigation3 זמינה בכתובת aosp/3708610. (76cbf7)

    @Composable
fun MyComposable() {
    LifecycleOwner(
        maxLifecycle = RESUMED,
        parentLifecycleOwner = LocalLifecycleOwner.current,
    ) {
        val childLifecycleOwner = LocalLifecycleOwner.current
    }
}

שינויים ב-API

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

גרסה 2.9

גרסה 2.9.4

‫17 בספטמבר 2025

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

תיקוני באגים

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

גרסה 2.9.3

‫27 באוגוסט 2025

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

תכונות חדשות

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

תיקוני באגים

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

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

גרסה 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 זמין עכשיו במחשבים ובמכשירי Android עם JVM.

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

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

גרסה ‎2.9.0-rc01

‫23 באפריל 2025

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

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

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

גרסה ‎2.9.0-beta01

‫9 באפריל 2025

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

שינויים ב-API

  • ‫Lifecycle ViewModel Compose משתמשת עכשיו באותה הגדרה של Kotlin Multiplatform כמו Compose Runtime 1.7.1 ומעלה – הארטיפקטים של -desktop הוסרו ועכשיו יש ארטיפקטים של -jvmStubs ו--linuxx64Stubs. לא מיועד שימוש באף אחד מהיעדים האלה, הם משמשים כ-placeholder כדי לעזור למאמצי Jetbrains Compose. ‫(I5cb14, ‏ b/406592090)

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

  • הספרייה הזו מטרגטת עכשיו את רמת השפה Kotlin 2.0 ונדרשת KGP 2.0.0 או גרסה חדשה יותר. (Idb6b5)
  • ‫Lifecycle ViewModel Compose תלוי עכשיו ב-Compose 1.7.8. ‫(I5cb14, ‏ b/406592090)

גרסה ‎2.9.0-alpha13

‫26 במרץ 2025

הגרסה androidx.lifecycle:lifecycle-*:2.9.0-alpha13 יוצאת ללא שינויים משמעותיים שגלויים לציבור. גרסה ‎2.9.0-alpha13 מכילה את השמירות האלה.

גרסה ‎2.9.0-alpha12

‫12 במרץ 2025

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

שינויים ב-API

  • הוספת הערה @MainThread ל-ViewModelProvider.get בכל פלטפורמות KMP הנתמכות. (I7e8dd, b/397736115)
  • שינוי השם של SavedState*Delegates לSavedState*Delegate. ‫(I8589b, ‏ b/399629301)

גרסה ‎2.9.0-alpha11

‫26 בפברואר 2025

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

שינויים ב-API

  • הוספת הפרמטר SavedStateConfig לנציגי saved() (I39b3a)

גרסה ‎2.9.0-alpha10

‫12 בפברואר 2025

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

שינויים ב-API

  • העברה של MutableStateSerializer אל savedstate-compose מ-lifecycle-viewmodel-compose. (I4f690, b/378895074)

External Contribution

  • נוספה בעיה חדשה ב-Lint שמתריעה על קריאה ל-Lifecycle::currentState בקומפוזיציה, ומציעה במקום זאת להשתמש ב-currentStateAsalue().value כדי לוודא ששינויים במצב Lifecycle גורמים לרה-קומפוזיציה בצורה נכונה. תודה, סטיבן שון! (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)

תיקוני באגים

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

גרסה ‎2.9.0-alpha07

‫13 בנובמבר 2024

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

תאימות ל-Kotlin Multiplatform

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

תמיכה ב-KotlinX Serialization

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

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

גרסה ‎2.9.0-alpha02

‫4 בספטמבר 2024

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

תיקוני באגים

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

External Contribution

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

גרסה ‎2.9.0-alpha01

‫7 באוגוסט 2024

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

Kotlin Multiplatform

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

תכונות חדשות

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

שינויים ב-API

  • מוסיפים את פונקציית היצירה CreationExtras.Key() כדי לפשט את היצירה של אובייקטים אנונימיים CreationExtras.Key. (I970ee)
  • ‫CreationExtras כולל עכשיו עומסי אופרטורים דמויי מפה כדי לאפשר מניפולציה אידיומטית של תוכן ב-Kotlin. היא מאפשרת שימוש ב-in, ב-+= וב-+ עם CreationExtras. (Ib4353)
  • ‫CreationExtras מטמיע עכשיו את ה-methods‏ equals,‏ hashCode ו-toString. (Ib4353)
  • ‫NewInstanceFactory זמין עכשיו במחשבים ובמכשירי Android עם JVM. (d3d0892)
  • הוספה של מאפיין הרחבה מוטמע כדי לחשוף את האפליקציה הבסיסית בצורה בטוחה בגרסה 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 פריטי מידע שנוצרו בתהליך פיתוח (Artifact). לא מיועד שימוש באף אחד מהיעדים האלה, הם משמשים כ-placeholder כדי לעזור למאמצי Jetbrains Compose. (6a3f5b3)

גרסה 2.8.6

‫18 בספטמבר 2024

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

תיקוני באגים

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

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

גרסה 2.8.5

‫4 בספטמבר 2024

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

תיקוני באגים

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

External Contribution

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בעיות מוכרות

גרסה 2.8.0-rc01

‫1 במאי 2024

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

תיקוני באגים

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

External Contribution

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

גרסה ‎2.8.0-beta01

‫17 באפריל 2024

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

תכונות חדשות

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

גרסה ‎2.8.0-alpha04

‫3 באפריל 2024

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

תכונות חדשות

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

תיקוני באגים

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

עדכון תלות

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

גרסה ‎2.8.0-alpha03

‫20 במרץ 2024

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

תכונות חדשות

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

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

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

תאימות ל-Kotlin Multiplatform

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

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

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

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

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

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

תיקוני באגים

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

External Contribution

  • ‫LocalLifecycleOwner הועבר מ-Compose UI ל-lifecycle-runtime-compose כדי שאפשר יהיה להשתמש בממשקי העזר מבוססי-Compose שלו מחוץ ל-Compose UI. תודה ל-Jake Wharton על התרומה. (I6c41b, b/328263448)

גרסה ‎2.8.0-alpha02

‫21 בפברואר 2024

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

תכונות חדשות

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

המרות של Kotlin

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

תאימות ל-Kotlin Multiplatform

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

שינויים ב-API

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

External Contribution

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

גרסה ‎2.8.0-alpha01

‫24 בינואר 2024

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

תכונות חדשות

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

גרסה 2.7

גרסה 2.7.0

‫10 בינואר 2024

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

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

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

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 to stopped ו-resumed to paused, בהתאמה. ה-API הזה זהה ל-API שמופיע ב-DisposableEffect והוא מתאים למקרים שבהם השינוי שמתבצע כשמצב המשתמש עולה צריך להתבטל כשמצב המשתמש יורד.
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleStartEffect(viewModel) {
    val timeTracking = viewModel.startTrackingTimeOnScreen()
    onStopOrDispose {
      timeTracking.stopTrackingTimeOnScreen()
    }
  }
  // …
}

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

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

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

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

גרסה ‎2.7.0-rc02

‫13 בדצמבר 2023

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

תיקוני באגים

  • תוקנה בעיה שבה SavedStateHandle לא שחזר כראוי מחלקות Parcelable מותאמות אישית אחרי השבתת תהליך ויצירה מחדש. בגלל מידע על סוגים שאבד ב-Android framework, מערכים של Parcelables מותאמים אישית דורשים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון). במסמכי התיעוד בנושא get, getLiveData ו-getStateFlow מצוינת עכשיו המגבלה הזו באופן ספציפי. (I0b55a)

גרסה ‎2.7.0-rc01

‫15 בנובמבר 2023

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

תיקוני באגים

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

גרסה ‎2.7.0-beta01

1 בנובמבר 2023

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

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

גרסה ‎2.7.0-alpha03

‫18 באוקטובר 2023

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎2.7.0-alpha02

‫6 בספטמבר 2023

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

תכונות חדשות

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

שינויים ב-API

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

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

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

תיקוני באגים

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

גרסה ‎2.7.0-alpha01

26 ביולי 2023

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.6

גרסה 2.6.2

‫6 בספטמבר 2023

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

תיקוני באגים

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

גרסה 2.6.1

‫22 במרץ 2023

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

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

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

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

Lifecycle 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-runtime-ktx לארטיפקט lifecycle-common. (I41d78, ‏ b/240298691)
  • התוסף Kotlin ב-Lifecycle שמספק את השדה coroutineScope הועבר מ-lifecycle-runtime-ktx לארטיפקט lifecycle-common. (Iabb91, ‏ b/240298691)

גרסה ‎2.6.0-alpha05

‫25 בינואר 2023

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

המרות של Kotlin

  • האפליקציה Transformations נכתבה עכשיו ב-Kotlin. זהו שינוי שגורם לאי-תאימות למקור עבור מחלקות שנכתבו ב-Kotlin והשתמשו ישירות בתחביר כמו Transformations.map – עכשיו חובה להשתמש בתחביר של שיטת ההרחבה של Kotlin, שהיה זמין בעבר רק כשמשתמשים ב-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 שאוסף נתונים מתוך תהליכים ומייצג את הערך האחרון שלו כ-Compose State באופן שמתחשב במחזור החיים. הערך של ה-Flow נאסף והערך החדש של ה-Emission מוגדר לערך של ה-State, כשה-Lifecycle נמצא לפחות ב-Lifecycle.State מסוים. אם מחזור החיים יורד מתחת ל-Lifecycle.State, איסוף הנתונים של הרצף נפסק והערך של המצב לא מתעדכן. ‫(I1856e, ‏ b/230557927)

גרסה 2.5

גרסה 2.5.1

‫27 ביולי 2022

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

תיקוני באגים

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

גרסה 2.5.0

29 ביוני 2022

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

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

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

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

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

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

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

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

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

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

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

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

    לדוגמה, כדי ליצור היקף של שגרת המשך (coroutine) שאפשר להזריק ל-ViewModel, אבל לשלוט בו באמצעות בדיקה, אפשר ליצור CoroutineScope שמטמיע את Closeable:

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

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

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

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

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

גרסה ‎2.5.0-rc02

‫15 ביוני 2022

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

תיקוני באגים

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

גרסה ‎2.5.0-rc01

‫11 במאי 2022

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

תיקוני באגים

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

גרסה ‎2.5.0-beta01

‫20 באפריל 2022

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha06

‫6 באפריל 2022

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha05

‫23 במרץ 2022

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha04

9 במרץ 2022

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

שינויים ב-API

  • ‫SavedStateHandle מציע עכשיו 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 וטעינת יתר חדשה של בנאי שמאפשרים להוסיף אובייקט אחד או יותר של Closeable ל-ViewModel שייסגר כשמנקים את ViewModel בלי שנדרשת עבודה ידנית ב-onCleared().addCloseable() (I55ea0)
  • ‫lifecycle-viewmodel מספק עכשיו InitializerViewModelFactory שמאפשר להוסיף lambda לטיפול במחלקות ViewModel מסוימות, באמצעות CreationExtras כמקור הנתונים הראשי. ‫(If58fc, b/216687549)
  • ‫lifecycle-viewmodel-compose מציע עכשיו viewModel() API שמקבל מפעל למבדה כדי ליצור מופע 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)

תיקוני באגים

  • מתוך מחזור החיים 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 וכו'), אנחנו עוברים לעולם של פקטורי (factory) חסרי מצב שמסתמכים על קונספט חדש, CreationExtras. (Ia7343, ‏ b/188691010, ‏ b/188541057)

בעקבות השינוי הזה, ViewModelProvider לא מבצע יותר קריאות ישירות לשיטה הקודמת create(Class<T>) של ViewModelProvider.Factory. במקום זאת, היא קוראת לעומס יתר חדש של create: create(Class<T>, CreationExtras). המשמעות היא שכל הטמעה ישירה של מופע ViewModelProvider.Factory מקבלת עכשיו גישה לכל אחד מהמאפיינים החדשים האלה של CreationExtras:

  • ‫ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY: String מספק גישה למפתח המותאם אישית שהועבר אל ViewModelProvider.get().
  • ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY מספק גישה לכיתה Application.
  • ‫SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY מספק גישה ל-SavedStateRegistryOwner שמשמש ליצירת ViewModel.
  • ‫SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY מספק גישה ל-ViewModelStoreOwner שמשמש ליצירת ViewModel.
  • הפונקציה SavedStateHandleSupport.DEFAULT_ARGS_KEY מספקת גישה לBundle של ארגומנטים שצריך להשתמש בהם כדי ליצור SavedStateHandle.

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

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

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

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

אפשר לספק CreationExtras בהתאמה אישית על ידי החלפת getDefaultViewModelCreationExtras() ב-ComponentActivity או ב-Fragment, וכך להפוך אותם לזמינים ב-ViewModelProvider.Factory בהתאמה אישית כסוג מוטמע של הזרקה בעזרת AI. התוספים האלה יהיו זמינים באופן אוטומטי ל-Factory בהתאמה אישית כשהיא תהיה בשימוש ישירות עם ViewModelProvider או עם תוספי המאפיינים 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 מכילה את השמירות האלה.

תיקוני באגים

  • בוצעה העברה חוזרת מ-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 לא מאפשרת יותר גנריות עם ערך null.
  • נוסף API חדש של קורוטינות ל-androidx.lifecycle:lifecycle-runtime-ktx:
  • ‫Lifecycle.repeatOnLifecycle, API שמריץ בלוק קוד ב-Coroutine כשה-Lifecycle נמצא לפחות במצב מסוים. הבלוק יבוטל ויופעל מחדש כשהסטטוס של מחזור החיים ישתנה ויחזור לסטטוס היעד.
  • ‫Flow.flowWithLifecycle, API שפולט ערכים מה-Flow במעלה הזרם כשהמחזור החיים נמצא לפחות במצב מסוים.
  • הפריט DefaultLifecycleObserver הועבר מ-lifecycle.lifecycle-common-java8 אל lifecycle.lifecycle-common. ‫lifecycle.lifecycle-common-java8 לא מספק יותר פונקציונליות נוספת מעבר ל-lifecycle.lifecycle-common, ולכן אפשר להחליף את התלות בו ב-lifecycle.lifecycle-common.
  • ממשקי API שאינם קורוטינות מ-lifecycle-viewmodel-ktx הועברו למודול lifecycle-viewmodel.

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

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

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

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

    (או)

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

גרסה ‎2.4.0-rc01

‫29 בספטמבר 2021

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

גרסה ‎2.4.0-beta01

‫15 בספטמבר 2021

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

שינויים ב-API

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

External Contribution

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

גרסה ‎2.4.0-alpha03

4 באוגוסט 2021

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

שינויים ב-API

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

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

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

External Contribution

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

גרסה ‎2.4.0-alpha02

‫16 ביוני 2021

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

תכונות חדשות

  • נוסף 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 כשמשתמשים ב-generics. (מס' 161, b/184830263)

External Contribution

גרסה ‎2.4.0-alpha01

‫24 במרץ 2021

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

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

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

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

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

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

    (או)

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.0.0 של Lifecycle Viewmodel Compose

גרסה ‎1.0.0-alpha07

‫16 ביוני 2021

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

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

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

גרסה ‎1.0.0-alpha06

‫2 ביוני 2021

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

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

גרסה ‎1.0.0-alpha05

‫18 במאי 2021

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎1.0.0-alpha04

‫7 באפריל 2021

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

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

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

גרסה ‎1.0.0-alpha03

10 במרץ 2021

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

שינויים ב-API

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

גרסה ‎1.0.0-alpha02 של Lifecycle-Viewmodel-Compose

24 בפברואר 2021

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

שינויים ב-API

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

גרסה 1.0.0-alpha01 של Lifecycle-Viewmodel-Compose

10 בפברואר 2021

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

תכונות חדשות

  • הקומפוזיציה viewModel() והרכיב LocalViewModelStoreOwner הועברו מ-androidx.compose.ui.viewinterop לארטיפקט הזה בחבילה androidx.lifecycle.viewmodel.compose. (I7a374)

גרסה 2.3.1

גרסה 2.3.1 של Lifecycle

‫24 במרץ 2021

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

תיקוני באגים

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

גרסה 2.3.0

גרסה 2.3.0

10 בפברואר 2021

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

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

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

גרסה ‎2.3.0-beta01

‫1 באוקטובר 2020

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

שינויים ב-API

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

תיקוני באגים

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

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

גרסה ‎2.3.0-alpha07

‫19 באוגוסט 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha06

22 ביולי 2020

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

תכונות חדשות

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

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

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha05

‫24 ביוני 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha04

‫10 ביוני 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha03

20 במאי 2020

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha02

29 באפריל 2020

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha01

4 במרץ 2020

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

תכונות חדשות

  • ‫API חדש של ViewTreeLifecycleOwner.get(View) מאפשר לכם לאחזר את LifecycleOwner שמכיל מופע של View. כדי שהנתונים יאוכלסו בצורה נכונה, צריך לשדרג ל-Activity 1.2.0-alpha01 ול-Fragment 1.3.0-alpha01. תוסף 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 מכילה את השמירות האלה.

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

גרסה 2.2.0

‫22 בינואר 2020

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

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

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

גרסה ‎2.2.0-rc03

4 בדצמבר 2019

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

תיקוני באגים

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

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

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

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

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

גרסה ‎2.2.0-rc02

‫7 בנובמבר 2019

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

תיקוני באגים

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

גרסה ‎2.2.0-rc01

‫23 באוקטובר 2019

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

תיקוני באגים

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

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

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

גרסה ‎2.2.0-beta01

‫9 באוקטובר 2019

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

תיקוני באגים

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

תכונות חדשות

שינויים ב-API

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

גרסה ‎2.2.0-alpha02

‫2 ביולי 2019

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

שינויים ב-API

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

גרסה ‎2.2.0-alpha01

‫7 במאי 2019

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

תכונות חדשות

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

גרסה 1.0.0 של ViewModel-SavedState

גרסה 1.0.0

‫22 בינואר 2020

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

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

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

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

4 בדצמבר 2019

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

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

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

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

‫7 בנובמבר 2019

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

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

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

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

‫23 באוקטובר 2019

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

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

‫9 באוקטובר 2019

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

תיקוני באגים

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

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

18 בספטמבר 2019

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

שינויים ב-API

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

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

‫7 באוגוסט 2019

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

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

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

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

‫2 ביולי 2019

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

תכונות חדשות

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

שינויים ב-API

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

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

‫13 במרץ 2019

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

תכונות חדשות

  • עכשיו ViewModels יכול לתרום ל-savedstate. כדי לעשות את זה, משתמשים במפעל SavedStateVMFactory של viewmodel שהוצג לאחרונה, ול-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 מופץ. כאן אפשר לראות את הרשימה המלאה של פעולות ה-commit שכלולות בגרסה הזו.

שינויים ב-API

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

גרסה ‎2.1.0-alpha02

30 בינואר 2019

‫androidx.lifecycle 2.1.0-alpha02 מופץ.

שינויים ב-API

  • ‫LifecycleRegistry כולל עכשיו את ה-method‏ setCurrentState() שמחליף את ה-method‏ setState() שיצא משימוש. (aosp/880715)

תיקוני באגים

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

גרסה ‎2.1.0-alpha01

‫17 בדצמבר 2018

‫androidx.lifecycle 2.1.0-alpha01 מופץ.

תכונות חדשות

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

גרסה 2.0.0

גרסה 2.0.0

‫21 בספטמבר 2018

‫Lifecycle 2.0.0 יוצא עם תיקון באג אחד מ-2.0.0-rc01 ב-ViewModel.

תיקוני באגים

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

גרסה ‎2.0.0-beta01

‫2 ביולי 2018

תיקוני באגים

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

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

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

dependencies {
    def lifecycle_version = "1.1.1"

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

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

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

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

גרסה 1.1.1

‫21 במרץ 2018

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

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

גרסה 1.1.0

‫22 בינואר 2018

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

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

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

שינויים ב-API

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