חלוקה לדפים

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

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

פריט מידע שנוצר בתהליך פיתוח (Artifact) גרסה יציבה גרסה מועמדת להפצה גרסת בטא גרסת אלפא
paging-*‎ 3.5.3 - - ‎3.6.0-alpha01
paging-compose 3.5.3 - - ‎3.6.0-alpha01
הספרייה הזו עודכנה לאחרונה ב-18 בנובמבר 2026

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

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

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

Groovy

dependencies {
  def paging_version = "3.5.3"

  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.5.3"
}

Kotlin

dependencies {
  val paging_version = "3.5.3"

  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.5.3")
}

למידע על השימוש בתוספים של Kotlin, עיינו במסמכי התיעוד של ktx.

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

משוב

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

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

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

גרסה 3.6

גרסה ‎3.6.0-alpha01

‫18 בנובמבר 2026

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

שינויים ב-API

  • נוספו ItemSnapshotList תוספים ל-Lazy foundations. עכשיו אפשר להפעיל את ItemSnapshotList#itemKey ו-ItemSnapshotList#itemContentType כדי ליצור באופן אוטומטי את itemKey ו-contentType ל-Lazy foundation. (I73455,‏ b/560754841)

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

  • תודה לכמאל על הוספת התוספים של ItemSnapshotList.

גרסה 3.5

גרסה 3.5.3

‫12 באוקטובר 2026

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

תיקוני באגים

  • הפונקציה ItemSnapshotListFlow לא תפעיל יותר את IllegalArgumentException כש-RemoteMediator מגיע לסוף העימוד בכל כיוון, וכותרת עליונה או כותרת תחתונה מומרת למפריד סופי. (I821c7, b/566336825)
  • כשהדפים שנטענו חורגים מ-PagingConfig.maxSize, הדפים שנטענו לא ירדו מתחת לשני דפים כדי לוודא שחלון התצוגה מאוכלס כראוי בנתונים. (I037a0, b/565835910)

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

תודה ל-Igor על שליחת התיקון לבאג b/565835910

גרסה 3.5.2

‫7 באוקטובר 2026

‫androidx.paging:paging-*:3.5.2 מופץ. גרסה 3.5.2 מכילה את ה-commits האלה.

תיקוני באגים

  • קריאות ל-Pager.append() לפני שהרענון הראשוני מסתיים לא יגרמו יותר לשגיאה NoSuchElementException. הקריאה ל-append תהיה ללא פעולה. (Ide387,‏ b/556780796)

גרסה 3.5.1

‫12 באוגוסט 2026

‫androidx.paging:paging-*:3.5.1 מופץ. גרסה 3.5.1 מכילה את ה-commits האלה.

תיקוני באגים

  • תוקנה הבעיה שבה PagingSource.getRefreshKey סיפק anchorPosition שגוי וגדול מדי בזמן רענון דף עם מפרידים תוך כדי גלילה אל פלייסהולדרים. (I475f0,‏ b/516565503)

גרסה 3.5.0

‫6 במאי 2026

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

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

  • נוסף האופרטור Flow<PagingData>.asItemSnapshotListFlow כדי להמיר את Flow<PagingData> ל-Flow<ItemSnapshotList>. כלומר, עכשיו אפשר לגשת לנתונים שנטענו מחוץ לשכבת ממשק המשתמש, לשלב את Flow<ItemSnapshotList> עם מקורות נתונים אחרים, לשמור במטמון ולשנות נתונים שחולקו לדפים באופן מקומי, או לחשוף נתונים שחולקו לדפים כחלק ממצב ממשק המשתמש ועוד.

  • הוספנו את פונקציות התוסף Pager.append ו-Pager.prepend כדי לטעון עוד נתונים באופן ידני בלי לגלול.

  • הוספנו את פונקציות ההרחבה Pager.refresh ו-Paging.retry כדי להתאושש משגיאות טעינה כשמשתמשים ב-API של asItemSnapshotListFlow.

גרסה ‎3.5.0-rc01

‫22 באפריל 2026

‫androidx.paging:paging-*:3.5.0-rc01 מופץ. גרסה 3.5.0-rc01 מכילה את ה-commits האלה.

ללא שינוי

  • אין שינויים משמעותיים מגרסה 3.5.0-beta01.

גרסה ‎3.5.0-beta01

