หน้าจากเครือข่ายและฐานข้อมูล

มอบประสบการณ์การใช้งานที่ดียิ่งขึ้นให้แก่ผู้ใช้โดยตรวจสอบว่าแอปของคุณใช้งานได้ เมื่อการเชื่อมต่อเครือข่ายไม่เสถียรหรือเมื่อผู้ใช้ออฟไลน์อยู่ วิธีหนึ่งในการทำเช่นนี้คือการโหลดหน้าเว็บจากเครือข่ายและจากฐานข้อมูลในเครื่องพร้อมกัน ด้วยวิธีนี้ แอปจะขับเคลื่อน UI จากแคชฐานข้อมูลในเครื่องและส่งคำขอไปยังเครือข่ายเฉพาะเมื่อไม่มีข้อมูลในฐานข้อมูลอีกต่อไป

คู่มือนี้มีสมมติฐานว่าคุณคุ้นเคยกับไลบรารีการคงอยู่ของ Room และการใช้งานไลบรารี Paging ขั้นพื้นฐาน

ประสานงานการโหลดข้อมูล

ไลบรารีการแบ่งหน้ามีคอมโพเนนต์ RemoteMediator สำหรับกรณีการใช้งานนี้ RemoteMediator ทำหน้าที่เป็นสัญญาณจากไลบรารีการแบ่งหน้า เมื่อแอปไม่มีข้อมูลที่แคชไว้แล้ว คุณใช้สัญญาณนี้เพื่อโหลดข้อมูลเพิ่มเติมจากเครือข่ายและจัดเก็บไว้ในฐานข้อมูลในเครื่องได้ ซึ่ง PagingSource จะโหลดข้อมูลดังกล่าวและแสดงใน UI

เมื่อต้องการข้อมูลเพิ่มเติม ไลบรารีการแบ่งหน้าจะเรียกใช้เมธอด load() จากการใช้งาน RemoteMediator นี่เป็นฟังก์ชันการระงับ จึงปลอดภัย ที่จะทำงานที่ใช้เวลานาน โดยปกติฟังก์ชันนี้จะดึงข้อมูลใหม่จาก แหล่งข้อมูลในเครือข่ายและบันทึกลงในที่เก็บข้อมูลในเครื่อง

กระบวนการนี้ใช้ได้กับข้อมูลใหม่ แต่เมื่อเวลาผ่านไป ข้อมูลที่จัดเก็บไว้ในฐานข้อมูล จะต้องมีการลบล้าง เช่น เมื่อผู้ใช้ทริกเกอร์การรีเฟรชด้วยตนเอง โดยพร็อพเพอร์ตี้ LoadType จะแสดงถึงพร็อพเพอร์ตี้นี้ซึ่งส่งไปยังเมธอด load() LoadType จะแจ้งให้ RemoteMediator ทราบว่าต้องรีเฟรชข้อมูลที่มีอยู่หรือดึงข้อมูลเพิ่มเติมที่ต้องต่อท้ายหรือนำหน้าในรายการที่มีอยู่หรือไม่

ด้วยวิธีนี้ RemoteMediator จะช่วยให้มั่นใจว่าแอปจะโหลดข้อมูลที่ผู้ใช้ต้องการดูตามลำดับที่เหมาะสม

วงจรการใช้งานการแบ่งหน้า

เมื่อมีการแบ่งหน้าจากเครือข่ายโดยตรง PagingSource จะโหลดข้อมูลและ แสดงออบเจ็กต์ LoadResult ระบบจะส่งการติดตั้งใช้งาน PagingSource ไปยัง Pager ผ่านพารามิเตอร์ pagingSourceFactory

เมื่อ UI ต้องการข้อมูลใหม่ Pager จะเรียกเมธอด load() จาก PagingSource และแสดงผลสตรีมของออบเจ็กต์ PagingData ที่ แคปซูลข้อมูลใหม่ โดยปกติแล้ว ระบบจะแคชออบเจ็กต์ PagingData แต่ละรายการใน ViewModel ก่อนที่จะส่งไปยัง UI เพื่อแสดง

รูปที่ 1 แผนภาพวงจรการใช้งานของ Paging ที่มี PagingSource และ RemoteMediator

