Android ページングの高度な Codelab

 git clone https://github.com/googlecodelabs/android-paging 

class GithubPagingSource(         private val service: GithubService,         private val query: String ) : PagingSource<Int, Repo>() {     override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Repo> {         TODO("Not yet implemented")     }    override fun getRefreshKey(state: PagingState<Int, Repo>): Int? {         TODO("Not yet implemented")     }  } 

// GitHub page API is 1 based: https://developer.github.com/v3/#pagination private const val GITHUB_STARTING_PAGE_INDEX = 1  class GithubPagingSource(         private val service: GithubService,         private val query: String ) : PagingSource<Int, Repo>() {      override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Repo> {         val position = params.key ?: GITHUB_STARTING_PAGE_INDEX         val apiQuery = query + IN_QUALIFIER         return try {             val response = service.searchRepos(apiQuery, position, params.loadSize)             val repos = response.items             val nextKey = if (repos.isEmpty()) {                 null             } else {                 // initial load size = 3 * NETWORK_PAGE_SIZE                 // ensure we're not requesting duplicating items, at the 2nd request                 position + (params.loadSize / NETWORK_PAGE_SIZE)             }             LoadResult.Page(                     data = repos,                     prevKey = if (position == GITHUB_STARTING_PAGE_INDEX) null else position - 1,                     nextKey = nextKey             )         } catch (exception: IOException) {             return LoadResult.Error(exception)         } catch (exception: HttpException) {             return LoadResult.Error(exception)         }     }     // The refresh key is used for subsequent refresh calls to PagingSource.load after the initial load     override fun getRefreshKey(state: PagingState<Int, Repo>): Int? {         // We need to get the previous key (or next key if previous is null) of the page         // that was closest to the most recently accessed index.         // Anchor position is the most recently accessed index         return state.anchorPosition?.let { anchorPosition ->             state.closestPageToPosition(anchorPosition)?.prevKey?.plus(1)                 ?: state.closestPageToPosition(anchorPosition)?.nextKey?.minus(1)         }     }  } 

fun getSearchResultStream(query: String): Flow<PagingData<Repo>> {     return Pager(           config = PagingConfig(             pageSize = NETWORK_PAGE_SIZE,             enablePlaceholders = false          ),           pagingSourceFactory = { GithubPagingSource(service, query) }     ).flow } 

class GithubRepository(private val service: GithubService) {      fun getSearchResultStream(query: String): Flow<PagingData<Repo>> {         return Pager(                 config = PagingConfig(                 pageSize = NETWORK_PAGE_SIZE,                 enablePlaceholders = false              ),                 pagingSourceFactory = { GithubPagingSource(service, query) }         ).flow     }      companion object {         const val NETWORK_PAGE_SIZE = 50     } } 

sealed class UiAction {     data class Search(val query: String) : UiAction()     data class Scroll(         val visibleItemCount: Int,         val lastVisibleItemPosition: Int,         val totalItemCount: Int     ) : UiAction() }  data class UiState(     val query: String,     val searchResult: RepoSearchResult ) 

data class UiState(     val query: String = DEFAULT_QUERY,     val lastQueryScrolled: String = DEFAULT_QUERY,     val hasNotScrolledForCurrentSearch: Boolean = false ) 

   /**      * Stream of immutable states representative of the UI.      */     val state: StateFlow<UiState>      val pagingDataFlow: Flow<PagingData<Repo>> 

sealed class UiAction {     ...     data class Scroll(val currentQuery: String) : UiAction() } 

class SearchRepositoriesViewModel{   ...    override fun onCleared() {         savedStateHandle[LAST_SEARCH_QUERY] = state.value.query         savedStateHandle[LAST_QUERY_SCROLLED] = state.value.lastQueryScrolled         super.onCleared()     } }  // This is outside the ViewModel class, but in the same file private const val LAST_QUERY_SCROLLED: String = "last_query_scrolled" 

class SearchRepositoriesViewModel(     ... ) : ViewModel() {      override fun onCleared() {         ...     }      private fun searchRepo(queryString: String): Flow<PagingData<Repo>> =         repository.getSearchResultStream(queryString) } 