‫8 באפריל 2026

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

שינויים ב-API

  • ה-API‏ Flow<PagingData>.asState נקרא עכשיו Flow<PagingData>.asItemSnapshotListFlow (I0dc11,‏ b/496548025)

גרסה ‎3.5.0-alpha01

‫11 במרץ 2026

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

תכונות חדשות

  • הארטיפקט paging-common מכיל עכשיו אופרטור זרימה חדש של asState ב-Flow<PagingData> כדי להמיר אותו ל-Flow<ItemSnapshotList>. הדוחות המתקדמים האלה מספקים לכם תובנות נוספות, כמו:

    • לשלב את הנתונים של ItemSnapshotList עם מקורות נתונים אחרים
    • שיתוף תהליך עם כמה אוספים בלי cachedIn
    • לשמור במטמון נתונים מדופדפים באופן מקומי
    • לשנות נתונים בדפים בזיכרון
    • לחשוף נתונים מחולקים לדפים כחלק ממצב של ממשק משתמש
    // In your ViewModel
    val pager = Pager(pagingConfig, pagingSourceFactory)
    val pagerFlow = pager.flow.asState()
    
    // alterantively convert the flow to a SharedFlow
    val pagerFlow = pager.flow.asState().stateIn()
    
    // In presenter layer
    val snapshotFlow = viewModel.pagerFlow.collectAsStateWithLifecycle(initialList)
    val snapshot = itemsFlow.value
    
    LazyColumn {
    items(items = snapshot.items) { ... }
    }
    
  • פריט המידע שנוצר באופן מלאכותי paging-common הוסיף גם ממשקי API מסוג Pager.append ו-Pager.prepend כדי להפעיל באופן ידני טעינות בכל אחד מהקצוות של הפריטים שנטענו.

    • כשמשתמשים ב-paging-runtime או ב-paging-compose, יש חלופה לטעינת נתונים נוספים מלבד גלילה
    • כשמשתמשים בו עם ה-API החדש של asState, זו הדרך היחידה לטעון עוד נתונים
    LazyColumn {
    item {
           /**
           * Load more items when users scroll near the top of loaded items.
           */
           LaunchedEffect(viewModel) { viewModel.prepend() }
        }
    items(snapshot.items) { item -> Text("Item: $item") }
    item {
            /**
            * Load more items when users scroll near the bottom of loaded items.
            */
          LaunchedEffect(viewModel) { viewModel.append() }
      }
    }
    
  • הוספנו את Pager.refresh ואת Pager.retry כדי להתאושש משגיאות טעינה כשמשתמשים ב-API של asState. במסמך הזה מפורטות דוגמאות נוספות לשימוש בממשקי ה-API החדשים. (I1e1e9, If3c87, Idbd48, Id1e1d, I816fe)

גרסה 3.4

גרסה 3.4.2

‫11 במרץ 2026

‫androidx.paging:paging-*:3.4.2 מופץ. גרסה 3.4.2 מכילה את ה-commits האלה.

ללא שינוי

  • בגרסה הזו אין שינויים ב-API או בהתנהגות בהשוואה לגרסה 3.4.1.

גרסה 3.4.1

‫11 בפברואר 2026

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

עדכון של יחסי תלות

  • עודכנה התלות של paging-guava ב-guava מגרסה 31.1 לגרסה 32.0.1.

גרסה 3.4.0

‫28 בינואר 2026

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

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

  • נוספו עוד יעדי KMP אל paging-common,‏ paging-testing ו-paging-compose. עכשיו כולם תומכים ב-JVM (‏Android ומחשב), ב-Native (‏Linux,‏ iOS,‏ watchOS,‏ tvOS,‏ macOS,‏ MinGW) ובאינטרנט (JavaScript,‏ WasmJS)
  • ‫paging-common,‏ paging-testing ו-paging-compose הסירו את התמיכה ב-macosX64,‏ iosX64,‏ watchosX64 ו-tvosX64 כדי להתאים להוצאה משימוש של יעדי macosX64 על ידי Jetbrains.
  • הוספנו PagingState API closestItemAroundPosition חדש כדי לאחזר את הפריט שנטען שהכי קרוב למיקום היעד ותואם לפרדיקט הקלט. אפשר להשתמש בזה כדי ליצור מפתחות רענון שמבוססים על פריטים, כשהפריט האידיאלי לעיגון נמצא בסביבה אבל לא במיקום המדויק של היעד.

