דף מהרשת וממסד הנתונים

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

במדריך הזה אנחנו מניחים שאתם מכירים את ספריית Room persistence ואת השימוש הבסיסי בספריית Paging.

תיאום של טעינות נתונים

ספריית Paging מספקת את הרכיב RemoteMediator לתרחיש השימוש הזה. ‫RemoteMediator פועל כאות מספריית Paging כשהאפליקציה נגמרים הנתונים במטמון. אפשר להשתמש באות הזה כדי לטעון נתונים נוספים מהרשת ולשמור אותם במסד הנתונים המקומי, שממנו PagingSource יכול לטעון אותם ולהציג אותם בממשק המשתמש.

כשנדרשים נתונים נוספים, ספריית ה-Paging קוראת ל-method load() מההטמעה של RemoteMediator. זו פונקציית השהיה, ולכן אפשר לבצע בה עבודות ארוכות טווח. הפונקציה הזו בדרך כלל מאחזרת את הנתונים החדשים ממקור ברשת ושומרת אותם באחסון מקומי.

התהליך הזה פועל עם נתונים חדשים, אבל עם הזמן הנתונים שמאוחסנים במסד הנתונים צריכים לעבור פסילה, למשל כשהמשתמש מפעיל רענון באופן ידני. המאפיין הזה מיוצג על ידי LoadType שמועבר למתודה load(). הערך LoadType מודיע ל-RemoteMediator אם צריך לרענן את הנתונים הקיימים או לאחזר נתונים נוספים שצריך להוסיף בסוף או בהתחלה של הרשימה הקיימת.

כך, RemoteMediator מוודא שהנתונים שהמשתמשים רוצים לראות באפליקציה ייטענו בסדר הנכון.

מחזור החיים של החלוקה לדפים

כשמבצעים החלפה בין דפים ישירות מהרשת, הנתונים נטענים ב-PagingSource ומוחזר אובייקט LoadResult. ההטמעה של PagingSource מועברת אל Pager באמצעות הפרמטר pagingSourceFactory.

כשנדרשים נתונים חדשים בממשק המשתמש, הפונקציה Pager קוראת לשיטה load() מתוך PagingSource ומחזירה זרם של אובייקטים PagingData שמכילים את הנתונים החדשים. כל אובייקט PagingData בדרך כלל נשמר במטמון ב-ViewModel לפני שהוא נשלח לממשק המשתמש לתצוגה.

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

שימוש בסיסי

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

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

יצירת ישויות של חדרים

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

לאחר מכן, מגדירים ישות Room כדי לייצג טבלה של פריטים ברשימה, כמו שמתואר במאמר הגדרת נתונים באמצעות ישויות Room. נותנים לו שדה id כמפתח ראשי, וגם שדות לכל מידע אחר שפריטי הרשימה מכילים.

@Entity(tableName = "users")
data class User(val id: String, val label: String)

צריך גם להגדיר אובייקט לגישה לנתונים (DAO) עבור ישות Room הזו, כמו שמתואר במאמר גישה לנתונים באמצעות אובייקטים לגישה לנתונים (DAO) של Room. אובייקט ה-DAO של ישות פריט הרשימה חייב לכלול את ה-methods הבאות:

• ‫Method‏ insertAll() שמוסיף רשימת פריטים לטבלה.
• שיטה שמקבלת את מחרוזת השאילתה כפרמטר ומחזירה אובייקט PagingSource לרשימת התוצאות. כך, אובייקט Pager יכול להשתמש בטבלה הזו כמקור לנתונים עם מספור עמודים.
• שיטה clearAll() שמוחקת את כל הנתונים בטבלה.

@Dao
interface UserDao {
  @Insert(onConflict = OnConflictStrategy.REPLACE)
  suspend fun insertAll(users: List<User>)

  @Query("SELECT * FROM users WHERE label LIKE :query")
  fun pagingSource(query: String): PagingSource<Int, User>

  @Query("DELETE FROM users")
  suspend fun clearAll()
}

הטמעה של RemoteMediator

התפקיד העיקרי של RemoteMediator הוא לטעון נתונים נוספים מהרשת כשPager נגמרים הנתונים או כשהנתונים הקיימים לא תקפים. הוא כולל שיטה load() שצריך לבטל כדי להגדיר את אופן הטעינה.

הטמעה טיפוסית של אירוע RemoteMediator כוללת את הפרמטרים הבאים:

• ‫query: מחרוזת שאילתה שמגדירה אילו נתונים לאחזר משירות ה-Backend.
• ‫database: מסד הנתונים של Room שמשמש כמטמון מקומי.
• ‫networkService: מופע API לשירות העורפי.

