מחזור חיים

מחזור חיים

מדריך למשתמש  דוגמת קוד  Codelab

API Reference
androidx.lifecycle

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

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

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

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

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

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

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

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

Kotlin

Groovy

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

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

Java

Groovy

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

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

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

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

משוב

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

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

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

גרסה 2.10

גרסה 2.10.0

‫19 בנובמבר 2025

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

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

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

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

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

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

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

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

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

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

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

גרסה ‎2.10.0-rc01

‫5 בנובמבר 2025

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

גרסה ‎2.10.0-beta01

‫22 באוקטובר 2025

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.10.0-alpha05

‫8 באוקטובר 2025

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

שינויים ב-API

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

גרסה ‎2.10.0-alpha04

‫24 בספטמבר 2025

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

שינויים ב-API

• משנים את השם של הרכיב הקומפוזבילי LifecycleOwner ל-rememberLifecycleOwner. הפונקציה מחזירה עכשיו את LifecycleOwner ישירות. כדי לספק את הבעלים הזה לרכיב משנה, משתמשים ב-CompositionLocalProvider. (Ic57f0, ‏ b/444446629)
• הוספת stub של KMP ל-lifecycle-viewmodel-navigation3 כדי לאפשר ל-JetBrains לספק מזלגות שממלאים את היעדים האלה וכך לתמוך ב-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, כדי לספק API נוח יותר ואידיומטי יותר של Kotlin. (Iab2bd)
• הוספנו תמיכה מקורית בסוגים שניתנים לאיפוס ב-SavedStateHandle.saved, כדי לפשט את השמירה והשחזור של מאפיינים שניתנים לאיפוס. (I54d69, ‏ b/421325690)
• סימון של קונסטרוקטורים של SavedStateHandle כ-@VisibleForTesting. (Iff0e0, b/408002794)

גרסה 2.9

גרסה 2.9.4

‫17 בספטמבר 2025

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

תיקוני באגים

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

גרסה 2.9.3

‫27 באוגוסט 2025

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

תכונות חדשות

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

תיקוני באגים

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

גרסה 2.9.2

‫16 ביולי 2025

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

תיקוני באגים

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

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

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

גרסה 2.9.1

‫4 ביוני 2025

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

תיקוני באגים

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

גרסה 2.9.0

‫7 במאי 2025

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

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

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

תמיכה ב-KotlinX Serialization

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

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

Kotlin Multiplatform

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

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

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

גרסה ‎2.9.0-rc01

‫23 באפריל 2025

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

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

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

גרסה ‎2.9.0-beta01

‫9 באפריל 2025

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

שינויים ב-API

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

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

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

גרסה ‎2.9.0-alpha13

‫26 במרץ 2025

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

גרסה ‎2.9.0-alpha12

‫12 במרץ 2025

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

שינויים ב-API

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

גרסה ‎2.9.0-alpha11

‫26 בפברואר 2025

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

שינויים ב-API

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

גרסה ‎2.9.0-alpha10

‫12 בפברואר 2025

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

שינויים ב-API

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

External Contribution

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

גרסה ‎2.9.0-alpha09

‫29 בינואר 2025

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

תכונות חדשות

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

שינויים ב-API

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

גרסה ‎2.9.0-alpha08

‫11 בדצמבר 2024

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

תכונות חדשות

• מוסיפים את ViewModelScenario.recreate כדי לדמות את התהליך System Process Death, ליצור מחדש את ViewModel שנבדק ואת כל הרכיבים המשויכים. (Id6a69, b/381063087)
• עכשיו אפשר לפתור מקרים של LifecycleOwner ו-ViewModelStoreOwner שאוחזרו באמצעות ממשקי ה-API המתאימים שלהם דרך הורים לא רציפים של תצוגה, כמו ViewOverlay.findViewTree מידע נוסף על הורים של תצוגות לא רציפות זמין בהערות הגרסה של ליבת או במאמרי העזרה בכתובת ViewTree.setViewTreeDisjointParent. (I800f4)

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.9.0-alpha07

‫13 בנובמבר 2024

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

תאימות ל-Kotlin Multiplatform

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

תמיכה ב-KotlinX Serialization

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

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

שינויים ב-API

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

גרסה ‎2.9.0-alpha06

‫30 באוקטובר 2024

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

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

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

תיקוני באגים

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