class SearchRepositoriesViewModel(     ... ) : ViewModel() {     ...     init {         val initialQuery: String = savedStateHandle.get(LAST_SEARCH_QUERY) ?: DEFAULT_QUERY         val lastQueryScrolled: String = savedStateHandle.get(LAST_QUERY_SCROLLED) ?: DEFAULT_QUERY         val actionStateFlow = MutableSharedFlow<UiAction>()         val searches = actionStateFlow             .filterIsInstance<UiAction.Search>()             .distinctUntilChanged()             .onStart { emit(UiAction.Search(query = initialQuery)) }         val queriesScrolled = actionStateFlow             .filterIsInstance<UiAction.Scroll>()             .distinctUntilChanged()             // This is shared to keep the flow "hot" while caching the last query scrolled,             // otherwise each flatMapLatest invocation would lose the last query scrolled,             .shareIn(                 scope = viewModelScope,                 started = SharingStarted.WhileSubscribed(stopTimeoutMillis = 5000),                 replay = 1             )             .onStart { emit(UiAction.Scroll(currentQuery = lastQueryScrolled)) }    } } 

init {         ...         pagingDataFlow = searches             .flatMapLatest { searchRepo(queryString = it.query) }             .cachedIn(viewModelScope)          state = combine(             searches,             queriesScrolled,             ::Pair         ).map { (search, scroll) ->             UiState(                 query = search.query,                 lastQueryScrolled = scroll.currentQuery,                 // If the search query matches the scroll query, the user has scrolled                 hasNotScrolledForCurrentSearch = search.query != scroll.currentQuery             )         }             .stateIn(                 scope = viewModelScope,                 started = SharingStarted.WhileSubscribed(stopTimeoutMillis = 5000),                 initialValue = UiState()             )          accept = { action ->             viewModelScope.launch { actionStateFlow.emit(action) }         }     } } 

class ReposAdapter : PagingDataAdapter<Repo, RepoViewHolder>(REPO_COMPARATOR) { // body is unchanged } 

   private fun ActivitySearchRepositoriesBinding.bindState(         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         uiActions: (UiAction) -> Unit     ) {         ...     } 

   private fun ActivitySearchRepositoriesBinding.bindSearch(         uiState: StateFlow<UiState>,         onQueryChanged: (UiAction.Search) -> Unit     ) {         searchRepo.setOnEditorActionListener {...}         searchRepo.setOnKeyListener {...}          lifecycleScope.launch {             uiState                 .map { it.query }                 .distinctUntilChanged()                 .collect(searchRepo::setText)         }     } 

   private fun ActivitySearchRepositoriesBinding.bindList(         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         list.addOnScrollListener(object : RecyclerView.OnScrollListener() {             override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {                 if (dy != 0) onScrollChanged(UiAction.Scroll(currentQuery = uiState.value.query))             }         })         // the rest of the code is unchanged     } 

    private fun ActivitySearchRepositoriesBinding.bindList(         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         list.addOnScrollListener(...)         val notLoading = repoAdapter.loadStateFlow             // Only emit when REFRESH LoadState for the paging source changes.             .distinctUntilChangedBy { it.source.refresh }             // Only react to cases where REFRESH completes i.e., NotLoading.             .map { it.source.refresh is LoadState.NotLoading }          val hasNotScrolledForCurrentSearch = uiState             .map { it.hasNotScrolledForCurrentSearch }             .distinctUntilChanged()          val shouldScrollToTop = combine(             notLoading,             hasNotScrolledForCurrentSearch,             Boolean::and         )             .distinctUntilChanged()          lifecycleScope.launch {             pagingData.collectLatest(repoAdapter::submitData)         }          lifecycleScope.launch {             shouldScrollToTop.collect { shouldScroll ->                 if (shouldScroll) list.scrollToPosition(0)             }         }     } 

class SearchRepositoriesActivity : AppCompatActivity() {      override fun onCreate(savedInstanceState: Bundle?) {         super.onCreate(savedInstanceState)         val binding = ActivitySearchRepositoriesBinding.inflate(layoutInflater)         val view = binding.root         setContentView(view)          // get the view model         val viewModel = ViewModelProvider(this, Injection.provideViewModelFactory(owner = this))             .get(SearchRepositoriesViewModel::class.java)          // add dividers between RecyclerView's row items         val decoration = DividerItemDecoration(this, DividerItemDecoration.VERTICAL)         binding.list.addItemDecoration(decoration)          // bind the state         binding.bindState(             uiState = viewModel.state,             pagingData = viewModel.pagingDataFlow,             uiActions = viewModel.accept         )     }      /**      * Binds the [UiState] provided  by the [SearchRepositoriesViewModel] to the UI,      * and allows the UI to feed back user actions to it.      */     private fun ActivitySearchRepositoriesBinding.bindState(         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         uiActions: (UiAction) -> Unit     ) {         val repoAdapter = ReposAdapter()         list.adapter = repoAdapter          bindSearch(             uiState = uiState,             onQueryChanged = uiActions         )         bindList(             repoAdapter = repoAdapter,             uiState = uiState,             pagingData = pagingData,             onScrollChanged = uiActions         )     }      private fun ActivitySearchRepositoriesBinding.bindSearch(         uiState: StateFlow<UiState>,         onQueryChanged: (UiAction.Search) -> Unit     ) {         searchRepo.setOnEditorActionListener { _, actionId, _ ->             if (actionId == EditorInfo.IME_ACTION_GO) {                 updateRepoListFromInput(onQueryChanged)                 true             } else {                 false             }         }         searchRepo.setOnKeyListener { _, keyCode, event ->             if (event.action == KeyEvent.ACTION_DOWN && keyCode == KeyEvent.KEYCODE_ENTER) {                 updateRepoListFromInput(onQueryChanged)                 true             } else {                 false             }         }          lifecycleScope.launch {             uiState                 .map { it.query }                 .distinctUntilChanged()                 .collect(searchRepo::setText)         }     }      private fun ActivitySearchRepositoriesBinding.updateRepoListFromInput(onQueryChanged: (UiAction.Search) -> Unit) {         searchRepo.text.trim().let {             if (it.isNotEmpty()) {                 list.scrollToPosition(0)                 onQueryChanged(UiAction.Search(query = it.toString()))             }         }     }      private fun ActivitySearchRepositoriesBinding.bindList(         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         list.addOnScrollListener(object : RecyclerView.OnScrollListener() {             override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {                 if (dy != 0) onScrollChanged(UiAction.Scroll(currentQuery = uiState.value.query))             }         })         val notLoading = repoAdapter.loadStateFlow             // Only emit when REFRESH LoadState for the paging source changes.             .distinctUntilChangedBy { it.source.refresh }             // Only react to cases where REFRESH completes i.e., NotLoading.             .map { it.source.refresh is LoadState.NotLoading }          val hasNotScrolledForCurrentSearch = uiState             .map { it.hasNotScrolledForCurrentSearch }             .distinctUntilChanged()          val shouldScrollToTop = combine(             notLoading,             hasNotScrolledForCurrentSearch,             Boolean::and         )             .distinctUntilChanged()          lifecycleScope.launch {             pagingData.collectLatest(repoAdapter::submitData)         }          lifecycleScope.launch {             shouldScrollToTop.collect { shouldScroll ->                 if (shouldScroll) list.scrollToPosition(0)             }         }     } } 

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"     android:layout_width="match_parent"     android:layout_height="wrap_content"     xmlns:tools="http://schemas.android.com/tools"     android:orientation="vertical"     android:padding="8dp">     <TextView         android:id="@+id/error_msg"         android:textColor="?android:textColorPrimary"         android:textSize="@dimen/error_text_size"         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:layout_gravity="center"         android:textAlignment="center"         tools:text="Timeout"/>     <ProgressBar         android:id="@+id/progress_bar"         style="?android:attr/progressBarStyle"         android:layout_width="match_parent"         android:layout_height="wrap_content"         android:layout_gravity="center"/>     <Button         android:id="@+id/retry_button"         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:layout_gravity="center"         android:text="@string/retry"/> </LinearLayout> 

class ReposLoadStateViewHolder(         private val binding: ReposLoadStateFooterViewItemBinding,         retry: () -> Unit ) : RecyclerView.ViewHolder(binding.root) {      init {         binding.retryButton.setOnClickListener { retry.invoke() }     }      fun bind(loadState: LoadState) {         if (loadState is LoadState.Error) {             binding.errorMsg.text = loadState.error.localizedMessage         }         binding.progressBar.isVisible = loadState is LoadState.Loading         binding.retryButton.isVisible = loadState is LoadState.Error         binding.errorMsg.isVisible = loadState is LoadState.Error     }      companion object {         fun create(parent: ViewGroup, retry: () -> Unit): ReposLoadStateViewHolder {             val view = LayoutInflater.from(parent.context)                     .inflate(R.layout.repos_load_state_footer_view_item, parent, false)             val binding = ReposLoadStateFooterViewItemBinding.bind(view)             return ReposLoadStateViewHolder(binding, retry)         }     } } 

class ReposLoadStateAdapter(private val retry: () -> Unit) : LoadStateAdapter<ReposLoadStateViewHolder>() {     override fun onBindViewHolder(holder: ReposLoadStateViewHolder, loadState: LoadState) {         holder.bind(loadState)     }      override fun onCreateViewHolder(parent: ViewGroup, loadState: LoadState): ReposLoadStateViewHolder {         return ReposLoadStateViewHolder.create(parent, retry)     } } 

   private fun ActivitySearchRepositoriesBinding.bindState(         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         uiActions: (UiAction) -> Unit     ) {         val repoAdapter = ReposAdapter()         list.adapter = repoAdapter.withLoadStateHeaderAndFooter(             header = ReposLoadStateAdapter { repoAdapter.retry() },             footer = ReposLoadStateAdapter { repoAdapter.retry() }         )         ...     } 

private fun ActivitySearchRepositoriesBinding.bindList(         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         ...         lifecycleScope.launch {             repoAdapter.loadStateFlow.collect { loadState ->                 val isListEmpty = loadState.refresh is LoadState.NotLoading && repoAdapter.itemCount == 0                 // show empty list                 emptyList.isVisible = isListEmpty                 // Only show the list if refresh succeeds.                 list.isVisible = !isListEmpty                 }             }         }     } 

<androidx.constraintlayout.widget.ConstraintLayout     xmlns:android="http://schemas.android.com/apk/res/android"     xmlns:app="http://schemas.android.com/apk/res-auto"     xmlns:tools="http://schemas.android.com/tools"     android:layout_width="match_parent"     android:layout_height="match_parent"     tools:context=".ui.SearchRepositoriesActivity">     <com.google.android.material.textfield.TextInputLayout         android:id="@+id/input_layout"         android:layout_width="0dp"         android:layout_height="wrap_content"         android:layout_marginEnd="8dp"         android:layout_marginStart="8dp"         android:layout_marginTop="8dp"         android:layout_marginLeft="8dp"         android:layout_marginRight="8dp"         style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"         app:layout_constraintEnd_toEndOf="parent"         app:layout_constraintStart_toStartOf="parent"         app:layout_constraintTop_toTopOf="parent">         <EditText             android:id="@+id/search_repo"             android:layout_width="match_parent"             android:layout_height="wrap_content"             android:hint="@string/search_hint"             android:imeOptions="actionSearch"             android:inputType="textNoSuggestions"             android:selectAllOnFocus="true"             tools:text="Android"/>     </com.google.android.material.textfield.TextInputLayout>      <androidx.recyclerview.widget.RecyclerView         android:id="@+id/list"         android:layout_width="0dp"         android:layout_height="0dp"         android:paddingVertical="@dimen/row_item_margin_vertical"         android:scrollbars="vertical"         app:layoutManager="LinearLayoutManager"         app:layout_constraintBottom_toBottomOf="parent"         app:layout_constraintEnd_toEndOf="parent"         app:layout_constraintStart_toStartOf="parent"         app:layout_constraintTop_toBottomOf="@+id/input_layout"         tools:ignore="UnusedAttribute"/>      <ProgressBar         android:id="@+id/progress_bar"         style="?android:attr/progressBarStyle"         android:layout_width="match_parent"         android:layout_height="wrap_content"         android:layout_gravity="center"         app:layout_constraintLeft_toLeftOf="parent"         app:layout_constraintRight_toRightOf="parent"         app:layout_constraintTop_toTopOf="parent"         app:layout_constraintBottom_toBottomOf="parent"/>      <Button         android:id="@+id/retry_button"         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:text="@string/retry"         app:layout_constraintLeft_toLeftOf="parent"         app:layout_constraintRight_toRightOf="parent"         app:layout_constraintTop_toTopOf="parent"         app:layout_constraintBottom_toBottomOf="parent"/>      <TextView android:id="@+id/emptyList"         android:layout_width="0dp"         android:layout_height="match_parent"         android:gravity="center"         android:text="@string/no_results"         android:textSize="@dimen/repo_name_size"         android:visibility="gone"         app:layout_constraintBottom_toBottomOf="parent"         app:layout_constraintEnd_toEndOf="parent"         app:layout_constraintStart_toStartOf="parent"         app:layout_constraintTop_toTopOf="parent"/>  </androidx.constraintlayout.widget.ConstraintLayout> 

// SearchRepositoriesActivity.kt     private fun ActivitySearchRepositoriesBinding.bindList(         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         retryButton.setOnClickListener { repoAdapter.retry() }         ... } 

private fun ActivitySearchRepositoriesBinding.bindList(         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         pagingData: Flow<PagingData<Repo>>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         ...         lifecycleScope.launch {             repoAdapter.loadStateFlow.collect { loadState ->                 val isListEmpty = loadState.refresh is LoadState.NotLoading && repoAdapter.itemCount == 0                 // show empty list                 emptyList.isVisible = isListEmpty                 // Only show the list if refresh succeeds.                 list.isVisible = !isListEmpty                 // Show loading spinner during initial load or refresh.                 progressBar.isVisible = loadState.source.refresh is LoadState.Loading                 // Show the retry state if initial load or refresh fails.                 retryButton.isVisible = loadState.source.refresh is LoadState.Error                  // Toast on any error, regardless of whether it came from RemoteMediator or PagingSource                 val errorState = loadState.source.append as? LoadState.Error                     ?: loadState.source.prepend as? LoadState.Error                     ?: loadState.append as? LoadState.Error                     ?: loadState.prepend as? LoadState.Error                 errorState?.let {                     Toast.makeText(                         this@SearchRepositoriesActivity,                         "\uD83D\uDE28 Wooops ${it.error}",                         Toast.LENGTH_LONG                     ).show()                 }             }         }     } 

sealed class UiModel {     data class RepoItem(val repo: Repo) : UiModel()     data class SeparatorItem(val description: String) : UiModel() } 

private val UiModel.RepoItem.roundedStarCount: Int     get() = this.repo.stars / 10_000 

class SearchRepositoriesViewModel(     private val repository: GithubRepository,     private val savedStateHandle: SavedStateHandle ) : ViewModel() {      ...      fun searchRepo(queryString: String): Flow<PagingData<UiModel>> {         ...     } } 

... val newResult: Flow<PagingData<UiModel>> = repository.getSearchResultStream(queryString)                 .map { pagingData -> pagingData.map { UiModel.RepoItem(it) } } ... 

   private fun searchRepo(queryString: String): Flow<PagingData<UiModel>> =         repository.getSearchResultStream(queryString)             .map { pagingData -> pagingData.map { UiModel.RepoItem(it) } }             .map {                 it.insertSeparators { before, after ->                     if (after == null) {                         // we're at the end of the list                         return@insertSeparators null                     }                      if (before == null) {                         // we're at the beginning of the list                         return@insertSeparators UiModel.SeparatorItem("${after.roundedStarCount}0.000+ stars")                     }                     // check between 2 items                     if (before.roundedStarCount > after.roundedStarCount) {                         if (after.roundedStarCount >= 1) {                             UiModel.SeparatorItem("${after.roundedStarCount}0.000+ stars")                         } else {                             UiModel.SeparatorItem("< 10.000+ stars")                         }                     } else {                         // no separator                         null                     }                 }             } 

<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout     xmlns:android="http://schemas.android.com/apk/res/android"     xmlns:app="http://schemas.android.com/apk/res-auto"     xmlns:tools="http://schemas.android.com/tools"     android:layout_width="match_parent"     android:layout_height="wrap_content"     android:background="@color/separatorBackground">      <TextView         android:id="@+id/separator_description"         android:layout_width="0dp"         android:layout_height="wrap_content"         android:padding="@dimen/row_item_margin_horizontal"         android:textColor="@color/separatorText"         android:textSize="@dimen/repo_name_size"         app:layout_constraintEnd_toEndOf="parent"         app:layout_constraintStart_toStartOf="parent"         app:layout_constraintTop_toTopOf="parent"         tools:text="10000+ stars" /> </androidx.constraintlayout.widget.ConstraintLayout> 

class SeparatorViewHolder(view: View) : RecyclerView.ViewHolder(view) {     private val description: TextView = view.findViewById(R.id.separator_description)      fun bind(separatorText: String) {         description.text = separatorText     }      companion object {         fun create(parent: ViewGroup): SeparatorViewHolder {             val view = LayoutInflater.from(parent.context)                     .inflate(R.layout.separator_view_item, parent, false)             return SeparatorViewHolder(view)         }     } } 

class ReposAdapter : PagingDataAdapter<UiModel, ViewHolder>(UIMODEL_COMPARATOR) {      override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {         return if (viewType == R.layout.repo_view_item) {             RepoViewHolder.create(parent)         } else {             SeparatorViewHolder.create(parent)         }     }      override fun getItemViewType(position: Int): Int {         return when (getItem(position)) {             is UiModel.RepoItem -> R.layout.repo_view_item             is UiModel.SeparatorItem -> R.layout.separator_view_item             null -> throw UnsupportedOperationException("Unknown view")         }     }      override fun onBindViewHolder(holder: ViewHolder, position: Int) {         val uiModel = getItem(position)         uiModel.let {             when (uiModel) {                 is UiModel.RepoItem -> (holder as RepoViewHolder).bind(uiModel.repo)                 is UiModel.SeparatorItem -> (holder as SeparatorViewHolder).bind(uiModel.description)             }         }     }      companion object {         private val UIMODEL_COMPARATOR = object : DiffUtil.ItemCallback<UiModel>() {             override fun areItemsTheSame(oldItem: UiModel, newItem: UiModel): Boolean {                 return (oldItem is UiModel.RepoItem && newItem is UiModel.RepoItem &&                         oldItem.repo.fullName == newItem.repo.fullName) ||                         (oldItem is UiModel.SeparatorItem && newItem is UiModel.SeparatorItem &&                                 oldItem.description == newItem.description)             }              override fun areContentsTheSame(oldItem: UiModel, newItem: UiModel): Boolean =                     oldItem == newItem         }     } } 

@Entity(tableName = "repos") data class Repo(     @PrimaryKey @field:SerializedName("id") val id: Long,     @field:SerializedName("name") val name: String,     @field:SerializedName("full_name") val fullName: String,     @field:SerializedName("description") val description: String?,     @field:SerializedName("html_url") val url: String,     @field:SerializedName("stargazers_count") val stars: Int,     @field:SerializedName("forks_count") val forks: Int,     @field:SerializedName("language") val language: String? ) 

 @Insert(onConflict = OnConflictStrategy.REPLACE)  suspend fun insertAll(repos: List<Repo>) 

@Query("SELECT * FROM repos WHERE " +   "name LIKE :queryString OR description LIKE :queryString " +   "ORDER BY stars DESC, name ASC") fun reposByName(queryString: String): PagingSource<Int, Repo> 

@Query("DELETE FROM repos") suspend fun clearRepos() 

@Dao interface RepoDao {      @Insert(onConflict = OnConflictStrategy.REPLACE)     suspend fun insertAll(repos: List<Repo>)      @Query("SELECT * FROM repos WHERE " +    "name LIKE :queryString OR description LIKE :queryString " +    "ORDER BY stars DESC, name ASC")     fun reposByName(queryString: String): PagingSource<Int, Repo>      @Query("DELETE FROM repos")     suspend fun clearRepos() } 

@Database(     entities = [Repo::class],     version = 1,     exportSchema = false ) abstract class RepoDatabase : RoomDatabase() {      abstract fun reposDao(): RepoDao      companion object {          @Volatile         private var INSTANCE: RepoDatabase? = null          fun getInstance(context: Context): RepoDatabase =                 INSTANCE ?: synchronized(this) {                     INSTANCE                             ?: buildDatabase(context).also { INSTANCE = it }                 }          private fun buildDatabase(context: Context) =                 Room.databaseBuilder(context.applicationContext,                         RepoDatabase::class.java, "Github.db")                         .build()     } } 

@OptIn(ExperimentalPagingApi::class) class GithubRemoteMediator(     private val query: String,     private val service: GithubService,     private val repoDatabase: RepoDatabase ) : RemoteMediator<Int, Repo>() {      override suspend fun load(loadType: LoadType, state: PagingState<Int, Repo>): MediatorResult {     } } 

@Entity(tableName = "remote_keys") data class RemoteKeys(     @PrimaryKey     val repoId: Long,     val prevKey: Int?,     val nextKey: Int? ) 

@Dao interface RemoteKeysDao {      @Insert(onConflict = OnConflictStrategy.REPLACE)     suspend fun insertAll(remoteKey: List<RemoteKeys>)      @Query("SELECT * FROM remote_keys WHERE repoId = :repoId")     suspend fun remoteKeysRepoId(repoId: Long): RemoteKeys?      @Query("DELETE FROM remote_keys")     suspend fun clearRemoteKeys() } 

@Database(         entities = [Repo::class, RemoteKeys::class],         version = 1,         exportSchema = false ) abstract class RepoDatabase : RoomDatabase() {      abstract fun reposDao(): RepoDao     abstract fun remoteKeysDao(): RemoteKeysDao      ...     // rest of the class doesn't change } 

override suspend fun load(loadType: LoadType, state: PagingState<Int, Repo>): MediatorResult {     val page = when (loadType) {         LoadType.REFRESH -> {          // TODO         }         LoadType.PREPEND -> {         // TODO         }         LoadType.APPEND -> {         // TODO         }     }     val apiQuery = query + IN_QUALIFIER      try {         val apiResponse = service.searchRepos(apiQuery, page, state.config.pageSize)          val repos = apiResponse.items         val endOfPaginationReached = repos.isEmpty()         repoDatabase.withTransaction {             // clear all tables in the database             if (loadType == LoadType.REFRESH) {                 repoDatabase.remoteKeysDao().clearRemoteKeys()                 repoDatabase.reposDao().clearRepos()             }             val prevKey = if (page == GITHUB_STARTING_PAGE_INDEX) null else page - 1             val nextKey = if (endOfPaginationReached) null else page + 1             val keys = repos.map {                 RemoteKeys(repoId = it.id, prevKey = prevKey, nextKey = nextKey)             }             repoDatabase.remoteKeysDao().insertAll(keys)             repoDatabase.reposDao().insertAll(repos)         }         return MediatorResult.Success(endOfPaginationReached = endOfPaginationReached)     } catch (exception: IOException) {         return MediatorResult.Error(exception)     } catch (exception: HttpException) {         return MediatorResult.Error(exception)     } } 

    private suspend fun getRemoteKeyForLastItem(state: PagingState<Int, Repo>): RemoteKeys? {         // Get the last page that was retrieved, that contained items.         // From that last page, get the last item         return state.pages.lastOrNull() { it.data.isNotEmpty() }?.data?.lastOrNull()                 ?.let { repo ->                     // Get the remote keys of the last item retrieved repoDatabase.remoteKeysDao().remoteKeysRepoId(repo.id)                 }     } 

val page = when (loadType) {     LoadType.APPEND -> {         val remoteKeys = getRemoteKeyForLastItem(state)         // If remoteKeys is null, that means the refresh result is not in the database yet.         // We can return Success with endOfPaginationReached = false because Paging         // will call this method again if RemoteKeys becomes non-null.         // If remoteKeys is NOT NULL but its nextKey is null, that means we've reached         // the end of pagination for append.         val nextKey = remoteKeys?.nextKey         if (nextKey == null) {             return MediatorResult.Success(endOfPaginationReached = remoteKeys != null)         }         nextKey     }       ...   } 

private suspend fun getRemoteKeyForFirstItem(state: PagingState<Int, Repo>): RemoteKeys? {     // Get the first page that was retrieved, that contained items.     // From that first page, get the first item     return state.pages.firstOrNull { it.data.isNotEmpty() }?.data?.firstOrNull()             ?.let { repo ->                 // Get the remote keys of the first items retrieved                 repoDatabase.remoteKeysDao().remoteKeysRepoId(repo.id)             } } 

val page = when (loadType) {     LoadType.PREPEND -> {         val remoteKeys = getRemoteKeyForFirstItem(state)         // If remoteKeys is null, that means the refresh result is not in the database yet.         val prevKey = remoteKeys?.prevKey         if (prevKey == null) {             return MediatorResult.Success(endOfPaginationReached = remoteKeys != null)         }         prevKey     }        ...   } 

private suspend fun getRemoteKeyClosestToCurrentPosition(         state: PagingState<Int, Repo> ): RemoteKeys? {     // The paging library is trying to load data after the anchor position     // Get the item closest to the anchor position     return state.anchorPosition?.let { position ->         state.closestItemToPosition(position)?.id?.let { repoId ->    repoDatabase.remoteKeysDao().remoteKeysRepoId(repoId)         }     } } 

val page = when (loadType) {     LoadType.REFRESH -> {         val remoteKeys = getRemoteKeyClosestToCurrentPosition(state)         remoteKeys?.nextKey?.minus(1) ?: GITHUB_STARTING_PAGE_INDEX     }     LoadType.PREPEND -> {         val remoteKeys = getRemoteKeyForFirstItem(state)         val prevKey = remoteKeys?.prevKey         if (prevKey == null) {             return MediatorResult.Success(endOfPaginationReached = remoteKeys != null)         }         prevKey     }     LoadType.APPEND -> {         val remoteKeys = getRemoteKeyForLastItem(state)         val nextKey = remoteKeys?.nextKey         if (nextKey == null) {             return MediatorResult.Success(endOfPaginationReached = remoteKeys != null)         }         nextKey     } } 

class GithubRepository(         private val service: GithubService,         private val database: RepoDatabase ) { ... } 

object Injection {     private fun provideGithubRepository(context: Context): GithubRepository {         return GithubRepository(GithubService.create(), RepoDatabase.getInstance(context))     }      fun provideViewModelFactory(context: Context, owner: SavedStateRegistryOwner): ViewModelProvider.Factory {         return ViewModelFactory(owner, provideGithubRepository(context))     } } 

       // get the view model         val viewModel = ViewModelProvider(             this, Injection.provideViewModelFactory(                 context = this,                 owner = this             )         )             .get(SearchRepositoriesViewModel::class.java) 

// appending '%' so we can allow other characters to be before and after the query string val dbQuery = "%${query.replace(' ', '%')}%" val pagingSourceFactory =  { database.reposDao().reposByName(dbQuery)} 

@OptIn(ExperimentalPagingApi::class) return Pager(         config = PagingConfig(             pageSize = NETWORK_PAGE_SIZE,             enablePlaceholders = false          ),         remoteMediator = GithubRemoteMediator(                 query,                 service,                 database         ),         pagingSourceFactory = pagingSourceFactory ).flow 

enum class RemotePresentationState {     INITIAL, REMOTE_LOADING, SOURCE_LOADING, PRESENTED } 

@OptIn(ExperimentalCoroutinesApi::class) fun Flow<CombinedLoadStates>.asRemotePresentationState(): Flow<RemotePresentationState> =     scan(RemotePresentationState.INITIAL) { state, loadState ->         when (state) {             RemotePresentationState.PRESENTED -> when (loadState.mediator?.refresh) {                 is LoadState.Loading -> RemotePresentationState.REMOTE_LOADING                 else -> state             }             RemotePresentationState.INITIAL -> when (loadState.mediator?.refresh) {                 is LoadState.Loading -> RemotePresentationState.REMOTE_LOADING                 else -> state             }             RemotePresentationState.REMOTE_LOADING -> when (loadState.source.refresh) {                 is LoadState.Loading -> RemotePresentationState.SOURCE_LOADING                 else -> state             }             RemotePresentationState.SOURCE_LOADING -> when (loadState.source.refresh) {                 is LoadState.NotLoading -> RemotePresentationState.PRESENTED                 else -> state             }         }     }         .distinctUntilChanged() 

       val notLoading = repoAdapter.loadStateFlow             .asRemotePresentationState()             .map { it == RemotePresentationState.PRESENTED } 

private fun ActivitySearchRepositoriesBinding.bindList(         header: ReposLoadStateAdapter,         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         ...          lifecycleScope.launch {             repoAdapter.loadStateFlow.collect { loadState ->                 ...                 val isListEmpty = loadState.refresh is LoadState.NotLoading && repoAdapter.itemCount == 0                 // show empty list                 emptyList.isVisible = isListEmpty                 // Only show the list if refresh succeeds, either from the the local db or the remote.                 list.isVisible =  loadState.source.refresh is LoadState.NotLoading || loadState.mediator?.refresh is LoadState.NotLoading                 // Show loading spinner during initial load or refresh.                 progressBar.isVisible = loadState.mediator?.refresh is LoadState.Loading                 // Show the retry state if initial load or refresh fails.                 retryButton.isVisible = loadState.mediator?.refresh is LoadState.Error && repoAdapter.itemCount == 0                 }             }         }     } 

private fun ActivitySearchRepositoriesBinding.bindList(         header: ReposLoadStateAdapter,         repoAdapter: ReposAdapter,         uiState: StateFlow<UiState>,         onScrollChanged: (UiAction.Scroll) -> Unit     ) {         ...          lifecycleScope.launch {             repoAdapter.loadStateFlow.collect { loadState ->                 // Show a retry header if there was an error refreshing, and items were previously                 // cached OR default to the default prepend state                 header.loadState = loadState.mediator                     ?.refresh                     ?.takeIf { it is LoadState.Error && repoAdapter.itemCount > 0 }                     ?: loadState.prepend                 ...             }         }     }