RemoteMediator จะเปลี่ยนโฟลว์ข้อมูลนี้ PagingSource ยังคงโหลดข้อมูล แต่เมื่อข้อมูลที่แบ่งหน้าหมดแล้ว ไลบรารีการแบ่งหน้าจะทริกเกอร์ RemoteMediator เพื่อโหลดข้อมูลใหม่จากแหล่งที่มาของเครือข่าย RemoteMediator จะจัดเก็บข้อมูลใหม่ในฐานข้อมูลของเครื่อง จึงไม่จำเป็นต้องใช้แคชในหน่วยความจำใน ViewModel สุดท้าย PagingSource จะทำให้ตัวเองใช้ไม่ได้ และPager จะสร้างอินสแตนซ์ใหม่เพื่อโหลดข้อมูลล่าสุดจากฐานข้อมูล

การใช้งานพื้นฐาน

สมมติว่าคุณต้องการให้แอปโหลดหน้าของรายการ User จากแหล่งข้อมูลเครือข่ายที่ใช้คีย์รายการ ลงในแคชในเครื่องที่จัดเก็บไว้ในฐานข้อมูล Room

การติดตั้งใช้งาน RemoteMediator จะช่วยโหลดข้อมูลที่แบ่งหน้าจากเครือข่ายลงในฐานข้อมูล แต่จะไม่โหลดข้อมูลลงใน UI โดยตรง แต่แอปจะใช้ฐานข้อมูลเป็นแหล่งข้อมูลที่ เชื่อถือได้แทน กล่าวคือ แอปจะแสดงเฉพาะข้อมูลที่แคชไว้ในฐานข้อมูลเท่านั้น PagingSource การใช้งาน (เช่น การใช้งานที่สร้างโดย Room) จะจัดการการโหลดข้อมูลที่แคชไว้ จากฐานข้อมูลลงใน UI

สร้างเอนทิตีห้อง

ขั้นตอนแรกคือการใช้ไลบรารีการคงอยู่ของ Room เพื่อกำหนดฐานข้อมูลที่เก็บ แคชในเครื่องของข้อมูลที่แบ่งหน้าจากแหล่งข้อมูลเครือข่าย เริ่มต้นด้วยการ ติดตั้งใช้งาน RoomDatabase ตามที่อธิบายไว้ในบันทึกข้อมูลในฐานข้อมูลของเครื่องโดยใช้ Room

จากนั้นกำหนดเอนทิตี Room เพื่อแสดงตารางของรายการในลิสต์ตามที่อธิบายไว้ในการกำหนดข้อมูลโดยใช้เอนทิตี Room กำหนดให้มีฟิลด์ id เป็นคีย์หลัก รวมถึงฟิลด์สำหรับข้อมูลอื่นๆ ที่รายการในลิสต์มี

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

นอกจากนี้ คุณยังต้องกำหนดออบเจ็กต์การเข้าถึงข้อมูล (DAO) สำหรับเอนทิตี Room นี้ตามที่อธิบายไว้ในการเข้าถึงข้อมูลโดยใช้ DAO ของ Room DAO สำหรับรายการในรายการ เอนทิตีต้องมีเมธอดต่อไปนี้

เมธอด 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: สตริงคำค้นหาที่กำหนดข้อมูลที่จะดึงจากบริการแบ็กเอนด์
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() รับพารามิเตอร์ 2 รายการดังนี้

PagingState ซึ่งมีข้อมูลเกี่ยวกับ หน้าเว็บที่โหลดไปแล้ว ดัชนีที่เข้าถึงล่าสุด และออบเจ็กต์ PagingConfig ที่คุณใช้เพื่อเริ่มต้นสตรีมการแบ่งหน้า
LoadType ซึ่งระบุประเภทการโหลด REFRESH APPEND หรือ PREPEND

ค่าที่ส่งคืนของเมธอด load() คือออบเจ็กต์ MediatorResult MediatorResult อาจเป็น MediatorResult.Error (ซึ่งรวมถึงคำอธิบายข้อผิดพลาด) หรือ MediatorResult.Success (ซึ่งรวมถึงสัญญาณที่ระบุว่ามีข้อมูลเพิ่มเติมที่จะโหลดหรือไม่)

เมธอด load() ต้องดำเนินการตามขั้นตอนต่อไปนี้

