חלוקה לדפים

בטבלה הזו מפורטים כל הארטיפקטים בקבוצה androidx.paging.

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

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

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

מידע נוסף זמין במסמכי התיעוד של Issue Tracker.

גרסה 3.3

גרסה 3.3.4

13 בנובמבר 2024

androidx.paging:paging-*:3.3.4 משוחרר. גרסה 3.3.4 כוללת את ההוספות האלה.

תיקוני באגים

• בדיקות יחידה של Android שמושכות את Paging 3.3 ואילך לא יגרמו יותר לשגיאה כמו Method isLoggable in android.util.Log not mocked. (Ia9400, b/331684448)

גרסה 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 שנוצרו על סמך AsyncPagingDataDiffer, כמו 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 נמצא במצב Error או במצב NotLoading, בהתאמה. הוספנו גם שיטה חדשה של awaitNotLoading() Kotlin extension ב-Flow<CombinedLoadStates> שמחכה עד שהעומס יגיע לסטטוס NotLoading או לסטטוס Error.
• PagingData.empty() מעביר עכשיו מצבי NotLoading כברירת מחדל, אלא אם מועברים ל-constructor שלו LoadStates מותאמים אישית. המצב הזה שונה מההתנהגות הקיימת, שבה לא מתבצעת שליחה של LoadStates כששולחים אותו ל-PagingDataAdapter, או שסטטוסים של טעינה נשלחים כשהם נאספים כ-LazyPagingItems. כשיוצרים את הרשימה כ-LazyPagingItems, עכשיו תוצג גם רשימה ריקה מיד אחרי היצירה הראשונית.

תאימות של Kotlin למספר פלטפורמות

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

• paging-common העביר את כל ממשקי ה-API של Paging 3 אל common, והוא תואם עכשיו ל-JVM ול-iOS בנוסף ל-Android.
• הקוד של paging-testing הועבר אל common והוא תואם עכשיו ל-JVM ול-iOS בנוסף ל-Android.
• paging-compose העביר את הקוד שלו ל-common ושלח ארטיפקט ל-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 משוחרר ללא שינויים ב-Paging 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 Annotation נעשה שימוש בתיוג @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 נמצא במצב Error או במצב NotLoading. הוספנו גם ממשק API חדש שממתין ל-LoadStateFlow עד שהעומס יגיע למצב NotLoading או למצב שגיאה. (Id6c67)

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

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

גרסה 3.3.0-alpha02

20 בספטמבר 2023

androidx.paging:paging-*:3.3.0-alpha02 משוחרר. גרסה 3.3.0-alpha02 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

תאימות של Kotlin למספר פלטפורמות

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

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

שינויים ב-API

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

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