גרסה ‎2.9.0-alpha05

‫16 באוקטובר 2024

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

גרסה ‎2.9.0-alpha04

‫2 באוקטובר 2024

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

Kotlin Multiplatform

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

גרסה ‎2.9.0-alpha03

‫18 בספטמבר 2024

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

תיקוני באגים

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

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

• ‫Lifecycle 2.8.6: ‏Lifecycle Runtime Compose תלוי עכשיו ב-Compose Runtime 1.7.1
• זמן הריצה של מחזור החיים תלוי עכשיו ב-ProfileInstaller 1.4.0

גרסה ‎2.9.0-alpha02

‫4 בספטמבר 2024

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

תיקוני באגים

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

External Contribution

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

גרסה ‎2.9.0-alpha01

‫7 באוגוסט 2024

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

Kotlin Multiplatform

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.8

גרסה 2.8.7

‫30 באוקטובר 2024

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

שינויים ב-API

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

גרסה 2.8.6

‫18 בספטמבר 2024

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

תיקוני באגים

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

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

• ‫Lifecycle Runtime Compose תלוי עכשיו ב-Compose Runtime 1.7.1

גרסה 2.8.5

‫4 בספטמבר 2024

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

תיקוני באגים

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

External Contribution

• הנציג של התוסף SavedStateHandle.saveable תומך עכשיו בערכים שניתן להגדיר כ-null. תודה ל-Roman Kalukiewicz על התרומה. (0d78ea6)

גרסה 2.8.4

‫24 ביולי 2024

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

תיקוני באגים

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

גרסה 2.8.3

‫1 ביולי 2024

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

תיקוני באגים

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

גרסה 2.8.2

‫12 ביוני 2024

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

תיקוני באגים

• תוקנו שגיאות CompositionLocal LocalLifecycleOwner not present כשמשתמשים ב-Lifecycle 2.8.X עם Compose 1.6.X או גרסה מוקדמת יותר – עכשיו אפשר להשתמש ב-Lifecycle 2.8.2 עם כל גרסה של Compose בלי צורך בפתרונות עקיפים. ‫(aosp/3105647, ‏ b/336842920)
• ‫ViewModelProvider לא יקרוס יותר כשמשלבים גרסאות קודמות של compileOnly Lifecycle עם גרסאות 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 באמצעות נציגי מאפיינים (property delegates) ב-saveable משתמש עכשיו בשם המחלקה כחלק מהמפתח שנוצר באופן אוטומטי, וכך נמנעות התנגשויות אם כמה מחלקות משתמשות באותו SavedStateHandle. (aosp/3063463)

גרסה 2.8.0

‫14 במאי 2024

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

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

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

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

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

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

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

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

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

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

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

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

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

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

תאימות של ViewModel Kotlin Multiplatform

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

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

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

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

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

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

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

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

בעיות מוכרות

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

גרסה ‎2.8.0-rc01

‫1 במאי 2024

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

תיקוני באגים

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

External Contribution

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

גרסה ‎2.8.0-beta01

‫17 באפריל 2024

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

תכונות חדשות

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

גרסה ‎2.8.0-alpha04

‫3 באפריל 2024

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

תכונות חדשות

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

תיקוני באגים

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

עדכון תלות

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

גרסה ‎2.8.0-alpha03

‫20 במרץ 2024

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

תכונות חדשות

• הפרמטר ViewModel.viewModelScope הוא עכשיו פרמטר של constructor שאפשר לשנות, וכך להוסיף את ה-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 נשמרה, אבל יש כמה שינויים בולטים בהשוואה בין ממשק ה-API של Android לבין ממשק ה-API המשותף:

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

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

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

תיקוני באגים

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

External Contribution

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

גרסה ‎2.8.0-alpha02

‫21 בפברואר 2024

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

תכונות חדשות

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

המרות ב-Kotlin

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

תאימות ל-Kotlin Multiplatform

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

שינויים ב-API

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

External Contribution

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

גרסה ‎2.8.0-alpha01

‫24 בינואר 2024

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

תכונות חדשות

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

גרסה 2.7

גרסה 2.7.0

‫10 בינואר 2024

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

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

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

Lifecycle Event Observability

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

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

