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

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

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

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

dependencies {
  def paging_version = "3.3.2"

  implementation "androidx.paging:paging-runtime:$paging_version"

  // alternatively - without Android dependencies for tests
  testImplementation "androidx.paging:paging-common:$paging_version"

  // optional - RxJava2 support
  implementation "androidx.paging:paging-rxjava2:$paging_version"

  // optional - RxJava3 support
  implementation "androidx.paging:paging-rxjava3:$paging_version"

  // optional - Guava ListenableFuture support
  implementation "androidx.paging:paging-guava:$paging_version"

  // optional - Jetpack Compose integration
  implementation "androidx.paging:paging-compose:3.3.2"
}

dependencies {
  val paging_version = "3.3.2"

  implementation("androidx.paging:paging-runtime:$paging_version")

  // alternatively - without Android dependencies for tests
  testImplementation("androidx.paging:paging-common:$paging_version")

  // optional - RxJava2 support
  implementation("androidx.paging:paging-rxjava2:$paging_version")

  // optional - RxJava3 support
  implementation("androidx.paging:paging-rxjava3:$paging_version")

  // optional - Guava ListenableFuture support
  implementation("androidx.paging:paging-guava:$paging_version")

  // optional - Jetpack Compose integration
  implementation("androidx.paging:paging-compose:3.3.2")
}

מידע על השימוש בתוספי Kotlin זמין בכתובת מסמכי ktx.

אפשר לקרוא מידע נוסף על יחסי תלות במאמר הוספת יחסי תלות של build.

משוב

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

דיווח על בעיה חדשה

מקורות מידע בנושא מעקב אחר בעיות אפשר לקבל מידע נוסף.

גרסה 3.3

גרסה 3.3.2

7 באוגוסט 2024

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

תכונות חדשות

• paging-common ו-paging-testing הוסיפו יעדים חדשים של Kotlin-Multiplatform: watchos, tvos ו-linuxArm64 (90c9768), (53e0eca)

גרסה 3.3.1

24 ביולי 2024

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

תיקוני באגים

• תוקנה בעיה שבה AsyncPagingDataDiffer או ממשקי API שמבוססים עליו, כמו PagingDataAdapter שבהם נעשה שימוש עם RecyclerView, לא יכלו להפעיל טעינות נוספות כשמקור הנתונים לגיבוי מתבצע רענון במהלך הגלילה. (I60ca5, b/352586078)
• תוקנה קריסה שמתרחשת כשפריטים הוסרו ממקור הנתונים לגיבוי במהלך גלילה ב-RecyclerView באמצעות PagingDataAdapter או AsyncPagingDataDiffer. (I8c65a, b/347649763)

גרסה 3.3.0

14 במאי 2024

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

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

• PagingDataPresenter הוא עכשיו כיתה ציבורית. מעכשיו אפשר להתבסס על PagingDataPresenter כדי ליצור תצוגות בכמה פלטפורמות במקום להשתמש בממשקי API פנימיים של חלוקה לדפים או להשתמש ב-AsyncPagingDataDiffer של paging-runtime.
• נוספו שיטות עזר חדשות LoadStates ו-CombinedLoadStates ב-hasError וב-isIdle כדי לבדוק אם LoadStates במצב שגיאה או NotLoading, בהתאמה. נוספה גם שיטה חדשה מסוג awaitNotLoading() של תוסף Kotlin ב-Flow<CombinedLoadStates>, שממתינה עד שהעומס יסתנכרן למצב NotLoading או למצב שגיאה.
• עכשיו PagingData.empty() שולח NotLoading מצבים כברירת מחדל, אלא אם LoadStates בהתאמה אישית מועבר ל-constructor שלו. זה יוצא מהמצב הקיים שבו לא נשלחת LoadStates כאשר היא נשלחת אל PagingDataAdapter או שהיא שולחת את מצבי הטעינה לאחר שנאספו בתור LazyPagingItems. כשהמערכת אוספת את הנתונים בתור LazyPagingItems, היא תציג מעכשיו גם רשימה ריקה מיד עם ההרכבה הראשונית.

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

מעכשיו, החלוקה לדפים של השירות שולחת פריטי מידע שתואמים ל-Kotlin Multiplatform, הודות במידה רבה לעבודה מושקעת בפרויקט ההחלפה בין פלטפורמות שונות של CashApp.

• paging-common העביר את כל ממשקי ה-API של Paging 3 אל common ועכשיו הוא תואם ל-jvm ול-iOS בנוסף ל-Android.
• הקוד של paging-testing הועבר אל common ועכשיו הוא תואם ל-jvm ול-iOS בנוסף ל-Android.
• הקוד של paging-compose הועבר אל common ונשלח פריט מידע שנוצר בתהליך הפיתוח (Artifact) ל-Android, שתואם לתמיכה בפלטפורמות השונות של androidx.compose.
• paging-runtime, paging-guava, paging-rxjava2 ו-paging-rxjava3 יישארו ב-Android בלבד.

גרסה 3.3.0-rc01

1 במאי 2024

androidx.paging:paging-*:3.3.0-rc01 מופצת ללא שינויים בחלוקה לדפים 3.3.0-beta01. גרסה 3.3.0-rc01 מכילה את ההתחייבויות האלה.

גרסה 3.3.0-beta01

3 באפריל 2024

ההשקה של androidx.paging:paging-*:3.3.0-beta01 ללא שינויים משמעותיים. גרסה 3.3.0-beta01 כוללת את ההתחייבויות האלה.

גרסה 3.3.0-alpha05

20 במרץ 2024

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

שינויים ב-API

• החלוקה לדפים משתמשים עכשיו בהערת AndroidX @MainThread בשביל קוד נפוץ. (I78f0d, b/327682438)

גרסה 3.3.0-alpha04

6 במרץ 2024

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

תיקוני באגים

• תוקנו שגיאות תיעוד קלות שקשורות להוספת תאימות לפלטפורמות מרובות של Kotlin. (aosp/2950785)

גרסה 3.3.0-alpha03

7 בפברואר 2024

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

תכונות חדשות

• PagingDataPresenter הוא עכשיו כיתה ציבורית. מעכשיו אפשר להתבסס על PagingDataPresenter כדי ליצור תצוגות בכמה פלטפורמות במקום להשתמש בממשקי API פנימיים של חלוקה לדפים או להשתמש ב-AsyncPagingDataDiffer של paging-runtime. (Id1f74, b/315214786)
• נוספו שיטות עזר חדשות LoadStates ו-CombinedLoadStates כדי לבדוק אם LoadStates במצב שגיאה או NotLoading. נוסף גם ממשק API חדש שממתין ל-LoadStateFlow עד שהעומס יסתנכרן למצב NotLoading או למצב שגיאה. (Id6c67)

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

• עכשיו PagingData.empty() שולח NotLoading מצבים כברירת מחדל, אלא אם LoadStates בהתאמה אישית מועבר ל-constructor שלו. זה יוצא מהמצב הקיים שבו לא נשלחת LoadStates כאשר היא נשלחת אל PagingDataAdapter או שהיא שולחת את מצבי הטעינה לאחר שנאספו בתור LazyPagingItems. כשהמערכת אוספת את הנתונים בתור LazyPagingItems, היא תציג מעכשיו גם רשימה ריקה מיד עם ההרכבה הראשונית. (I4d11d, b/301833847)

גרסה 3.3.0-alpha02

20 בספטמבר 2023

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

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

מעכשיו, החלוקה לדפים של השירות שולחת פריטי מידע שתואמים ל-Kotlin Multiplatform, הודות במידה רבה לעבודה מושקעת בפרויקט ההחלפה בין פלטפורמות שונות של CashApp. כך נוכל למנוע פער בין שני מאגרים ולשמור על תאימות.

• paging-common העביר את כל ממשקי ה-API של Paging 3 אל common ועכשיו הוא תואם ל-jvm ול-iOS בנוסף ל-Android.
• הקוד של paging-testing הועבר אל common ועכשיו הוא תואם ל-jvm ול-iOS בנוסף ל-Android.
• הקוד של paging-compose הועבר אל common ונשלח פריט מידע שנוצר בתהליך הפיתוח (Artifact) ל-Android, שתואם לתמיכה בפלטפורמות השונות של androidx.compose.
• paging-runtime, paging-guava, paging-rxjava2 ו-paging-rxjava3 יישארו ב-Android בלבד.

שינויים ב-API

• ממשק יומן הרישום הציבורי שנועד לשימוש פנימי בלבד הוצא משימוש (I16e95, b/288623117)

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

גרסה 3.3.0-alpha01

20 בספטמבר 2023

• זוהי המהדורה הראשונה של ספריות androidx.paging במספר פלטפורמות. הגרסה הזו כוללת רק פריטי מידע שנוצרו בתהליך פיתוח (Artifact) מסוג *-jvm ו-*-android. ב-macOS, ב-iOS וב-linux, צריך להשתמש ב-3.3.0-alpha02.

גרסה 3.2

גרסה 3.2.1

6 בספטמבר 2023

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

תיקוני באגים

• תוקנה בעיה שבה ממשק ה-API של asSnapshot() ה-API של ארטיפקט בדיקת הדפים היה נתקע במהלך העברה של זרימה שפותחה באמצעות PagingData.from(List) מאז שasSnapshot() לא היה מכיל מידע על סיום הטעינה (בניגוד לעומס יתר PagingData.from(List, LoadStates)). הפתרון הזה לעקוף את הבעיה פועל רק בתהליכי עבודה משולבים (למשל, flowOf(PagingData.from(...))). לתהליכים לא פשוטים (למשל, MutableStateFlow, משתמשים בעומס היתר של PagingData.from שמספק LoadStates). (I502c3)
• התכונה 'פיתוח נייטיב' משתמשת עכשיו באופן פנימי ב-AndroidUiDispatcher.Main כדי לוודא שנתונים חדשים יהיו זמינים באותה מסגרת שבה הושלמה הטעינה. (Ia55af)

גרסה 3.2.0

26 ביולי 2023

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

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