• תודה ל-veyndan מ-Cash App על העזרה בהעברת Paging ל-Kotlin Multiplatform (#560, ‏ #561, ‏ #562, ‏ #573, ‏ #576, ‏ #577, ‏ #578, ‏ #579, ‏ #580, ‏ #581, ‏ #583, ‏ #584, ‏ #586, ‏ #609)

גרסה 3.3.0-alpha01

20 בספטמבר 2023

• זוהי הגרסה הראשונה של ספריות androidx.paging לפלטפורמות מרובות. בגרסה הזו יש רק ארטיפקטים מסוג *-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() של הארטיפקט של בדיקת הטעינה נתקע כשהועברו אליו תהליכים שנוצרו באמצעות PagingData.from(List), כי ל-asSnapshot() לא היה מידע על מועד סיום הטעינה (בניגוד לעומס יתר של PagingData.from(List, LoadStates)). הפתרון החלופי הזה פועל רק בתהליכי Flow שניתן להשלים (למשל, flowOf(PagingData.from(...))). בתהליכי Flow שלא ניתן להשלים (למשל, MutableStateFlow, צריך להשתמש ב-overload של PagingData.from שמספק את LoadStates). (I502c3)
• עכשיו, רכיב 'כתיבה בחלוקה לדפים' משתמש באופן פנימי ב-AndroidUiDispatcher.Main כדי לוודא שנתונים חדשים יהיו זמינים באותו פריים בסיום הטעינה. (Ia55af)

גרסה 3.2.0

26 ביולי 2023

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

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

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

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

כתיבה מהירה עם דפים

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

שינויים ב-API

• הוסרו ממשק ה-API items(LazyPagingItems) וממשק ה-API itemsIndexed(LazyPagingItems) שהוצאו משימוש מ-Paging Compose. דוגמה לממשקי ה-API החלופיים מופיעה בהערות הגרסה של 1.0.0-alpha20 ל-Paging Compose. (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 כדי להבטיח שהם ישמשו רק בבדיקות. (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

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

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

• עדכנו את המסמכים לגבי asPagingSourceFactory() כדי להבהיר שזוהי שיטת הרחבה ב-Flow שמחזירה מפעל לשימוש חוזר ליצירת מכונות PagingSource. (I5ff4f, ‏ I705b5)
• עדכנו את המסמכים לגבי המאגר LoadResult.Page כדי להבהיר את הצורך לשנות את 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 מכילה את ההצהרות האלה.

בדיקת דפים

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

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

  הפעולה הזו מתבצעת באמצעות התוסף asSnapshot Kotlin ב-Flow<PagingData<Value>>, שמתרגם את ה-Flow<PagingData<Value>> ל-List<Value> ישיר. פונקציית הלמה של 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 היא שיטת suspend שצפויה לפעול בתוך runTest. מידע נוסף זמין במאמר בדיקת פונקציות רפיטיביות (coroutines) ב-Kotlin ב-Android. (I55fd2, I5bd26, I7ce34, I51f4d, I2249f, Id6223, Ic4bab, Ib29b9, Ic1238, I96def, b/235528239)

שינויים ב-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. הארטיפקט הזה מספק ממשקי API שמיועדים לבדיקות יחידה (unit testing) של כל שכבה באפליקציה והשילוב שלה עם דפדוף בנפרד.

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

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

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

שינויים ב-API

• מאפשרת איטרציה נוחה מ-LoadResult.Page.data עד LoadResult.Page.iterator(). כך אפשר להשתמש באופן עקיף בשיטה flatten בספרייה הסטנדרטית של Kotlin כשנותנים 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)

תיקוני באגים

• תוקנה השגיאה בקונסטרוקטור 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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

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

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

גרסה 3.1.0-rc01

3 בנובמבר 2021

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

תיקוני באגים

• תוקנה בעיה של תנאי מרוץ (race condition) ודליפת זיכרון ב-cachedIn()‎ במקרים שבהם Paging שלח כמה אירועי טעינה במורד הזרם בזמן שאין משגיחים, או בין הזמנים שבהם משגיח עובר ל-PagingData חדש. (Ib682e)

גרסה 3.1.0-beta01

13 באוקטובר 2021

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

תיקוני באגים

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

גרסה 3.1.0-alpha04

29 בספטמבר 2021

androidx.paging:paging-*:3.1.0-alpha04 משוחרר. גרסה 3.1.0-alpha04 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

שינויים ב-API

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

תיקוני באגים

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

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

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

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

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

גרסה 3.1.0-alpha03

21 ביולי 2021

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

שינויים ב-API

• נוסף לסוג ההחזרה השלישי של LoadResult, LoadResult.Invalid, למקור הטעינה. כש-PagingSource.load מחזיר את הערך LoadResult.Invalid, המערכת תשליך את הנתונים שהועלו ותבטל את התוקף של PagingSource. סוג ההחזרה הזה מיועד לטיפול בנתונים שעשויים להיות לא חוקיים או לא עדכניים, שיכולים להוחזר מהמסד נתונים או מהרשת.

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

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

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

תיקוני באגים

• קריאות חזרה (callbacks) לביטול תוקף שנוספו באמצעות PagingSource.registerInvalidatedCallback או DataSource.addInvalidatedCallback מופעלות עכשיו באופן אוטומטי אם הן נרשמו ב-PagingSource או ב-DataSource שכבר לא תקפים. כך פותרים מצב מרוץ שגרם ל-Paging להשמיט אותות ביטול תוקף ולהיתקע כשסופק מקור שכבר לא היה תקין במהלך הטעינה הראשונית. בנוסף, פונקציות ה-callbacks של הביטול הוסרו כראוי אחרי שהן הופעלו, כי מובטח שהן יישלחו לכל היותר פעם אחת. (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 ושל מציג תהליך, שמופעל מיד אחרי שהדפים המוצגים מתעדכנים בממשק המשתמש.

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

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

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

תיקוני באגים

• הגישה ל-PagedList.dataSource מהערך הראשוני שנוצר על ידי LivePagedList או RxPagedList לא תגרום יותר להפעלה שגויה של IllegalStateException (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)

תיקוני באגים

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

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

• נוספו ממשקי API תואמים של PagedList ל-artifact של rxjava3 (Id1ce2, ‏ b/182497591)

Paging Compose גרסה 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 מכילה את ההוספות האלה.

תמיכה בכל הפריסות עם טעינת נתונים בזמן אמת

בעבר, רכיב Paging Compose סיפק תוספים מותאמים אישית של items ו-itemsIndexed ב-LazyListScope, כלומר לא ניתן היה להשתמש ב-Paging Compose עם פריסות אחרות של פריטים שהוטענו באיטרציה ראשונית (lazy), כמו LazyVerticalGrid, ‏ HorizontalPager או רכיבים מותאמים אישית אחרים של פריטים שהוטענו באיטרציה ראשונית שסופקו על ידי ספריות Wear ו-TV. הטיפול בבעיה הזו הוא העדכון העיקרי במהדורה הזו.

כדי לתמוך בפריסות 'עיכוב טעינה' נוספות, נדרשנו לפתח ממשקי API בשכבה אחרת – במקום לספק ממשק items API מותאם אישית לכל פריסה של 'עיכוב טעינה', Paging Compose מספק עכשיו שיטות הרחבה ברמה מעט נמוכה יותר ב-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, אבל לדעתנו עקביות בכל הפריסות הלא פעילות היא גורם חשוב למשתמשים שישתמשו ב-Paging Compose בהמשך. לכן, התוספים הקיימים ל-LazyListScope הוצאו משימוש. (I0c459, ‏ I92c8f, ‏ b/276989796)

שינויים ב-API

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

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

• העדכון של Paging Compose כלל שינוי של יחסי התלות מ-Compose 1.0.5 ל-Compose 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 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

תכונות חדשות

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

תיקוני באגים

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

תאימות ל-Compose

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

גרסה 1.0.0-alpha08

24 בפברואר 2021

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

עודכן כדי לשלב עם Compose 1.0.0-beta01.

גרסה 1.0.0-alpha07

10 בפברואר 2021

androidx.paging:paging-compose:1.0.0-alpha07 משוחרר. גרסה 1.0.0-alpha07 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

העדכון משולב עם Compose alpha12.

גרסה 1.0.0-alpha06

28 בינואר 2021

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

תיקוני באגים

העדכון מותנה ב-Compose 1.0.0-alpha11.

גרסה 1.0.0-alpha05

13 בינואר 2021

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

העדכון מותנה ב-Compose 1.0.0-alpha10.

גרסה 1.0.0-alpha04

16 בדצמבר 2020

androidx.paging:paging-compose:1.0.0-alpha04 משוחרר. גרסה 1.0.0-alpha04 מכילה את ההצהרות האלה על ביצוע שינויים (commits).

תיקוני באגים

• עדכנו את מאפייני הנוחות, 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 כוללת את ההצהרות האלה.

• העדכון תואם ל-Compose 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 מכילה את ההצהרות האלה.

תכונות חדשות

הארטיפקט paging-compose מספק שילוב בין ספריית הגיליון לבין Jetpack Compose. דוגמה פשוטה לשימוש:

  @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 לא תגרום יותר להפעלה שגויה של IllegalStateException (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 coroutines וב-Flow
• תמיכה בביטול
• אותות מובנים של מצב עומס ושגיאות
• פונקציונליות של ניסיון חוזר ורענון
• כל שלוש המחלקות המשניות של DataSource שולבו לכיתה מאוחדת בשם PagingSource
• טרנספורמציות דפים בהתאמה אישית, כולל טרנספורמציה מובנית להוספת מפרידים
• טעינה של כותרות עליונות ותחתונות של מדינה

גרסה 3.0.0-rc01

21 באפריל 2021

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

תיקוני באגים

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

גרסה 3.0.0-beta03

24 במרץ 2021

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

תיקוני באגים

• שיפרנו את האופן שבו נעשה טיפול בסמלי placeholder כשהרשימה נטענת מחדש, כדי למנוע קפיצות בלתי צפויות ב-RecyclerView. פרטים נוספים זמינים במאמר NullPaddedDiffing.md. (If1490, ‏ b/170027529, ‏ b/177338149)
• ה-builders השונים של PagedList (נתיב התאימות הישן) כבר לא קוראים באופן שגוי לסנכרון של DataSource.Factory.create() בשרשור הראשי כשקוראים ל-.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 בגלל: https://youtrack.jetbrains.com/issue/KT-45227 (I5733c)

תיקוני באגים

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

גרסה 3.0.0-beta01

10 בפברואר 2021

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 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, המערכת מתעלמת מ-loadState המרוחק. האפשרות הזו שימושית בעיקר אם רוצים להציג את מפרידי הקטעים רק כשהקטע נטען במלואו, כולל אחזור ממקור מרוחק, למשל רשת.
  • SOURCE_COMPLETE – רק להמתין ש-PagingSource יסמן את endOfPaginationReached, גם אם נעשה שימוש ב-RemoteMediator. כך אפשר להציג כותרות עליונות ותחתונות באופן סינכרוני עם הטעינה הראשונית, וכך המשתמשים לא צריכים לגלול כדי לראות את התו המפריד של מסוף. (Ibe993, ‏ b/174700218)

תיקוני באגים

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

גרסה 3.0.0-alpha12

13 בינואר 2021

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

שינויים ב-API

• InvalidatingPagingSourceFactory כבר לא היא סוג של כיתה מופשטת, כי אף פעם לא היו לה שיטות מופשטות. (I4a8c4)
• נוספה עומס יתר של ‎ .cachedIn() שמקבל ViewModel במקום Lifecycle או CoroutineScope למשתמשים ב-Java. (I97d81, ‏ b/175332619)
• מאפשרים למבצעי קריאה ב-Java להשתמש בפעולות טרנספורמציה של PagingData באופן אסינכרוני, על ידי קבלת Executor בארגומנטים של אופרטורי הטרנספורמציה. הסיומת -Sync הוסרה מכל אופרטורי הטרנספורמציה של -Sync, ומשתמשי Kotlin Coroutine יצטרכו לבצע הסרת עמימות על ידי קריאה לפונקציית ההרחבה שמקבלת במקום זאת בלוק השהיה. כל אופרטורי הטרנספורמציה של PagingData הועברו להרחבות, בכיתה הסטטית 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 כבר לא פתוחה. אם אתם צריכים לקבל התראה כשהתוקף של המפתח יבוטל, כדאי לקרוא ל-method‏ registerInvalidatedCallback במקום לשנות את invalidate. (I628d9, ‏ b/173029013, ‏ b/137971356)
• ל-Pager יש עכשיו קונסטרוקטור ניסיוני יחיד לצד הקונסטרוקטורים הרגילים שלו, במקום לאפשר זליגה של ממשקי API ניסיוניים לממשק API ציבורי לא ניסיוני באמצעות ההערה להסכמה מראש. (I9dc61, ‏ b/174531520)
• עדכנו את מאפייני הנוחות, CombinedLoadStates.refresh,‏ CombinedLoadStates.prepend ו-CombinedLoadStates.append, כדי לעבור מ-Loading ל-NotLoading רק אחרי שמצבי העומס של המתווך והמקור יהיו NotLoading, כדי לוודא שהעדכון מרחוק הוחל. (I65619)

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

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

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

תיקוני באגים

• תוקנה קריסה שנגרמה בגלל IllegalStateException כשמשתמשים בפסיקים עם ההגדרה PagingConfig.maxSize. (I0ed33, ‏ b/174787528)
• תוקן באג שבו מצב הטעינה של PREPEND / APPEND לא מתעדכן ל-NotLoading(endOfPaginationReached = true) מיד אחרי הטעינה הראשונית אם RemoteMediator הוגדר (I8cf5a)
• תוקן באג שבו ממשקי API בצד המציג, כמו ‎.snapshot(), ‏ ‎.peek() וכו', היו מחזירים את הרשימה הקודמת (לא עדכנית) בעדכונים של ListUpdateCallback.
• תוקן באג שבו אופרטורים של Separators לא הוסיפו כותרות עליונות או תחתונות כשנעשה בהם שימוש עם RemoteMediator
• תוקן באג שבו עדכוני LoadState ל-NotLoading ב-RemoteMediator נתקעו בסטטוס Loading
• תוקנה באג שבו ממשק ה-API לתאימות ל-Paging2.0, .asPagingSourceFactory(), עלול לגרום להפעלה של DataSource התומך ב-CoroutineDispatcher שגוי. כך ניתן לפתור קריסות ומקרים אפשריים של ANR, במיוחד כשמשתמשים בהטמעה הנוכחית של Room ל-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)

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

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

בעיות מוכרות

• יכול להיות שכותרות עליונות ותחתונות מהטרנספורמציה insertSeparators() לא יופיעו מיד כשמשתמשים ב-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

• הוצאה משימוש מלאה של שיטות dataRefreshFlow / Listener באמצעות תנאי replaceWith. (I6e2dd)

תיקוני באגים

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

גרסה 3.0.0-alpha08

28 באוקטובר 2020

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

שינויים ב-API

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

תיקוני באגים

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

גרסה 3.0.0-alpha07

1 באוקטובר 2020

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

שינויים ב-API

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

תיקוני באגים

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

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

• תודה ל-@simonschiller על הוספת אופרטורים של טרנספורמציה אסינכרונית מבוססת-Guava ל-RxJava2, ל-RxJava3 ול-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)

תיקוני באגים

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

גרסה 3.0.0-alpha05

19 באוגוסט 2020

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

תיקוני באגים

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

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

• תודה ל-Clara F על העזרה בניקוי כמה בדיקות! (549612)

גרסה 3.0.0-alpha04

5 באוגוסט 2020

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

שינויים ב-API

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

תיקוני באגים

• PositionalDataSource שהומר ל-PagingSource באמצעות ה-helper‏ toPagingSourceFactory, כולל PagingSource שנוצר על ידי Room, מסומנים עכשיו בצורה נכונה כדי לתמוך באפשרות של דילוג. (I3e84c, ‏ b/162161201)
• תוקן באג שבו שימוש בגרסת submitData הסכנכרונית לפעמים מוביל לתחרות (race) שגורמת ל-ClosedSendChannelException (I4d702, ‏ b/160192222)

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

• תודה ל-Zac Sweers על הוספת חבילות עטיפה לתאימות ל-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 הוא עכשיו ציבורי, כך שקל יותר לבדוק הטמעות של getRefreshKey()‎ (I8bf15)
• הוסתרו וריאציות של פונקציית המפה של DataSource ב-Kotlin מ-Java, כדי לפתור את אי-הבהירות בין הווריאציות המקוריות לבין הווריאציות של Kotlin. (If7b23, ‏ b/161150011)
• ממשקי API מיותרים שנועדו להקל על משתמשי Kotlin סומנו בתווית @JvmSynthetic (I56ae5)
• נוספו עומסי יתר ל-constructor של LoadResult.Page, שמגדירים את הערך של itemsBefore ו-itemsAfter ל-COUNT_UNDEFINED כברירת מחדל (I47849)
• שינינו את האופן שבו אופרטורים קיימים של PagingData מקבלים שיטות השהיה, והוספנו אופרטורים חדשים ללא השהיה: mapSync, ‏ flatMapSync ו-filterSync למשתמשים ב-Java. שיטות הטרנספורמציה הקיימות הועברו לפונקציות הרחבה, כך שמשתמשי Kotlin יצטרכו לייבא אותן עכשיו. (I34239, ‏ b/159983232)

תיקוני באגים

• מעכשיו, ב-Room (וב-PositionalDataSource) יוצג מפריד בתחילת הדף הראשון, כדי שהמשתמשים לא יצטרכו לגלול כדי לראות אותו. (I6f747, ‏ b/160257628)
• גישה לפריטים במשתני placeholder מפעילה עכשיו נכון את הטעינות של PagingSource עד שחוזרים לדף שעומד בדרישות האינדקס המבוקש אחרי שהוא עובר טרנספורמציה על ידי PagingData.filter()‏ (I95625, ‏ b/158763195)
• תיקון באג שבו לפעמים גלילה אחרי ש-PagingSource מחזיר שגיאה מונעת מ-PagingDataAdapter.retry() לנסות שוב. (I1084f, ‏ b/160194384)
• תוקנה בעיה שבה ייתכן שלא ייטענו דפים אחרי ביטול הבחירה בדף, למרות שגישת הפריט הייתה בטווח prefetchDistance (Ie95ae,‏ b/160038730)
• הגדרת PagingConfig.maxSize כבר לא מפעילה placeholders אחרי אירוע השמטה (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)
• נוספו עומסי יתר למקלטי ה-constructor של PagingDataAdapter ו-AsyncPagingDataDiffer עם ערכי ברירת מחדל נפוצים (Ie91f5)
• ממשקי ה-API של המתאם, dataRefreshFlow ו-dataRefreshListener, מעבירים עכשיו ערך בוליאני כדי לסמן אם PagingData ריק (I6e37e,‏ b/159054196)
• נוספו ממשקי API של RxJava ו-Guava ל-RemoteMediator – RxRemoteMediator ו-ListenableFutureRemoteMediator
• נוספו פונקציות עזר ל-PagingState לגישה לפריטים נפוצים כמו isEmpty() ו-firstItemOrNull() (I3b5b6, ‏ b/158892717)

תיקוני באגים

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

גרסה 3.0.0-alpha01

10 ביוני 2020

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

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

תכונות חדשות בגרסה 3.0

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

בעיות מוכרות

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

גרסה 2.1.2

גרסה 2.1.2

18 במרץ 2020

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

תיקוני באגים

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

דיווח על בעיה בגרסת build

• גרסה 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 מושבתים

גרסה

גרסה

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 לכל ארטיפקט – וגם כמה שינויים אחרים ב-API ותיקוני באגים.

שינויים ב-API

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

תיקוני באגים

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

גרסה 2.0.0

גרסה 2.0.0

1 באוקטובר 2018

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

תיקוני באגים

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

גרסה 2.0.0-beta01

2 ביולי 2018

תיקוני באגים

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

יחסי תלות מהתקופה שלפני AndroidX

לגרסאות הקודמות של Paging ב-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 לצורך יציבות. גם 1.0.1 של דפדוף ב-RxJava2 שוחרר, והוא זהה ל-1.0.0-rc1.

תיקוני באגים

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

RxJava2 גרסה 1.0.0

RxJava2 גרסה 1.0.0-rc1

16 במאי 2018

ה-paging של 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

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

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

הספרייה החדשה הזו מספקת חלופה ל-LivePagedListBuilder ב-RxJava2, שיכולה ליצור אובייקטים מסוג 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 מתווסף באמצעות הארטיפקט החדש android.arch.paging:rxjava2.

שינויים ב-API

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

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

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

• חבר PagedList.mCallbacks הוגדר כפרטי.

תיקוני באגים

• LivePagedListBuilder מפעיל עומס PagedList ראשוני במבצע (executor) שצוין, במקום במאגר השרשור של IO של Arch Components.

• תוקנה ההתנהגות של ביטול התוקף ברכיבי העטיפה הפנימיים של DataSource (שמשמש להטמעת DataSource.map, וגם לטעינת PositionalDataSource עם Placeholder מושבת) b/77237534

גרסה 1.0.0-alpha7

21 במרץ 2018

דף הבית 1.0.0-alpha7 משוחרר יחד עם Lifecycles 1.1.1. מכיוון ש-Paging alpha7 תלוי בהעברה של הכיתה Function שצוינה למעלה, תצטרכו לעדכן את התלות של lifecycle:runtime ב-android.arch.lifecycle:runtime:1.1.1.

alpha7 היא הגרסה האחרונה של Paging לפני שהיא תעבור לגרסת בטא.

שינויים ב-API

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

תיקוני באגים

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

גרסה 1.0.0-alpha5

22 בינואר 2018

תיקוני באגים

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