יוצרים הטמעה של RemoteMediator<Key, Value>. הסוגים Key ו-Value צריכים להיות זהים לסוגים שהיו מוגדרים אם הייתם מגדירים PagingSource מול אותו מקור נתונים ברשת. מידע נוסף על בחירת פרמטרים של סוג זמין במאמר בחירת סוגי מפתח וערך.

@OptIn(ExperimentalPagingApi::class)
class ExampleRemoteMediator(
  private val query: String,
  private val database: RoomDb,
  private val networkService: ExampleBackendService
) : RemoteMediator<Int, User>() {
  val userDao = database.userDao()

  override suspend fun load(
    loadType: LoadType,
    state: PagingState<Int, User>
  ): MediatorResult {
    // ...
  }
}

שיטת load() אחראית לעדכון מערך הנתונים הבסיסי ולביטול התוקף של PagingSource. ספריות מסוימות שתומכות בהחלפה (כמו Room) יבטלו באופן אוטומטי את התוקף של אובייקטים מסוג PagingSource שהן מטמיעות.

השיטה load() מקבלת שני פרמטרים:

• ‫PagingState, שמכיל מידע על הדפים שנפרסו עד עכשיו, על האינדקס שאליו ניגשת לאחרונה ועל אובייקט PagingConfig שבו השתמשת כדי לאתחל את זרם העמודים.
• ‫LoadType, שמציין את סוג הטעינה: ‫REFRESH,‏ ‫APPEND או ‫PREPEND.

ערך ההחזרה של השיטה load() הוא אובייקט MediatorResult. ‫MediatorResult יכול להיות MediatorResult.Error (שכולל את תיאור השגיאה) או MediatorResult.Success (שכולל אות שמציין אם יש עוד נתונים לטעינה).

השיטה load() צריכה לבצע את השלבים הבאים:

1. קובעים איזה דף לטעון מהרשת בהתאם לסוג הטעינה ולנתונים שכבר נטענו.
2. מפעילים את בקשת הרשת.
3. מבצעים פעולות בהתאם לתוצאה של פעולת הטעינה:
   • אם הטעינה הצליחה והרשימה שהתקבלה של הפריטים לא ריקה, הפריטים נשמרים במסד הנתונים ומוחזר הערך MediatorResult.Success(endOfPaginationReached = false). אחרי שהנתונים מאוחסנים, צריך לבטל את התוקף של מקור הנתונים כדי להודיע לספריית Paging על הנתונים החדשים.
   • אם הטעינה הצליחה והרשימה שהתקבלה של הפריטים ריקה או שזהו אינדקס הדף האחרון, מחזירים MediatorResult.Success(endOfPaginationReached = true). אחרי שהנתונים נשמרים, צריך לבטל את התוקף של מקור הנתונים כדי להודיע לספריית Paging על הנתונים החדשים.
   • אם הבקשה גורמת לשגיאה, הפונקציה מחזירה את הערך MediatorResult.Error.

override suspend fun load(
  loadType: LoadType,
  state: PagingState<Int, User>
): MediatorResult {
  return try {
    // The network load method takes an optional after=<user.id>
    // parameter. For every page after the first, pass the last user
    // ID to let it continue from where it left off. For REFRESH,
    // pass null to load the first page.
    val loadKey = when (loadType) {
      LoadType.REFRESH -> null
      // In this example, you never need to prepend, since REFRESH
      // will always load the first page in the list. Immediately
      // return, reporting end of pagination.
      LoadType.PREPEND ->
        return MediatorResult.Success(endOfPaginationReached = true)
      LoadType.APPEND -> {
        val lastItem = state.lastItemOrNull()

        // You must explicitly check if the last item is null when
        // appending, since passing null to networkService is only
        // valid for initial load. If lastItem is null it means no
        // items were loaded after the initial REFRESH and there are
        // no more items to load.
        if (lastItem == null) {
          return MediatorResult.Success(
            endOfPaginationReached = true
          )
        }

        lastItem.id
      }
    }

    // Suspending network load via Retrofit. This doesn't need to be
    // wrapped in a withContext(Dispatcher.IO) { ... } block since
    // Retrofit's Coroutine CallAdapter dispatches on a worker
    // thread.
    val response = networkService.searchUsers(
      query = query, after = loadKey
    )

    database.withTransaction {
      if (loadType == LoadType.REFRESH) {
        userDao.deleteByQuery(query)
      }

      // Insert new users into database, which invalidates the
      // current PagingData, allowing Paging to present the updates
      // in the DB.
      userDao.insertAll(response.users)
    }

    MediatorResult.Success(
      endOfPaginationReached = response.nextKey == null
    )
  } catch (e: IOException) {
    MediatorResult.Error(e)
  } catch (e: HttpException) {
    MediatorResult.Error(e)
  }
}