• התכונה 'פיתוח נייטיב' הגיעה ליציבות של ה-API ומוזגה בחזרה לשאר השלבים של התכונה 'דפים', כשהגרסה שלה תואמת עכשיו לכל שאר פריטי המידע שנוצרו בתהליך הפיתוח (Artifact). השינויים שבוצעו מאז 3.1.0 כוללים:
  • תמיכה בתצוגה מקדימה של רשימת נתונים מזויפים על ידי יצירת PagingData.from(fakeData) ועטיפת ה-PagingData ב-MutableStateFlow (למשל MutableStateFlow(PagingData.from(listOf(1, 2, 3)))). צריך להעביר את התהליך הזה לתכנים קומפוזביליים של @Preview בתור המקלט כדי לצפות בהם ב-collectAsLazyPagingItems().
  • תמיכה בכל הפריסות העצלות, כמו LazyVerticalGrid ו-HorizontalPager, וכן ברכיבי עצמאות בהתאמה אישית מספריות Wear וטלוויזיה. היעד הזה הושג באמצעות LazyPagingItems שיטות תוסף חדשות itemKey ו-itemContentType ברמה נמוכה יותר. השיטות האלה עוזרות להטמיע את הפרמטרים key ו-contentType בממשקי ה-API הרגילים של items שכבר קיימים עבור LazyColumn ו-LazyVerticalGrid, וגם בממשקי API מקבילים כמו HorizontalPager.
  • הוצאנו משימוש את items(lazyPagingItems) ואת itemsIndexed(lazyPagingItems), שתומכים רק ב-LazyListScope.
• ארטיפקט חדש של paging-testing שמספק ממשקי API שמיועדים לבדיקת יחידה של כל שכבה באפליקציה והשילוב שלה עם החלוקה לדפים. לדוגמה, הוא כולל
  • מחלקה TestPager שמאפשרת לאמת את ההתנהגות של הטמעת PagingSource מותאמת אישית משלכם, ללא תלות בזימונית ובממשק המשתמש האמיתי.
  • asPagingSourceFactory ממשקי API לטרנספורמציה של Flow<List<Value>> או List<Value> סטטי ל-PagingSourceFactory שניתן להעביר לזימונית בבדיקות
  • תוסף asSnapshot של Kotlin ב-Flow<PagingData<Value>>, שמתרגם את Flow<PagingData<Value>> ל-List<Value> ישיר. asSnapshot lambda מאפשר לחקות את ממשק המשתמש של האפליקציה דרך ממשקי API כמו scrollTo או appendScrollWhile, כדי שתוכלו לאמת שתמונת המצב של הנתונים נכונה בכל שלב בקבוצת הנתונים שבדפים.
• יומני ברירת מחדל נוספו כדי לחשוף מידע על תוצאות ניפוי הבאגים בשתי רמות: VERBOSE ו-DEBUG. ניתן להפעיל את היומנים באמצעות הפקודה adb shell setprop log.tag.Paging [DEBUG|VERBOSE]. העיקרון הזה חל גם על חלוקה לדפים עם תצוגות וגם על החלוקה לדפים באמצעות 'כתיבה'.
• נוספו בנאים עבור PagingDataAdapter ו-AsyncPagingDataDiffer שמקבלים CoroutineContext במקום CoroutineDispatcher.
• נוסף ממשק פונקציונלי חדש מסוג PagingSourceFactory שמספק פלטפורמת API מפורשת יותר מזו הקודמת () -> PagingSource lambdas. ניתן להשתמש במפעל הזה כדי ליצור זימונית.

גרסה 3.2.0-rc01

21 ביוני 2023

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

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

• תודה Veyndan על התרומה שלך להסרת העימוד מהפרטים של Android/JVM. (#553, #554, #555, #559)

גרסה 3.2.0-beta01

7 ביוני 2023

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

פיתוח נייטיב

• הפינגים לכתיבה הגיעו ליציבות של ה-API באופן רשמי. לכן, הגרסה עודכנה מ-1.0.0-alpha20 ועכשיו היא תואמת לגרסה של כל שאר פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) של החלוקה לדפים.

שינויים ב-API

• הוסרו ממשקי ה-API items(LazyPagingItems) ו-itemsIndexed(LazyPagingItems) שהוצאו משימוש מהתכונה 'כתיבה מהירה'. דוגמה לממשקי ה-API החלופיים שלהם מופיעה בנתוני הגרסה של 1.0.0-alpha20 לכתיבה מהירה. (I9626e)

גרסה 3.2.0-alpha06

24 במאי 2023

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

תכונות חדשות

• נוסף ממשק פונקציונלי חדש של PagingSourceFactory שמספק פלטפורמת API מפורשת יותר מאשר ה-lambda הקיימות של () -> PagingSource. ניתן להשתמש במפעל הזה כדי ליצור Pager. (I33165, b/280655188)
• נוסף paging-testing API חדש של List<Value>.asPagingSourceFactory() כדי לקבל PagingSourceFactory שנטען רק מרשימת נתונים שלא ניתנת לשינוי. התוסף הקיים ב-Flow<List<Value>> עדיין צריך לשמש לבדיקה עם מספר גנרציות של נתונים סטטיים. (Id34d1, b/280655188)

שינויים ב-API

• כל ממשקי ה-API הציבוריים בבדיקת דפים מצורפים עכשיו עם הערות @VisibleForTesting כדי לוודא שממשקי ה-API האלה ישמשו רק בבדיקות. (I7db6e)
• ה-API של asSnapshot כבר לא מחייב העברה של CoroutineScope. כברירת מחדל, המערכת משתמשת בהקשר שעבר בירושה מהיקף ההורה שלה. (Id0a78, b/282240990)
• סדר הפרמטרים של ה-constructor של TestPager השתנה כדי להתאים באופן אינטואיטיבי את הסדר של הפרמטרים האמיתיים של ה-constructor של Pager (I6185a)
• הועבר השימוש של בדיקת דפים מסוג lambda מסוג () -> PagingSource<Key, Value> למקלידים PagingSourceFactory<Key, Value>. (I4a950, b/280655188)

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

• המפיץ הראשי לא נדרש יותר להרצת בדיקות החלוקה לדפים של asSnapshot. ההגדרה לא תגרום יותר לשינויים בהתנהגות הבדיקה. (Ie56ea)

גרסה 3.2.0-alpha05

3 במאי 2023

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

שינויים ב-API

• ה-API לבדיקת דפים של asSnapshot מוגדר עכשיו כברירת מחדל לפרמטר loadOperations כ-lambda ריק. כך אפשר לקרוא ל-asSnapshot בלי להעביר פעולות טעינה כלשהן, לאחזר את הנתונים מעומס הרענון הראשוני. (Ied354, b/277233770)

שיפורים במסמכים

• המסמכים עודכנו ב-asPagingSourceFactory() כדי להבהיר שזו שיטת תוסף ב-Flow שמחזירה מפעל לשימוש חוזר ליצירת מכונות PagingSource. (I5ff4f, I705b5)
• התיעוד ב-LoadResult.Pageconstructor עודכן כדי להבהיר את הצורך לבטל את itemsBefore ואת itemsAfter כדי לתמוך בקפיצה. (Ied354)

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