גרסה ‎3.4.0-rc01

‫14 בינואר 2026

‫androidx.paging:paging-*:3.4.0-rc01 מופץ. גרסה ‎3.4.0-rc01 מכילה את ה-commits האלה.

תכונות חדשות

גרסה ‎3.4.0-beta01

‫17 בדצמבר 2025

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

תיקוני באגים

  • תיקון מצב המרוץ בין הטעינות של RecyclerView ו-Refresh שמוביל ל-IndexOutOfBoundsException ב-RecyclerView. עדכונים של ממשק המשתמש שנקטעו בגלל טעינות רציפות של Refresh יכולים לגרום למצב של חוסר סנכרון בין מצב חלוקת הדפים לבין RecyclerView. כדי לתקן את הבעיה, צריך לאפס את העימוד למצב שלפני הרענון אם הרענון הופסק (למשל, בגלל טעינה רציפה של Refresh). (I771b0,‏ b/409809768)

גרסה ‎3.4.0-alpha04

‫10 בספטמבר 2025

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

שינויים ב-API

  • הוספנו PagingState API closestItemAroundPosition חדש כדי לאחזר את הפריט שנטען שהכי קרוב למיקום היעד ותואם לפרדיקט הקלט. אפשר להשתמש בזה כדי ליצור מפתחות רענון שמבוססים על פריטים, כשהפריט האידיאלי לעיגון נמצא בסביבה אבל לא במיקום המדויק של היעד. (I96e5c,‏ b/440187139)

גרסה 3.4.0-alpha03

‫27 באוגוסט 2025

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

תכונות חדשות

  • ב-Paging-common נוסף מחשב כיעד חדש של Kotlin Multiplatform ‏(KMP). בסך הכול, הוא תומך עכשיו ב-JVM (Android ומחשב), ב-Native (Linux, ‏ iOS, ‏ watchOS, ‏ tvOS, ‏ macOS,‏ MinGW) ובאינטרנט (JavaScript, ‏ WasmJS). (Id2483,‏ b/436884811)
  • ב-Paging-testing נוספו יעדים חדשים של Kotlin Multiplatform ‏(KMP). בסך הכול, הוא תומך עכשיו ב-JVM (Android ומחשב), ב-Native (Linux, ‏ iOS, ‏ watchOS, ‏ tvOS, ‏ macOS,‏ MinGW) ובאינטרנט (JavaScript, ‏ WasmJS). (I0c543, b/435014650)
  • נוספו יעדים חדשים של Kotlin Multiplatform‏ (KMP) ל-Paging-compose. בסך הכול, הוא תומך עכשיו ב-JVM (Android ומחשב), ב-Native (Linux, ‏ iOS, ‏ watchOS, ‏ tvOS, ‏ macOS,‏ MinGW) ובאינטרנט (JavaScript, ‏ WasmJS). (I70d44,‏ b/436884801)

שינויים ב-API

גרסה ‎3.4.0-alpha02

‫30 ביולי 2025

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

שינויים ב-API

  • עכשיו אפשר להגדיר את placeholdersBefore ו-placeholdersAfter ב-PagingData.from. חשוב לזכור שגלילה בין הפלייסהולדרים האלה לא מפעילה טעינות. (I06983)

גרסה ‎3.4.0-alpha01

‫2 ביולי 2025

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

תכונות חדשות

תיקוני באגים

  • בדיקות יחידה ב-Android שכוללות את Paging 3.3 ואילך לא יזרקו יותר חריגות מ-PagingLogger (Ia9400,‏ b/331684448)
  • תוקן באג שבו RecyclerView זורק IndexOutOfBoundsException כשהמשתמש גולל בזמן עדכון RecyclerView (Id1f16,‏ b/381024738)
  • תוקן באג שבו הדפדוף לא הצליח להפעיל טעינות נוספות בזמן רענון תוך כדי גלילה. (I60ca5, b/352586078)
  • תוקנה קריסה שהתרחשה כשגוללים בזמן רענון של פריטים בדף. (I8c65a, b/347649763)

גרסה 3.3

גרסה 3.3.6

‫12 בפברואר 2025

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