הגדרה של שיטת initialize

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

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

• במקרים שבהם צריך לרענן את הנתונים מחנויות מקומיות באופן מלא, הפונקציה initialize() צריכה להחזיר את הערך InitializeAction.LAUNCH_INITIAL_REFRESH. בעקבות זאת, מתבצע רענון מרחוק של RemoteMediator כדי לטעון מחדש את הנתונים באופן מלא. כל טעינה מרחוק של APPEND או PREPEND ממתינה עד שטעינת REFRESH תסתיים בהצלחה לפני שממשיכים.
• במקרים שבהם אין צורך לרענן את הנתונים מחנויות מקומיות, הפונקציה initialize() צריכה להחזיר את הערך InitializeAction.SKIP_INITIAL_REFRESH. במקרה כזה, RemoteMediator ידלג על הרענון מרחוק ויטען את הנתונים במטמון.

override suspend fun initialize(): InitializeAction {
  val cacheTimeout = TimeUnit.MILLISECONDS.convert(1, TimeUnit.HOURS)
  return if (System.currentTimeMillis() - db.lastUpdated() <= cacheTimeout)
  {
    // Cached data is up-to-date, so there is no need to re-fetch
    // from the network.
    InitializeAction.SKIP_INITIAL_REFRESH
  } else {
    // Need to refresh cached data from network; returning
    // LAUNCH_INITIAL_REFRESH here will also block RemoteMediator's
    // APPEND and PREPEND from running until REFRESH succeeds.
    InitializeAction.LAUNCH_INITIAL_REFRESH
  }
}

יצירת מכשיר פייג'ר

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

• במקום להעביר ישירות בנאי PagingSource, צריך לספק את שיטת השאילתה שמחזירה אובייקט PagingSource מ-DAO.
• אתם צריכים לספק מופע של ההטמעה של RemoteMediator כפרמטר remoteMediator.

val userDao = database.userDao()
val pager = Pager(
  config = PagingConfig(pageSize = 50)
  remoteMediator = ExampleRemoteMediator(query, database, networkService)
) {
  userDao.pagingSource(query)
}

טיפול במרוץ תהליכים

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

אם ה-method initialize() מההטמעה של RemoteMediator מחזירה את הערך LAUNCH_INITIAL_REFRESH, סימן שהנתונים לא עדכניים וצריך להחליף אותם בנתונים חדשים. כל בקשה לטעינת PREPEND או APPEND נאלצת להמתין עד שטעינת REFRESH מרחוק תצליח. מכיוון שהבקשות PREPEND או APPEND הוכנסו לתור לפני הבקשה REFRESH, יכול להיות שהערך PagingState שמועבר לקריאות לטעינה יהיה לא עדכני בזמן ההפעלה שלהן.

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

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

ניהול מפתחות לשליטה מרחוק

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

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

מפתחות פריטים

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

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

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

@OptIn(ExperimentalPagingApi::class)
class ExampleRemoteMediator(
  private val query: String,
  private val database: RoomDb,
  private val networkService: ExampleBackendService
) : RemoteMediator<Int, User>() {
  val userDao = database.userDao()

  override suspend fun load(
    loadType: LoadType,
    state: PagingState<Int, User>
  ): MediatorResult {
    return try {
      // The network load method takes an optional String
      // parameter. For every page after the first, pass the String
      // token returned from the previous page to let it continue
      // from where it left off. For REFRESH, pass null to load the
      // first page.
      val loadKey = when (loadType) {
        LoadType.REFRESH -> null
        // In this example, you never need to prepend, since REFRESH
        // will always load the first page in the list. Immediately
        // return, reporting end of pagination.
        LoadType.PREPEND -> return MediatorResult.Success(
          endOfPaginationReached = true
        )
        // Get the last User object id for the next RemoteKey.
        LoadType.APPEND -> {
          val lastItem = state.lastItemOrNull()

          // You must explicitly check if the last item is null when
          // appending, since passing null to networkService is only
          // valid for initial load. If lastItem is null it means no
          // items were loaded after the initial REFRESH and there are
          // no more items to load.
          if (lastItem == null) {
            return MediatorResult.Success(
              endOfPaginationReached = true
            )
          }

          lastItem.id
        }
      }

      // Suspending network load via Retrofit. This doesn't need to
      // be wrapped in a withContext(Dispatcher.IO) { ... } block
      // since Retrofit's Coroutine CallAdapter dispatches on a
      // worker thread.
      val response = networkService.searchUsers(query, loadKey)

      // Store loaded data, and next key in transaction, so that
      // they're always consistent.
      database.withTransaction {
        if (loadType == LoadType.REFRESH) {
          userDao.deleteByQuery(query)
        }

        // Insert new users into database, which invalidates the
        // current PagingData, allowing Paging to present the updates
        // in the DB.
        userDao.insertAll(response.users)
      }

      // End of pagination has been reached if no users are returned from the
      // service
      MediatorResult.Success(
        endOfPaginationReached = response.users.isEmpty()
      )
    } catch (e: IOException) {
      MediatorResult.Error(e)
    } catch (e: HttpException) {
      MediatorResult.Error(e)
    }
  }
}