กำหนดหน้าที่จะโหลดจากเครือข่ายโดยขึ้นอยู่กับประเภทการโหลดและ ข้อมูลที่โหลดไปแล้ว
ทริกเกอร์คำขอเครือข่าย
ดำเนินการตามผลลัพธ์ของการดำเนินการโหลด ดังนี้
- หากโหลดสำเร็จและรายการที่ได้รับไม่ว่าง ให้จัดเก็บรายการในฐานข้อมูลและแสดงผล MediatorResult.Success(endOfPaginationReached = false) หลังจากจัดเก็บข้อมูลแล้ว ให้ลบล้างแหล่งข้อมูลเพื่อแจ้งให้ไลบรารีการแบ่งหน้าทราบถึงข้อมูลใหม่
- หากโหลดสำเร็จและรายการที่ได้รับว่างเปล่า หรือเป็นดัชนีหน้าสุดท้าย ให้แสดงผล MediatorResult.Success(endOfPaginationReached = true) หลังจากจัดเก็บข้อมูลแล้ว ให้ล้างแหล่งข้อมูลเพื่อแจ้งให้ไลบรารีการแบ่งหน้าทราบถึงข้อมูลใหม่
- หากคำขอทำให้เกิดข้อผิดพลาด ให้แสดง 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 สามารถตรวจสอบว่าเวลาหมดอายุนี้ผ่านไปแล้วหรือไม่ ในกรณีนี้ไลบรารีการแบ่งหน้าจะต้องรีเฟรชข้อมูลทั้งหมด การติดตั้งใช้งาน 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จากแหล่งข้อมูลเครือข่ายอย่างง่าย แต่มี 2 สิ่งที่คุณต้องทำแตกต่างออกไป

คุณต้องระบุเมธอดการค้นหาที่แสดงผลออบเจ็กต์ PagingSource จาก DAO แทนการส่งเครื่องมือสร้าง PagingSource โดยตรง
คุณต้องระบุอินสแตนซ์ของการติดตั้งใช้งาน RemoteMediator เป็นพารามิเตอร์ remoteMediator

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

จัดการภาวะแข่งขัน

สถานการณ์หนึ่งที่แอปของคุณต้องจัดการเมื่อโหลดข้อมูลจากหลายแหล่ง คือกรณีที่ข้อมูลที่แคชไว้ในเครื่องไม่ซิงค์กับแหล่งข้อมูลระยะไกล

เมื่อเมธอด initialize() จากการติดตั้งใช้งาน RemoteMediator แสดงผลเป็น LAUNCH_INITIAL_REFRESH แสดงว่าข้อมูลล้าสมัยและต้องแทนที่ด้วยข้อมูลใหม่ ระบบจะบังคับให้คำขอโหลด PREPEND หรือ APPEND รอให้การโหลดจากระยะไกล REFRESH สำเร็จ เนื่องจากคำขอ PREPEND หรือ APPEND ถูกจัดคิวไว้ก่อนคำขอ REFRESH จึงเป็นไปได้ว่า PagingState ที่ส่งไปยังการเรียกใช้การโหลดเหล่านั้นจะล้าสมัยเมื่อถึงเวลาที่เรียกใช้

แอปสามารถละเว้นคำขอที่ซ้ำกันได้หากการเปลี่ยนแปลงข้อมูลที่แคชทำให้เกิดการลบล้างและดึงข้อมูลใหม่ ทั้งนี้ขึ้นอยู่กับวิธีจัดเก็บข้อมูลในเครื่อง เช่น Room จะทำให้คำค้นหาเป็นโมฆะเมื่อมีการแทรกข้อมูล ซึ่งหมายความว่าระบบจะจัดหาออบเจ็กต์ใหม่ PagingSourceที่มีข้อมูลที่รีเฟรชแล้วให้กับคำขอโหลดที่รอดำเนินการ เมื่อมีการแทรกข้อมูลใหม่ลงในฐานข้อมูล

การแก้ปัญหาการซิงค์ข้อมูลนี้เป็นสิ่งจำเป็นเพื่อให้ผู้ใช้เห็นข้อมูลที่เกี่ยวข้องและเป็นปัจจุบันมากที่สุด โซลูชันที่ดีที่สุดส่วนใหญ่ขึ้นอยู่กับ วิธีที่หน้าแหล่งข้อมูลเครือข่ายจัดหน้าข้อมูล ไม่ว่าในกรณีใด คีย์ระยะไกลจะช่วยให้คุณบันทึกข้อมูลเกี่ยวกับหน้าที่ขอจากเซิร์ฟเวอร์ล่าสุดได้ แอปของคุณสามารถใช้ข้อมูลนี้เพื่อระบุและ ขอหน้าข้อมูลที่ถูกต้องเพื่อโหลดถัดไป

จัดการกุญแจแบบรีโมต