תיקוני באגים

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

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

  • תודה ל-Eva על שליחת תיקון הבאג (#754)

גרסה 3.3.5

‫11 בדצמבר 2024

‫androidx.paging:paging-*:3.3.5 מופץ. גרסה 3.3.5 מכילה את ה-commits האלה.

תיקוני באגים

  • תוקן באג שבו RecyclerView זורק IndexOutOfBoundsException כשהמשתמש גולל בזמן עדכון RecyclerView. (Id1f16, b/381024738)

‫3.3.4 ומעלה

‫13 בנובמבר 2024

‫androidx.paging:paging-*:3.3.4 מופץ. גרסה 3.3.4 מכילה את ה-commits האלה.

תיקוני באגים

  • בדיקות יחידה ב-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 מכילה את ה-commits האלה.

תכונות חדשות

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

תאימות ל-Kotlin Multiplatform

עכשיו אפשר להשתמש ב-Paging כדי לשלוח פריטי מידע שנוצרו בתהליך הפיתוח (artifacts) שתואמים ל-Kotlin Multiplatform, בעיקר בזכות העבודה שנעשתה בפרויקט multiplatform-paging של 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 הושקה ללא שינויים ב-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 מכילה את ה-commits האלה.

גרסה ‎3.3.0-alpha05

‫20 במרץ 2024

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

שינויים ב-API

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

גרסה ‎3.3.0-alpha04

6 במרץ 2024

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

תיקוני באגים

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

גרסה ‎3.3.0-alpha03

‫7 בפברואר 2024

‫androidx.paging:paging-*:3.3.0-alpha03 מופץ. גרסה 3.3.0-alpha03 מכילה את השינויים האלה.

תכונות חדשות

  • הכיתה PagingDataPresenter היא עכשיו כיתה ציבורית. עכשיו אפשר ליצור מציגים מולטי-פלטפורמה על גבי PagingDataPresenter במקום לדרוש ממשקי API פנימיים של Paging או 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 Multiplatform

עכשיו אפשר להשתמש ב-Paging כדי לשלוח פריטי מידע שנוצרו בתהליך הפיתוח (artifacts) שתואמים ל-Kotlin Multiplatform, בעיקר בזכות העבודה שנעשתה בפרויקט multiplatform-paging של 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

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

גרסה 3.2.0

26 ביולי 2023

‫androidx.paging:paging-*:3.2.0 מופץ. גרסה 3.2.0 מכילה את השינויים האלה.

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

  • ‫Paging Compose הגיע ליציבות של API ומוזג בחזרה לשאר חלקי Paging, שבהם הגרסה שלו תואמת עכשיו לכל שאר פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) של Paging. השינויים שבוצעו מאז גרסה 3.1.0 כוללים:
    • תמיכה בתצוגה מקדימה של רשימת נתונים מזויפים על ידי יצירת PagingData.from(fakeData) וגלישת PagingData ב-MutableStateFlow (למשל MutableStateFlow(PagingData.from(listOf(1, 2, 3)))). מעבירים את התהליך הזה לרכיבי @Preview כנמען של collectAsLazyPagingItems() לתצוגה מקדימה.
    • תמיכה בכל פריסות הטעינה הlazy, כמו LazyVerticalGrid ו-HorizontalPager, וגם ברכיבי טעינה lazy בהתאמה אישית מספריות Wear ו-TV. השגנו את זה באמצעות שיטות חדשות להרחבת LazyPagingItems ברמה נמוכה יותר, itemKey ו-itemContentType, שעוזרות להטמיע את הפרמטרים key ו-contentType בממשקי ה-API הרגילים של items שכבר קיימים ב-LazyColumn, ב-LazyVerticalGrid ובמקבילים שלהם בממשקי API כמו HorizontalPager.
    • התמיכה ב-items(lazyPagingItems) וב-itemsIndexed(lazyPagingItems), שתומכים רק ב-LazyListScope, הופסקה.
  • פריט מידע חדש שנוצר בתהליך הפיתוח (paging-testing) שמספק ממשקי API שנועדו לבדיקת יחידות של כל שכבה באפליקציה והשילוב שלה עם Paging בנפרד. לדוגמה, הוא כולל
    • TestPager שמאפשרת לאמת את ההתנהגות של ההטמעה בהתאמה אישית של PagingSource, בלי קשר לכלי לדפדוף ולממשק המשתמש האמיתי.
    • ​​ממשקי API של asPagingSourceFactory להמרת 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]. ההנחיה הזו רלוונטית גם לעימוד עם תצוגות וגם לעימוד עם Compose.
  • נוספו פונקציות בונות ל-PagingDataAdapter ול-AsyncPagingDataDiffer שמקבלות את CoroutineContext במקום את CoroutineDispatcher.
  • הוספנו ממשק פונקציונלי חדש של PagingSourceFactory שמספק ממשק API מפורש יותר מהביטויים הקודמים של למבדה ‎() -> PagingSource. אפשר להשתמש במפעל הזה כדי ליצור מופע של כלי לדפדוף.