מפתחות של דפים

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

הוספה של טבלת מפתחות מרוחקת

אם מפתחות מרוחקים לא משויכים ישירות לפריטים ברשימה, מומלץ לאחסן אותם בטבלה נפרדת במסד הנתונים המקומי. מגדירים ישות Room שמייצגת טבלה של מפתחות מרחוק:

@Entity(tableName = "remote_keys")
data class RemoteKey(val label: String, val nextKey: String?)

צריך גם להגדיר DAO עבור הישות RemoteKey:

@Dao
interface RemoteKeyDao {
  @Insert(onConflict = OnConflictStrategy.REPLACE)
  suspend fun insertOrReplace(remoteKey: RemoteKey)

  @Query("SELECT * FROM remote_keys WHERE label = :query")
  suspend fun remoteKeyByQuery(query: String): RemoteKey

  @Query("DELETE FROM remote_keys WHERE label = :query")
  suspend fun deleteByQuery(query: String)
}

טעינה באמצעות מקשי השלט הרחוק

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

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

@OptIn(ExperimentalPagingApi::class)
class ExampleRemoteMediator(
  private val query: String,
  private val database: RoomDb,
  private val networkService: ExampleBackendService
) : RemoteMediator<Int, User>() {
  val userDao = database.userDao()
  val remoteKeyDao = database.remoteKeyDao()

  override suspend fun load(
    loadType: LoadType,
    state: PagingState<Int, User>
  ): MediatorResult {
    return try {
      // The network load method takes an optional String
      // parameter. For every page after the first, pass the String
      // token returned from the previous page to let it continue
      // from where it left off. For REFRESH, pass null to load the
      // first page.
      val loadKey = when (loadType) {
        LoadType.REFRESH -> null
        // In this example, you never need to prepend, since REFRESH
        // will always load the first page in the list. Immediately
        // return, reporting end of pagination.
        LoadType.PREPEND -> return MediatorResult.Success(
          endOfPaginationReached = true
        )
        // Query remoteKeyDao for the next RemoteKey.
        LoadType.APPEND -> {
          val remoteKey = database.withTransaction {
            remoteKeyDao.remoteKeyByQuery(query)
          }

          // You must explicitly check if the page key is null when
          // appending, since null is only valid for initial load.
          // If you receive null for APPEND, that means you have
          // reached the end of pagination and there are no more
          // items to load.
          if (remoteKey.nextKey == null) {
            return MediatorResult.Success(
              endOfPaginationReached = true
            )
          }

          remoteKey.nextKey
        }
      }

      // Suspending network load via Retrofit. This doesn't need to
      // be wrapped in a withContext(Dispatcher.IO) { ... } block
      // since Retrofit's Coroutine CallAdapter dispatches on a
      // worker thread.
      val response = networkService.searchUsers(query, loadKey)

      // Store loaded data, and next key in transaction, so that
      // they're always consistent.
      database.withTransaction {
        if (loadType == LoadType.REFRESH) {
          remoteKeyDao.deleteByQuery(query)
          userDao.deleteByQuery(query)
        }

        // Update RemoteKey for this query.
        remoteKeyDao.insertOrReplace(
          RemoteKey(query, response.nextKey)
        )

        // Insert new users into database, which invalidates the
        // current PagingData, allowing Paging to present the updates
        // in the DB.
        userDao.insertAll(response.users)
      }

      MediatorResult.Success(
        endOfPaginationReached = response.nextKey == null
      )
    } catch (e: IOException) {
      MediatorResult.Error(e)
    } catch (e: HttpException) {
      MediatorResult.Error(e)
    }
  }
}

רענון במקום

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

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

איור 2 מציג את תהליך טעינת הנתונים קודם ממסד הנתונים המקומי, ואחר כך מהרשת אחרי שנגמרו הנתונים במסד הנתונים.

מקורות מידע נוספים

איפה אפשר למצוא מידע נוסף על ספריית Paging?

צפייה בתוכן

• דף מהרשת וממסד הנתונים (תצוגות)