• תודה Veyndan על התרומה שלך להסרת העימוד מהפרטים של Android/JVM. (#525, #523, #520, #519, #507, #506, #505, #499, #497, #496, #493)

גרסה 3.2.0-alpha04

8 בפברואר 2023

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

בדיקת דפים

• פריט המידע שנוצר בתהליך הפיתוח (Artifact) מסוג paging-testing מכיל עכשיו שיטה asPagingSourceFactory כדי ליצור pagingSourceFactory מ-Flow<List<Value>> שיסופק ל-Pager. כל List<Value>> שנפלט מהזרימה מייצג יצירה של נתונים בדפי דפים. כך ניתן לבצע בדיקות דפים ב-PagingData, למשל על טרנספורמציות באמצעות זיוף מקור נתונים שממנו ה-Pager יאסוף. (I6f230, b/235528239)

• פריט המידע שנוצר בתהליך הפיתוח (Artifact) של paging-testing הורחב ונוספו לו ממשקי API חדשים שמאפשרים לאמת שהנתונים שנכללים בFlow<PagingData<T>> נכונים. לדוגמה, אפשר להשתמש בכך כדי להצהיר על הפלט של Flow<PagingData<T>> משכבת ה-ViewModel.

  אנחנו עושים זאת באמצעות תוסף asSnapshot Kotlin ב-Flow<PagingData<Value>>, שמתרגם את Flow<PagingData<Value>> ל-List<Value> ישיר. lambda של asSnapshot מאפשר לחקות את ממשק המשתמש של האפליקציה דרך ממשקי API כמו scrollTo או appendScrollWhile באופן שניתן לחזור עליו ועקבי, כדי שתוכלו לוודא שתמונת המצב של הנתונים נכונה בכל שלב בקבוצת הנתונים שבדפי הדפים.

  // Create your ViewModel instance
  val viewModel = …
  // Get the Flow of PagingData from the ViewModel
  val data< Flow<PagingData<String>> = viewModel.data
  val snapshot: List<String> = data.asSnapshot {
    // Each operation inside the lambda waits for the data to settle before continuing
    scrollTo(index = 50)
  
    // While you can’t view the items within the asSnapshot call,
    // you can continuously scroll in a direction while some condition is true
    // i.e., in this case until you hit a placeholder item
    appendScrollWhile {  item: String -> item != “Header 1” }
  }
  // With the asSnapshot complete, you can now verify that the snapshot
  // has the expected values
  

  asSnapshot היא method suspend שצפויה לפעול בתוך runTest. למידע נוסף, ראו בדיקת קורוטין של Kotlin ב-Android. (I55fd2, I5bd26, I7ce34, I51f4d, I2249f, Id6223, Ic4bab, Ib29b9, I

שינויים ב-API

• קריאות בממשק המשתמש getItem ו-peek ב-AsyncPagingDataDiffer וב-PagingDataAdapter מסומנות עכשיו כראוי כקריאות שניתן להתקשר אליהן רק בשרשור הראשי. (I699b6)
• הוסרו תווים כלליים לחיפוש מסוגים כלליים שמשמשים את TestPager, וכך קל יותר לצרוך את התוצאות של השיטות האלה בקוד שנכתב בשפת Java. (I56c42)

גרסה 3.2.0-alpha03

24 באוקטובר 2022

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

בדיקת דפים

הגרסה הזו כוללת פריט מידע שנוצר בתהליך פיתוח (Artifact): paging-testing. פריט המידע הזה שנוצר בתהליך הפיתוח (Artifact) מספק ממשקי API שמיועדים לבדיקת יחידה של כל שכבה באפליקציה והשילוב שלה עם החלוקה לדפים.

לדוגמה, הגרסה הראשונה הזו כוללת מחלקה TestPager שמאפשרת לאמת את ההתנהגות של הטמעת PagingSource בהתאמה אישית בנפרד מ-Pager ומממשק המשתמש האמיתי, שבדרך כלל צריך לדמות את שילוב החלוקה מקצה לקצה.

צריך להתייחס ל-TestPager כאל זיוף – מכפיל בדיקה שמשקף את ההטמעה האמיתית של Pager ומספק פלטפורמת API פשוטה יותר לבדיקת PagingSource. ממשקי ה-API האלה הם ממשקי API מסוג suspend וצריך להפעיל אותם בתוך runTest כפי שמתואר במדריך לבדיקת קורוטין של Kotlin ב-Android.

דוגמה לממשקי ה-API האלה בשימוש מופיעה בבדיקות room-paging, שעברו ארגון מחדש לשימוש ב-TestPager.

שינויים ב-API

• הפעלת איטרציה נוחה מעל LoadResult.Page.data עד LoadResult.Page.iterator(). כך אפשר באופן עקיף להשתמש ב-method flatten של הספרייה הרגילה של קוטלין כשניתן לו List<LoadResult.Page>. למשל, עם המאפיין pages של PagingState שמועבר לשיטה PagingSource.getRefreshKey. (Ie0718)

גרסה 3.2.0-alpha02

10 באוגוסט 2022

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

תכונות חדשות

• החלוקה לדפים מספקת עכשיו יומנים דרך המחלקות AsyncPagingDataDiffer או PagingDataAdapter כדי לחשוף מידע על ניפוי באגים שנאסף מ-PagingData.
• אפשר להפעיל את היומנים באמצעות הפקודה adb shell adb shell setprop log.tag.Paging [DEBUG|VERBOSE].(b/235527159)

תיקוני באגים

• תוקנה שגיאת constructor של PagingDataDiffer החסרה בעת שימוש ב-paging-common:3.2.0-alpha01 עם זמן ריצה paging-runtime:3.1.1 ואילך.(b/235256201)

גרסה 3.2.0-alpha01

1 ביוני 2022

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

שינויים ב-API

• נוספו בנאים עבור PagingDataAdapter ו-AsyncPagingDataDiffer שמקבלים CoroutineContext במקום CoroutineDispatcher. (Idc878)
• כברירת מחדל, PagingData.from() ו-PagingData.empty() לא ישפיעו יותר על CombinedLoadStates בצד של המציג. נוסף עומס יתר חדש שמאפשר להעביר את sourceLoadStates ו-remoteLoadStates למבנים האלה כדי לשמור על ההתנהגות הקיימת של הגדרת LoadStates כך שתהיה טרמינל מלא (כלומר, NotLoading(endOfPaginationReached = false)), עם אפשרות לכלול גם מצבים מרחוק לפי הצורך. אם לא תעבירו את LoadStates, הערך הקודם של CombinedLoadStates יישמר בצד של המציג כשהוא יקבל את הערך PagingData הסטטי. (Ic3ce5, b/205344028)

תיקוני באגים

• עכשיו מוגדר הערך של התוצאה PagingSource.getRefreshKey() תקין ב-initialKey במקרים שבהם היא הייתה מחזירה null, אבל הוגדר initialKey שאינו null. (Ic9542, b/230391606)

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

• עודכן :compose:ui:ui-test api (updateApi) עקב העברה מסוג test-coroutines-lib (I3366d)

גרסה 3.1

גרסה 3.1.1

9 במרץ 2022

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

תיקוני באגים

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

גרסה 3.1.0

17 בנובמבר 2021

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

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

• ממשקי ה-API של Flow<PagingData>.observable ושל Flow<PagingData>.flowable כבר לא ניסיוניים
• שינויים בהתנהגות של LoadState:
  • עכשיו endOfPaginationReached הוא תמיד false ל-LoadType.REFRESH גם ב-PagingSource וגם ב-RemoteMediator
  • LoadStates מ'הדפים' ממתינים עכשיו לערכים חוקיים מ-PagingSource וגם מ-RemoteMediator לפני פליטת הנתונים במורד הזרם. גרסאות חדשות של PagingData תמיד יתחילו עכשיו בצורה נכונה ב-Loading למצב הרענון במקום לאפס ל-NotLoading במקרים מסוימים באופן שגוי.
  • .loadStateFlow ו-.addLoadStateListener בממשקי API של מציגים כבר לא שולחים יותר מדי CombinedLoadStates ראשוני שבו מצבי המגשר מוגדרים תמיד כ-null
• הביטול של דורות קודמים מתבצע עכשיו בקוצר רוח לאחר ביטול התוקף / דורות חדשים. לא אמורה להיות חובה לעשות את זה יותר כדי להשתמש ב-.collectLatest ב-Flow<PagingData>, אבל עדיין מומלץ לעשות זאת.
• PagingSource.LoadResult.Invalid נוסף כסוג החזרה חדש מ-PagingSource.load. כתוצאה מכך, ההחלפה תגרום למחיקת כל בקשות הטעינה הממתינות או העתידיות אל הPagingSource הזה ולביטול התוקף שלה. סוג ההחזרה הזה נועד לטפל בנתונים שעשויים להיות לא חוקיים או בנתונים לא פעילים שניתן להחזיר ממסד הנתונים או מהרשת.
• נוספו ממשקי API של מציג .onPagesPresented ו-.addOnPagesUpdatedListener שהופעלו באופן סינכרוני כשהדפים מוצגים בממשק המשתמש. עדכוני דפים יכולים להתרחש בתרחישים הבאים:
  • הטעינה הראשונית של דור חדש של נתוני PagingData מסתיימת, ללא קשר שהגנרציה החדשה מכילה שינויים כלשהם בפריטים המוצגים. לדוגמה, יצירה חדשה שמשלים טעינה ראשונית ללא עדכונים כי הרשימה זהה לחלוטין, תפעיל את הקריאה החוזרת הזו.
  • דף נוסף, גם אם הדף שהוכנס לא מכיל פריטים חדשים.
  • דף מושמט, גם אם הדף שהושמט היה ריק.

גרסה 3.1.0-rc01

3 בנובמבר 2021

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

תיקוני באגים

• תוקנו מרוץ תהליכים + דליפת זיכרון ב- .cachedIn() במקרים שבהם מספר אירועי טעינה נשלחו על ידי חיפוש במורד הזרם בזמן שאין צופים או בין העובדה שצופה עבר ל-PagingData חדש. (Ib682e)

גרסה 3.1.0-beta01

13 באוקטובר 2021

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

תיקוני באגים

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

גרסה 3.1.0-alpha04

29 בספטמבר 2021

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

שינויים ב-API

• ממשקי API של Flow<PagingData>.observable ו-Flow<PagingData>.flowable הן כבר לא ניסיוניות. (Ie0bdd)

תיקוני באגים

• ב-LoadStates, עכשיו הערך endOfPaginationReached הוא תמיד false עבור LoadType.REFRESH. בעבר, היה אפשר endOfPagination הזמין את true עבור RemoteMediator REFRESH, אבל לא עבור PagingSource. עכשיו ההתנהגות הזו אוחדה כדי להחזיר תמיד false, מפני שלפעמים לא הגיוני ש-REFRESH יהיה סופי, מתועד כחלק מחוזה ה-API ב-LoadStates. כשאתם מחליטים אם החלוקה לדפים הופסקה, עליך לעשות זאת תמיד אחת מהאפשרויות: APPEND או PREPEND. (I047b6)

• LoadStates מחלוקה לדפים ממתינים עכשיו לערכים חוקיים משני הסוגים PagingSource ו- RemoteMediator לפני פליטת ערך במורד הזרם בין מהדור הקודם. האפשרות הזו מונעת שליחה של נתוני PagingData מדורות חדשים לא נטען ב-IntegrationLoadStates.source.refresh אם הוא כבר היה בטעינה; דורות חדשים של PagingData תמיד יתחילו כמו שצריך עם טעינה למצב רענון במקום איפוס תחילה למצב NotLoading במקרים מסוימים.

  ביטולים לדורות קודמים מתרחשים עכשיו באופן נלהב לאחר ביטול תוקף / ולדורות חדשים. לא צריך יותר להשתמש בו כדי להשתמש ב- .collectLatest בתאריך Flow<PagingData>, למרות שעדיין מומלץ מאוד לעשות זאת. (I0b2b5, b/177351336, b/195028524)

• .loadStateFlow ו-.addLoadStateListener בממשקי API של מציגים לא שולח יותר מדי CombinedLoadStates ראשוני שתמיד מצבי המגשר מוגדרים לnull ומצבי המקור מוגדרים NotLoading(endOfPaginationReached = false) זאת אומרת ש:

  1. אם משתמשים ב- RemoteMediator, מצבי המגשר תמיד יאוכלסו.
  2. רישום LoadState חדש מסוג loadState או אוסף חדש ב- הערך הנוכחי לא יפלוט באופן מיידי מ-.loadStateFlow אם הוא לא קיבל CombinedLoadStates אמיתי מ- PagingData. זה יכול לקרות אם מקודד או מאזינים מתחילים לפני שליחה של PagingData. (I1a748)

גרסה 3.1.0-alpha03

21 ביולי 2021

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

שינויים ב-API

• סוג החזרה שלישי של Load result נוסף אל Load result.Invalid (לא חוקי) PagingSource. כשחוזר PagingSource.load LoadLoad.לא חוקי, החלוקה לדפים תמחק את הנתונים שנטענו לבטל את התוקף של PagingSource. סוג ההחזרה הזה נועד תטפל בנתונים שעשויים להיות לא חוקיים או לא פעילים שאפשר להחזיר ממסד הנתונים או מהרשת.

  לדוגמה, אם מסד הנתונים הבסיסי נכתב ב- ה-PagingSource לא מבטל זמן, והוא עשוי להחזיר לא עקביות בתוצאות אם ההטמעה שלהן תלויה ומערך הנתונים המגובה שהוא נטען ממנו (למשל, LIMIT הטמעות db בסגנון OFFSET. במקרה הזה, עדיף מומלץ לבדוק את התקינות לאחר הטעינה הפונקציה מחזירה Load result.invalid, וכתוצאה מכך הפינגים מוחקים בקשות טעינה עתידיות או ממתינות ל-PagingSource הזה לבטל אותה.

  סוג ההחזרה הזה נתמך גם על ידי Paging2 API שמנצל את LivePagedList או RxPagedList. כשמשתמשים ב-PagingSource עם ממשקי ה-API של PagedList של Paging2 מנותקים מיד, לעצור ניסיונות נוספים לטעון נתונים ב-PagedList תגרום לביטול תוקף ב-PagingSource.

  Loadresults הוא מחלקה חתומה, כלומר שינוי שלא תואם למקור, כך שהתרחישים לדוגמה ישתמשו ישירות התוצאות של PagingSource.load יצטרכו לטפל ב-Load Results.Invalid בזמן הידור. לדוגמה, משתמשי Kotlin משתמשים מתי לבדוק את סוג ההחזרה, צריך להוסיף בדיקה עבור סוג לא חוקי. (Id6bd3, b/191806126, b/192013267)

תיקוני באגים

• נוספו קריאות חוזרות לביטול תוקף דרך PagingSource.registeratedCallback או DataSource.add ValidatedCallback יופעל באופן אוטומטי אם הם רשומים ב-PagingSource / DataSource שכבר לא תקין. הפעולה הזו פותרת מרוץ תהליכים שגרם לירידה בנתוני ההצמדה והם נתקעים בזמן שסופק מקור כבר לא חוקי במהלך הטעינה הראשונית. בנוסף, מבטלים את התוקף קריאות חוזרות (callback) מוסרות עכשיו באופן תקין אחרי שהן הופעלו, שמובטח להיקרא פעם אחת לכל היותר. (I27e69)
• שליחת הערך הראשוני של ה-placeholder (InitialPagedList) מזרם PagedList שנוצר לאחרונה, למשל, LivePagedListBuilder או RxPagedListBuilder לא ינקו יותר נתונים שנטענו בעבר.

גרסה 3.1.0-alpha02

1 ביולי 2021

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

תכונות חדשות

• נוספו ממשקי API של OnPagespresented Listener ו-Fflow מוצגים שמופעלות מיד אחרי שהדפים שמוצגים מתעדכנים בממשק המשתמש.

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

  עדכוני דפים יכולים להתרחש בתרחישים הבאים:

  • הטעינה הראשונית של דור חדש של PagingData הושלמה בלי קשר אם הדור החדש כולל שינויים כלשהם פריטים שהוצגו. לדוגמה, גרסה חדשה שמשלים טעינה ראשונית ללא עדכונים מכיוון שהרשימה זהה לחלוטין תפעיל את הקריאה החוזרת (callback) הזו.
  • דף נוסף, גם אם הדף שהוכנס לא מכיל פריטים
  • דף מושמט, גם אם הדף ששחרר היה ריק (I272c9, b/189999634)

תיקוני באגים

• גישה ל-PagedList.dataSource מהערך הראשוני שהופק מאת LivePagedList או RxPagedList לא יקפיצו יותר בטעות DisallowStateError (I96707)

גרסה 3.1.0-alpha01

2 ביוני 2021

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

שינויים ב-API

• כיתות שמסופקות על ידי paging-rxjava3 זמינות עכשיו במסגרת חבילת androidx.paging.rxjava3 שלא מתנגשת עם paging-rxjava2 (Ifa7f6)

תיקוני באגים

• תוקנה בעיה שבה החלוקה לדפים הייתה לפעמים לא תקינה אירועים ל-RecyclerView, שעשויים לגרום להפעלה של מאזינים מסוימים מוקדם. (Ic507f, b/182510751)

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

• נוספו ממשקי API תואמים של PagedList compat הוצאו משימוש לארטיפקט rxjava3 (Id1ce2, b/182497591)

גרסה 1.0.0 של כתיבת חלוקה לדפים

גרסה 1.0.0-alpha20

24 במאי 2023

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

תכונות חדשות

• עכשיו אפשר להשתמש בניסוח האוטומטי כדי לראות תצוגה מקדימה של רשימה של נתונים מזויפים על ידי יצירת PagingData.from(fakeData) ועטיפת ה-PagingData ב-MutableStateFlow (לדוגמה, MutableStateFlow(PagingData.from(listOf(1, 2, 3)))). על ידי שימוש בנתונים האלה כקלט ב-@Preview, שיחות ל-collectAsLazyPagingItems() יספקו LazyPagingItems לתצוגה מקדימה. (I8a78d, b/194544557)

תיקוני באגים

• נתונים שנשמרו במטמון מ-pager.flow.cachedIn שנאספו ב-LazyPagingItems יהיו זמינים עכשיו אחרי שחזור המצב, ללא צורך באיסוף אסינכרוני. המשמעות היא שהנתונים שנשמרו במטמון יהיו מוכנים להצגה מיד אחרי ההרכבה הראשונית, אחרי שחזור המצב. (I97a60, b/177245496)

גרסה 1.0.0-alpha19

3 במאי 2023

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

תמיכה בכל הפריסות העצלות

בעבר, התכונה 'כתיבה מהירה' סיפקה תוספים מותאמים אישית מסוג items ו-itemsIndexed ב-LazyListScope, וכתוצאה מכך לא הייתה אפשרות להשתמש בתכונה 'כתיבה מהירה' עם פריסות עצלות אחרות כמו LazyVerticalGrid, HorizontalPager או רכיבים אחרים עם עצלנות בהתאמה אישית שסופקו על ידי ספריות Wear ו-TV. טיפול בחוסר הגמישות הזה הוא העדכון העיקרי לגרסה הזו.

כדי לתמוך בפריסות עצלות יותר, היה עלינו ליצור ממשקי API בשכבה שונה – במקום לספק API של items בהתאמה אישית לכל פריסה מדורגת, התכונה 'כתיבה מהירה' מספקת עכשיו שיטות הרחבה ברמה מעט נמוכה יותר ב-LazyPagingItems ב-itemKey וב-itemContentType. ממשקי ה-API האלה עוזרים לך להטמיע את הפרמטרים key ו-contentType בממשקי ה-API הרגילים מסוג items שכבר קיימים עבור LazyColumn, LazyVerticalGrid ועם המקבילים שלהם בממשקי API כמו HorizontalPager. (Ifa13b, Ib04f0, b/259385813)

המשמעות היא שהתמיכה ב-LazyVerticalGrid תיראה כך:

// This part is unchanged
val lazyPagingItems = pager.collectAsLazyPagingItems()

LazyVerticalGrid(columns = GridCells.Fixed(2)) {
  // Here we use the standard items API
  items(
    count = lazyPagingItems.itemCount,
    // Here we use the new itemKey extension on LazyPagingItems to
    // handle placeholders automatically, ensuring you only need to provide
    // keys for real items
    key = lazyPagingItems.itemKey { it.uniqueId },
    // Similarly, itemContentType lets you set a custom content type for each item
    contentType = lazyPagingItems.itemContentType { "contentType" }
  ) { index ->
    // As the standard items call provides only the index, we get the item
    // directly from our lazyPagingItems
    val item = lazyPagingItems[index]
    PagingItem(item = item)
  }
}

דוגמאות נוספות לשימוש בממשקי ה-API החדשים האלה מפורטות בדוגמאות שלנו.

למרות שהשינויים האלה מאריכים את כמה מהדוגמאות של LazyColumn ו-LazyRow, אנחנו מרגישים שעקביות בכל הפריסות העצלניות הייתה גורם חשוב עבור אלה שישתמשו בניסוח האוטומטי. לכן, התוספים הקיימים ל-LazyListScope הוצאו משימוש. (I0c459, I92c8f, b/276989796)

שינויים ב-API

• כדי להקל את המעבר לממשקי ה-API החדשים, הפונקציות של התוסף items ו-itemsIndexed ב-LazyListScope תומכות עכשיו בפרמטר contentType, שמשקף את התמיכה בממשקי ה-API החדשים. (Ib1918, b/255283378)

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

• התכונה 'כתיבה מהירה' עדכנה את התלות שלה מ'כתיבה' 1.0.5 ל'כתיבה' 1.2.1. (Ib1918, b/255283378)

גרסה 1.0.0-alpha18

8 בפברואר 2023

ההשקה של androidx.paging:paging-compose:1.0.0-alpha18 ללא שינויים. גרסה 1.0.0-alpha18 מכילה את התחייבויות אלה.

גרסה 1.0.0-alpha17

24 באוקטובר 2022

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

תכונות חדשות

• הוספת תמיכה ל-CoroutineContext בהתאמה אישית כשמתקשרים אל collectLazyPagingItems. (I7a574, b/243182795, b/233783862)

גרסה 1.0.0-alpha16

10 באוגוסט 2022

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

תכונות חדשות

• החלוקה לדפים מספקת עכשיו יומנים דרך המחלקה LazyPagingItems כדי לחשוף מידע על ניפוי באגים שנאסף מ-PagingData.
• אפשר להפעיל את היומנים באמצעות הפקודה adb shell adb shell setprop log.tag.Paging [DEBUG|VERBOSE]. ([b/235527159}(https://issuetracker.google.com/issues/235527159))

תיקוני באגים

• תוקנה שגיאת constructor של PagingDataDiffer החסרה בעת שימוש ב-paging-compose:1.0.0-alpha15 עם paging-common:3.1.1 או לפני כן.(b/235256201,b/239868768)

גרסה 1.0.0-alpha15

1 ביוני 2022

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

שינויים ב-API

• נוספו בנאים עבור PagingDataAdapter ו-AsyncPagingDataDiffer שמקבלים CoroutineContext במקום CoroutineDispatcher. (Idc878)

תיקוני באגים

• LazyPagingItems מגדיר עכשיו את הפרמטר loadState הראשוני עם רענון של LoadState.Loading. (I55043, b/224855902)

גרסה 1.0.0-alpha14

13 באוקטובר 2021

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

גרסה 1.0.0-alpha13

29 בספטמבר 2021

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

שינויים ב-API

• הפונקציה LazyPagingItems.snapshot() הוחלפה במאפיין LazyPagingItems.itemSnapshotList (Ie2da8)
• LazyPagingItems.getAsState() שהוצא משימוש הוסר (Ie65e4)

גרסה 1.0.0-alpha12

21 ביולי 2021

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

שינויים ב-API

• items(lazyPagingItems) ו-itemsIndexed(lazyPagingItems) שמשמשים לחיבור העימוד אל LazyColumn/Row מקבלים עכשיו את הפרמטר של מפתח האפשרות, שמאפשר לציין מפתח יציב שמייצג את הפריט. אפשר לקרוא מידע נוסף על מפתחות כאן. (I7986d)
• הפונקציה lazyPagingItems.getAsState(index) הוצאה משימוש. במקומה צריך להשתמש במדיניות lazyPagingItems[index]. (I086cb, b/187339372)

גרסה 1.0.0-alpha11

30 ביוני 2021

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

גרסה 1.0.0-alpha10

2 ביוני 2021

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

גרסה 1.0.0-alpha09

18 במאי 2021

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

תיקוני באגים

• LazyPagingItems עכשיו ניתן לראות את itemCount ואת item getter, וכך להשתמש בהם גם עם LazyVerticalGrid (Ie2446, b/171872064, b/168285687)

תאימות לכתיבה

• androidx.paging:paging-compose:1.0.0-alpha09 תואם רק לגרסה 1.0.0-beta07 ואילך של 'כתיבה'.

גרסה 1.0.0-alpha08

24 בפברואר 2021

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

עודכנה לשילוב עם 'כתיבה' 1.0.0-beta01.

גרסה 1.0.0-alpha07

10 בפברואר 2021

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

עודכן לשילוב עם 'כתיבה' alpha12.

גרסה 1.0.0-alpha06

28 בינואר 2021

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

תיקוני באגים

עודכנה לאפשרות 'כתיבה' 1.0.0-alpha11.

גרסה 1.0.0-alpha05

13 בינואר 2021

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

עודכנה לאפשרות 'כתיבה' 1.0.0-alpha10.

גרסה 1.0.0-alpha04

16 בדצמבר 2020

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

תיקוני באגים

• עדכנת את מאפייני הנוחות CombinedLoadStates.refresh, CombinedLoadStates.prepend CombinedLoadStates.append כדי לעבור רק מLoading אל NotLoading אחרי שמצב הטעינה של המתווך וגם טעינת המקור הם NotLoading כדי להבטיח העדכון מרחוק הוחל. (I65619)

גרסה 1.0.0-alpha03

2 בדצמבר, 2020

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

• עודכנה להתאמה ל'כתיבה' 1.0.0-alpha08.

גרסה 1.0.0-alpha02

11 בנובמבר 2020

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

שינויים ב-API

• נוספו שיטות מסוג .peek(), .snapshot(), .retry() ו-.refresh() אל LazyPagingItem שחושפים את אותה פונקציונליות שזמינה AsyncPagingDataDiffer / PagingDataAdapter (Iddfe8, b/172041660)

גרסה 1.0.0-alpha01

28 באוקטובר 2020

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

תכונות חדשות

פריט המידע שנוצר בתהליך הפיתוח (Artifact) של paging-compose מאפשר שילוב בין ספריית העמודים לבין Jetpack פיתוח נייטיב. דוגמה לשימוש פשוט:

  @Composable
  @OptIn(ExperimentalLazyDsl::class)
  fun ItemsDemo(flow: Flow<PagingData<String>>) {
      val lazyPagingItems = flow.collectAsLazyPagingItems()
      LazyColumn {
          items(lazyPagingItems) {
              Text("Item is $it")
          }
      }
  }

גרסה 3.0.1

גרסה 3.0.1

21 ביולי 2021

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

תיקוני באגים

• גישה אל PagedList.dataSource מהערך הראשוני שנוצר על ידי LivePagedList או RxPagedList לא תגרור יותר חריג לא חוקי (I96707)

גרסה 3.0.0

גרסה 3.0.0

5 במאי 2021

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

התכונות העיקריות של 3.0.0

רוב ממשק ה-API הקיים מ-Paging 2.x.x הוצא משימוש לטובת ממשקי ה-API החדשים של Paging 3 כדי לספק את השיפורים הבאים:

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

גרסה 3.0.0-rc01

21 באפריל 2021

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

תיקוני באגים

• תוקנה בעיה שבה החלוקה לדפים הייתה לפעמים לא תקינה אירועים ל-RecyclerView, שעשויים לגרום להפעלה של מאזינים מסוימים מוקדם. (Ic507f, b/182510751)

גרסה 3.0.0-beta03

24 במרץ 2021

androidx.paging:paging-*:3.0.0-beta03 משוחרר. גרסה 3.0.0-beta03 מכילה את התחייבויות אלה.

תיקוני באגים

• שיפרנו את אופן הטיפול ב-placeholders כאשר הרשימה נטען מחדש כדי למנוע קפיצות לא צפויות ב-RecyclerView. צפייה לפרטים נוספים, אפשר למצוא פרטים נוספים על NullPaddedDiffing.md. (If1490, b/170027529, b/177338149)
• ה-builders השונים של PagedList (נתיב תאימות ישן) לא מבצעים יותר סנכרון שגוי ל-DataSource.Factory.create() ב-thread הראשי כשמתבצעת קריאה ל-.build(). (b/182798948)

גרסה 3.0.0-beta02

10 במרץ 2021

androidx.paging:paging-*:3.0.0-beta02 משוחרר. גרסה 3.0.0-beta02 מכילה את התחייבויות אלה.

שינויים ב-API

• תוספים Rx3 מופצים עכשיו בצורה תקינה @ExperimentalCoroutinesApi דרישה להביע הסכמה. בעבר הם היו מסומנות בשיטה @get, והמערכת של Kotlin Compiler מתעלם ממנה אל: https://youtrack.jetbrains.com/issue/KT-45227 (I5733c)

תיקוני באגים

• לאכוף הגבלות על שימוש ציבורי בממשקי API ניסיוניים (I6aa29, b/174531520)
• תוקן באג שגרם ל-PagingState להיות תמיד null כאשר מתבצעת קריאה לרענון מרחוק.
• תוקן באג שגרם לכך שדפים ריקים שהוחזרו על ידי PagingSource לא יאחזרו שוב את העמודים כדי למלא את הפקודה prefetchDistance, וכתוצאה מכך העמודים נתקע.

גרסה 3.0.0-beta01

10 בפברואר 2021

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

שינויים ב-API

• wrappers של Rx2 ו-Rx3 חושפים עכשיו את ההערה הניסיונית תלויה. אם אתם משתמשים ב-wrappers תואמים של Rx ב-paging-rxjava2 או paging-rxjan3, עכשיו תצטרכו להוסיף הערות לשימושים @OptIn(ExperimentalCoroutinesApi::class) (Ib1f9d)

תיקוני באגים

• שגיאה מסוג IndexOutOfBoundsException: Inconsistency detected הוחזרה לפעמים במהלך שימוש בממשקי API של DataSource בגרסה 2 דרך נתיבי תאימות
• קריאת isInvalid במהלך האתחול של DataSource בשימוש דרך נתיבי תאימות מופעלת עכשיו בצורה נכונה ב-FetchDispatcher במקום ב-thread הראשי. הפתרון הזה פותר את הבעיה IllegalStateException בגלל גישה ל-Db ב-thread הראשי כשמשתמשים בהטמעה של PagingSource בחדר.

גרסה 3.0.0-alpha13

27 בינואר, 2021

androidx.paging:paging-*:3.0.0-alpha13 משוחרר. גרסה 3.0.0-alpha13 מכילה את התחייבויות אלה.

שינויים ב-API

• כבר אי אפשר להטמיע את PagingSource.getRefreshKey, עכשיו זו פונקציה מופשטת ללא הטמעה כברירת מחדל. העברת משתמשים יכולה להמשיך להחזיר את ברירת המחדל של הטמעה, שמחזירה פשוט null, אבל getRefreshKey() צריך לבצע הטמעה אמיתית שמחזירה מפתח בהתבסס על מיקום הגלילה הנוכחי שמאפשר החלוקה לדפים להמשיך בטעינה מתרכזת סביב אזור התצוגה דרך PagingState.anchorPosition אם ככל האפשר. (I4339a)
• InvalidatingPagingSourceFactory הוא עכשיו מחלקה אחרונה (Ia3b0a)
• אפשר להגדיר את מפריד הטרמינלים (כותרת עליונה / כותרת תחתונה) עם פרמטר SeparatorType אופציונלי נוסף. שני הסוגים האפשרויות הן:
  • FULLY_COMPLETE – התנהגות קיימת; להמתין גם ל-PagingSource וגם RemoteMediator כדי לסמן endOfPaginationReached לפני הוספת הטרמינל תווי הפרדה. אם לא נעשה שימוש ב-remoteMediator, Remote loadState הוא המערכת מתעלמת ממנו. האפשרות הזו שימושית בעיקר אם רוצים להציג רק את הקטע תווי הפרדה כשהקטע נטען במלואו, כולל אחזור מ- מקור מרוחק, למשל רשת.
  • SOURCE_COMPLETE – צריך להמתין רק לסימון ה-PingSource endOfPaginationReached גם אם נעשה שימוש ב- RemoteMediator. כך אפשר כותרות עליונות ותחתונות שיוצגו באופן סינכרוני עם טעינה, שמונע מהמשתמשים לגלול כדי לראות את מסוף תווי הפרדה. (Ibe993, b/174700218)

תיקוני באגים

• תוקנה דליפת זיכרון נדירה שמתרחשת כאשר PagingSource לא תקף לפני שמאחזר הדפים יוכל אפילו להתחיל להיטען ממנו. (I9606b, b/174625633)

גרסה 3.0.0-alpha12

13 בינואר 2021

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

שינויים ב-API

• InvalidatingPagingSourceDefault כבר לא מחלקה מופשטת כי מעולם לא היו בו שיטות מופשטות. I4a8c4
• נוסף עומס יתר של .cachedIn() שמקבל את ViewModel במקום להשתמש במחזור החיים או ב-CoroutineScope למשתמשי Java. (I97d81, b/175332619)
• אפשר למתקשרים ב-Java להשתמש בפעולות טרנספורמציה של PagingData ב- בדרך אסינכרונית, באמצעות קבלת אופרטור טרנספורמציה לאופרטור ארגומנטים. לכל האופרטורים מסוג 'סנכרון טרנספורמציה' יש את הסיומת -Sync הוסרו עכשיו, שמשתמשי Kotlin Coroutine יצטרכו להבחין קריאה לפונקציה של התוסף שמקבלת בלוק השעיה במקום זאת. כל האופרטורים של טרנספורמציה של נתוני דפים הועברו לתוספים במחלקה הסטטית PagingDataTransforms. משתמשי Java יצטרכו להתקשר אליהם באמצעות עוזרים סטטיים, למשל, PagingDataTransforms.map(pagingData, transform) למשתמשי Kotlin, התחביר זהה אבל תצטרכו לייבא מותאמת אישית. (If6885, b/172895919)

תיקוני באגים

• תוקן באג שגרם לכך שלא תתבצע קריאה אל RemoteMediator.load() במהלך adapter.refresh() אם החלוקה לדפים כבר הסתיימה.

גרסה 3.0.0-alpha11

16 בדצמבר 2020

androidx.paging:paging-*:3.0.0-alpha11 משוחרר. גרסה 3.0.0-alpha11 מכילה את התחייבויות אלה.

תכונות חדשות

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

שינויים ב-API

• PagingSource.getRefreshKey() הוא עכשיו API יציב (I22f6f, b/173530980)
• PagingSource.invalidate כבר לא פונקציה פתוחה. אם צריכים לקבל הודעה כשמבטלים תוקף, כדאי להתקשר אל הרישום של פעולת ה-callback בוטל, במקום לבטל את התוקף. (I628d9, b/173029013, b/137971356)
• לזימונית יש עכשיו בנאי ניסיוני יחיד לצד constructors רגילים, במקום להדליף ממשקי API ניסיוניים API ציבורי לא ניסיוני דרך ההערה להבעת הסכמה. (I9dc61, b/174531520)
• עדכנת את מאפייני הנוחות CombinedLoadStates.refresh, CombinedLoadStates.prepend CombinedLoadStates.append כדי לעבור רק מLoading אל NotLoading אחרי שמצב הטעינה של המתווך וגם טעינת המקור הם NotLoading כדי להבטיח העדכון מרחוק הוחל. (I65619)

• LoadParams.pageSize הוסר (הוא כבר היה קיים) הוצא משימוש). ההמלצה היא להשתמש ב-LoadParams.loadSize ב-PingSource.

  LoadParams.loadSize תמיד שווה ל-PagingConfig.pageSize מלבד קריאת הטעינה הראשונית שבה הוא שווה ל- PagingConfig.initialLoadSize.

  אם אתם בודקים את מקור הנתונים של Paging2 בלי להשתמש ב-Pager או PagedList, pageSize לא יכול להתאים ל-PagingConfig.pageSize אם הגדרת גם את initialLoadSize. אם זה חשוב ונסיון להשתמש במקום זאת ב-Pager/PagedList, שיגדיר באופן פנימי את גודל הדף הנכון עבור שיטות הטעינה של DataSource. (I98ac7, b/149157296)

תיקוני באגים

• תוקנה קריסה עקב DisallowStateError כאשר באמצעות תווי הפרדה שבהם מוגדר PagingConfig.maxSize. (I0ed33, b/174787528)
• תוקן באג שמצב הטעינה של האפשרויות PREPEND / APPEND לא היה תקין עדכון מיידי ל-NotLoading(endOfPaginationReached = true) לאחר הטעינה הראשונית, אם הוגדר RemoteMediator (I8cf5a)
• תוקן באג שבו ממשקי API בצד המציג, כמו .snapshot() , .peek() וכו', יחזירו את הרשימה הקודמת (שלא מעודכנת) בעדכוני ListUpdateCallback.
• תוקן באג שגרם למפרידים שלא הוסיפו כותרות עליונות או תחתונות בשימוש עם RemoteMediator
• תוקן באג שגרם לכך שעדכוני LoadState ל-NotLoading for RemoteMediator נתקעו במצב הטעינה
• תוקן באג שבו ה-API לתאימות של Paging2.0, .asPagingSourceFactory(), עלול לגרום לאתחול של הגיבוי DataSource ב-CoroutineDispatcher השגוי. הפעולה הזו מאפשרת לפתור קריסה ומקרי ANR אפשריים, במיוחד כשמשתמשים בהטמעה הנוכחית של PagingSource ב-חדר, שמשתמשת בנתיב התאימות הזה.

גרסה 3.0.0-alpha10

2 בדצמבר, 2020

androidx.paging:paging-*:3.0.0-alpha10 משוחרר. גרסה 3.0.0-alpha10 מכילה את התחייבויות אלה.

שינויים ב-API

• ממשקי ה-API dataRefreshFlow ו-dataRefreshListener שהוצאו משימוש הוסרו כי הם מיותרים בעדכוני loadStateFlow / Listener. עבור את אלה שמעבירים, הערך המקביל של loadStateFlow הוא:

  loadStateFlow.distinctUntilChangedBy { it.refresh }
      .filter { it.refresh is NotLoading }
  

  (Ib5570, b/173530908)

תיקוני באגים

• endOfPaginationReached עבור RemoteMediator REFRESH עכשיו להפיץ באופן תקין לעדכוני LoadState ומונעים מצב של APPEND מרחוק PREPEND מההפעלה. (I94a3f, b/155290248)
• הצגת רשימה ריקה בגלל דף ראשוני ריק או סינון נרחב כבר לא ימנע את ההחלפה של PREPEND או APPEND נטענים. (I3e702, b/168169730)
• תוקנה בעיה שבה לא ניתן להתקשר אל getRefreshKey הדורות הבאים של PagingSource כשהפרות המדיניות מתרחשות במהירות. (I45460, b/170027530)

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

• נוסף מחלקה מופשטת חדשה של InvalidatingPagingSource6 עם API מסוג .invalidate() שמעביר את התוקף של כל ערכי ה-PingSources שהוא פולט. תודה ל-@claraf3! (Ie71fc, b/160716447)

בעיות מוכרות

• יכול להיות שכותרות עליונות ותחתונות מהטרנספורמציה של .insertSeparator() לא יופיעו מיד כשמשתמשים ב- RemoteMediator b/172254056
• השימוש ב- RemoteMediator עלול לגרום ל-LoadState להיתקע במקרה של ביטול התוקף, והפקודה PagingSource.load(LoadParams.Refresh(...)) מסתיימת לפני ההחזרה של RemoteMediator.load() b/173717820

גרסה 3.0.0-alpha09

11 בנובמבר 2020

androidx.paging:paging-*:3.0.0-alpha09 משוחרר. גרסה 3.0.0-alpha09 מכילה את התחייבויות אלה.

שינויים ב-API

• להוציא משימוש באופן מלא את data RefreshFlow / methods של Listener באמצעות החלפה עם תנאי. (I6e2dd)

תיקוני באגים

• תיקון לשגיאה של IllegalArgumentException בעת שימוש במפרידים עם RemoteMediator וביטול תוקף מופעל בזמן שטעינה מרחוק מחזירה endOfPagination עדיין פועלת (I3a260)

גרסה 3.0.0-alpha08

28 באוקטובר 2020

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

שינויים ב-API

• וריאציות של Kotlin / Java של DataSource.InvalidatedCallback משולבות על ידי הפעלת המרות מסוג SAM ב-Kotlin באמצעות פונקציונליות (זמין ב-Kotlin 1.4). הפעולה הזו גם פותרת באג שבו לא בוצעה קריאה לווריאנט kotlin של קריאות חוזרות לא חוקיות לאחר השינוי של .map או של .mapByPage. (I1f244, b/165313046)

תיקוני באגים

• האינטראקציה של ההחלפה עם ViewPager שופרה באופן משמעותי. באופן ספציפי, החלוקה לדפים לא תבטל יותר קריאה אל RemoteMediator#load בגלל ביטול תוקף של דף. כמו כן, לא תתבצע יותר בקשה לטעינת הוספה/הוספה מראש, אם נדרש רענון (REFRESH), עד שהבקשה לרענון תושלם בהצלחה. (I6390b, b/162252536)
• בדיקת איתור השגיאות בקוד של API עבור missingGetterMatchingBuilder מופעלת ב-androidx (I4bbea, b/138602561)
• תוקן באג שבו עוזרים של .withLoadState* ConcatAdapter היו קריסה עקב הודעה על RecyclerView משרשור ברקע (I18bb5, b/170988309)
• תוקן באג שגרם לפעמים לשליפה של דף קטן מאוד שאינו ריק למנוע הפעלת שליפה מראש (prefetch) בצורה נכונה.Iffda3 b/169259468

גרסה 3.0.0-alpha07

1 באוקטובר 2020

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

שינויים ב-API

• אופרטורים אסינכרוניים של PagingData Guava מקבלים עכשיו קובץ הפעלה כפרמטר, כדי לשלוט בהקשר של הביצוע. (Id4372)

תיקוני באגים

• תוקנה חריגה ב-IndexOutOfBounds שנרשמה ב- RemoteMediator עקב למרוץ תהליכים. (I00b7f, b/165821814)
• תוקן תנאי מרוץ ב-DataSource -> המרה של PagingSource שעלולה לגרום ל-PingSource שמתקבל להתעלם מאותות לא חוקיים מ-DataSource.
• תוקנה בעיה בלוגיקת אחזור הדף שגרמה לפעמים לכשל באיסוף דורות חדשים של PagingSource עד להפעלת PagingDataAdapter.refresh() .
• תוקנה בעיה שגרמה לאובדן של מיקום הגלילה בעת שימוש במקור נתונים שהומר ל-PagingSource (למשל המקור שנוצר על ידי Room), בשילוב עם RemoteMediator

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

• תודה ל- @simonschiller שהוסיפו אופרטורים של טרנספורמציה אסינכרונית מסוג RxJava2, RxJava3 ו-Guava ל-PagingData!

גרסה 3.0.0-alpha06

2 בספטמבר 2020

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

שינויים ב-API

• UnsupportedOperationException עם מסרים ברורים יותר במקרים שבהם אין תמיכה במזהים יציבים, קוראים לפונקציה PagingDataAdapter.setHasStableIds. (Ib3890, b/158801427)

תיקוני באגים

• תכונת ההפרדה אינה מסננת יותר דפים ריקים המרחק של השליפה מראש שהמציג יכבד אותו גם במקרים שבהם נוספו דפים ריקים רבים. (I9cff6, b/162538908)

גרסה 3.0.0-alpha05

19 באוגוסט 2020

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

תיקוני באגים

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

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

• תודה ל-Clera F שעזרת לסיים כמה בדיקות! (549612)

גרסה 3.0.0-alpha04

5 באוגוסט 2020

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

שינויים ב-API

• נוסף API של peek() ל-AsyncPagingDataDiffer ו PagingDataAdapter כדי לאפשר גישה לנתונים המוצגים ללא הפעלת דף בטעינה. (I38898, b/159104197)
• הוספת API של snapshot() ל-PagingDataAdapter ו AsyncPagingDataDiffer כדי לאפשר אחזור של הפריטים המוצגים בלי שמפעילה את אחזור הדף. (I566b6, b/159104197)
• נוסף constructor של PagingData.from(List<T>) כדי לאפשר על סמך רשימות סטטיות, ואפשר לשלב אותן עם כל המגוון זרימה של נתוני דפים כדי להציג רשימות סטטיות במצבים מסוימים, למשל לפני בסיום ה-REFRESH הראשוני או פשוט לצורך בדיקת טרנספורמציות. (Id134d)
• להוציא משימוש את ממשקי ה-API של זרימת נתונים והאזנות / Listener כפי שהם שמטרתו לחשוף את מצב הפריטים המוצג ב-REFRESH, אבל עם שיפורים ב-loadState Flow / Callback של ה-listener ובמאפיין itemCount, הוא מיותר (Ia19f3)
• נוספו wrappers של תאימות RxJava3 עבור PagingSource ו-RemoteMediator (I49ef3, b/161480176)

תיקוני באגים

• בוצעה המרה של PositionalDataSource לPagingSource באמצעות כלי העזר toPagingSourceFactory, כולל PagingSource שנוצרו על ידי 'חדר' לסמן את עצמם בצורה נכונה כדי לתמוך בקפיצה. (I3e84c, b/162161201)
• תוקן באג שבו נעשה שימוש בווריאנט הסינכרוני של sendData עלולה לפעמים להוביל למרוץ תהליכים שגורמת לClosedSendChannelException (I4d702, b/160192222)

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

• תודה לזאק Sweers שיוסיף wrappers לתאימות של RxJava3 מטעם Slack! (I49ef3, b/161480176)

גרסה 3.0.0-alpha03

22 ביולי 2020

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

שינויים ב-API

• ה-constructor של PagingState הוא ציבורי עכשיו, ולכן קל יותר לבצע בדיקות של getrecoveryKey() (I8bf15)
• הסתרת וריאציות של פונקציות מיפוי של kotlin מ-Java, אל פתרון חוסר בהירות בין הווריאנט המקורי לווריאנט של קוטלין. (If7b23, b/161150011)
• ממשקי API מיותרים שמיועדים לנוחיות משתמשי Kotlin סומן @JvmSynthetic (I56ae5)
• נוספו עומסי יתר ל-constructor של Loadresult.Page שברירת המחדל שלו היא itemsBefore ו-itemAfter ל-COUNT_UNDEFINED (I47849)
• הגדרת אופרטורים קיימים של PagingData לקבל שיטות השעיה והשקנו תכונות חדשות שלmapSync, flatMapSync ו-FilterSync ללא השהיית תשלומים אופרטורים למשתמשי Java. שיטות הטרנספורמציה הקיימות הועברו לפונקציות תוספים, כך שמשתמשי Kotlin יצטרכו לייבא אותן עכשיו. (I34239, b/159983232)

תיקוני באגים

• מעכשיו, ה-PingSources של Room (ו-PositionalDataSource) להציג מפריד מוביל כחלק מהדף הראשון, כך שהמשתמש אין צורך לגלול כדי לחשוף אותו. (I6f747, b/160257628)
• עכשיו מתבצעת גישה לפריט ב-placeholders תפעיל בצורה נכונה את טעינת PagingSource עד מוחזר דף שמשלים את האינדקס המבוקש אחרי טרנספורמציה באמצעות PagingData.filter() (I95625, b/158763195)
• תיקון באג שלפעמים צריך לגלול אחריו שיטת PagingSource מחזירה שגיאה כדי למנוע מ-PagingDataAdapter.retry() מניסיון חוזר. (I1084f, b/160194384)
• פתרון בעיה שבה פריט ניגש לפריט אחרי שחרור של דף לא טוענים דפים, למרות שהגישה לפריט הייתה בטווח השליפה מראש (Ie95ae, b/160038730)
• הגדרת PagingConfig.maxSize לא מפעילה יותר ערכי placeholder אחרי אירוע של ירידה (I2be29, b/159667766)

גרסה 3.0.0-alpha02

24 ביוני 2020

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

שינויים ב-API

• נוספו עומסי יתר עבור ה-constructor של PagingConfig עם ערכי ברירת מחדל נפוצים (I39c50, b/158576040)
• נוספו עומסי יתר לבנאים של PagingDataAdapter ו- AsyncPagingDataDiffer עם ערכי ברירת מחדל נפוצים (Ie91f5)
• ממשקי ה-API של המתאם, dataRefreshFlow ו-dataRefreshListener מעבירים ערך בוליאני כדי לציין אם PagingData ריק (I6e37e, b/159054196)
• נוספו ממשקי API של RxJava ו-Guava עבור RemoteMediator – RxremoteMediator ו-ListenableFutureRemoteMediator
• נוספו ל-PagingState עוזרים כדי לגשת לפריטים נפוצים כמו isEmpty() ו-firstItemOrNull() (I3b5b6, b/158892717)

תיקוני באגים

• Pager בודק עכשיו אם נעשה שימוש חוזר ב-PingSource במפעל, כדי למנוע שימוש חוזר בטעות ב-PingSources לא חוקיים, שגרם לשגיאה לא ברורה (I99809, b/158486430)
• כשלים ב- RemoteMediator REFRESH לא מונעים יותר את טעינת ה-PingSource (I38b1b, b/158892717)
• הגרסה של submitData שלא מושעית כבר לא גורמת לקריסה בגלל איסוף בו-זמנית במספר PagingData כאשר בוצעה קריאה אחרי גרסת ההשעיה של submitData. (I26358, b/158048877)
• תוקן השגיאה 'לא ניתן לאסוף פעמיים מ'זימונית' חריג שעלול להתרחש לאחר שינוי הגדרה (I58bcc, b/158784811)

גרסה 3.0.0-alpha01

10 ביוני 2020

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

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

תכונות חדשות של 3.0

• תמיכה ברמה ראשונה לקורוטינים ולזרימה ב-Kotlin.
• תמיכה בטעינה אסינכרונית באמצעות פונקציות השעיה של Coroutines, RxJava Single או Guava ListenableFuture primitives.
• אותות שגיאה ומצב טעינה מובנים לעיצוב ממשק משתמש רספונסיבי, כולל פונקציונליות של ניסיון חוזר ורענון.
• שיפורים בשכבת המאגר
  • ממשק פשוט של מקורות נתונים
  • עימוד פשוט יותר של רשת + מסד נתונים
  • תמיכה בביטולים
• שיפורים לשכבת המצגת
  • טרנספורמציות דף מותאמות אישית
  • מפרידים לרשימה
  • כותרות עליונות ותחתונות של מצב הטעינה

בעיות מוכרות

• העמודים השלישיים של Java Docs עדיין לא זמינים. בינתיים, היעזרו במדריכים המקושרים למעלה או במסמכי Kotlin. (b/158614050)

גרסה 2.1.2

גרסה 2.1.2

18 במרץ 2020

androidx.paging:paging:2.1.2 משוחרר. גרסה 2.1.2 כוללת את ההתחייבויות האלה מול 2.1.0.

תיקוני באגים

• יש לתקן את הבעיה IndexOutOfBoundsException במקרים נדירים שבהם ממירים מיקום במהלך ביטול התוקף.

בעיית הפצה

• גרסת ההחלפה 2.1.1 שוחררה באופן שגוי מהסתעפות שהוגדרה באופן שגוי. כתוצאה מכך, ממשקי ה-API שהוטמעו באופן חלקי והפונקציונליות שנשיק בקרוב בגרסה עתידית.

• החלוקה לדפים של 2.1.2 כוללת את תיקון מרכז העומסים שפורסם במקור בגרסה 2.1.1, אבל הפעם נבחרה בצורה נכונה גרסה 2.1.0. מומלץ מאוד לשדרג לגרסה הזו אם הגרסה הנוכחית שלך היא 2.1.1.

גרסה 2.1.1

גרסה 2.1.1

18 בדצמבר 2019

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

תיקוני באגים

• טעינות ראשוניות רציפות מ-PositionalDataSources מתרכזות עכשיו סביב הגישה האחרונה כאשר placeholders מושבתים

גרסה 2.1.0

גרסה 2.1.0

25 בינואר 2019

החלוקה לדפים של 2.1.0 תתפרסם ללא שינויים החל מ-2.1.0-rc01.

גרסה 2.1.0-rc01

6 בדצמבר 2018

החלוקה לדפים של 2.1.0-rc01 תתפרסם ללא שינויים החל מ-2.1.0-beta01.

גרסה 2.1.0-beta01

1 בנובמבר 2018

החלוקה לדפים של 2.1.0-beta01 תתפרסם ללא שינויים החל מ-2.1.0-alpha01.

גרסה 2.1.0-alpha01

12 באוקטובר 2018

החלוקה לדפים ב-2.1.0-alpha01 כוללת שתי תוספות עיקריות – שחרור דפים וספריות של תוספים ל-KTX לכל פריט מידע שנוצר בתהליך הפיתוח (Artifact) – וגם מספר שינויים נוספים בממשק ה-API ותיקוני באגים.

שינויים ב-API

• הוספת את PagedList.Config.Builder.setMaxSize() כדי להגביל את מספר הפריטים שנטענו בזיכרון.
• הוספת את androidx.paging.Config() כחלופה ל-Kotlin עבור PagedList.Config.Builder
• הוספת את androidx.paging.PagedList() כחלופה ל-Kotlin עבור PagedList.Builder
• הוספת את DataSourceFactory.toLiveData() כחלופה ל-Kotlin עבור LivePagedListBuilder
• נוספו DataSourceFactory.toObservable() ו-toFlowable() כחלופות ב-Kotlin עבור RxPagedListBuilder
• נוספה AsyncPagedListDiffer.addPagedListListener() להאזנה כשמוחלף רשימת PagedList. b/111698609
• נוסף וריאנט אחד (PagedListAdapter.onCurrentListChanged()) שעובר דרך רשימה ישנה וחדשה, וריאנט קודם שהוצא משימוש.
• נוספו PagedListAdapter/AsyncPagedListDiffer.submitList() וריאנטים שיוצרים קריאה חוזרת (callback) נוספת שמופעלת אם בזמן שרשימת הדפים מוצגת, לאחר הבחנה. כך ניתן לסנכרן החלפת PagedList עם עדכונים אחרים בממשק המשתמש. b/73781068
• הוספנו את PagedList.getLoadedCount() כדי לאפשר לך לדעת כמה פריטים יש בזיכרון. חשוב לשים לב שהערך המוחזר תמיד שווה ל-.size() אם ה-placeholders מושבתים.

תיקוני באגים

• תוקן מרוץ תהליכים בזמן שוני אם נעשה שימוש חוזר ברשימות b/111591017
• עכשיו PagedList.loadAround() יקפיץ/ה IndexOutOfBoundsException כשהאינדקס לא חוקי. בעבר הוא היה יכול לקרוס עם חריגה לא ברורה אחרת.
• תוקן מקרה שבו גודל טעינה ראשוני קטן במיוחד יחד עם נתונים שלא השתנו יובילו לטעינה נוספת של b/113122599

גרסה 2.0.0

גרסה 2.0.0

1 באוקטובר 2018

הפינגים של 2.0.0 מתפרסמים עם תיקון באג אחד.

תיקוני באגים

• תוקנה קריסה שעשויה להתרחש במהלך גלילה מהירה מאוד באמצעות PositionalDataSource ו-placeholders b/114635383.

גרסה 2.0.0-beta01

2 ביולי 2018

תיקוני באגים

• תוכן תוקן שנעלם בחלק מהמקרים המשניים (placeholders מושבתים, PositionalDataSource) b/80149146
• (כבר הושק ב-1.0.1) תוקנו קריסות שבהן לא ניתן היה לסמן אירועי העברה ב-PagedListAdapter וב-AsyncPagedListDiffer. b/110711937

יחסי תלות לפני AndroidX

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

dependencies {
    def paging_version = "1.0.0"

    implementation "android.arch.paging:runtime:$paging_version"

    // alternatively - without Android dependencies for testing
    testImplementation "android.arch.paging:common:$paging_version"

    // optional - RxJava support
    implementation "android.arch.paging:rxjava2:$paging_version"
}

גרסה 1.0.1

גרסה 1.0.1

26 ביוני 2018

הפינגים של 1.0.1 מתפרסמים עם תיקון באג אחד ב-runtime. כדי לשמור על היציבות, מומלץ מאוד להשתמש ב-1.0.1. גם החלוקה ל-RxJava2 של 1.0.1 הושקה, והיא זהה ל-1.0.0-rc1.

תיקוני באגים

• תוקנו קריסות שבהן לא ניתן היה לסמן אירועי העברה ב-PagedListAdapter וב-AsyncPagedListDiffer. b/110711937

RxJava2 גרסה 1.0.0

RxJava2 גרסה 1.0.0-rc1

16 במאי 2018

ההחלפה של RxJava2 1.0.0-rc1 עוברת למהדורת מועמד, ללא שינויים אלפא.

גרסה 1.0.0

גרסה 1.0.0-rc1

19 באפריל 2018 מועמד להשקת דפים

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

אין שינויים בגרסה הזו, היא זהה ל-1.0.0-beta1.

גרסה 1.0.0-beta1

5 באפריל 2018

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

התמיכה באלפא RxJava2 בפינגים מוצעת כמודול אופציונלי נפרד (android.arch.paging:rxjava2:1.0.0-alpha1) והוא ינוסח באופן זמני בנפרד, עד שיתייצב.

הספרייה החדשה מספקת חלופה ל-RxJava2 ל-LivePagedListBuilder, שמסוגלת לבנות Observable שנ' ו-Flowable, שנמשכת Scheduler במקום Executor:

val pagedItems = RxPagedListBuilder(myDataSource, /* page size */ 50)
        .setFetchScheduler(myNetworkScheduler)
        .buildObservable()

Observable<PagedList<Item>> pagedItems =
        RxPagedListBuilder(myDataSource, /* page size */ 50)
                .setFetchScheduler(myNetworkScheduler)
                .buildObservable();

תכונות חדשות

• RxPagedListBuilder נוסף באמצעות פריט המידע החדש שנוצר בתהליך הפיתוח (Artifact) של android.arch.paging:rxjava2.

שינויים ב-API

• שינויים ב-API שנועדו להבהיר את התפקיד של אדמינים ב-builders:

  • השם של setBackgroundThreadExecutor() שונה ל-setFetchExecutor() (ב-PagedList.Builder וב-LivePagedListBuilder)

  • השם של setMainThreadExecutor() השתנה ל-setNotifyExecutor() (ב-PagedList.Builder).

• בוצע תיקון של חבר אחד (PagedList.mCallbacks) כפרטי.

תיקוני באגים

• LivePagedListBuilder מפעיל את הטעינה הראשונית של PagedList בקובץ ה-exe שצוין, במקום את מאגר ה-thread של רכיבי Arch.

• תוקנה התנהגות ביטול תוקף ב-wrappers פנימיים של DataSource (משמש להטמעה של DataSource.map, וגם טעינה PositionalDataSource מושבתת באמצעות placeholder) b/77237534

גרסה 1.0.0-alpha7

21 במרץ 2018

החלוקה לדפים של 1.0.0-alpha7 תתפרסם לצד מחזורי החיים 1.1.1. ההחלפה לגרסת alpha7 תלויה בהעברה של המחלקה Function שצוינה למעלה, לכן צריך לעדכן את התלות של lifecycle:runtime ל-android.arch.lifecycle:runtime:1.1.1.

החלוקה לדפים של alpha7 מתוכננת להיות הגרסה הסופית לפני גרסת הבטא של היטים של ההחלפה.

שינויים ב-API

• ל-DataSource.LoadParams אובייקטים יש עכשיו constructor ציבורי ו-DataSource.LoadCallback אובייקטים הם עכשיו מופשטים. הפעולה הזו מאפשרת גלישת DataSource או בדיקה ישירה של DataSource באמצעות סימולציה של קריאה חוזרת (callback). b/72600421
• ממפים של DataSource ו-DataSource.מפעל
  • map(Function<IN,OUT>) מאפשר לשנות, לעטוף או לקשט תוצאות שנטענות על ידי DataSource.
  • הפונקציה mapByPage(<List<IN>,List<OUT>>) מאפשרת את אותו הדבר גם בעיבוד באצווה (למשל, אם פריטים שנטענים מ-SQL צריכים גם לשלוח שאילתה למסד נתונים נפרד, אפשר לעשות זאת כאצווה).
• השיטה PagedList#getDataSource() נוספה כאמצעי נוחות b/72611341
• כל הכיתות שהוצאו משימוש הוסרו מה-API, כולל שאר המחלקות של recyclerview.extensions וה-LivePagedListProvider.
• כדי להפעיל את הפונקציונליות של המפה, DataSource.Factory משתנה מממשק למחלקה מופשטת.

תיקוני באגים

• שינינו את ה-Builds כדי להפוך לסופיים. b/70848565
• ההטמעה של החדר DataSource תוקנה והיא יכולה לטפל בשאילתות מרובות טבלאות. התיקון הזה נכלל בחדר 1.1.0-beta1, כפי שמפורט למעלה.
• תוקן באג שגרם לכך שלא ניתן יהיה להפעיל את BoundaryCallback.onItemAtEndLoaded עבור PositionalDataSource אם placeholders מופעלים ו הגודל הכולל הוא כפולה מדויקת של גודל הדף.

גרסה 1.0.0-alpha5

22 בינואר 2018

תיקוני באגים

• תיקון טעינת הדף כאשר placeholders מושבתים b/70573345
• רישום נוסף ביומן למעקב אחר הבאג DisallowArgumentexcept שb/70360195 (ותיקון ספקולטיבי בצד החדר)
• תיקוני קוד לדוגמה של Javadoc b/70411933, b/71467637