גרסה ‎3.2.0-rc01

‫21 ביוני 2023

‫androidx.paging:paging-*:3.2.0-rc01 מופץ. גרסה 3.2.0-rc01 מכילה את השינויים האלה.

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

  • תודה ל-Veyndan על התרומה להעברת Paging מפרטים של 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

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

שינויים ב-API

גרסה ‎3.2.0-alpha06

‫24 במאי 2023

‫androidx.paging:paging-*:3.2.0-alpha06 מופץ. גרסה 3.2.0-alpha06 מכילה את השינויים האלה.

תכונות חדשות

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

שינויים ב-API

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

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

  • כבר לא צריך את ה-dispatcher הראשי כדי להריץ בדיקות של asSnapshot Paging. ההגדרה הזו כבר לא משנה את אופן הפעולה של הבדיקה. (Ie56ea)

גרסה ‎3.2.0-alpha05

‫3 במאי 2023

‫androidx.paging:paging-*:3.2.0-alpha05 מופץ. גרסה 3.2.0-alpha05 מכילה את השינויים האלה.

שינויים ב-API

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

שיפורים בתיעוד

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

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

גרסה ‎3.2.0-alpha04

‫8 בפברואר 2023

‫androidx.paging:paging-*:3.2.0-alpha04 מופץ. גרסה 3.2.0-alpha04 מכילה את השינויים האלה.

בדיקת חלוקה לדפים

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

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

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

צריך להתייחס ל-TestPager כאל זיוף – כפיל בדיקה שמשקף את ההטמעה האמיתית של Pager, תוך מתן ממשק API פשוט לבדיקת PagingSource. ממשקי ה-API האלה הם ממשקי API מסוג suspend וצריך להריץ אותם בתוך 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)