คีย์ระยะไกลคือคีย์ที่การติดตั้งใช้งาน RemoteMediator ใช้เพื่อบอกบริการแบ็กเอนด์ว่าจะโหลดข้อมูลใดต่อไป ในกรณีที่ง่ายที่สุด แต่ละรายการของข้อมูลที่แบ่งหน้าจะมีคีย์ระยะไกลที่คุณอ้างอิงได้ง่ายๆ อย่างไรก็ตาม หากคีย์ระยะไกลไม่สอดคล้องกับรายการแต่ละรายการ คุณจะต้องจัดเก็บคีย์เหล่านั้นแยกกันและจัดการในเมธอด load()

ส่วนนี้อธิบายวิธีรวบรวม จัดเก็บ และอัปเดตคีย์ระยะไกลที่ไม่ได้จัดเก็บไว้ในแต่ละรายการ

คีย์รายการ

ส่วนนี้อธิบายวิธีใช้คีย์ระยะไกลที่สอดคล้องกับ รายการแต่ละรายการ โดยปกติ เมื่อคีย์ API ปิดรายการแต่ละรายการ ระบบจะส่งรหัส รายการเป็นพารามิเตอร์การค้นหา ชื่อพารามิเตอร์จะระบุว่าเซิร์ฟเวอร์ควรตอบกลับด้วยรายการก่อนหรือหลังรหัสที่ระบุ ในตัวอย่าง ของคลาสโมเดล User ระบบจะใช้ฟิลด์ id จากเซิร์ฟเวอร์เป็นคีย์ระยะไกล เมื่อขอข้อมูลเพิ่มเติม

เมื่อload()ต้องจัดการคีย์ระยะไกลที่เฉพาะเจาะจงรายการ โดยปกติแล้วคีย์เหล่านี้จะเป็นรหัสของข้อมูลที่ดึงมาจากเซิร์ฟเวอร์ การดำเนินการรีเฟรช ไม่จำเป็นต้องใช้คีย์การโหลด เนื่องจากจะดึงข้อมูลล่าสุดเท่านั้น ในทำนองเดียวกัน การดำเนินการนำหน้าไม่จำเป็นต้องดึงข้อมูลเพิ่มเติมเนื่องจาก การรีเฟรชจะดึงข้อมูลล่าสุดจากเซิร์ฟเวอร์เสมอ

แต่การดำเนินการต่อท้ายต้องใช้รหัส ซึ่งคุณจะต้องโหลดรายการสุดท้ายจากฐานข้อมูลและใช้รหัสของรายการนั้นเพื่อโหลดข้อมูลหน้าถัดไป หากไม่มีรายการในฐานข้อมูล ระบบจะตั้งค่า endOfPaginationReached เป็นจริง ซึ่งบ่งชี้ว่าต้องรีเฟรชข้อมูล

@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การติดตั้งใช้งานPagingSource.getRefreshKey()ของ Room จะจัดการเรื่องนี้ให้คุณ แต่หากไม่ได้ใช้ Room คุณก็ทำได้โดยการแทนที่ PagingSource.getRefreshKey() ดูตัวอย่างการใช้งาน getRefreshKey() ได้ที่กำหนด PagingSource

รูปที่ 2 แสดงกระบวนการโหลดข้อมูลจากฐานข้อมูลในเครื่องก่อน แล้วจึงโหลดจากเครือข่ายเมื่อฐานข้อมูลไม่มีข้อมูล

PagingSource จะโหลดจากฐานข้อมูลไปยัง UI จนกว่าฐานข้อมูล
จะไม่มีข้อมูล จากนั้น RemoteMediator จะโหลดจากเครือข่ายลงในฐานข้อมูล และหลังจากนั้น PagingSource จะโหลดต่อไป

รูปที่ 2 แผนภาพแสดงวิธีการทำงานร่วมกันของ PagingSource และ RemoteMediator เพื่อโหลดข้อมูล

แหล่งข้อมูลเพิ่มเติม

ดูข้อมูลเพิ่มเติมเกี่ยวกับไลบรารี Paging ได้ที่แหล่งข้อมูลเพิ่มเติมต่อไปนี้

ดูเนื้อหา

หน้าจากเครือข่ายและฐานข้อมูล (มุมมอง)

แนะนำสำหรับคุณ

หมายเหตุ: ข้อความลิงก์จะแสดงเมื่อ JavaScript ปิดอยู่
โหลดและแสดงข้อมูลแบบแบ่งหน้า
ทดสอบการใช้งานการแบ่งหน้า
ย้ายข้อมูลไปยัง Paging 3