מחזור חיים
בטבלה הזו מפורטים כל פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) בקבוצה androidx.lifecycle
.
פריט מידע שנוצר בתהליך פיתוח (Artifact) | גרסה יציבה | מועמד לפרסום | גרסת בטא | גרסת אלפא |
---|---|---|---|---|
מחזור חיים-* | 2.8.5 | - | - | 2.9.0-alpha02 |
הרכבה של מודל צפייה במחזור חיים | 2.8.5 | - | - | 2.9.0-alpha02 |
הצהרה על יחסי תלות
כדי להוסיף תלות במחזור החיים, צריך להוסיף את מאגר Google Maven פרויקט. למאגר Maven של Google אפשר לקבל מידע נוסף.
מוסיפים את יחסי התלות של פריטי המידע הנדרשים בקובץ build.gradle
בשביל
האפליקציה או המודול שלך:
Kotlin
Groovy
dependencies { def lifecycle_version = "2.8.5" def arch_version = "2.2.0" // ViewModel implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version" // ViewModel utilities for Compose implementation "androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version" // LiveData implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version" // Lifecycles only (without ViewModel or LiveData) implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version" // Lifecycle utilities for Compose implementation "androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version" // Saved state module for ViewModel implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version" // Annotation processor kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // alternately - if using Java8, use the following instead of lifecycle-compiler implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version" // optional - helpers for implementing LifecycleOwner in a Service implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version" // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version" // optional - ReactiveStreams support for LiveData implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version" // optional - Test helpers for LiveData testImplementation "androidx.arch.core:core-testing:$arch_version" // optional - Test helpers for Lifecycle runtime testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version" }
Kotlin
dependencies { val lifecycle_version = "2.8.5" val arch_version = "2.2.0" // ViewModel implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version") // ViewModel utilities for Compose implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version") // LiveData implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version") // Lifecycles only (without ViewModel or LiveData) implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version") // Lifecycle utilities for Compose implementation("androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version") // Saved state module for ViewModel implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version") // Annotation processor kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version") // alternately - if using Java8, use the following instead of lifecycle-compiler implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version") // optional - helpers for implementing LifecycleOwner in a Service implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version") // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version") // optional - ReactiveStreams support for LiveData implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version") // optional - Test helpers for LiveData testImplementation("androidx.arch.core:core-testing:$arch_version") // optional - Test helpers for Lifecycle runtime testImplementation ("androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version") }
Java
Groovy
dependencies { def lifecycle_version = "2.8.5" def arch_version = "2.2.0" // ViewModel implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // LiveData implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version" // Lifecycles only (without ViewModel or LiveData) implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version" // Saved state module for ViewModel implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version" // Annotation processor annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // alternately - if using Java8, use the following instead of lifecycle-compiler implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version" // optional - helpers for implementing LifecycleOwner in a Service implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version" // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version" // optional - ReactiveStreams support for LiveData implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // optional - Test helpers for LiveData testImplementation "androidx.arch.core:core-testing:$arch_version" // optional - Test helpers for Lifecycle runtime testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version" }
Kotlin
dependencies { val lifecycle_version = "2.8.5" 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.9
גרסה 2.9.0-alpha02
4 בספטמבר 2024
androidx.lifecycle:lifecycle-*:2.9.0-alpha02
משוחרר. גרסה 2.9.0-alpha02 מכילה את התחייבויות אלה.
תיקוני באגים
- ממחזור החיים
2.8.5
: מעדכנים את כלליandroidx.lifecycle.ReportFragment
ProGuard כדי לאפשר ערפול קוד (obfuscation). (ff898e1)
תרומה חיצונית
- מעבירים את
androidx.compose.ui.platform.LocalLifecycleOwner
לקבוצת מקור משותפת (KMP). תודה לאיוון מטקוב מ-JetBrains על התרומה. (8cd5d03) - מ-Lifecycle
2.8.5
: המשתמש שקיבל הרשאה לניהול התוסף SaveStateHandle.saveable תומך עכשיו בערכים שאינם יכולים להיות בעלי ערך null. תודה רומן קלוקיביץ' על התרומה. (0d78ea6)
גרסה 2.9.0-alpha01
7 באוגוסט 2024
androidx.lifecycle:lifecycle-*:2.9.0-alpha01
משוחרר. גרסה 2.9.0-alpha01 מכילה את התחייבויות אלה.
Kotlin Multiplatform
- האפליקציה
lifecycle-testing
תואמת עכשיו ל-KMP. (Iea41e) - הוספת תמיכה ליעד מרובה-פלטפורמות של
linuxArm64
kotlin (I139d3, b/338268719)
תכונות חדשות
- יש ארטיפקט חדש מסוג
androidx.lifecycle:lifecycle-viewmodel-testing
KMP שמספק מחלקה שלViewModelScenario
לבדיקת ViewModels באופן מבודד, עם תמיכה ב-onCleared
(כל הפלטפורמות) וב-SavedStateHandle
(Android בלבד). (337f68d, c9b3409, 9799a95c, b/264602919) - מעכשיו, יצירת
ViewModel
באמצעותViewModelProvider
בטוחה בשרשור.@MainThread
הערות הוסרו. (Ifd978, b/237006831)
שינויים ב-API
- כדי לפשט את היצירה של אובייקטים אנונימיים מסוג
CreationExtras.Key
, צריך להוסיף את הפונקציה להגדרות המקוריותCreationExtras.Key()
. (I970ee) CreationExtras
כולל עכשיו עומסי יתר של אופרטורים דמויי מפה שמאפשרים מניפולציה אידיומטית של תוכן ב-Kotlin. היא מאפשרת להשתמש ב-in
, ב-+=
וב-+
עםCreationExtras
. (Ib4353)CreationExtras
מטמיעה עכשיו שיטותequals
,hashCode
ו-toString
. (Ib4353)- הניסוי
NewInstanceFactory
זמין עכשיו ביעדים של JVM למחשב ו-Android. (d3d0892) - מאפיין תוסף מוטבע כדי לחשוף את האפליקציה הבסיסית בצורה בטוחה בגרסה 2.0 של Kotlin לשפה (I39df2)
תיקוני באגים
- הוסרה חלוקה ידנית של הגישה לממשקי API של פלטפורמות חדשות, כי זה קורה באופן אוטומטי באמצעות בניית מודלים של API כשמשתמשים ב-R8 עם AGP 7.3 ואילך (למשל R8 גרסה 3.3) ובכל גרסאות ה-build כשמשתמשים ב-AGP 8.1 ואילך (למשל D8 גרסה 8.1). ללקוחות שלא משתמשים ב-AGP מומלץ לעדכן לגרסה D8 ואילך. למידע נוסף, מומלץ לעיין במאמר הזה. (If6b4c, b/345472586)
גרסה 2.8
גרסה 2.8.5
4 בספטמבר 2024
androidx.lifecycle:lifecycle-*:2.8.5
משוחרר. גרסה 2.8.5 כוללת את ההתחייבויות האלה.
תיקוני באגים
- צריך לעדכן את
androidx.lifecycle.ReportFragment
כללי ProGuard כדי לאפשר ערפול קוד (obfuscation). (ff898e1)
תרומה חיצונית
- משתמש שקיבל הרשאה לתוסף
SavedStateHandle.saveable
תומך עכשיו בערכים שניתנים לביטול. תודה רומן קלוקיביץ' על התרומה. (0d78ea6)
גרסה 2.8.4
24 ביולי 2024
androidx.lifecycle:lifecycle-*:2.8.4
משוחרר. גרסה 2.8.4 כוללת את ההתחייבויות האלה.
תיקוני באגים
LiveData.asFlow()
מטפל עכשיו בצורה נכונה במקרים שבהם הזרימה שהוחזרה מסתיימת מיד לאחר קבלת ערך שכבר הוגדר ב-LiveData
(לדוגמה, כשמשתמשים ב-take(1)
). (I9c566)- עכשיו ההשלמה של
Lifecycle*Effect
היא אידמפוטנטית (כלומר, אם נשלחה קריאה לonStopOrDispose
בגלל הפסקת מחזור החיים, היא לא תיקרא פעם שנייה לאחר ההשלכה, אלא אם מחזור החיים יחזור לערךSTARTED
). (I5f607, b/352364595)
גרסה 2.8.3
1 ביולי 2024
androidx.lifecycle:lifecycle-*:2.8.3
משוחרר. גרסה 2.8.3 כוללת את ההתחייבויות האלה.
תיקוני באגים
- תוקנה בעיה בתאימות לאחור של מחזור חיים 2.8 עם 'כתיבה' בגרסה 1.6.0 ומטה במהלך שימוש בכיווץ קוד. (aosp/3133056, b/346808608)
גרסה 2.8.2
12 ביוני 2024
androidx.lifecycle:lifecycle-*:2.8.2
משוחרר. גרסה 2.8.2 כוללת את ההתחייבויות האלה.
תיקוני באגים
- תוקנו
CompositionLocal LocalLifecycleOwner not present
שגיאות במחזור חיים 2.8.X עם 'כתיבה' בגרסה 1.6.X ומטה. עכשיו אפשר להשתמש במחזור חיים 2.8.2 בכל גרסה של 'כתיבה' ללא צורך בפתרונות עקיפים. (aosp/3105647, b/336842920) ViewModelProvider
לא תקרוס יותר במהלך שילוב גרסאות קודמות של יחסי תלות שלcompileOnly
במחזור החיים עם גרסאות 2.8 ואילך, ופתרון בעיות בספריות כמו LeakCanary. (I80383, b/341792251)
גרסה 2.8.1
29 במאי 2024
androidx.lifecycle:lifecycle-*:2.8.1
משוחרר. גרסה 2.8.1 כוללת את ההתחייבויות האלה.
תיקוני באגים
- עכשיו יש ל-
lifecycle-viewmodel-compose
רק תלות משותפת ב-compose-runtime
, והיא מסירה את התלות המשותפת ב-compose-ui
. פריט המידע שנוצר בתהליך הפיתוח (Artifact) של Android שומר אתcompose-ui
שלו לצורכי תאימות. (aosp/3079334, b/339562627) - בשילוב של
saveable
שלViewModel
, באמצעות משתמשים שקיבלו הרשאה לניהול הנכס, נעשה עכשיו שימוש בשם הכיתה כחלק מהמפתח שנוצר באופן אוטומטי, כדי למנוע התנגשויות אם כמה כיתות משתמשות באותוSavedStateHandle
. (aosp/3063463)
גרסה 2.8.0
14 במאי 2024
androidx.lifecycle:lifecycle-*:2.8.0
משוחרר. גרסה 2.8.0 כוללת את ההתחייבויות האלה.
שינויים חשובים מאז 2.7.0
- בוצעה העברה של
LocalLifecycleOwner
מממשק המשתמש של 'פיתוח נייטיב' ל-lifecycle-runtime-compose
כדי שאפשר יהיה להשתמש בממשקי ה-API לעזרה שמבוססים על הכתיבה מחוץ לממשק המשתמש של הכתיבה. - פריט המידע שנוצר בתהליך הפיתוח (Artifact) של
lifecycle-runtime-compose
מכיל עכשיו את ממשקי ה-APIdropUnlessResumed
ו-dropUnlessStarted
שמאפשרים לך להחריג קליקים או אירועים אחרים שמתרחשים גם אחרי שהשדהLifecycleOwner
ירד אל מתחת ל-Lifecycle.State
הנתון. לדוגמה, אפשר להשתמש באפשרות הזו בשילוב עם 'ניסוח ניווט' כדי להימנע מטיפול באירועי קליקים אחרי שכבר התחיל מעבר למסך אחר:onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }
ViewModel.viewModelScope
הוא עכשיו פרמטר constructor שניתן לשינוי, שמאפשר להזריק את הסדרן שלך וגםSupervisorJob()
, או לשנות את ברירת המחדל באמצעות ה-backgroundScope
שזמין ב-runTest
. (I2817c, b/264598574)class MyViewModel( // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob() ) : ViewModel(viewModelScope) { // Use viewModelScope as before, without any code changes } // Allows overriding the viewModelScope in a test fun Test() = runTest { val viewModel = MyViewModel(backgroundScope) }
המסמך
ViewModel
נכתב מחדש ב-Kotlin ועכשיו הוא משתמש ב-AutoClosable
במקום ב-Closeable
. עכשיו יש תמיכה בהוספת אובייקטים מסוגAutoCloseable
עםkey
שמאפשר לאחזר אותם דרךgetCloseable()
.קריאה ל-
LifecycleStartEffect
ול-LifecycleResumeEffect
בלי מפתח היא עכשיו שגיאה, בהתאם לאותה מוסכמה כמו ה-API שלDisposableEffect
שממשקי ה-API האלה משקפים.הוצא משימוש
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData)
לטובתLiveData.toPublisher(lifecycleOwner)
.תוספי ה-Kotlin
lifecycle-livedata-core-ktx
הועברו למודולlifecycle-livedata-core
.בוצע ארגון מחדש של
NullSafeMutableLiveData
כדי להימנע מהרבה תוצאות חיוביות מוטעות.
תאימות ל-Kotlin מרובה-פלטפורמות במחזור חיים
ממשקי ה-API העיקריים של מחזור החיים ב-Lifecycle
, ב-LifecycleOwner
, ב-LifecycleObserver
, ב-Lifecycle.State
, ב-Lifecycle.Event
וב-LifecycleRegistry
נשלחים עכשיו בפריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שתואמים ל-Kotlin Multiplatform.
פריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שהושפעו:
lifecycle-common
מעביר את רוב ממשקי ה-API ל-common
ותומך ב-jvm וב-iOS בנוסף ל-Android.lifecycle-runtime
מעביר את רוב ממשקי ה-API ל-common
ותומך ב-jvm וב-iOS בנוסף ל-Android.- השדה
lifecycle-runtime-ktx
ריק עכשיו, וכל ממשקי ה-API מועברים אלlifecycle-runtime
. lifecycle-runtime-compose
מעביר את כל ממשקי ה-API אלcommon
ושולח פריט מידע שנוצר בתהליך הפיתוח (Artifact) של Android, שתואם לתמיכה בפלטפורמות מרובות שלandroidx.compose
.
תאימות ל-ViewModel Kotlin לריבוי פלטפורמות
פריט המידע שנוצר בתהליך הפיתוח (Artifact) של lifecycle-viewmodel
וממשקי ה-API כמו ViewModel
, ViewModelStore
, ViewModelStoreOwner
ו-ViewModelProvider
נשלחים עכשיו בפריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שתואמים ל-Kotlin Multiplatform.
כדי לאפשר את השינוי הזה, שיטות כמו אלה שהתבצעו ב-ViewModelProvider
שבהן התבצעו java.lang.Class<T>
יש עכשיו שיטה מקבילה של kotlin.reflect.KClass<T>
.
תאימות בינארית ב-Android נשמרה, אבל יש כמה שינויים חשובים כשמשווים את פלטפורמת Android API לפלטפורמה המשותפת של ה-API:
- בניית המכונה של
ViewModelProvider
מתבצעת עכשיו באמצעות ה-methodsViewModelProvider.create()
ולא בקריאה ישירה ל-constructor שלה. ViewModelProvider.NewInstanceFactory
ו-ViewModelProvider.AndroidViewModelFactory
זמינים רק ב-Android.- מומלץ להגדיר 'גורמים מותאמים אישית' מ-
ViewModelProvider.Factory
ולהשתמש בשיטהcreate
עםCreationExtras
או ב-Kotlin DSLviewModelFactory
.
- מומלץ להגדיר 'גורמים מותאמים אישית' מ-
- שימוש ב-
ViewModelProvider
ללא יצרן מותאם אישית בפלטפורמות שאינן JVM יוביל לUnsupportedOperationException
. בפלטפורמות JVM, התאימות נשמרת באמצעות constructor של ViewModel ללא ארגומנטים, אם לא מספקים מפעל בהתאמה אישית. viewModelScope
יחזור לערךEmptyCoroutineContext
בפלטפורמות שבהןDispatchers.Main
לא זמין (למשל, Linux).
פריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שהושפעו:
lifecycle-viewmodel
מעביר את רוב ממשקי ה-API ל-common
ותומך ב-jvm וב-iOS בנוסף ל-Android.- השדה
lifecycle-viewmodel-ktx
ריק עכשיו, וכל ממשקי ה-API מועברים אלlifecycle-viewmodel
. lifecycle-viewmodel-compose
מעביר את כל ממשקי ה-API אלcommon
ושולח פריט מידע שנוצר בתהליך הפיתוח (Artifact) של Android, שתואם לתמיכה בפלטפורמות מרובות שלandroidx.compose
.
שינויים בהתנהגות
InitializerViewModelFactory
(כולל פונקציית ה-builderviewModelFactory
) יקפיץ עכשיוIllegalArgumentException
אם כבר נוסףinitializer
עם אותוclazz: KClass<VM : ViewModel>
. (Ic3a36)
בעיות מוכרות
lifecycle-*:2.8.0
מחייב גרסת פיתוח מינימלית של 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
כיתות לא נארז כמו שצריך. המוצרים האלה ארוזים עכשיו ב-AAR שלlifecycle-runtime
. (aosp/3038274, b/322382422) - תוקן שינוי לא מכוון בהזמנה באופן שבו המכונות של
AutoCloseable
שמצורפים ל-ViewModel נמחקו – הסדר הקודםaddCloseable(String, AutoCloseable)
ואחר כךaddClosable(AutoCloseable)
, ואזonCleared()
שוחזר. (aosp/3041632) - לשפר את התנהגות היצירה שמוגדרת כברירת מחדל ל-
viewModelScope
בסביבות מקוריות ובסביבות JVM Desktop. (aosp/3039221)
תרומה חיצונית
- תודה Victor Kropp על שיפור הבדיקה של ה-thread הראשי ב-JVM Desktop. (aosp/3037116)
גרסה 2.8.0-beta01
17 באפריל 2024
androidx.lifecycle:lifecycle-*:2.8.0-beta01
משוחרר. גרסה 2.8.0-beta01 כוללת את ההתחייבויות האלה.
תכונות חדשות
- פריט המידע שנוצר בתהליך הפיתוח (Artifact) של
lifecycle-runtime-compose
תואם עכשיו ל-Kotlin Multiplatform, ומעביר את הקוד שלו אלcommon
ושולח פריט מידע שנוצר בתהליך הפיתוח (Artifact) של Android, שתואם לתמיכה במגוון פלטפורמות ב-androidx.compose
. (If7a71, I4f4a0, b/331769623)
גרסה 2.8.0-alpha04
3 באפריל 2024
androidx.lifecycle:lifecycle-*:2.8.0-alpha04
משוחרר. גרסה 2.8.0-alpha04 מכילה את התחייבויות אלה.
תכונות חדשות
- פריט המידע שנוצר בתהליך הפיתוח (Artifact) של
lifecycle-viewmodel-compose
תואם עכשיו ל-Kotlin Multiplatform, ומעביר את הקוד שלו אלcommon
ושולח פריט מידע שנוצר בתהליך הפיתוח (Artifact) של Android, שתואם לתמיכה בפלטפורמות מרובות שלandroidx.compose
. בהתאם לשינוי הזה, השיטה הקומפוזביליתviewModel
מקבלת עכשיוKClass
בנוסף ל-java.lang.Class
. (b/330323282)
תיקוני באגים
- בוצע ארגון מחדש של
NullSafeMutableLiveData
כדי להימנע מהרבה תוצאות חיוביות מוטעות. (I2d8c1, Iafb18, I03463, I7ecef)
עדכון בנושא תלות
- פריט המידע שנוצר בתהליך הפיתוח (Artifact) מסוג
lifecycle-viewmodel-compose
תלוי עכשיו ב-Compose 1.6.0. - מחזור החיים תלוי עכשיו בגרסה 1.3.1 של מנהל ההתקנה של הפרופיל.
גרסה 2.8.0-alpha03
20 במרץ 2024
androidx.lifecycle:lifecycle-*:2.8.0-alpha03
משוחרר. גרסה 2.8.0-alpha03 מכילה את התחייבויות אלה.
תכונות חדשות
ViewModel.viewModelScope
הוא עכשיו פרמטר constructor שניתן לשינוי, שמאפשר להזריק את הסדרן שלך וגםSupervisorJob()
, או לשנות את ברירת המחדל באמצעות ה-backgroundScope
שזמין ב-runTest
. (I2817c, b/264598574)class MyViewModel( // Make Dispatchers.Main the default, rather than Dispatchers.Main.immediate viewModelScope: CoroutineScope = Dispatchers.Main + SupervisorJob() ) : ViewModel(viewModelScope) { // Use viewModelScope as before, without any code changes } // Allows overriding the viewModelScope in a test fun Test() = runTest { val viewModel = MyViewModel(backgroundScope) }
תאימות ל-Kotlin בריבוי פלטפורמות
פריט המידע שנוצר בתהליך הפיתוח (Artifact) של lifecycle-viewmodel
וממשקי ה-API כמו ViewModel
, ViewModelStore
, ViewModelStoreOwner
ו-ViewModelProvider
נשלחים עכשיו בפריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שתואמים ל-Kotlin Multiplatform. (b/214568825)
כדי לאפשר את השינוי הזה, שיטות כמו אלה שהתבצעו ב-ViewModelProvider
שבהן התבצעו java.lang.Class<T>
יש עכשיו שיטה מקבילה של kotlin.reflect.KClass<T>
.
תאימות בינארית ב-Android נשמרה, אבל יש כמה שינויים חשובים כשמשווים את פלטפורמת Android API לפלטפורמה המשותפת של ה-API:
- בניית המכונה של
ViewModelProvider
מתבצעת עכשיו באמצעות ה-methodsViewModelProvider.create()
ולא בקריאה ישירה ל-constructor שלה. ViewModelProvider.NewInstanceFactory
ו-ViewModelProvider.AndroidViewModelFactory
זמינים רק ב-Android.- מומלץ להגדיר 'גורמים מותאמים אישית' מ-
ViewModelProvider.Factory
ולהשתמש בשיטהcreate
עםCreationExtras
או ב-Kotlin DSLviewModelFactory
.
- מומלץ להגדיר 'גורמים מותאמים אישית' מ-
- שימוש ב-
ViewModelProvider
ללא יצרן מותאם אישית בפלטפורמות שאינן JVM יוביל לUnsupportedOperationException
. בפלטפורמות JVM, התאימות נשמרת באמצעות constructor של ViewModel ללא ארגומנטים, אם לא מספקים מפעל בהתאמה אישית. viewModelScope
יחזור לערךEmptyCoroutineContext
בפלטפורמות שבהןDispatchers.Main
לא זמין (למשל, Linux).
שינויים בהתנהגות
InitializerViewModelFactory
(כולל פונקציית ה-builderviewModelFactory
) יקפיץ עכשיוIllegalArgumentException
אם כבר נוסףinitializer
עם אותוclazz: KClass<VM : ViewModel>
. (Ic3a36)
תיקוני באגים
ViewModel.getCloseable
מטפל עכשיו במפתחות כפולים: אם לkey
כבר משויך משאבAutoCloseable
, המשאב הישן יוחלף וייסגר מיד. (Ibeb67)- גישה אל
viewModelScope
שלViewModel
בטוחה עכשיו בשרשור. (If4766, b/322407038)
תרומה חיצונית
LocalLifecycleOwner
עבר מממשק המשתמש של כתיבת הודעה לכתיבה בזמן הרצה של מחזור החיים, כדי שאפשר יהיה להשתמש בממשקי ה-API לעזרה שמבוססים על הכתיבה מחוץ לממשק המשתמש של הכתיבה. תודה על התרומה, Jake Wharton. (I6c41b, b/328263448)
גרסה 2.8.0-alpha02
21 בפברואר 2024
androidx.lifecycle:lifecycle-*:2.8.0-alpha02
משוחרר. גרסה 2.8.0-alpha02 מכילה את התחייבויות אלה.
תכונות חדשות
- נוספו ממשקי ה-API
dropUnlessResumed
ו-dropUnlessStarted
שמאפשרים לך לשחרר קליקים או אירועים אחרים שמתרחשים גם אחרי שה-LifecycleOwner
ירד מתחת ל-Lifecycle.State
הנתון. לדוגמה, אפשר להשתמש באפשרות הזו בשילוב עם 'כתיבה' כדי להימנע מטיפול באירועי קליקים אחרי שמעבר למסך אחר כבר התחיל:onClick: () -> Unit = dropUnlessResumed { navController.navigate(NEW_SCREEN) }
(Icba83, b/317230685)
המרות של קוטלין
ViewModel
כתוב עכשיו ב-Kotlin (I16f26, b/214568825)- תוספי Kotlin עם
lifecycle-viewmodel-ktx
הועברו למודול של מחזור החיים הבסיסי. (Id787b, b/274800183) - תוספי Kotlin עם
lifecycle-runtime-ktx
הועברו למודול של מחזור החיים הבסיסי. (Ic3686, b/274800183) - תוספי Kotlin עם
lifecycle-livedata-core-ktx
הועברו למודול של מחזור החיים הבסיסי. (I54a3d, b/274800183)
תאימות ל-Kotlin בריבוי פלטפורמות
- ממשקי ה-API העיקריים של מחזור החיים ב-
Lifecycle
, ב-LifecycleOwner
, ב-LifecycleObserver
, ב-Lifecycle.State
, ב-Lifecycle.Event
וב-LifecycleRegistry
נשלחים עכשיו בפריטי מידע שנוצרו בתהליך הפיתוח (Artifact) שתואמים ל-Kotlin Multiplatform. (b/317249252)
שינויים ב-API
- קריאה ל-
LifecycleStartEffect
ול-LifecycleResumeEffect
בלי מפתח היא עכשיו שגיאה, בהתאם לאותה מוסכמה כמו ה-API שלDisposableEffect
שממשקי ה-API האלה משקפים. (Ib0e0c, b/323518079) ViewModel
משתמש עכשיו ב-AutoCloseable
במקום ב-Closeable
. מדובר בשינוי בתאימות לאחור. (I27f8e, b/214568825)- הוצא משימוש
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData)
לטובתLiveData.toPublisher(lifecycleOwner)
. (Iabe29, b/262623005)
תרומה חיצונית
- תודה לאבן מטקוב מ-Jetbrains על העזרה בהעברת מחזור החיים ל-Kotlin Multiplatform. (aosp/2926690, I0c5ac, If445d)
גרסה 2.8.0-alpha01
24 בינואר 2024
androidx.lifecycle:lifecycle-*:2.8.0-alpha01
משוחרר. גרסה 2.8.0-alpha01 מכילה את התחייבויות אלה.
תכונות חדשות
- ב-
ViewModel
יש עכשיו תמיכה בהוספת אובייקטים מסוגCloseable
עםkey
שמאפשר לאחזר אותם דרךgetCloseable()
. (I3cf63)
גרסה 2.7
גרסה 2.7.0
10 בינואר 2024
androidx.lifecycle:lifecycle-*:2.7.0
משוחרר. גרסה 2.7.0 כוללת את ההתחייבויות האלה.
שינויים חשובים מאז 2.6.0
TestLifecycleOwner
כולל עכשיו פונקציית השעיהsetCurrentState()
שמבטיחה ששינוי המצב וכל הקריאות החוזרות (callback) שלLifecycleObserver
הושלמו לפני החזרה. חשוב לציין שבניגוד להגדרה ישירה של המאפייןcurrentState
, השיטה הזו לא משתמשת ב-runBlocking
, כך שבטוח להשתמש בה בתוך קורוטין, כמו למשל שסופק על ידיrunTest
.- התוספים
LiveData
שלmap
ו-switchMap
משקפים עכשיו את ההתנהגות שלdistinctUntilChanged
. אם ל-LiveData
מוגדרvalue
, תתבצע קריאה לפונקציהmap
/switchMap
מיד כדי לאכלס את ה-value
של הערכים המוחזריםLiveData
. הפעולה הזו מבטיחה שהערך הראשוני יוגדר כחלק מההרכב הראשון (כשמשתמשים בו עםobserveAsState()
), אבל הוא לא ישנה את התנהגות התצפית. עדכוני ערכים מהמקורLiveData
עדיין יחולו רק לאחר שתתחילו לצפות ב-LiveData
. - בגרסה הזו מתקנת בעיה שגרמה לכך ש-
SavedStateHandle
לא ישחזר באופן תקין מחלקותParcelable
בהתאמה אישית אחרי מוות ויצירה של תהליך מחדש. בגלל מידע על סוגים שאבד על ידי מסגרת Android, מערכים של מגרשים בהתאמה אישית דורשות עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון). בנוסף, במסמכים ב-get
, ב-getLiveData
וב-getStateFlow
מוסברת עכשיו המגבלה הזו באופן ספציפי. - כללי השמירה במסגרת ההגנה המשויכים אל
LifecycleObserver
הוסרו. כלומר, קוד מוגן שרוצה להשתמש בממשקי API דרך הרפליקציה (למשל, באמצעות ההערה@OnLifecycleEvent
שהוצאה משימוש) יצטרך לספק כללי שמירה משלו לתרחיש הספציפי לדוגמה שלו.
ניראות של אירועים במחזור החיים
- במקום להשתמש ב-
LifecycleEventObserver
, עכשיו אפשר לצפות ב-Flow
שלLifecycle.Event
באמצעות שיטת התוסףLifecycle.asFlow()
. - מעכשיו, משתמשי Jetpack Compose יכולים להשתמש ב-
LifecycleEventEffect
כדי להריץ תופעות לוואי של 'כתיבה' על סמךLifecycle.Event
.
@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
viewModel.refreshData()
}
// …
}
- משתמשי Jetpack Compose יכולים להשתמש ב-
LifecycleStartEffect
וב-LifecycleResumeEffect
כדי לטפל בצמדים של אירועים – שהתחילו לפעול והושהו בהשהיה, בהתאמה. ה-API הזה משקף את ה-API שנמצא ב-DisposableEffect
, והוא מתאים למקרים שבהם צריך לבצע את השינוי כשמופיע חזרה למצב הקודם.
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
LifecycleStartEffect(viewModel) {
val timeTracking = viewModel.startTrackingTimeOnScreen()
onStopOrDispose {
timeTracking.stopTrackingTimeOnScreen()
}
}
// …
}
מידע נוסף זמין במאמר הרצת קוד על אירועים במחזור החיים.
ניראות (observability) המצב של מחזור החיים
- עכשיו אפשר לראות את הערך הנוכחי של
Lifecycle.State
דרך הנכסLifecycle.currentStateFlow
, שמחזירStateFlow
כאשרvalue
הואLifecycle.State
הנוכחי. - משתמשי 'Jetpack פיתוח נייטיב' יכולים להשתמש בתוסף
Lifecycle.currentStateAsState()
כדי לחשוף אתLifecycle.State
ישירות כ'כתיבה'State
. היא מקבילה (וחלופה קצרה יותר) ל-lifecycle.currentStateFlow.collectAsState()
.
מידע נוסף מופיע במאמר איסוף מצב מחזור חיים באמצעות תהליכים.
גרסה 2.7.0-rc02
13 בדצמבר 2023
androidx.lifecycle:lifecycle-*:2.7.0-rc02
משוחרר. גרסה 2.7.0-rc02 מכילה את שמירות האלה.
תיקוני באגים
- תוקנה בעיה שגרמה לכך ש-
SavedStateHandle
לא הצליח לשחזר באופן תקין כיתותParcelable
בהתאמה אישית אחרי מוות של תהליך ויצירה של נכס מחדש. בגלל מידע על סוגים שאבד על ידי מסגרת Android, מערכים של מגרשים בהתאמה אישית מחייבים עבודה נוספת (יצירה ידנית של מערך מוקלד מהסוג הנכון). בנוסף, במסמכים ב-get
, ב-getLiveData
וב-getStateFlow
מוסברת עכשיו המגבלה הזו באופן ספציפי. (I0b55a)
גרסה 2.7.0-rc01
15 בנובמבר 2023
androidx.lifecycle:lifecycle-*:2.7.0-rc01
משוחרר. גרסה 2.7.0-rc01 מכילה את ההתחייבויות האלה.
תיקוני באגים
- עכשיו
LifecycleStartEffect
ו-LifecycleResumeEffect
מסירים ויוצרים מחדש את בלוק האפקט אם משנים אתLifecycleOwner
. (Ia25c6)
גרסה 2.7.0-beta01
1 בנובמבר 2023
ההשקה של androidx.lifecycle:lifecycle-*:2.7.0-beta01
ללא שינויים. גרסה 2.7.0-beta01 מכילה את התחייבויות אלה.
- מעבר לגרסת בטא, ללא שינויים משמעותיים בגרסת הגרסה הזו.
גרסה 2.7.0-alpha03
18 באוקטובר 2023
androidx.lifecycle:lifecycle-*:2.7.0-alpha03
משוחרר. גרסה 2.7.0-alpha03 מכילה את התחייבויות אלה.
תכונות חדשות
- הפונקציה
lifecycle-runtime-testing
מכילה עכשיו בדיקת שגיאות בקוד (lint) חדשה שמונעת את ההגדרה שלLifecycle.State
שלTestLifecycleOwner
באמצעות השדהcurrentState
כשנמצאים בקורוטין. בדיקת השגיאות לאיתור שגיאות בקוד מציעה עכשיו השעיה שלsetCurrentState
, שמאפשרת להגדיר אתLifecycle.State
בלי לחסום. (Icf728, b/297880630)
תיקוני באגים
- תוקנה בעיה ב-
LiveData.switchMap
שגרמה לכך שהחזר של אותו מופע שלLiveData
גם בשיחה הראשונית וגם בהפעלה לאחר מכן מנעה את הוספת המופע שלLiveData
כמקור. (Ibedcba7)
גרסה 2.7.0-alpha02
6 בספטמבר 2023
androidx.lifecycle:lifecycle-*:2.7.0-alpha02
משוחרר. גרסה 2.7.0-alpha02 מכילה את התחייבויות אלה.
תכונות חדשות
TestLifecycleOwner
כולל עכשיו את פונקציית ההשעיהsetCurrentState()
, שנותנת למשתמשים אפשרות להשתמש ב-TestLifecycleOwner
מתוך קורוטין, כמו שניתן על ידיrunTest
. (I329de, b/259344129)
שינויים ב-API
- כל הקבצים מהמודולים של
lifecycle-livedata-ktx
הועברו למודול הראשי שלlifecycle-livedata
. (I10c6f, b/274800183)
שינויים בהתנהגות
- התוסף
LiveData.map()
ו-LiveData.switchMap()
מגדיר עכשיו את הערךvalue
שלLiveData
שהוחזרו אם הוגדר ערך ב-LiveData
הקודם. כך מובטח שהשימוש ב-LiveData שמתקבל ב-Jetpack פיתוח נייטיב מאפשר את המצב הנכון עבור היצירה הראשונית. (I91d2b, b/269479952) - המכשיר
addCloseable()
שלViewModel
סוגר עכשיו אתCloseable
אםViewModel
כבר קיבל שיחה למספרonCleared()
. (I4712e, b/280294730)
תיקוני באגים
- ממחזור חיים
2.6.2
: תוקנה בעיה שבהSavedStateHandle
לא ישוחזר כראוי אחרי מוות של תהליך אם המצב שוחזר,save()
בלי לשמור את המצב בפועל במצב ההורהSavedStateRegistry
ואז המצב שוחזר שוב. הפעולה הזו מתקנת את האינטראקציה ביןrememberSaveable
לביןNavHost
של התכונה 'ניווט'. (aosp/2729289)
גרסה 2.7.0-alpha01
26 ביולי 2023
androidx.lifecycle:lifecycle-*:2.7.0-alpha01
משוחרר. גרסה 2.7.0-alpha01 מכילה את התחייבויות אלה.
שינויים ב-API
- עכשיו השדה
Lifecycle.State
ניתן ל'כתיבה' דרךLifecycle.currentStateFlow
. הפונקציה הזו מחזירהStateFlow
כאשרvalue
הוא הערך הנוכחי שלLifecycle.State
. (Ib212d, b/209684871) - עכשיו אפשר לראות נתונים של
Lifecycle.Event
כ-Flow
בעזרתLifecycle.asFlow().
(If2c0f, b/176311030) - הוספנו את
LifecycleResumeEffect
API כדי להריץ שאילתות כתיבהSideEffect
על סמך קריאות חוזרות (callback) של אירועים מסוגLifecycle.Event.ON_RESUME
ושלLifecycle.Event.ON_PAUSE
. (I60386, b/235529345) - הוספנו את
LifecycleStartEffect
API כדי להריץ שאילתות כתיבהSideEffect
על סמך קריאות חוזרות (callback) של אירועים מסוגLifecycle.Event.ON_START
ו-Lifecycle.Event.ON_STOP
. (I5a8d1, b/235529345) - הוספנו את ממשק ה-API
LifecycleEventEffect
כדי להריץ תגובותSideEffect
על סמךLifecycle.Event
. (Ic9794, b/235529345) - תוסף אחד (
Lifecycle.collectAsState()
) נוסף כדי לחשוף אתLifecycle.State
באופן ישיר כ'אימייל חדש'State
. היא מקבילה (וחלופה קצרה יותר) ל-lifecycle.currentStateFlow.collectAsState()
. (I11015, b/235529345)
תיקוני באגים
- התוסף
LiveData.distinctUntilChanged()
מגדיר עכשיו את ה-value
של ה-LiveData
שהוחזר אם הוגדר ערך ל-LiveData
הקודם. הפעולה הזו לא משנה את התנהגות התצפית – ערכים מעודכנים מהמקורLiveData
עדיין יחולו רק לאחר שתתחילו לראות אתLiveData
שהוחזרו מ-distinctUntilChanged()
. (Ib482f) - כללי השמירה במסגרת ההגנה המשויכים אל
LifecycleObserver
הוסרו. כלומר, קוד מוגן שרוצה להשתמש בממשקי API דרך הרפליקה צריך לספק כללי שמירה משלו לתרחיש הספציפי לדוגמה שלו. (Ia12fd)
גרסה 2.6
גרסה 2.6.2
6 בספטמבר 2023
androidx.lifecycle:lifecycle-*:2.6.2
משוחרר. גרסה 2.6.2 כוללת את ההתחייבויות האלה.
תיקוני באגים
- תוקנה בעיה שבה
SavedStateHandle
לא ישוחזר באופן תקין אחרי מוות של תהליך אם המצב ישוחזר, נשלחה קריאה לפעולהsave()
בלי לשמור בפועל את המצב ברמת ההורהSavedStateRegistry
, ואז המצב שוחזר שוב. הפעולה הזו מתקנת את האינטראקציה ביןrememberSaveable
לביןNavHost
של התכונה 'ניווט'. (aosp/2729289)
גרסה 2.6.1
22 במרץ 2023
androidx.lifecycle:lifecycle-*:2.6.1
משוחרר. גרסה 2.6.1 כוללת את ההתחייבויות האלה.
עדכונים בנושא תלות
- הערך
lifecycle-viewmodel-savedstate
תלוי עכשיו ב-SavedState1.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
כולל עכשיו constructor להגדרה של ערך ראשוני.- נוסף תוסף חדש ב-
StateFlow
וב-Flow
שלcollectAsStateWithLifecycle()
שאוסף מתהליכים ומייצג את הערך האחרון שלו כמצב 'כתיבה' באופן שמתחשב במחזור החיים. - השיטות
Lifecycle.launchWhenX
וה-methodsLifecycle.whenX
הוצאו משימוש, כי במקרים מסוימים השימוש בסדרת השהיה עלול לגרום לבזבוז משאבים. מומלץ להשתמש ב-Lifecycle.repeatOnLifecycle
. כדי לקבל מידע נוסף על השעיה חד-פעמית של עבודה, אפשר לקרוא את ההסבר הזה למה ההגדרה לא בטוחה מטבעה. - המרה של Kotlin – מספר גדול של כיתות במחזור החיים הומרו ל-Kotlin. כל המחלקות שעברו המרה עדיין שומרות על תאימות בינארית לגרסאות קודמות. במחלקות הבאות יש שינויים לא תואמים למקור לכיתות שנכתבו ב-Kotlin:
ViewTreeLifecycleOwner
,LiveDataReactiveStreams
,HasDefaultViewModelProviderFactory
,ViewTreeViewModelStoreOwner
,Transformations
,ViewModelStoreOwner
,LifecycleOwner
הטבלה הבאה מציגה את המרות המקור של הגרסה החדשה של מחזור החיים.
מחזור חיים 2.5 | Lifecycle 2.5 (KTX) | מחזור חיים 2.6 |
---|---|---|
Transformations.switchMap(liveData) {...} |
liveData.switchMap {...} |
liveData.switchMap {...} |
Transformations.map(liveData) {...} |
liveData.map {...} |
liveData.map {...} |
Transformations.distinctUntilChanged(liveData) {...} |
liveData.distinctUntilChanged{...} |
liveData.distinctUntilChanged{...} |
LiveDataReactiveStreams.fromPublisher(publisher) |
publisher.toLiveData() |
publisher.toLiveData() |
LiveDataReactiveStreams.toPublisher(lifecycleOwner, liveData) |
liveData.toPublisher(lifecycleOwner) |
liveData.toPublisher(lifecycleOwner) |
override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory |
override fun getDefaultViewModelProviderFactory(): ViewModelProvider.Factory = factory |
override val defaultViewModelProviderFactory = factory |
override fun getDefaultViewModelCreationExtras(): CreationExtras = extras |
override fun getDefaultViewModelCreationExtras(): CreationExtras = extras |
override val defaultViewModelProviderCreationExtras = extras |
ViewTreeLifecycleOwner.set(view, owner) |
ViewTreeLifecycleOwner.set(view, owner) |
view.setViewTreeLifecycleOwner(owner) |
ViewTreeLifecycleOwner.get(view) |
view.findViewTreeLifecycleOwner() |
view.findViewTreeLifecycleOwner() |
override fun getViewModelStore(): ViewModelStore = store |
override fun getViewModelStore(): ViewModelStore = store |
override val viewModelStore: ViewModelStore = store |
override fun getLifecycle(): Lifecycle = registry |
override fun getLifecycle(): Lifecycle = registry |
override val lifecycle: Lifecycle get() = registry |
- ערך ה-null של שיטת
onChanged
שלObserver
שנוצר ב-Kotlin תואם עכשיו ליכולת ה-null של הסוג הגנרי. כדי ש-Observer.onChanged()
יקבל סוג של null, צריך ליצור מופע שלObserver
עם סוג שהוא ערך null. - גם הכיתות האלה הומרו ל-Kotlin, אבל נשארות תואמות למקור:
DefaultLifecycleObserver
,LifecycleEventObserver
,Lifecycle
,LifecycleRegistry
,LifecycleObserver
,ViewModelStore
,AndroidViewModel
,AbstractSavedStateViewModelFactory
,LifecycleService
,ServiceLifecycleDispatcher
וגםProcessLifecycleOwner
גרסה 2.6.0-rc01
22 בפברואר 2023
androidx.lifecycle:lifecycle-*:2.6.0-rc01
משוחרר. גרסה 2.6.0-rc01 מכילה את שמירות האלה.
תיקוני באגים
- התוסף
LiveData.distinctUntilChanged()
מגדיר עכשיו את ה-value
של ה-LiveData
שהוחזר אם הוגדר ערך ל-LiveData
הקודם. הפעולה הזו לא משנה את התנהגות התצפית – ערכים מעודכנים מהמקורLiveData
עדיין יחולו רק לאחר שתתחילו לראות אתLiveData
שהוחזרו מ-distinctUntilChanged()
. (Ib482f)
גרסה 2.6.0-beta01
8 בפברואר 2023
androidx.lifecycle:lifecycle-*:2.6.0-beta01
משוחרר. גרסה 2.6.0-beta01 מכילה את התחייבויות אלה.
המרות של קוטלין
LifecycleOwner
כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור לכיתות שנכתבו ב-Kotlin. עכשיו הן צריכות לעקוף את המאפייןlifecycle
במקום ליישם את הפונקציהgetLifecycle()
הקודמת. (I75b4b, b/240298691)ViewModelStoreOwner
נמצא עכשיו ב-Kotlin. זהו שינוי לא תואם למקור לכיתות שנכתבו ב-Kotlin. עכשיו הן צריכות לעקוף את המאפייןviewModelStore
במקום ליישם את הפונקציהgetViewModelStore()
הקודמת. (I86409, b/240298691)- תוסף Kotlin ב-
LifecycleOwner
שמספק את השדהlifecycleScope
הועבר לארטיפקטlifecycle-common
מ-lifecycle-runtime-ktx
. (I41d78, b/240298691) - תוסף Kotlin ב-
Lifecycle
שמספק את השדהcoroutineScope
הועבר לארטיפקטlifecycle-common
מ-lifecycle-runtime-ktx
. (Iabb91, b/240298691)
גרסה 2.6.0-alpha05
25 בינואר 2023
androidx.lifecycle:lifecycle-*:2.6.0-alpha05
משוחרר. גרסה 2.6.0-alpha05 מכילה את התחייבויות אלה.
המרות של קוטלין
Transformations
כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור עבור הכיתות שנכתבו ב-Kotlin באופן ישיר שהשתמשו בתחביר כמוTransformations.map
– קוד Kotlin חייב עכשיו להשתמש בתחביר שיטת התוסף Kotlin שהיה זמין בעבר רק בעת השימוש ב-lifecycle-livedata-ktx
. כשמשתמשים בשפת התכנות Java, הגרסאות של השיטות האלה שמבוססות על שיטתandroidx.arch.core.util.Function
הוצאו משימוש ומוחלפות בגרסאות שמשתמשות ב-KotlinFunction1
. השינוי הזה שומר על תאימות בינארית. (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. ה-methodonChanged()
משתמשת עכשיו בשםvalue
כפרמטר. (Iffef2, I4995e, b/240298691)AndroidViewModel
,AbstractSavedStateViewModelFactory
,LifecycleService
,ServiceLifecycleDispatcher
ו-ProcessLifecycleOwner
נכתבים עכשיו ב-Kotlin (I2e771, Ibae40, I160d7, I08884, I1cda7, b/240298)691{/11
גרסה 2.6.0-alpha04
11 בינואר 2023
androidx.lifecycle:lifecycle-*:2.6.0-alpha04
משוחרר. גרסה 2.6.0-alpha04 מכילה את התחייבויות אלה.
תכונות חדשות
LiveData
כולל עכשיו מאפייןisInitialized
חדש שמציין אם ערך מפורש הוגדר אי פעם ב-LiveData
, ומאפשר לך להבחין ביןliveData.value
מוחזרותnull
כי מעולם לא הוגדר ערך או ערךnull
מפורש. (Ibd018)
שינויים ב-API
- ממשקי ה-API של
collectAsStateWithLifecycle()
שלlifecycle-runtime-compose
כבר לא במצב ניסיוני. (I09d42, b/258835424) - השיטות
Lifecycle.launchWhenX
וה-methodsLifecycle.whenX
הוצאו משימוש, כי במקרים מסוימים השימוש בסדרת השהיה עלול לגרום לבזבוז משאבים. מומלץ להשתמש ב-Lifecycle.repeatOnLifecycle
. (Iafc54, b/248302832)
המרות של קוטלין
ViewTreeLifecycleOwner
כתוב עכשיו ב-Kotlin. זהו שינוי לא תואם למקור לכיתות שנכתבו ב-Kotlin. עליך לייבא עכשיו ישירות את שיטות התוסף של Kotlin ולהשתמש בהן ב-View
שלandroidx.lifecycle.setViewTreeLifecycleOwner
וב-androidx.lifecycle.findViewTreeLifecycleOwner
כדי להגדיר ולמצוא בעלים שהוגדרו בעבר. הפעולה הזו מחליפה את תוסף Kotlin הקודם ב-lifecycle-runtime-ktx
. שיטה זו תואמת בינארית ותואמת למקור חדש להטמעות שנכתבו בשפת התכנות Java. (I8a77a, I5234e, b/240298691)LiveDataReactiveStreams
כתוב עכשיו ב-Kotlin. התוספים של Kotlin שהיו בעבר ב-lifecycle-reactivestreams-ktx
הועברו למודולlifecycle-reactivestreams
והפכו לפלטפורמה הראשית של קוד שנכתב ב-Kotlin. זהו שינוי לא תואם למקור עבור קוד שנכתב ב-Kotlin אם עדיין לא השתמשת בממשקי ה-API של שיטת התוספים של Kotlin. (I2b1b9, I95d22, b/240298691)DefaultLifecycleObserver
,LifecycleEventObserver
,Lifecycle
,LifecycleRegistry
,LifecycleObserver
ו-ViewModelStore
נכתבים עכשיו ב-Kotlin (Iadffd, (I60034, I8c52c, I9593d, I01fe1, I59a/23I59a23
תיקוני באגים
SavedStateHandle
כבר לא קורס עםClassCastException
בהתקשרות אלget()
עם המחלקה הלא נכונה מהסוג הזה. (I6ae7c)
גרסה 2.6.0-alpha03
24 באוקטובר 2022
androidx.lifecycle:lifecycle-*:2.6.0-alpha03
משוחרר. גרסה 2.6.0-alpha03 מכילה את התחייבויות אלה.
תיקוני באגים
- תוקנה בעיה במגבלות בין מודולים שונים של מחזור חיים שלא פעלו כמתוכנן. (I18d0d, b/249686765)
- השגיאות שנרשמה על ידי
LifecycleRegistry.moveToState()
כוללות עכשיו הודעות שגיאה מועילות יותר, שמיידעות מפתחים לגבי הרכיב שגורם לשגיאה. (Idf4b2, b/244910446)
גרסה 2.6.0-alpha02
7 בספטמבר 2022
androidx.lifecycle:lifecycle-*:2.6.0-alpha02
משוחרר. גרסה 2.6.0-alpha02 מכילה את התחייבויות אלה.
שינויים ב-API
MediatorLiveData
כולל עכשיו constructor להגדרה של ערך ראשוני. (Ib6cc5, b/151244085)
תיקוני באגים
- פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) של
Lifecycle
כוללים עכשיו מגבלות שמבטיחות שכל פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) של מחזור החיים התלויים האלה ישתמשו באותה גרסה, כך שיחסי התלות האחרים ישודרגו באופן אוטומטי לאחר שדרוג אחד. b/242871265 FlowLiveData.asFlow()
יוצר עכשיוcallbackFlow
במקום להשתמש בהטמעה משלו שלChannel
כדי לוודא הגנה על שרשורים ושימור הקשר. (I4a8b2, b/200596935)- עכשיו, הפונקציה
asLiveData
שלFlowLiveData
תשמר את הערך הראשוני שלStateFlow
במהלך היצירה את האובייקטLiveData
החדש. (I3f530, b/157380488) - ממחזור חיים
2.5.1
: הטמעות בהתאמה אישית שלAndroidViewModelFactory
קוראות עכשיו בצורה נכונה לפונקציהcreate(modelClass)
כשמשתמשים ב-constructor של המצב (State) 2.4 ואילך (I5b315, b/238011621)Lifecycle
גרסה 2.6.0-alpha01
29 ביוני 2022
androidx.lifecycle:lifecycle-*:2.6.0-alpha01
משוחרר. גרסה 2.6.0-alpha01 מכילה את התחייבויות אלה.
תכונות חדשות
- נוסף תוסף חדש ב-
StateFlow
וב-Flow
שלcollectAsStateWithLifecycle
שאוסף מתהליכים ומייצג את הערך האחרון שלו כמצב 'כתיבה' באופן שמתחשב למחזור החיים. הזרימה נאסף והפליטה החדשה מוגדרת לערך המדינה כשמחזור החיים נמצא לפחות בטווח שלLifecycle.State
מסוים. כשמחזור החיים נמוך מ-Lifecycle.State
, איסוף הזרימה נפסק והערך של המדינה לא מתעדכן. (I1856e, b/230557927)
גרסה 2.5
גרסה 2.5.1
27 ביולי 2022
androidx.lifecycle:lifecycle-*:2.5.1
משוחרר. גרסה 2.5.1 כוללת את ההתחייבויות האלה.
תיקוני באגים
- הטמעות מותאמות אישית של
AndroidViewModelFactory
קוראות עכשיו לפונקציהcreate(modelClass)
כראוי כשמשתמשים ב-constructor שלAndroidViewModelFactory
עם המצבים הבאים:Lifecycle
מגרסה 2.4 ואילך. (I5b315, b/238011621)
גרסה 2.5.0
29 ביוני 2022
androidx.lifecycle:lifecycle-*:2.5.0
משוחרר. גרסה 2.5.0 כוללת את ההתחייבויות האלה.
שינויים חשובים מאז 2.4.0
ב-
SavedStateHandle
יש עכשיו API שלgetStateFlow()
שמחזיר KotlinStateFlow
למעקב אחרי שינויים בערכים, במקום להשתמש ב-LiveData
.ViewModel CreationExtras – כשכותבים
ViewModelProvider.Factory
בהתאמה אישית, לא צריך יותר להרחיב אתAndroidViewModelFactory
אוAbstractSavedStateViewModelFactory
כדי לקבל גישה אלApplication
אוSavedStateHandle
, בהתאמה. במקום זאת, השדות האלה מסופקים לכל תת-מחלקות שלViewModelProvider.Factory
בתורCreationExtras
באמצעות עומס היתר החדש שלcreate
:create(Class<T>, CreationExtras)
. התוספות האלה מסופקות באופן אוטומטי על ידי 'הפעילות או המקטע' שלך, בעת שימוש בפעילות1.5.0
ובמקטע1.5.0
, בהתאמה.class CustomFactory : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T { return when (modelClass) { HomeViewModel::class -> { // Get the Application object from extras val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY]) // Pass it directly to HomeViewModel HomeViewModel(application) } DetailViewModel::class -> { // Create a SavedStateHandle for this ViewModel from extras val savedStateHandle = extras.createSavedStateHandle() DetailViewModel(savedStateHandle) } else -> throw IllegalArgumentException("Unknown class $modelClass") } as T } }
lifecycle-viewmodel
מספק עכשיו DSL של Kotlin מסוגviewModelFactory
שמאפשר להגדיר אתViewModelProvider.Factory
במונחים של מאתחל אחד או יותר של lambda, אחד לכל מחלקה ספציפית שלViewModel
שנתמכת על ידי המפעל המותאם אישית שלך, תוך שימוש ב-CreationExtras
כמקור הנתונים הראשי.val customFactory = viewModelFactory { // The return type of the lambda automatically sets what class this lambda handles initializer { // Get the Application object from extras provided to the lambda val application = checkNotNull(get(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY)) HomeViewModel(application) } initializer { val savedStateHandle = createSavedStateHandle() DetailViewModel(savedStateHandle) } }
ב-
lifecycle-viewmodel-compose
יש עכשיו API שלviewModel()
שלוקח למפעל lambda ליצור מכונה שלViewModel
בלי צורך ביצירה שלViewModelProvider.Factory
בהתאמה אישית.// Within a @Composable, you can now skip writing a custom Factory // and instead write a lambda to do the initialization of your ViewModel val detailViewModel = viewModel { // This lambda is only called the first time the ViewModel is created // and all CreationExtras are available inside the lambda val savedStateHandle = createSavedStateHandle() DetailViewModel(savedStateHandle) }
שילוב של מצב חיסכון בכתיבה של SavedStateHandle – פריט המידע שנוצר בתהליך הפיתוח (Artifact) מסוג
lifecycle-viewmodel-compose
מכיל עכשיו ממשקי API ניסיוניים חדשים ב-SavedStateHandle.saveable
, שמאפשרים התנהגות דומה ל-rememberSaveable
שמגובה ב-SavedStateHandle
של 'ViewModel'.class ListScreenViewModel(handle: SavedStateHandle): ViewModel() { // This value survives both configuration changes and process death and recreation val editMode by handle.saveable { mutableStateOf(false) } }
נוספו API של
addCloseable()
ועומס יתר חדש של constructor, שמאפשר להוסיף אובייקטCloseable
אחד או יותר ל-ViewModel
, שייסגר אחרי מחיקתViewModel
בלי צורך בפעולות ידניות ב-onCleared()
.לדוגמה, כדי ליצור היקף מסוג קורוטין שאפשר להחדיר ל-ViewModel, אבל שליטה באמצעות בדיקה, אפשר ליצור
CoroutineScope
שמיישם אתCloseable
:class CloseableCoroutineScope( context: CoroutineContext = SupervisorJob() + Dispatchers.Main.immediate ) : Closeable, CoroutineScope { override val coroutineContext: CoroutineContext = context override fun close() { coroutineContext.cancel() } }
לאחר מכן ניתן להשתמש בו ב-constructor של
ViewModel
ולשמור על אותם משך חיים כמוviewModelScope
:class TestScopeViewModel( val customScope: CloseableCoroutineScope = CloseableCoroutineScope() ) : ViewModel(customScope) { // You can now use customScope in the same way as viewModelScope }
שינויים בהתנהגות
- ניסיון להעביר את
Lifecycle.State
מ-INITIALIZED
אלDESTROYED
תמיד יקפיץIllegalStateException
, ללא קשר אם ל-Lifecycle
יש צופה מצורף. - מעכשיו,
LifecycleRegistry
ינקה את התצפיתנים שלו כשתגיעו למצבDESTROYED
.
גרסה 2.5.0-rc02
15 ביוני 2022
androidx.lifecycle:lifecycle-*:2.5.0-rc02
משוחרר. גרסה 2.5.0-rc02 מכילה את שמירות האלה.
תיקוני באגים
ViewModelProvider
לא תקרוס יותר כשמשלבים גרסאות קודמות של יחסי תלות של מחזור חיים עם גרסאות 2.5 ואילך. (I81a66, b/230454566)
גרסה 2.5.0-rc01
11 במאי 2022
androidx.lifecycle:lifecycle-*:2.5.0-rc01
משוחרר. גרסה 2.5.0-rc01 מכילה את שמירות האלה.
תיקוני באגים
- עכשיו
MediatorLiveData.addSource()
זורקתNullPointerException
כשמעבירים מקורnull
במקום להפיץ את המקורnull
לתצפית.(Ibd0fb, b/123085232)
גרסה 2.5.0-beta01
20 באפריל 2022
androidx.lifecycle:lifecycle-*:2.5.0-beta01
משוחרר. גרסה 2.5.0-beta01 מכילה את התחייבויות אלה.
שינויים ב-API
- נוספו בעלי גישה לנכסים ב-
SavedStateHandle.saveable
כדי להשתמש בשמות נכסים כמפתחות לשמירה על מצב קבוע בתוךSavedStateHandle
(I8bb86, b/225014345)
תיקוני באגים
- תוקנה בעיה שבה הצבת
NavHost
בתוךNavHost
אחר בכרטיסיית ניווט תחתונה שאינה ראשית הובילה לערךIllegalStateException
כשמשתמשים במספר מקבצים של אחורה. (I11bd5, b/228865698)
גרסה 2.5.0-alpha06
6 באפריל 2022
androidx.lifecycle:lifecycle-*:2.5.0-alpha06
משוחרר. גרסה 2.5.0-alpha06 מכילה את התחייבויות אלה.
תכונות חדשות
- הוספת עומס יתר ניסיוני של
MutableState
ל-SavedStateHandle.saveable
עבור התאמה ל-rememberSaveable
(I38cfe, b/224565154)
שינויים ב-API
- עכשיו הטקסט
CreationExtras
מופשט במקום בחתימה. (Ib8a7a)
תיקוני באגים
- תוקנה שגיאה מסוג
IllegalStateException: Already attached to lifecycleOwner
שנגרמה על ידיSavedStateHandleController
. (I7ea47, b/215406268)
גרסה 2.5.0-alpha05
23 במרץ, 2022
androidx.lifecycle:lifecycle-*:2.5.0-alpha05
משוחרר. גרסה 2.5.0-alpha05 מכילה את התחייבויות אלה.
תכונות חדשות
- המודול
lifecycle-viewmodel-compose
מספק עכשיו אתSavedStateHandleSaver
, API ניסיוני שמבטיח שהערכים ב-SavedStateHandle
משולבים בצורה תקינה באותו מצב מכונה שמור שמשמש אתrememberSaveable
. (Ia88b7, b/195689777)
שינויים ב-API
- תוקנה בעיית תאימות לגרסה 2.3 של מחזור החיים ולגרסאות חדשות יותר של מחזור החיים ב-Java. (I52c8a, b/219545060)
תיקוני באגים
SavedStateViewFactory
תומך עכשיו בשימוש ב-CreationExtras
גם כאשר הוא אותחל עםSavedStateRegistryOwner
. אם תספקו תוספות, המערכת תתעלם מהארגומנטים המאתחלים. (I6c43b, b/224844583)
גרסה 2.5.0-alpha04
9 במרץ 2022
androidx.lifecycle:lifecycle-*:2.5.0-alpha04
משוחרר. גרסה 2.5.0-alpha04 מכילה את התחייבויות אלה.
שינויים ב-API
- ב-
SavedStateHandle
יש עכשיו API שלgetStateFlow()
שמחזיר KotlinStateFlow
למעקב אחרי שינויים בערכים במקום להשתמש ב-LiveData
. (Iad3ab, b/178037961)
גרסה 2.5.0-alpha03
23 בפברואר 2022
androidx.lifecycle:lifecycle-*:2.5.0-alpha03
משוחרר. גרסה 2.5.0-alpha03 מכילה את התחייבויות אלה.
תכונות חדשות
- נוספו ממשק API של
addCloseable()
וממשק חדש עומס יתר של ה-constructor, שמאפשר להוסיף פריט אחד או יותרCloseable
אובייקטים ל-ViewModel
שיהיו נסגר כשהערך שלViewModel
נמחק ללא צורך כל עבודה ידנית בonCleared()
. (I55ea0) lifecycle-viewmodel
מספק עכשיוInitializerViewModelFactory
שמאפשר להוסיף lambda לטיפול מחלקותViewModel
ספציפיות, תוך שימוש ב-CreationExtras
כנתונים הראשיים מקור. (If58fc, b/216687549)lifecycle-viewmodel-compose
מציע עכשיו API שלviewModel()
לוקחת מפעל lambda כדי ליצור מכונה שלViewModel
מחייב יצירה שלViewModelProvider.Factory
בהתאמה אישית. (I97fbb, b/216688927)
שינויים ב-API
- עכשיו אפשר ליצור
ViewModel
באמצעותCreationExtras
דרךlifecycle-viewmodel-compose
. (I08887, b/216688927)
שינויים בהתנהגות
- מתבצע ניסיון להעביר את
Lifecycle.State
מ-INITIALIZED
אלDESTROYED
תמיד יקפיץIllegalStateException
, ללא קשר אם ל-Lifecycle
יש צופה מצורף. (I7c390, b/177924329) - מעכשיו
LifecycleRegistry
ימחק את התצפיתנים שלו כאשר מגיעים למצבDESTROYED
. (I4f8dd, b/142925860)
גרסה 2.5.0-alpha02
9 בפברואר 2022
androidx.lifecycle:lifecycle-*:2.5.0-alpha02
משוחרר. גרסה 2.5.0-alpha02 מכילה את התחייבויות אלה.
שינויים ב-API
SavedStateHandle
ו-SavedStateViewModelFactory
הומרו ל-Kotlin. כתוצאה מכך, יכולת האפס של הגנריות בשני המחלקות שיפרה. (Ib6ce2, b/216168263, I9647a, b/177667711)- הפרמטר
LiveData
של הפונקציהswitchMap
יכול עכשיו יש פלט עם ערך null. (I40396, b/132923666) - נוספו הערות לתוספי ktx של
LiveData
@CheckResult
כדי לאכוף את השימוש בתוצאה כשמפעילים אותם למשימות ספציפיות. (Ia0f05, b/207325134)
שינויים בהתנהגות
SavedStateHandle
מאחסן עכשיו כראוי את defaultValue כאשר לא קיים ערך למפתח שצוין. (I1c6ce, b/178510877)
תיקוני באגים
- ממחזור חיים
2.4.1
: עודכןlifecycle-process
ועכשיו הוא תלוי ב-Startup 1.1.1, כדי להבטיח שהתיקונים שמונעים מ-ProcessLifecycleInitializer
להקפיץStartupException
זמינים כברירת מחדל. (Ib01df, b/216490724) - עכשיו יש הודעת שגיאה משופרת כשיש מחלקות בהתאמה אישית של
AndroidViewModel
פרמטרים בסדר שגוי ומנסים ליצורViewModel
. (I340f7, b/177667711) - עכשיו אפשר ליצור מודל צפייה דרך
CreationExtras
באמצעותAndroidViewModelFactory
בלי להגדיר אפליקציה. (I6ebef, b/217271656)
גרסה 2.5.0-alpha01
26 בינואר, 2022
androidx.lifecycle:lifecycle-*:2.5.0-alpha01
משוחרר. גרסה 2.5.0-alpha01 מכילה את התחייבויות אלה.
ViewModel CreationExtras
בגרסה הזו, אנחנו מניחים את היסודות לשינוי המבנה של ViewModel
. במקום קבוצה קשיחה של מחלקות משנה של ViewModelProvider.Factory
שכל אחת מהן מוסיפה פונקציונליות נוספת (המאפשרת פרמטר Application
של constructor דרך AndroidViewModelFactory
, מה שמאפשר פרמטר SavedStateHandle
של constructor דרך SavedStateViewModelFactory
ו-AbstractSavedStateViewModelFactory
וכו'), אנחנו עוברים לעולם של מפעלים ללא שמירת מצב שמבוססים על קונספט חדש, CreationExtras
. (Ia7343, b/188691010, b/188541057)
בעקבות השינוי הזה, ViewModelProvider
לא יבצע יותר שיחות ישירות לשיטה הקודמת (create(Class<T>)
) של ViewModelProvider.Factory
. במקום זאת, היא שולחת קריאה לעומס יתר חדש של create
: create(Class<T>, CreationExtras)
. כלומר, לכל הטמעה ישירה של המכונה של ViewModelProvider.Factory
יש עכשיו גישה לכל אחד מהCreationExtras
החדשים הבאים:
ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY
:String
הזה מספק גישה למפתח המותאם אישית שהעברת אלViewModelProvider.get()
.ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
מספקת גישה לכיתהApplication
.SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY
מספק גישה אלSavedStateRegistryOwner
שמשמש לבניית ה-ViewModel הזה.SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY
מספק גישה אלViewModelStoreOwner
שמשמש לבניית ה-ViewModel הזה.- הפונקציה
SavedStateHandleSupport.DEFAULT_ARGS_KEY
מספקת גישה ל-Bundle
של הארגומנטים שבהם צריך להשתמש כדי ליצורSavedStateHandle
.
התוספות האלה מסופקות כברירת מחדל בעת שימוש בפעילות 1.5.0-alpha01
, מקטע 1.5.0-alpha01
וניווט 2.5.0-alpha01
. אם משתמשים בגרסה קודמת של הספריות האלה, CreationExtras
יהיה ריק – כל מחלקות המשנה הקיימות של ViewModelProvider.Factory
נכתבו מחדש כדי לתמוך בנתיב היצירה מהדור הקודם ששימשו בגרסאות הקודמות של הספריות האלה, וגם בנתיב CreationExtras
שבו ייעשה שימוש בעתיד.
הCreationExtras
האלה מאפשרות לך ליצור ViewModelProvider.Factory
שמעביר רק את המידע שדרוש לכל ViewModel
, בלי להסתמך על היררכיה מחמירה של מחלקות משנה של מפעלים:
class CustomFactory : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
return when (modelClass) {
HomeViewModel::class -> {
// Get the Application object from extras
val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY])
// Pass it directly to HomeViewModel
HomeViewModel(application)
}
DetailViewModel::class -> {
// Create a SavedStateHandle for this ViewModel from extras
val savedStateHandle = extras.createSavedStateHandle()
DetailViewModel(savedStateHandle)
}
else -> throw IllegalArgumentException("Unknown class $modelClass")
} as T
}
}
אנחנו משתמשים בפונקציית התוסף createSavedStateHandle()
Kotlin ב-CreationExtras
מ-SavedStateHandleSupport
כדי ליצור SavedStateHandle
רק עבור ה-ViewModel היחידה שדורשת אותה. (Ia6654, b/188541057)
אפשר לספק CreationExtras
בהתאמה אישית על ידי שינוי של getDefaultViewModelCreationExtras()
בComponentActivity
או ב-Fragment
, וכך להפוך אותם לזמינים ל-ViewModelProvider.Factory
בהתאמה אישית כגרסה מובנית של החדרה בסיוע. התוספות האלה יהיו זמינות באופן אוטומטי למפעל שלך בהתאמה אישית כשמשתמשים בו ישירות עם ViewModelProvider
או כשמשתמשים בתוספי הנכסים by viewModels()
ו-by activityViewModels()
Kotlin. (I79f2b, b/207012584, b/207012585, b/207012490)
תיקוני באגים
- תוקנה בעיה שבה צוין ערך ברירת מחדל
ל
SavedStateHandle
תופיע שוב אחרי התהליך מוות ופנאי, גם אם זה היה ספציפי הוסר מSavedStateHandle
. כתוצאה מ זה,SavedStateHandle
לא ימזג יותר את ברירת המחדל והערכים שחזרנו בהם ביחד, במקום זאת באמצעות את הערכים המשוחזרים כמקור האמת. (I53a4b)
גרסה 2.4
גרסה 2.4.1
9 בפברואר 2022
androidx.lifecycle:lifecycle-*:2.4.1
משוחרר. גרסה 2.4.1 כוללת את ההתחייבויות האלה.
תיקוני באגים
- אחרי העברה לאחור ממחזור החיים
2.5.0-alpha01
: תוקנה בעיה שבה צוין ערך ברירת מחדל ל-SavedStateHandle
יופיע שוב אחרי התהליך מוות ופנאי, גם אם זה היה ספציפי הוסר מ-SavedStateHandle
. כתוצאה מ זה,SavedStateHandle
לא ימזג יותר את ברירת המחדל והערכים שחזרנו בהם ביחד, במקום זאת באמצעות את הערכים המשוחזרים כמקור האמת. (I53a4b) lifecycle-process
תלוי עכשיו בתוכנית Androidx Startup 1.1.1 שתיקן רגרסיה במקומות שבהם השימוש ב-ProcessLifecycleInitializer
יגרום לStartupException
. (b/216490724)
גרסה 2.4.0
27 באוקטובר 2021
androidx.lifecycle:lifecycle-*:2.4.0
משוחרר. גרסה 2.4.0 כוללת את ההתחייבויות האלה.
שינויים חשובים מאז 2.3.0
- האפשרות
@OnLifecycleEvent
הוצאה משימוש. במקומו צריך להשתמש ב-LifecycleEventObserver
או ב-DefaultLifecycleObserver
. - נוספה ספרייה אחת (
androidx.lifecycle:lifecycle-viewmodel-compose
). הוא מספק תוכן קומפוזביליviewModel()
ו-LocalViewModelStoreOwner
.- שינוי מהלכי מקור:
ViewModelProvider
נכתב מחדש ב-Kotlin. שיטתViewModelProvider.Factory.create
לא מאפשרת יותר הגדרה גנרית באמצעות ערך null.
- שינוי מהלכי מקור:
- ממשק API חדש של coroutines נוסף ל-
androidx.lifecycle:lifecycle-runtime-ktx
: Lifecycle.repeatOnLifecycle
, API שמפעיל בלוק קוד בקורוטין כשמחזור החיים נמצא לפחות במצב מסוים. הבלוק יבוטל ויופעל מחדש כשמחזור החיים יעבור למצב היעד ויצא ממנו.Flow.flowWithLifecycle
, API שפולט ערכים מהזרימה ב-upstream כשמחזור החיים נמצא לפחות במצב מסוים.DefaultLifecycleObserver
הועבר מ-lifecycle.lifecycle-common-java8
ל-lifecycle.lifecycle-common
.lifecycle.lifecycle-common-java8
לא מספקת יותר פונקציונליות נוספת בנוסף ל-lifecycle.lifecycle-common
, כך שהתלות בה יכולה להחליף ב-lifecycle.lifecycle-common
.- ממשק API שאינו קורוטינים מ-
lifecycle-viewmodel-ktx
הועבר למודולlifecycle-viewmodel
. עכשיו
lifecycle-process
משתמש בפונקציהandroidx.startup
כדי לאתחל אתProcessLifecycleOwner
.בעבר, הפעולה הזו בוצעה על ידי
androidx.lifecycle.ProcessLifecycleOwnerInitializer
.אם השתמשת ב-
tools:node="remove"
, ה-ContentProvider
ששימש לאתחול לעבד את מחזור החיים בעבר, ולכן עליכם לבצע את הפעולות הבאות.<provider android:name="androidx.startup.InitializationProvider" android:authorities=\"${applicationId}.androidx-startup" android:exported="false" tools:node=\"merge"> <!-- If you are using androidx.startup to initialize other components --> <meta-data android:name="androidx.lifecycle.ProcessLifecycleInitializer" android:value="androidx.startup" tools:node="remove" /> </provider>
(או)
<!-- If you want to disable androidx.startup completely. --> <provider android:name="androidx.startup.InitializationProvider" android:authorities="${applicationId}.androidx-startup" tools:node="remove"> </provider>
גרסה 2.4.0-rc01
29 בספטמבר 2021
androidx.lifecycle:lifecycle-*:2.4.0-rc01
הושקה ללא שינויים במחזור החיים 2.4.0-beta01. גרסה 2.4.0-rc01 מכילה את שמירות האלה.
גרסה 2.4.0-beta01
15 בספטמבר 2021
androidx.lifecycle:lifecycle-*:2.4.0-beta01
משוחרר. גרסה 2.4.0-beta01 מכילה את התחייבויות אלה.
שינויים ב-API
- האפשרות
@OnLifecycleEvent
הוצאה משימוש.LifecycleEventObserver
או במקומם יש להשתמש ב-DefaultLifecycleObserver
. (I5a8fa) - DefaultLifecycleObserver הועבר מ-
androidx.lifecycle.lifecycle-common-java8
אלandroidx.lifecycle.lifecycle-common
.androidx.lifecycle.lifecycle-common-java8
לא מספק יותר פונקציונליות נוספת בנוסף ל-androidx.lifecycle.lifecycle-common
, כך שתלות בו יכולה להחליף ב-androidx.lifecycle.lifecycle-common
. (I021aa) - ממשק API שאינו coroutines מ-
lifecycle-viewmodel-ktx
הועבר אל מודולlifecycle-viewmodel
. (I6d5b2)
תרומה חיצונית
גרסה 2.4.0-alpha03
4 באוגוסט 2021
androidx.lifecycle:lifecycle-*:2.4.0-alpha03
משוחרר. גרסה 2.4.0-alpha03 מכילה את התחייבויות אלה.
שינויים ב-API
- שינוי גורם בעייתי במקור: ViewModelProvider נכתב מחדש ב-Kotlin.
השיטה
ViewModelProvider.Factory.create
לא מאפשרת יותר ערך null כלליות. (I9b9f6)
שינויים בהתנהגות
- הפקודה
Lifecycle.repeatOnLifecycle
:block
תמיד מופעלת באופן סדרתי כשחוזרים על עצמה. (Ibab33)
תרומה חיצונית
- תודה chao2zhang על תיקון קטעי הקוד בתיעוד של
repeatOnLifecycle
. #205.
גרסה 2.4.0-alpha02
16 ביוני 2021
androidx.lifecycle:lifecycle-*:2.4.0-alpha02
משוחרר. גרסה 2.4.0-alpha02 מכילה את התחייבויות אלה.
תכונות חדשות
- נוספה בדיקת שגיאות בקוד של
RepeatOnLifecycleWrongUsage
חדשה ל-lifecycle-runtime-ktx
, שמזוהה מתי נעשה שימוש שגוי ב-repeateOnLifecycle
ב-onStart()
או ב-onResume()
. (706078, b/187887400)
שינויים ב-API
- ממשק ה-API של
LifecycleOwner.addRepeatingJob
יוסר בעוד לטובתLifecycle.repeatOnLifecycle
ששומרת בו-זמניות (concurrency) וקל יותר להסביר אותן. (I4a3a8) - צריך להגדיר את
ProcessLifecycleInitializer
כציבורית כדי ששירותיandroidx.startup.Initializer
אחרים יוכלו להשתמש בהם כיחסי תלות. (I94c31)
תיקוני באגים
- תוקנה בעיה בבדיקת השגיאות בקוד של
NullSafeMutableLiveData
כשהשדה כולל רכיבי שינוי. (#147, b/183696616) - תוקנה בעיה אחרת בבדיקת השגיאות בקוד של
NullSafeMutableLiveData
במהלך השימוש בפריטים גנריים. (#161, b/184830263)
תרומה חיצונית
- תודה maxsav שעזרת לשפר את בדיקת השגיאות בקוד
NullSafeMutableLiveData
. (#147, b/183696616) - תודה kozaxinan על שיפור בדיקת השגיאות של
NullSafeMutableLiveData
. (#161, b/184830263)
גרסה 2.4.0-alpha01
24 במרץ 2021
androidx.lifecycle:lifecycle-*:2.4.0-alpha01
משוחרר. גרסה 2.4.0-alpha01 מכילה את התחייבויות אלה.
שינויים בהתנהגות
עכשיו
lifecycle-process
משתמש בפונקציהandroidx.startup
כדי לאתחל אתProcessLifecycleOwner
.בעבר, הפעולה הזו בוצעה על ידי
androidx.lifecycle.ProcessLifecycleOwnerInitializer
.אם השתמשת ב-
tools:node="remove"
, ה-ContentProvider
ששימש לאתחול לעבד את מחזור החיים בעבר, ולכן עליכם לבצע את הפעולות הבאות.<provider android:name="androidx.startup.InitializationProvider" android:authorities=\"${applicationId}.androidx-startup" android:exported="false" tools:node=\"merge"> <!-- If you are using androidx.startup to initialize other components --> <meta-data android:name="androidx.lifecycle.ProcessLifecycleInitializer" android:value="androidx.startup" tools:node="remove" /> </provider>
(או)
<!-- If you want to disable androidx.startup completely. --> <provider android:name="androidx.startup.InitializationProvider" android:authorities="${applicationId}.androidx-startup" tools:node="remove"> </provider>
שינויים ב-API
- נוסף API מסוג
Flow.flowWithLifecycle
שפולט ערכים מהזרימה ב-upstream כשמחזור החיים נמצא לפחות במצב מסוים באמצעות ה-API שלLifecycle.repeatOnLifecycle
. זוהי חלופה ל-API החדש שלLifecycleOwner.addRepeatinJob
. (I0f4cd)
תיקוני באגים
- מ-Lifecycle 2.3.1: הכלל של אימות השגיאות בקוד
NonNullableMutableLiveData
יכול עכשיו להיות תקין להבחין בין משתני שדה עם יכולת null שונה. (b/169249668)
גרסה 1.0.0 של כתיבת מודל תצוגה של מחזור החיים
גרסה 1.0.0-alpha07
16 ביוני 2021
androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha07
משוחרר. גרסה 1.0.0-alpha07 מכילה את התחייבויות אלה.
הפרות שינויים ב-API
- עכשיו
viewModel()
לוקחViewModelStoreOwner
אופציונלי, כך שיהיה קל יותר לעבוד עם בעלים אחרים מלבדLocalViewModelStoreOwner
. לדוגמה, עכשיו אפשר להשתמש ב-viewModel(navBackStackEntry)
כדי לאחזר ViewModel המשויכת לתרשים ניווט מסוים. (I2628d, b/188693123)
גרסה 1.0.0-alpha06
2 ביוני 2021
androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha06
משוחרר. גרסה 1.0.0-alpha06 מכילה את התחייבויות אלה.
עודכנה להתאמה לגרסה 1.0.0-beta08
של 'כתיבה'.
גרסה 1.0.0-alpha05
18 במאי 2021
androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha05
משוחרר. גרסה 1.0.0-alpha05 מכילה את התחייבויות אלה.
תכונות חדשות
- עודכנה להתאמה לגרסה
1.0.0-beta07
של 'כתיבה'.
תיקוני באגים
- הקבצים AndroidManifest מה-ui-test-manifest וגם ui-tooling-data תואמים עכשיו ל-Android 12 (I6f9de, b/184718994)
גרסה 1.0.0-alpha04
7 באפריל 2021
androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha04
משוחרר. גרסה 1.0.0-alpha04 מכילה את התחייבויות אלה.
שינויים בתלות
- הגרסה הזו מאפשרת
androidx.hilt:hilt-navigation-compose
וandroidx.navigation:navigation-compose
כדי לסנכרן את יחסי התלות ב-androidx.compose.compiler:compiler:1.0.0-beta04
וב-androidx.compose.runtime:runtime:1.0.0-beta04
. ב-1.0.0, צריך שהמהדר (compiler)' ו'סביבת זמן הריצה' יהיו תואמים.
גרסה 1.0.0-alpha03
10 במרץ 2021
androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha03
משוחרר. גרסה 1.0.0-alpha03 מכילה את התחייבויות אלה.
שינויים ב-API
- הפונקציה
LocalViewModelStoreOwner.current
מחזירה עכשיו ערך המאפייןViewModelStoreOwner
ריק כדי לקבוע בצורה מדויקת יותר האםViewModelStoreOwner
זמין של משפטים יחידים, ממשקי API שנדרשים להםViewModelStoreOwner
, כמו בתורviewModel()
ו-NavHost
, עדיין תגרום לחריגה אם לא מוגדרViewModelStoreOwner
. (Idf39a)
גרסה 1.0.0-alpha02 של מחזור חיים-Viewmodel-Compose
24 בפברואר 2021
androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha02
משוחרר. גרסה 1.0.0-alpha02 מכילה את התחייבויות אלה.
שינויים ב-API
- ב-
LocalViewModelStoreOwner
יש עכשיו פונקציותprovides
שיכולות בשימוש ב-CompositionLocalProvider
, מחליף את ממשק ה-API שלasProvidableCompositionLocal()
. (I45d24)
גרסה 1.0.0-alpha01 של מחזור חיים-Viewmodel-Compose
10 בפברואר 2021
androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha01
משוחרר. גרסה 1.0.0-alpha01 מכילה את התחייבויות אלה.
תכונות חדשות
- התוכן הקומפוזבילי
viewModel()
ו-LocalViewModelStoreOwner
הועברו מ-androidx.compose.ui.viewinterop
לפריט המידע הזה שנוצר בתהליך הפיתוח (Artifact) בחבילהandroidx.lifecycle.viewmodel.compose
. (I7a374)
גרסה 2.3.1
גרסה 2.3.1 של מחזור החיים
24 במרץ 2021
androidx.lifecycle:lifecycle-*:2.3.1
משוחרר. גרסה 2.3.1 כוללת את ההתחייבויות האלה.
תיקוני באגים
- עכשיו כלל השגיאות בקוד
NonNullableMutableLiveData
יכול להתבצע כמו שצריך להבחין בין משתני שדה עם יכולת null שונה. (b/169249668)
גרסה 2.3.0
גרסה 2.3.0
10 בפברואר 2021
androidx.lifecycle:lifecycle-*:2.3.0
משוחרר. גרסה 2.3.0 כוללת את ההתחייבויות האלה.
שינויים משמעותיים מאז 2.2.0
- תמיכה של
SavedStateHandle
במחלקות שאינן ניתנות לחלוקה:SavedStateHandle
תומך עכשיו בסידור טורי עצלני. לשם כך, אפשר להפעיל אתsetSavedStateProvider()
עבור מפתח נתון, וכך לקבל קריאה חוזרת (callback) אלsaveState()
כשנשלחת בקשה מ-SavedStateHandle
לשמור את המצב.SavedStateProvider
ראו שמירת מחלקות שאינן ניתנות לחלוקה. - אכיפת התנהגות במחזור החיים:
- LifecycleRegistry אוכף עכשיו את
DESTROYED
כמצב סופי. - עכשיו יתבצע אימות ל-
LifecycleRegistry
שה-methods שלו נקראות ב-thread הראשי. זה תמיד היה דרישה למחזורי חיים של פעילויות, מקטעים וכו'. תוספת של צופים משרשורים לא ראשיים גרמה לקריסה קשה של זמן הריצה. באובייקטים שלLifecycleRegistry
שנמצאים בבעלות הרכיבים שלכם אפשר לבטל באופן מפורש את השימוש בבדיקות באמצעותLifecycleRegistry.createUnsafe(...)
, אבל צריך לוודא שמתבצע סנכרון תקין כשניגשים ל-LifecycleRegistry
הזה משרשורים שונים.
- LifecycleRegistry אוכף עכשיו את
- עזרה במצב מחזור חיים וסיוע באירועים: נוספו שיטות עזר סטטיות של
downFrom(State)
,downTo(State)
,upFrom(State)
ו-upTo(State)
ל-Lifecycle.Event
ליצירתEvent
בהינתןState
וכיוון המעבר. נוספה השיטהgetTargetState()
שמספקת את ה-State
שאליו מחזור החיים יעבור ישירות אחריEvent
. withStateAtLeast
: נוספו ממשקי API שלLifecycle.withStateAtLeast
שממתינים למצב מחזור חיים, שמריצים בלוק קוד שלא נמצא במצב פעיל באופן סינכרוני בזמן שינוי המצב, ואז ממשיכים עם התוצאה. ממשקי ה-API האלה שונים מ-methods הקיימות שלwhen*
, כי הם לא מאפשרים להריץ קוד השעיה ולא משתמשים בשרת בהתאמה אישית. (aosp/1326081)- ממשקי API של
ViewTree
: ממשקי API חדשים שלViewTreeLifecycleOwner.get(View)
ו-ViewTreeViewModelStoreOwner.get(View)
מאפשרים לאחזר את ה-LifecycleOwner
וה-ViewModelStoreOwner
שמכילים בהתאמה, בהתאמה במופע שלView
. כדי לאכלס את הנתונים בצורה נכונה, צריך לשדרג לפעילות1.2.0
, ל-Fragment1.3.0
ול-AppCompat 1.3.0-alpha01 ואילך. התוספיםfindViewTreeLifecycleOwner
ו-findViewTreeViewModelStoreOwner
Kotlin זמינים ב-lifecycle-runtime-ktx
וב-lifecycle-viewmodel-ktx
, בהתאמה. LiveData.observe()
הוצאה משימוש של תוסף Kotlin: התוסףLiveData.observe()
של Kotlin שנדרש כדי להשתמש בתחביר lambda הוצא משימוש, כי הוא לא נחוץ כשמשתמשים ב-Kotlin 1.4.
גרסה 2.3.0-rc01
16 בדצמבר 2020
androidx.lifecycle:lifecycle-*:2.3.0-rc01
משוחרר. גרסה 2.3.0-rc01 מכילה את שמירות האלה.
תיקוני באגים
- שיטת
keys()
שלSavedStateHandle
עקבית עכשיו לפני ואחרי שמירת המצב – היא כוללת עכשיו מפתחות שהיו בשימוש בעבר עםsetSavedStateProvider()
, בנוסף למפתחות שבהם נעשה שימוש עםset()
ו-getLiveData()
. (aosp/1517919, b/174713653)
תרומה חיצונית
- ממשקי ה-API להשעיה של קורוטינים שמתחשבים במחזור החיים מטפלים עכשיו טוב יותר בקריאות ל-
yield()
. תודה ניקלס אנסמן גירץ! (aosp/1430830, b/168777346)
גרסה 2.3.0-beta01
1 באוקטובר 2020
androidx.lifecycle:lifecycle-*:2.3.0-beta01
משוחרר. גרסה 2.3.0-beta01 מכילה את התחייבויות אלה.
שינויים ב-API
- תוסף Kotlin
LiveData.observe()
מאוד לתחביר lambda הוצא משימוש כי הוא אין צורך כשמשתמשים ב-Kotlin 1.4. (I40d3f)
תיקוני באגים
- צריך לשדרג את androidx כדי להשתמש ב-Kotlin 1.4 (Id6471, b/165307851, b/165300826)
שינויים במסמכים
- ה-builder של
liveData
והמסמכים בנושאasLiveData()
עודכנו, ועכשיו הם כוללים פרטים על שינוי הערכים הנתונים של הזמן הקצוב לתפוגה. (aosp/1122324)
גרסה 2.3.0-alpha07
19 באוגוסט 2020
androidx.lifecycle:lifecycle-*:2.3.0-alpha07
משוחרר. גרסה 2.3.0-alpha07 מכילה את התחייבויות אלה.
תיקוני באגים
- תוקנה בעיית קריסה בבדיקה של איתור שגיאות בקוד (lint) של
NullSafeMutableLiveData
. (aosp/1395367)
גרסה 2.3.0-alpha06
22 ביולי 2020
androidx.lifecycle:lifecycle-*:2.3.0-alpha06
משוחרר. גרסה 2.3.0-alpha06 מכילה את התחייבויות אלה.
תכונות חדשות
- נוספו שיטות עזרה סטטיות של
downFrom(State)
,downTo(State)
,upFrom(State)
,upTo(State)
ל-Lifecycle.Event
ליצירתEvent
בהינתןState
וכיוון מעבר. נוספה השיטהgetTargetState()
שמספקת את ה-State
שאליו מחזור החיים יעבור ישירות אחריEvent
. (I00887) - נוספו ממשקי API מסוג
Lifecycle.withStateAtLeast
שממתינים למצב מחזור חיים ומריצים בלוק קוד שלא נמצא במצב המתנה באופן סינכרוני בזמן שינוי המצב, ולאחר מכן ממשיכים לפעול עם התוצאה. ממשקי ה-API האלה שונים מ-methods הקיימות שלwhen*
, כי הם לא מאפשרים להריץ קוד השעיה ולא משתמשים בשרת בהתאמה אישית. (aosp/1326081)
שינויים בהתנהגות
- LifecycleRegistry אוכף עכשיו את
DESTROYED
כמצב סופי. (I00887) - עכשיו יתבצע אימות ל-
LifecycleRegistry
שה-methods שלו נקראות ב-thread הראשי. זה תמיד היה דרישה למחזורי חיים של פעילויות, מקטעים וכו'. תוספת של צופים משרשורים לא ראשיים גרמה לקריסה קשה של זמן הריצה. באובייקטים שלLifecycleRegistry
שבבעלות רכיבים שלכם אפשר לבטל באופן מפורש את השימוש בבדיקות באמצעותLifecycleRegistry.createUnsafe(...)
, אבל צריך לוודא שמתבצע סנכרון תקין כשניגשים ל-LifecycleRegistry
הזה משרשורים שונים (Ie7280, b/137392809)
תיקוני באגים
- תוקנה קריסה ב-
NullSafeMutableLiveData
. (b/159987480) - תוקן
ObsoleteLintCustomCheck
לבדיקות לאיתור שגיאות בקוד (lint) בחבילה עםlifecycle-livedata-core-ktx
(ובמיוחדNullSafeMutableLiveData
). (b/158699265)
גרסה 2.3.0-alpha05
24 ביוני 2020
androidx.lifecycle:lifecycle-*:2.3.0-alpha05
משוחרר. גרסה 2.3.0-alpha05 מכילה את התחייבויות אלה.
תיקוני באגים
LiveData
מטפל עכשיו טוב יותר בבקשות של מצטרפים חדשים, ונמנע משיחות כפולות אלonActive()
או אלonInactive()
. (b/157840298)- תוקנה בעיה שבה בדיקות לאיתור שגיאות בקוד לא פעלו כשמשתמשים ב-Android Studio 4.1 Canary מגרסה 6 ואילך. (aosp/1331903)
גרסה 2.3.0-alpha04
10 ביוני 2020
androidx.lifecycle:lifecycle-*:2.3.0-alpha04
משוחרר. גרסה 2.3.0-alpha04 מכילה את התחייבויות אלה.
תיקוני באגים
- תוקנה קריסה בבדיקת איתור השגיאות בקוד של
NonNullableMutableLiveData
. (b/157294666) - עכשיו בדיקת השגיאות בקוד
NonNullableMutableLiveData
כוללת יותר מקרים שבהם הוגדר ערךnull
ב-MutableLiveData
עם פרמטר מסוג שהוא לא null. (b/156002218)
גרסה 2.3.0-alpha03
20 במאי 2020
androidx.lifecycle:lifecycle-*:2.3.0-alpha03
משוחררים. גרסה 2.3.0-alpha03 מכילה את התחייבויות אלה.
תכונות חדשות
SavedStateHandle
תומך עכשיו בסריאליזציה עגולה בכך שהוא מאפשר לקרוא ל-setSavedStateProvider()
עבור מפתח נתון, ולספקSavedStateProvider
שיקבל קריאה חוזרת אלsaveState()
כש-SavedStateHandle
תתקבל בקשה לשמור את המצב. (b/155106862)- באמצעות API חדש של
ViewTreeViewModelStoreOwner.get(View)
אפשר לאחזר את ה-ViewModelStoreOwner
שמכיל את הנתון הזה בהינתן מופעView
. כדי לאכלס את הנתונים האלה בצורה נכונה, צריך לשדרג לפעילות1.2.0-alpha05
, למקטע1.3.0-alpha05
ול-AppCompat1.3.0-alpha01
. תוסף Kotlin מסוגfindViewModelStoreOwner()
נוסף אלlifecycle-viewmodel-ktx
. (aosp/1295522)
תיקוני באגים
- תוקנה בעיה שגרמה לפרסום הבדיקות של איתור השגיאות בקוד (lint) של
MutableLiveData
שפורסמו במחזור החיים2.3.0-alpha01
לצד פריט המידע שנוצר בתהליך הפיתוח (Artifact)lifecycle-livedata-core-ktx
. (b/155323109)
גרסה 2.3.0-alpha02
29 באפריל 2020
androidx.lifecycle:lifecycle-*:2.3.0-alpha02
משוחרר. גרסה 2.3.0-alpha02 מכילה את התחייבויות אלה.
שינויים ב-API
- ב-
SavedStateViewModelFactory
יש עכשיו אפשרות להעבירApplication
אפס (null) ל-constructor שלו כדי לשפר את התמיכה במקרים שבהם אין זמינות מיידית ואין צורך בתמיכה ב-AndroidViewModel
. (aosp/1285740)
תיקוני באגים
- ביצועים משופרים להפעלה במצב התחלתי (cold start) על ידי מניעת כשל באימות המחלקה ב-API 28 ובמכשירים ישנים יותר. (aosp/1282118)
גרסה 2.3.0-alpha01
4 במרץ, 2020
androidx.lifecycle:lifecycle-*:2.3.0-alpha01
משוחרר. גרסה 2.3.0-alpha01 מכילה את התחייבויות אלה.
תכונות חדשות
- באמצעות API חדש של
ViewTreeLifecycleOwner.get(View)
אפשר לאחזר את ה-LifecycleOwner
שמכיל את הנתון הזה בהינתן מופעView
. כדי לאכלס את הנתונים האלה בצורה נכונה, צריך לשדרג לפעילות1.2.0-alpha01
ולמקטע1.3.0-alpha01
. תוסף Kotlin שלfindViewTreeLifecycleOwner
זמין בlifecycle-runtime-ktx
. (aosp/1182361, aosp/1182956) - נוספה בדיקה חדשה של איתור שגיאות בקוד (lint), עם אזהרה כשמנסים להגדיר ערך
null
ב-MutableLiveData
שהוגדר ב-Kotlin כ-N null. האפשרות הזו זמינה כשמשתמשים בפריטי המידע שנוצרו בתהליך הפיתוח (Artifact) מסוגlivedata-core-ktx
אוlivedata-ktx
. (aosp/1154723, aosp/1159092) - יש ארטיפקט חדש של
lifecycle-runtime-testing
שמספקTestLifecycleOwner
שמטמיע אתLifecycleOwner
ומספקLifecycle
שניתן לשנות את השרשורים שלו בצורה בטוחה. (aosp/1242438)
תיקוני באגים
- לפריט המידע שנוצר בתהליך הפיתוח (Artifact) מסוג
lifecycle-runtime
יש עכשיו שם חבילה ייחודי. (aosp/1187196)
גרסה 2.2.0
גרסה 2.2.0 של ViewModel-Savedstate
5 בפברואר 2020
androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0
משוחרר. גרסה 2.2.0 מכילה את ההתחייבויות האלה.
הגרסה של 'SavedState' בתצוגה של מחזור החיים משותפת עכשיו את אותה הגרסה כמו פריטי מידע אחרים שנוצרים בתהליך הפיתוח (Artifact) של מחזור החיים. ההתנהגות של 2.2.0
זהה להתנהגות של 1.0.0
.
גרסה 2.2.0
22 בינואר, 2020
androidx.lifecycle:lifecycle-*:2.2.0
משוחרר. גרסה 2.2.0 מכילה את ההתחייבויות האלה.
שינויים חשובים מאז 2.1.0
- שילוב קורוטין במחזור החיים: ארטיפקט
lifecycle-runtime-ktx
החדש מוסיף שילוב בין קורוטינים של מחזור חיים ו-Kotlin. בנוסף, הרחבנו את התוקף שלlifecycle-livedata-ktx
כדי לנצל את הקורוטינים. למידע נוסף, ראו שימוש בקורוטינים של Kotlin עם רכיבי ארכיטקטורה. - הוצאה משימוש של
ViewModelProviders.of()
: הוצאנו משימוש אתViewModelProviders.of()
. ניתן להעבירFragment
אוFragmentActivity
ל-constructor החדש שלViewModelProvider(ViewModelStoreOwner)
כדי לקבל את אותה הפונקציונליות כשמשתמשים ב-Fragment1.2.0
. lifecycle-extensions
Artifact הוצאה משימוש: לאחר ההוצאה משימוש שלViewModelProviders.of()
, הגרסה הזו מסמנת את הוצאה משימוש של ממשק ה-API האחרון ב-lifecycle-extensions
ועכשיו יש להתייחס אל פריט המידע הזה משימוש בשלמותו. מומלץ מאוד בהתאם לפריט המידע הספציפי במחזור החיים שדרוש לך (למשל,lifecycle-service
אם משתמשים ב-LifecycleService
וב-lifecycle-process
אם משתמשים ב-ProcessLifecycleOwner
), במקום ב-lifecycle-extensions
, כי לא תהיה השקה עתידית שלlifecycle-extensions
.2.3.0
- מעבד הערות מצטברות של Gradle: מעבד ההערות של מחזור החיים הוא מצטבר כברירת מחדל.
אם האפליקציה כתובה בשפת Java 8, אפשר להשתמש ב-
DefautLifecycleObserver
במקום זאת. ואם הוא כתוב בשפת התכנות Java 7 שאפשר להשתמש ב-LifecycleEventObserver
.
גרסה 2.2.0-rc03
4 בדצמבר 2019
androidx.lifecycle:lifecycle-*:2.2.0-rc03
משוחרר. גרסה 2.2.0-rc03 מכילה את התחייבויות אלה.
תיקוני באגים
- תוקן תקלה שאירעה כש-
ViewModel
מדומה מאוחסן ב-ViewModelStore
ונשלחה שאילתה מאוחר יותר במפעל ברירת המחדל. - תיקון שימוש ב-
Dispatchers.Main.immediate
ב-launchWhenCreated
ובשיטות דומות שייקראו באופן סינכרוני במהלך אירוע תואם במחזור החיים. (aosp/1156203)
תרומות חיצוניות
- תודה לאנדרס ירלברג (Anders Järleברג) שתרמת את התיקון! (aosp/1156203)
- תודה לווסבולוד טולסטופיאטוב מ-Jetbrains שבדק יישום של הוצאה להורג.
שינויים בתלות
- תוספים של מחזור חיים תלויים עכשיו ב-Fragment
1.2.0-rc03
.
גרסה 2.2.0-rc02
7 בנובמבר 2019
androidx.lifecycle:lifecycle-*:2.2.0-rc02
משוחרר. גרסה 2.2.0-rc02 מכילה את ההתחייבויות האלה.
תיקוני באגים
- תוקן באג בהגדרת ProGuard בספרייה שהשפיעה על מכשירים שמריצים את API 28 ואילך אם ערך ה-API לטירגוט נמוך מ-29. (b/142778206)
גרסה 2.2.0-rc01
23 באוקטובר 2019
androidx.lifecycle:lifecycle-*:2.2.0-rc01
משוחרר. גרסה 2.2.0-rc01 מכילה את ההתחייבויות האלה.
תיקוני באגים
- תוקנה בעיה שבה
launchWhenCreated
והשיטות הקשורות פעלו פריים אחד מאוחר יותר מהשיטה של מחזור החיים המשויכת בגלל השימוש ב-Dispatchers.Main
במקום ב-Dispatchers.Main.immediate
. (aosp/1145596)
תרומות חיצוניות
- תודה לניקלס אנסמן (Nicklas Ansman) שתרמת את התיקון! (aosp/1145596)
גרסה 2.2.0-beta01
9 באוקטובר 2019
androidx.lifecycle:lifecycle-*:2.2.0-beta01
משוחרר. גרסה 2.2.0-beta01 מכילה את התחייבויות אלה.
תיקוני באגים
- תוקנה רגרסיה שהוכנסה ל-Lifecycle 2.2.0-alpha05 בסדר הסדר של
ProcessLifecycleOwner
, וה-LifecycleOwner
של הפעילות עבר להתחלה ולהמשך הפעלה במכשירי Android 10. (aosp/1128132) - תוקנה רגרסיה חדשה במחזור החיים
2.2.0-alpha05
שגרמה ל-NullPointerException
כשמשתמשים בגרסה2.0.0
או2.1.0
שלlifecycle-process
. (b/141536990)
גרסה 2.2.0-alpha05
18 בספטמבר 2019
androidx.lifecycle:lifecycle-*:2.2.0-alpha05
משוחרר. גרסה 2.2.0-alpha05 מכילה את התחייבויות אלה.
תיקוני באגים
- תוקן מרוץ תהליכים ב-Livedata Builder. b/140249349
גרסה 2.2.0-alpha04
5 בספטמבר 2019
androidx.lifecycle:lifecycle-*:2.2.0-alpha04
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
תכונות חדשות
lifecycleScope
,whenCreated
,whenStarted
,whenResumed
,viewModelScope
וההטמעה הבסיסית שלliveData
משתמשים עכשיו ב-Dispatchers.Main.immediate
במקום ב-Dispatchers.Main
. (b/139740492)
תרומות חיצוניות
- תודה לניקלס אנסמן (Nicklas Ansman) שתרמו את המעבר ל-
Dispatchers.Main.immediate
! (aosp/1106073)
גרסה 2.2.0-alpha03
7 באוגוסט 2019
androidx.lifecycle:lifecycle-*:2.2.0-alpha03
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
תכונות חדשות
- בהטמעות של
ViewModelStoreOwner
אפשר עכשיו להטמיע אתHasDefaultViewModelProviderFactory
כדי לספק ברירת מחדל שלViewModelProvider.Factory
. פעולות אלה בוצעו לגבי הפעילות1.1.0-alpha02
, מקטע1.2.0-alpha02
וניווט2.2.0-alpha01
. (aosp/1092370, b/135716331)
שינויים ב-API
- האפשרות
ViewModelProviders.of()
הוצאה משימוש. אפשר להעבירFragment
אוFragmentActivity
ל-constructor החדש שלViewModelProvider(ViewModelStoreOwner)
כדי לקבל את אותה הפונקציונליות. (aosp/1009889)
גרסה 2.2.0-alpha02
2 ביולי 2019
androidx.lifecycle:*:2.2.0-alpha02
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
שינויים ב-API
- הפונקציה
LiveDataScope.initialValue
הוחלפה בערךLiveDataScope.latestValue
שיעקוב אחר הערך הנוכחי של הבלוקliveData
. - נוסף עומס יתר חדש ל-builder
liveData
שמקבל פרמטרtimeout
מסוגDuration
גרסה 2.2.0-alpha01
7 במאי 2019
androidx.lifecycle:*:2.2.0-alpha01
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
תכונות חדשות
- בגרסה הזו נוספו תכונות חדשות שמוסיפה תמיכה בקורוטינים של Kotlin במסגרת מחזור חיים ו-LiveData. תוכלו למצוא מידע מפורט בנושא כאן.
ViewModel-SavedState גרסה 1.0.0
גרסה 1.0.0
22 בינואר, 2020
androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0
משוחרר. גרסה 1.0.0 מכילה את ההתחייבויות האלה.
תכונות חשובות בגרסה 1.0.0
- נוספה מחלקה חדשה בשם SavedStateHandle. היא מאפשרת לכיתות שלך ב
ViewModel
לגשת למצב שנשמר ולתרום להן. ניתן לקבל את האובייקט הזה ב-constructor של המחלקהViewModel
, וב-מפעלים שמסופקים כברירת מחדל על ידי Fragments ו-AppCompatActivity מחדיר אתSavedStateHandle
באופן אוטומטי. - נוסף הערך AbstractSavedStateViewModelConfiguration. זה מאפשר לך ליצור מפעלים בהתאמה אישית עבור
ViewModel
ולספק להם גישה אלSavedStateHandle
.
ViewModel-Savedstate גרסה 1.0.0-rc03
4 בדצמבר 2019
androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc03
משוחרר. גרסה 1.0.0-rc03 מכילה את ההתחייבויות האלה.
שינויים בתלות
- הערך 'SavedState' של תצוגת מחזור החיים תלוי עכשיו במחזור החיים
2.2.0-rc03
.
Viewmodel-Savedstate גרסה 1.0.0-rc02
7 בנובמבר 2019
androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc02
משוחרר. גרסה 1.0.0-rc02 מכילה את ההתחייבויות האלה.
שינויים בתלות
- עכשיו תלוי במחזור החיים
2.2.0-rc02
.
ViewModel-SavedState גרסה 1.0.0-rc01
23 באוקטובר 2019
androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-rc01
הושק ללא שינויים מ-1.0.0-beta01
. גרסה 1.0.0-rc01 מכילה את ההתחייבויות האלה.
ViewModel-Savedstate גרסה 1.0.0-beta01
9 באוקטובר 2019
androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-beta01
משוחרר. גרסה 1.0.0-beta01 מכילה את התחייבויות אלה.
תיקוני באגים
- תוקנה בעיה שבה גישה בפעם הראשונה ל-SavedState ViewModel בפעם הראשונה ב-
Activity.onActivityResult()
הייתהIllegalStateException
. (b/139093676) - תוקן
IllegalStateException
במהלך השימוש ב-AbstractSavedStateViewModelFactory
. (b/141225984)
ViewModel-SavedState גרסה 1.0.0-alpha05
18 בספטמבר 2019
androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha05
משוחרר. גרסה 1.0.0-alpha05 מכילה את התחייבויות אלה.
שינויים ב-API
SavedStateViewModelFactory
לא נמשך יותר את הדומייןAbstractSavedStateViewModelFactory
,SavedStateHandle
ונוצר רק עבור ViewModels שביקשו לקבל אותו (aosp/1113593)
ViewModel-SavedState גרסה 1.0.0-alpha03
7 באוגוסט 2019
androidx.lifecycle:lifecycle-viewmodel-savedstate:1.0.0-alpha03
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
שינויי תוכנה שעלולים לגרום לכשלים
lifecycle-viewmodel-savedstate
כבר לא תלוי ב-fragment
והבנאים הקשוריםSavedStateViewModelFactory(Fragment)
ו-SavedStateViewModelFactory(FragmentActivity)
הוסרו. במקום זאת,SavedStateViewModelFactory
הוא עכשיו היצרן המוגדר כברירת מחדל עבור פעילות1.1.0-alpha02
, מקטע1.2.0-alpha02
וניווט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
יכול לתרום למצב השמור. כדי לעשות את זה, צריך להשתמש ביצרן של מודל התצוגה החדשSavedStateVMFactory
, וב-ViewModel צריך להיות ב-constructor שמקבל את האובייקטSavedStateHandle
כפרמטר.
גרסה 2.1.0
שינויים חשובים מאז 2.0.0
- נוסף
LifecycleEventObserver
למקרים שבהם יש צורך בזרם של אירועים במחזור החיים. זהו API ציבורי במקום מחלקהGenericLifecycleObserver
מוסתרת. - נוספו תוספי ktx ל-methods
LiveData.observe
ול-Transformations.*
שיטות. - נוספה הפונקציה
Transformations.distinctUntilChanged
, שיוצרת אובייקט LiveData חדש שלא פולט ערך עד לשינוי של ערך המקורLiveData
. - נוספה תמיכה בקורטין ב-ViewModels על ידי הוספת נכס התוסף
ViewModel.viewModelScope
.
גרסה 2.1.0
5 בספטמבר 2019
androidx.lifecycle:lifecycle-*:2.1.0
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
גרסה 2.1.0-rc01
2 ביולי 2019
androidx.lifecycle:*:2.1.0-rc01
הושק ללא שינויים מ-androidx.lifecycle:*:2.1.0-beta01
. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
גרסה 2.1.0-beta01
7 במאי 2019
androidx.lifecycle:*:2.1.0-beta01
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
תכונות חדשות
- מחזורי החיים שודרגו לגרסת בטא: ממשק ה-API שהושק באלפאות קודמות, כמו פונקציות תוספים של
liveData
לטרנספורמציות ותצפיות, אתחולViewModel
עם הענקת גישה לנכסים ואחרים מיוצבים ולא עומדים להשתנות.
גרסה 2.1.0-alpha04
3 באפריל 2019
androidx.lifecycle:*:2.1.0-alpha04
משוחרר. אפשר למצוא כאן את ההתחייבות שכלולה בגרסה הזו.
שינויים ב-API
- שינוי תוכנה שעלול לגרום לכשל: ה-API הבסיסי שעומד מאחורי
by viewModels()
ו-by activityViewModels()
השתנה כך שיתמוך ישירות ב-ViewModelStore
, ולא ב-ViewModelStoreOwner
בלבד. (aosp/932932)
גרסה 2.1.0-alpha03
13 במרץ 2019
androidx.lifecycle:*:2.1.0-alpha03
משוחרר. הרשימה המלאה של ההתחייבויות שכלולות בגרסה הזו זמינה כאן.
שינויים ב-API
- השדה
ViewModelProvider.KeyedFactory
הוסר. הממשק השני בנוסף ל-ViewModelProvider.Factory
לא הצליח להגיע בצורה טובה לתכונות חדשות בהענקת גישה לנכסים ב-Kotlinby viewmodels {}
. (aosp/914133)
גרסה 2.1.0-alpha02
30 בינואר 2019
androidx.lifecycle 2.1.0-alpha02
משוחרר.
שינויים ב-API
- הפונקציה
LifecycleRegistry
מכילה עכשיו שיטהsetCurrentState()
שמחליפה את השיטהsetState()
שהוצאה משימוש. (aosp/880715)
תיקוני באגים
- תוקנה בעיה שגרמה לקריסה של מופעים מדומים של
ViewModel
אחרי הסרת ה-ViewModelStore
מכילה. b/122273087
גרסה 2.1.0-alpha01
17 בדצמבר 2018
androidx.lifecycle 2.1.0-alpha01
משוחרר.
תכונות חדשות
- נוסף
LifecycleEventObserver
למקרים שבהם יש צורך בזרם של אירועים במחזור החיים. זהו ממשק API ציבורי במקום מחלקהGenericLifecycleObserver
מוסתרת. - נוספו תוספי ktx ל-methods
LiveData.observe
ול-Transformations.*
שיטות. - השיטה
Transformations.distinctUntilChanged
נוספה. המערכת יוצרת אובייקטLiveData
חדש שלא פולט ערך עד לשינוי של ערך המקור LiveData. - תמיכה בקורטין ב-ViewModels: נכס התוסף
ViewModel.viewModelScope
נוסף. - נוסף
ViewModelProvider.KeyedFactory
, מפעל ל-ViewModels שמקבליםkey
ו-Class
בשיטהcreate
.
גרסה 2.0.0
גרסה 2.0.0
21 בספטמבר 2018
מחזור החיים 2.0.0
פורסם עם תיקון באג אחד מ-2.0.0-rc01
ב-ViewModel.
תיקוני באגים
- תוקן כלל ProGuard של ViewModel שהסיר באופן שגוי בונה b/112230489
גרסה 2.0.0-beta01
2 ביולי 2018
תיקוני באגים
- תוקן כלל מגן של LifecycleObserver שנועד לשמור רק הטמעות, ולא ממשקי משנה b/71389427
- תוקנו כללי הגנה ב-ViewModel על מנת לאפשר ערפול קוד (obfuscation) וכיווץ
גרסאות טרום-AndroidX
בגרסאות של מחזור החיים בגרסה שלפני AndroidX, צריך לכלול את יחסי התלות הבאים:
dependencies {
def lifecycle_version = "1.1.1"
// ViewModel and LiveData
implementation "android.arch.lifecycle:extensions:$lifecycle_version"
// alternatively - just ViewModel
implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
// alternatively - just LiveData
implementation "android.arch.lifecycle:livedata:$lifecycle_version"
// alternatively - Lifecycles only (no ViewModel or LiveData).
// Support library depends on this lightweight import
implementation "android.arch.lifecycle:runtime:$lifecycle_version"
annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
// alternately - if using Java8, use the following instead of compiler
implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
// optional - ReactiveStreams support for LiveData
implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
// optional - Test helpers for LiveData
testImplementation "android.arch.core:core-testing:$lifecycle_version"
}
גרסה 1.1.1
21 במרץ 2018
שינוי קטן אחד בלבד: android.arch.core.util.Function
הועבר מ-arch:runtime
אל arch:common
. כך אפשר להשתמש בו ללא תלות בסביבת זמן הריצה, למשל בpaging:common
למטה.
lifecycle:common
הוא תלות ב-lifecycle:runtime
, ולכן השינוי הזה לא משפיע ישירות על lifecycle:runtime
, אלא רק על מודולים שתלויים באופן ישיר ב-lifecycle:common
, כמו החלוקה לדפים.
גרסה 1.1.0
22 בינואר 2018
שינויים באריזה
עכשיו יש יחסי תלות חדשים הרבה יותר קטנים:
android.arch.lifecycle:livedata:1.1.0
android.arch.lifecycle:viewmodel:1.1.0
שינויים ב-API
- הפריטים
LifecycleActivity
ו-LifecycleFragment
שהוצאו משימוש הוסרו - יש להשתמש בהםFragmentActivity
,AppCompatActivity
או תמיכה ב-Fragment
. @NonNull
הערות נוספו ל-ViewModelProviders
ול-ViewModelStores
- ה-constructor של
ViewModelProviders
הוצא משימוש – צריך להשתמש ישירות בשיטות הסטטיות שלו - ההוראה
ViewModelProviders.DefaultFactory
הוצאה משימוש. צריך להשתמש ב-ViewModelProvider.AndroidViewModelFactory
- שיטת
ViewModelProvider.AndroidViewModelFactory.getInstance(Application)
הסטטית נוספה לאחזורFactory
סטטי שמתאים ליצירת מכונותViewModel
ו-AndroidViewModel
.