תיקוני באגים

  • תוקנה השגיאה של ה-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)

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

  • עודכן ה-API של ‎ :compose:ui:ui-test‏ (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 מ-Paging ממתין עכשיו לערכים תקינים גם מ-PagingSource וגם מ-RemoteMediator לפני שהוא פולט במורד הזרם. דורות חדשים של PagingData יתחילו עכשיו תמיד בצורה נכונה עם Loading למצב רענון, במקום לאפס ל-NotLoading באופן שגוי במקרים מסוימים.
    • ‫.loadStateFlow ו-.addLoadStateListener בממשקי ה-API של המציג כבר לא שולחים באופן מיותר CombinedLoadStates ראשוני שתמיד מוגדרים בו מצבי מגשר ל-null
  • עכשיו, כשמבטלים גרסאות קודמות, הביטול מתבצע באופן מיידי כשמבטלים את התוקף או כשיוצרים גרסאות חדשות. לא אמור להיות יותר צורך להשתמש ב-.collectLatest ב-Flow<PagingData>, אבל עדיין מומלץ לעשות זאת.
  • PagingSource.LoadResult.Invalid נוסף כסוג החזרה חדש מ-PagingSource.load, מה שגורם ל-Paging למחוק את כל בקשות הטעינה בהמתנה או העתידיות ל-PagingSource הזה ולבטל אותו. סוג ההחזרה הזה נועד לטפל בנתונים שעלולים להיות לא חוקיים או לא עדכניים, שמוחזרים ממסד הנתונים או מהרשת.
  • הוספנו את ממשקי ה-API של המציג .onPagesPresented ו-.addOnPagesUpdatedListener, שמופעלים באופן סינכרוני כשהדפים מוצגים בממשק המשתמש. עדכוני דפים יכולים להתרחש בתרחישים הבאים:
    • הטעינה הראשונית של דור חדש של PagingData הושלמה, גם אם הדור החדש מכיל שינויים בפריטים המוצגים. כלומר, הקריאה החוזרת הזו תופעל גם אם דור חדש ישלים את הטעינה הראשונית בלי עדכונים כי הרשימה זהה לחלוטין.
    • דף נוסף, גם אם הדף שנוסף לא מכיל פריטים חדשים.
    • הדף יוסר, גם אם הוא היה ריק.

גרסה ‎3.1.0-rc01

‫3 בנובמבר 2021

‫androidx.paging:paging-*:3.1.0-rc01 מופץ. גרסה 3.1.0-rc01 מכילה את השינויים האלה.

תיקוני באגים

  • תוקן מרוץ תהליכים ודליפת זיכרון ב-‎ .cachedIn()‎ במקרים שבהם נשלחו כמה אירועי טעינה על ידי Paging downstream כשאין משקיפים או בין הזמן שבו משקיף עובר ל-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 מכילה את השינויים האלה.

שינויים ב-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 לפני שהוא פולט במורד הזרם בין דורות. השינוי הזה מונע שליחה של NotLoading ב-CombinedLoadStates.source.refresh על ידי דורות חדשים של PagingData אם הוא כבר היה 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. כש-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 כדי לבדוק את סוג ההחזרה יצטרכו להוסיף בדיקה של סוג לא חוקי. (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 של flow presenter ושל מאזין onPagesPresented, שמופעלים מיד אחרי שהדפים המוצגים מתעדכנים בממשק המשתמש.

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

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

    • הטעינה הראשונית של דור חדש של PagingData מסתיימת, גם אם הדור החדש לא מכיל שינויים בפריטים המוצגים. כלומר, הפונקציה החוזרת הזו תופעל גם אם דור חדש משלים טעינה ראשונית בלי עדכונים, כי הרשימה זהה לחלוטין.
    • דף נוסף, גם אם הדף שנוסף לא מכיל פריטים חדשים
    • דף נמחק, גם אם הדף שנמחק היה ריק (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 שלח אירועי no-op differ ל-RecyclerView, מה שיכול היה לגרום למאזינים מסוימים לפעול מוקדם מדי. (Ic507f, b/182510751)

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

  • נוספו ממשקי API תואמים של PagedList שהוצאו משימוש לארטיפקט 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 מכילה את השמירות האלה.

תכונות חדשות

  • עכשיו אפשר להציג ב-Paging Compose תצוגה מקדימה של רשימת נתונים מזויפים. כדי לעשות את זה, יוצרים 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 עם פריסות אחרות של טעינה מדורגת כמו LazyVerticalGrid, HorizontalPager או רכיבים אחרים של טעינה מדורגת בהתאמה אישית שסופקו על ידי ספריות Wear ו-TV. העדכון העיקרי בגרסה הזו נועד לפתור את חוסר הגמישות הזה.

כדי לתמוך בפריסות עצלות נוספות, היינו צריכים ליצור ממשקי API בשכבה אחרת – במקום לספק ממשק API מותאם אישית של items לכל פריסה עצלה, 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 מכילה את השינויים האלה.

תכונות חדשות

  • עכשיו אפשר לקבל יומנים דרך המחלקה 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), שמשמשים לחיבור של Paging עם 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 מכילה את השינויים האלה.

תיקוני באגים

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

תאימות של Compose

  • ‫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 מכילה את השינויים האלה.

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

גרסה 1.0.0-alpha07

‫10 בפברואר 2021

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

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

תיקוני באגים

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

תכונות חדשות

רכיב ה-artifact של 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, כדי להביא את השיפורים הבאים:

  • תמיכה מעולה בשגרות המשך (coroutine) וב-Flow של Kotlin
  • תמיכה בביטול
  • אותות מובְנים לגבי מצב הטעינה ושגיאות
  • פונקציונליות של ניסיון חוזר ורענון
  • כל שלוש מחלקות המשנה של DataSource שולבו במחלקת PagingSource מאוחדת
  • טרנספורמציות מותאמות אישית של דפים, כולל טרנספורמציה מובנית להוספת מפרידי מודעות
  • כותרות עליונות ותחתונות של מצב טעינה

גרסה ‎3.0.0-rc01

‫21 באפריל 2021

‫androidx.paging:paging-*:3.0.0-rc01 מופץ. גרסה 3.0.0-rc01 מכילה את השינויים האלה.

תיקוני באגים

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

גרסה ‎3.0.0-beta03

‫24 במרץ 2021

‫androidx.paging:paging-*:3.0.0-beta03 מופץ. גרסה 3.0.0-beta03 מכילה את השינויים האלה.

תיקוני באגים

  • שינינו את אופן הטיפול בפלייסהולדרים כשהרשימה נטענת מחדש, כדי למנוע קפיצות לא צפויות ב-RecyclerView. פרטים נוספים מופיעים בקובץ NullPaddedDiffing.md. (If1490, b/170027529, b/177338149)
  • הכלים השונים ליצירת 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. בעבר הן סומנו ב-method‏ @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 חושפות עכשיו את ההערה הניסיונית שהן תלויות בה. אם אתם משתמשים ברכיבי wrapper תואמי Rx ב-paging-rxjava2 או ב-paging-rxjava3, תצטרכו להוסיף הערות לשימושים באמצעות @OptIn(ExperimentalCoroutinesApi::class) (Ib1f9d)

תיקוני באגים

  • תוקנה השגיאה IndexOutOfBoundsException: Inconsistency detected שלפעמים נזרקה כשמשתמשים בממשקי API של DataSource בגרסה 2 דרך נתיבי תאימות
  • קריאות ל-isInvalid במהלך ההפעלה של DataSource כשמשתמשים בנתיבי תאימות מופעלות עכשיו בצורה תקינה ב-fetchDispatcher במקום בשרשור הראשי. הפעולה הזו מתקנת IllegalStateException שנגרם בגלל גישה למסד הנתונים ב-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() צריכה להיות הטמעה אמיתית שמחזירה מפתח שמבוסס על מיקום הגלילה הנוכחי של המשתמש, שמאפשר ל-Paging להמשיך לטעון את התוכן במרכז אזור התצוגה דרך 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 מכילה את השמירות האלה.

תכונות חדשות

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

שינויים ב-API

  • thought ‫PagingSource.getRefreshKey() הוא עכשיו API יציב (I22f6f,‏ b/173530980)
  • הפונקציה PagingSource.invalidate כבר לא פתוחה. אם אתם צריכים לקבל התראה כשמתרחשת פסילה, כדאי להפעיל את השיטה 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, שיגדירו באופן פנימי את ה-PageSize הנכון לשיטות הטעינה של DataSource. (I98ac7, b/149157296)

תיקוני באגים

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

גרסה 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() שמעביר את הפעולה 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 שנזרק כשמשתמשים במפרידים עם 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)

תיקוני באגים

  • האינטראקציה של Paging עם ViewPager שופרה באופן משמעותי. באופן ספציפי, Paging לא יבטל יותר קריאה ל-RemoteMediator#load בגלל ביטול תוקף של דף. בנוסף, היא לא תשלח יותר בקשת טעינה של הוספה לפני או אחרי, אם נדרש REFRESH, עד שבקשת ה-REFRESH תושלם בהצלחה. (I6390b, b/162252536)
  • בדיקת ה-lint של ה-API ל-MissingGetterMatchingBuilder מופעלת ל-androidx‏ (I4bbea,‏ b/138602561)
  • תוקן באג שבו רכיבי העזר של .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)
  • תוקן מרוץ תהליכים בהמרה של DataSource -> PagingSource שעלול לגרום ל-PagingSource שנוצר להתעלם מאותות ביטול מ-DataSource.
  • תוקנה בעיה בלוגיקה של אחזור הדפים, שלפעמים גרמה לכך שהיא לא הצליחה לאסוף דורות חדשים של PagingSource עד להפעלת PagingDataAdapter.refresh()‎
  • תוקנה בעיה שגרמה לפעמים לאובדן של מיקום הגלילה כשמשתמשים ב-DataSource שהומר ל-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)