• משתמשי Jetpack Compose יכולים להשתמש ב-LifecycleStartEffect וב-LifecycleResumeEffect כדי לטפל בזוגות של אירועים – started עד stopped ו-resumed עד paused, בהתאמה. ה-API הזה זהה ל-API שמופיע ב-DisposableEffect והוא מתאים למקרים שבהם צריך לבטל את השינוי שבוצע כשהמצב עולה, כשחוזרים למצב הקודם.

fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
  LifecycleStartEffect(viewModel) {
    val timeTracking = viewModel.startTrackingTimeOnScreen()
    onStopOrDispose {
      timeTracking.stopTrackingTimeOnScreen()
    }
  }
  // …
}

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

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

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

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

גרסה ‎2.7.0-rc02

‫13 בדצמבר 2023

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

תיקוני באגים

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

גרסה ‎2.7.0-rc01

‫15 בנובמבר 2023

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

תיקוני באגים

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

גרסה ‎2.7.0-beta01

‫1 בנובמבר 2023

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

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

גרסה ‎2.7.0-alpha03

‫18 באוקטובר 2023

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎2.7.0-alpha02

‫6 בספטמבר 2023

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

תכונות חדשות

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

שינויים ב-API

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

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

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

תיקוני באגים

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

גרסה ‎2.7.0-alpha01

‫26 ביולי 2023

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

שינויים ב-API

• ‫Lifecycle.State ניתן עכשיו לצפייה ב-Compose דרך Lifecycle.currentStateFlow, שמחזיר StateFlow כאשר value הוא Lifecycle.State הנוכחי. ‫(Ib212d, ‏ b/209684871)
• עכשיו אפשר לראות את Lifecycle.Event כ-Flow עם Lifecycle.asFlow(). (If2c0f, ‏ b/176311030)
• LifecycleResumeEffect נוסף API להפעלת רכיבי 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 להפעלת תכונת ה-Compose של SideEffect על סמך Lifecycle.Event.LifecycleEventEffect (Ic9794, ‏ b/235529345)
• התוסף Lifecycle.collectAsState() נוסף כדי לחשוף ישירות את Lifecycle.State כ-Compose State. הפונקציה הזו מקבילה לפונקציה lifecycle.currentStateFlow.collectAsState() (והיא חלופה קצרה יותר). (I11015, ‏ b/235529345)

תיקוני באגים

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

גרסה 2.6

גרסה 2.6.2

‫6 בספטמבר 2023

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

תיקוני באגים

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

גרסה 2.6.1

‫22 במרץ 2023

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

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

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

גרסה 2.6.0

‫8 במרץ 2023

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

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

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

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

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

• הערך של האפשרות לקבלת ערך null של השיטה onChanged של Observer שנוצר ב-Kotlin תואם עכשיו לערך של האפשרות לקבלת ערך null של הסוג הגנרי. אם רוצים ש-Observer.onChanged() יקבל סוג שניתן להגדרה כ-null, צריך ליצור מופע של Observer עם סוג שניתן להגדרה כ-null.
• המחלקות האלה הומרו גם ל-Kotlin, אבל הן עדיין תואמות למקור: DefaultLifecycleObserver, LifecycleEventObserver, Lifecycle, LifecycleRegistry, LifecycleObserver, ViewModelStore, AndroidViewModel, AbstractSavedStateViewModelFactory, LifecycleService, ServiceLifecycleDispatcher ו-ProcessLifecycleOwner

גרסה ‎2.6.0-rc01

‫22 בפברואר 2023

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

תיקוני באגים

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

גרסה ‎2.6.0-beta01

‫8 בפברואר 2023

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

המרות ב-Kotlin

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

גרסה ‎2.6.0-alpha04

‫11 בינואר 2023

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

תכונות חדשות

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

שינויים ב-API

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

המרות ב-Kotlin

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

תיקוני באגים

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

גרסה ‎2.6.0-alpha03

24 באוקטובר 2022

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

תיקוני באגים

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

גרסה ‎2.6.0-alpha02

‫7 בספטמבר 2022

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.6.0-alpha01

29 ביוני 2022

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

תכונות חדשות

• נוספה תוסף חדש ב-StateFlow וב-Flow של collectAsStateWithLifecycle שאוסף נתונים מתוך רכיבי Flow ומייצג את הערך האחרון שלו כ-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().

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

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

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

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

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

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

גרסה ‎2.5.0-rc02

‫15 ביוני 2022

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

תיקוני באגים

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