תיקוני באגים

  • הפונקציה 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

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

תיקוני באגים

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

תיקוני באגים

  • מקורות PagingSource של Room (ו-PositionalDataSource) יציגו עכשיו מפריד מוביל כחלק מהדף הראשון, כך שהמשתמש לא צריך לגלול כדי לחשוף אותו. (I6f747, b/160257628)
  • גישה לפריטים בפלייסהולדרים מפעילה עכשיו בצורה תקינה טעינות של PagingSource עד שמוחזר דף שממלא את האינדקס המבוקש אחרי שהוא עובר טרנספורמציה על ידי PagingData.filter()‎‏ (I95625, b/158763195)
  • תיקון באג שבו לפעמים גלילה אחרי ש-PagingSource מחזיר שגיאה עלולה למנוע מ-PagingDataAdapter.retry()‎ לנסות שוב. (I1084f, b/160194384)
  • תוקנה בעיה שבה גישה לפריטים אחרי הסרת דף לא טענה דפים, למרות שהגישה לפריט הייתה בטווח של prefetchDistance‏ (Ie95ae,‏ b/160038730)
  • הגדרת PagingConfig.maxSize לא מפעילה יותר פלייסהולדרים אחרי אירוע שחרור (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)

תיקוני באגים

  • הכלי לדפדוף בודק עכשיו אם יש שימוש חוזר ב-PagingSource ב-factory, כדי למנוע שימוש חוזר מקרי ב-PagingSource לא תקין, שגרם לשגיאה לא ברורה (I99809, b/158486430)
  • כשלים ב-REFRESH של RemoteMediator לא מונעים יותר את הטעינה של 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 מכילה את השינויים האלה.

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

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