גרסה ‎2.5.0-rc01

‫11 במאי 2022

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

תיקוני באגים

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

גרסה ‎2.5.0-beta01

‫20 באפריל 2022

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha06

‫6 באפריל 2022

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha05

‫23 במרץ 2022

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha04

9 במרץ 2022

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

שינויים ב-API

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

גרסה ‎2.5.0-alpha03

23 בפברואר 2022

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

תכונות חדשות

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

שינויים ב-API

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

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

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

גרסה ‎2.5.0-alpha02

‫9 בפברואר 2022

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

שינויים ב-API

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

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

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

תיקוני באגים

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

גרסה ‎2.5.0-alpha01

26 בינואר 2022

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

ViewModel CreationExtras

בגרסה הזו אנחנו מניחים את היסודות לשינוי המבנה של ViewModel. במקום קבוצה קשיחה של מחלקות משנה של ViewModelProvider.Factory שכל אחת מהן מוסיפה פונקציונליות נוספת (מאפשרת פרמטר של constructor של Application באמצעות AndroidViewModelFactory, מאפשרת פרמטר של constructor של SavedStateHandle באמצעות SavedStateViewModelFactory ו-AbstractSavedStateViewModelFactory וכו'), אנחנו עוברים לעולם של מפעלים חסרי מצב שמסתמכים על קונספט חדש, CreationExtras. ‫(Ia7343, ‏ b/188691010, ‏ b/188541057)

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

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

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

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

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

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

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

תיקוני באגים

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

גרסה 2.4

גרסה 2.4.1

‫9 בפברואר 2022

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

תיקוני באגים

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

גרסה 2.4.0

‫27 באוקטובר 2021

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

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

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

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

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

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

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

  (או)

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

גרסה ‎2.4.0-rc01

‫29 בספטמבר 2021

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

גרסה ‎2.4.0-beta01

‫15 בספטמבר 2021

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

שינויים ב-API

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

External Contribution

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

גרסה ‎2.4.0-alpha03

‫4 באוגוסט 2021

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

שינויים ב-API

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

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

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

External Contribution

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

גרסה ‎2.4.0-alpha02

‫16 ביוני 2021

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

תכונות חדשות

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

שינויים ב-API

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

תיקוני באגים

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

External Contribution

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

גרסה ‎2.4.0-alpha01

‫24 במרץ 2021

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

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

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

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

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

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

  (או)

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

שינויים ב-API

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

תיקוני באגים

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

Lifecycle Viewmodel Compose Version 1.0.0

גרסה 1.0.0-alpha07

‫16 ביוני 2021

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

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

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

הערה: זהו שינוי בינארי שובר – אתם חייבים לשדרג ל-Hilt-Navigation-Compose 1.0.0-alpha03 ול-Navigation Compose 2.4.0-alpha03. יכול להיות שזה שינוי שובר תאימות אם לא ציינתם את key = כשנעזרתם ב-viewModel(key, factory). צריך להשתמש בארגומנטים עם שם: viewModel(key = key, factory = factory).

גרסה ‎1.0.0-alpha06

‫2 ביוני 2021

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

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

גרסה 1.0.0-alpha05

‫18 במאי 2021

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎1.0.0-alpha04

7 באפריל 2021

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

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

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

גרסה 1.0.0-alpha03

‫10 במרץ 2021

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

שינויים ב-API

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

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

24 בפברואר 2021

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

שינויים ב-API

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

הערה: ‏ Lifecycle ViewModel Compose 1.0.0-alpha02 תואם רק ל-Compose 1.0.0-beta01.

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

10 בפברואר 2021

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

תכונות חדשות

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

הערה: גרסה Lifecycle ViewModel Compose 1.0.0-alpha01 תואמת רק לגרסה Compose 1.0.0-alpha12.

גרסה 2.3.1

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

‫24 במרץ 2021

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

תיקוני באגים

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

גרסה 2.3.0

גרסה 2.3.0

10 בפברואר 2021

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

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

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

גרסה ‎2.3.0-rc01

‫16 בדצמבר 2020

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

תיקוני באגים

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

External Contribution

• ממשקי ה-API להשהיית קורוטינות עם מודעות למחזור החיים מטפלים עכשיו טוב יותר בקריאות ל-yield(). תודה לניקלאס אנסמן גירץ! (aosp/1430830, b/168777346)

גרסה ‎2.3.0-beta01

‫1 באוקטובר 2020

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

שינויים ב-API

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

תיקוני באגים

• שדרוג androidx לשימוש ב-Kotlin 1.4 ‏ (Id6471, ‏ b/165307851, ‏ b/165300826)

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

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

גרסה ‎2.3.0-alpha07

‫19 באוגוסט 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha06

‫22 ביולי 2020

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

תכונות חדשות

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

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

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha05

‫24 ביוני 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha04

‫10 ביוני 2020

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha03

20 במאי 2020

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

תכונות חדשות

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha02

29 באפריל 2020

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.3.0-alpha01

4 במרץ 2020

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

תכונות חדשות

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

תיקוני באגים

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

הערה: בהתאם להערות לגבי הגרסה של 2.2.0 Lifecycle, ארטיפקט lifecycle-extensions לא מתפרסם יותר.

גרסה 2.2.0

ViewModel-Savedstate גרסה 2.2.0

‫5 בפברואר 2020

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

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

גרסה 2.2.0

‫22 בינואר 2020

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

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

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

תכונות חדשות

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

שינויים ב-API

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

גרסה ‎2.2.0-alpha02

‫2 ביולי 2019

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

שינויים ב-API

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

גרסה ‎2.2.0-alpha01

‫7 במאי 2019

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

תכונות חדשות

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

ViewModel-SavedState גרסה 1.0.0

גרסה 1.0.0

‫22 בינואר 2020

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

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

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

‫ViewModel-Savedstate גרסה 1.0.0-rc03

4 בדצמבר 2019

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

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

• ה-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 Version 1.0.0-beta01

‫9 באוקטובר 2019

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

תיקוני באגים

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

ViewModel-SavedState גרסה ‎1.0.0-alpha05

‫18 בספטמבר 2019

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

שינויים ב-API

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

גרסה ‎1.0.0-alpha03 של ViewModel-SavedState

‫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 לשיטות LiveData.observe ולשיטות Transformations.*.
• נוסף Transformations.distinctUntilChanged, שיוצר אובייקט LiveData חדש שלא פולט ערך עד שהערך של המקור LiveData משתנה.
• הוספנו תמיכה ב-coroutines ב-ViewModels על ידי הוספת מאפיין ההרחבה ViewModel.viewModelScope.

גרסה 2.1.0

5 בספטמבר 2019

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

גרסה ‎2.1.0-rc01

‫2 ביולי 2019

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

גרסה ‎2.1.0-beta01

‫7 במאי 2019

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

תכונות חדשות

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

גרסה ‎2.1.0-alpha04

‫3 באפריל 2019

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

הערה: ‏lifecycle-viewmodel-ktx לא תואם ל-Activity 1.0.0-alpha01 עד 1.0.0-alpha05 ול-Fragment 1.1.0-alpha01 עד 1.1.0-alpha05. מומלץ לשדרג לגרסה Activity 1.0.0-alpha06 ולגרסה Fragment 1.1.0-alpha06, בהתאמה.

שינויים ב-API

• שינוי שעלול לגרום לבעיות: ה-API הבסיסי שמאחורי by viewModels() ו-by activityViewModels() השתנה כדי לתמוך ישירות ב-ViewModelStore, ולא רק ב-ViewModelStoreOwner. (aosp/932932)

גרסה ‎2.1.0-alpha03

‫13 במרץ 2019

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

שינויים ב-API

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

גרסה ‎2.1.0-alpha02

‫30 בינואר 2019

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

שינויים ב-API

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

תיקוני באגים

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

גרסה ‎2.1.0-alpha01

‫17 בדצמבר 2018

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

תכונות חדשות

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

הערה: התוסף Lifecycle Extensions 1.0.0 (android.arch.lifecycle:extensions:1.0.0) לא תואם ל-livedata:1.1.0 או ל-viewmodel:1.1.0. עליך לעדכן לגרסה extensions:1.1.0, שכוללת תלות טרנזיטיבית ב-livedata:1.1.0 וב-viewmodel 1.1.0.

הערה: android.arch.lifecycle:reactivestreams:1.1.0 תלויה עכשיו רק ב-android.arch.lifecycle:livedata:1.1.0, ולא בכל android.arch.lifecycle:extensions:1.1.0.

שינויים ב-API

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