בעיות מוכרות

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

  • גרסה 2.1.2 של Paging מכילה את התיקון למרכוז הטעינה שפורסם במקור בגרסה 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 מתמקדות עכשיו בגישה האחרונה כשפלייסהולדרים מושבתים

גרסה 2.1.0

גרסה 2.1.0

‫25 בינואר 2019

גרסה 2.1.0 של Paging הושקה ללא שינויים מגרסה 2.1.0-rc01.

גרסה ‎2.1.0-rc01

‫6 בדצמבר 2018

גרסה 2.1.0-rc01 של Paging הושקה ללא שינויים מגרסה 2.1.0-beta01.

גרסה ‎2.1.0-beta01

‫1 בנובמבר 2018

גרסה 2.1.0-beta01 של Paging הושקה ללא שינויים מגרסה 2.1.0-alpha01.

גרסה ‎2.1.0-alpha01

‫12 באוקטובר 2018

ב-Paging 2.1.0-alpha01 יש שתי תוספות עיקריות – ביטול דפים וספריות של תוספי KTX לכל פריט מידע שנוצר בתהליך פיתוח התוכנה – וגם כמה שינויים אחרים ב-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() שמקבלות קריאה חוזרת נוספת שמופעלת אם/כאשר רשימת הדפים מוצגת, אחרי השוואה. כך אפשר לסנכרן החלפה של PagedList עם עדכונים אחרים בממשק המשתמש. b/73781068
  • הוספנו את PagedList.getLoadedCount() כדי שתדעו כמה פריטים יש בזיכרון. שימו לב שהערך המוחזר תמיד שווה ל-.size() אם פלייסהולדרים מושבתים.

תיקוני באגים

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

גרסה 2.0.0

גרסה 2.0.0

‫1 באוקטובר 2018

גרסה 2.0.0 של Paging כוללת תיקון באג אחד.

תיקוני באגים

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

‫גרסה 2.0.0-beta01

‫2 ביולי 2018

תיקוני באגים

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

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

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

גרסה ‎1.0.0-beta1

‫5 באפריל 2018

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

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

הספרייה החדשה הזו מספקת חלופה של RxJava2 ל-LivePagedListBuilder, ומאפשרת ליצור Observable ו-Flowable, תוך שימוש ב-Scheduler במקום ב-Executor:

Kotlin

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

Java

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 שצוין, במקום במאגר השרשורים של Arch Components IO.

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

גרסה 1.0.0-alpha7

‫21 במרץ 2018

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

גרסה alpha7 של Paging מתוכננת להיות הגרסה האחרונה לפני ש-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 כ-final. b/70848565
  • ההטמעה של Room DataSource תוקנה ועכשיו היא מטפלת בשאילתות עם כמה טבלאות. התיקון הזה כלול ב-Room 1.1.0-beta1, כמו שמופיע למעלה.
  • תוקן באג שבו BoundaryCallback.onItemAtEndLoaded לא הופעל עבור PositionalDataSource אם פלייסהולדרים מופעלים והגודל הכולל הוא כפולה מדויקת של גודל הדף.

גרסה 1.0.0-alpha5

‫22 בינואר 2018

תיקוני באגים

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