Making the RemoteMediator key conversion work

Author: florina-muntenescu

app/src/main/java/com/example/android/codelabs/paging/Injection.kt

@@ -22,6 +22,7 @@ import com.example.android.codelabs.paging.api.GithubService
 import com.example.android.codelabs.paging.data.GithubRepository
 import com.example.android.codelabs.paging.db.RepoDatabase
 import com.example.android.codelabs.paging.ui.ViewModelFactory
+import kotlinx.coroutines.Dispatchers
 
 /**
  * Class that handles object creation.
@@ -35,7 +36,7 @@ object Injection {
      * [GithubLocalCache]
      */
     private fun provideGithubRepository(context: Context): GithubRepository {
-        return GithubRepository(GithubService.create(), provideDatabase(context))
+        return GithubRepository(GithubService.create(), provideDatabase(context), Dispatchers.IO)
     }
 
     private fun provideDatabase(context: Context): RepoDatabase {

app/src/main/java/com/example/android/codelabs/paging/data/GithubRemoteMediator.kt

@@ -28,6 +28,7 @@ import com.example.android.codelabs.paging.db.RepoDatabase
 import com.example.android.codelabs.paging.model.Repo
 import retrofit2.HttpException
 import java.io.IOException
+import java.io.InvalidObjectException
 
 // GitHub page API is 1 based: https://developer.github.com/v3/#pagination
 const val GITHUB_STARTING_PAGE_INDEX = 1
@@ -38,50 +39,74 @@ class GithubRemoteMediator(
         private val repoDatabase: RepoDatabase
 ) : RemoteMediator<Int, Repo>() {
 
+    /**
+     * The paging library will call this method when there is no more data in the database to
+     * load from.
+     *
+     * For every item we retrieve we store the previous and next keys, so we know how to request
+     * more data, based on that specific item.
+     *
+     * state.pages holds the pages that were loaded until now and saved in the database.
+     *
+     * If the load type is REFRESH it means that we are in one of the following situations:
+     *  * it's the first time when the query was triggered and there was nothing saved yet in the
+     *  database
+     *  * a swipe to refresh was called
+     * If the load type is START, we need to rely on the first item available in the pages
+     * retrieved so far to compute they key for the previous page.
+     * If the load type is END, we need to rely on the last item available in the pages
+     * retrieved so far to compute they key for the next page.
+     */
     override suspend fun load(loadType: LoadType, state: PagingState<Int, Repo>): MediatorResult {
-        Log.d("GithubRemoteMediator", "load type: $loadType ")
-
-        if (loadType == LoadType.REFRESH) {
-            repoDatabase.withTransaction {
-                repoDatabase.reposDao().clearRepos()
-                repoDatabase.remoteKeysDao().clearRemoteKeys()
-            }
-        }
-        val remoteKeys = repoDatabase.remoteKeysDao().remoteKeys()
-                ?: RemoteKeys(null, GITHUB_STARTING_PAGE_INDEX)
-
         val page = when (loadType) {
-            LoadType.REFRESH -> remoteKeys.nextKey
-            LoadType.START -> remoteKeys.prevKey
-            LoadType.END -> remoteKeys.nextKey
-        }
-
-        if (page == null) {
-            return MediatorResult.Success(canRequestMoreData = false)
+            LoadType.REFRESH -> {
+                val remoteKeys = getRemoteKeyClosestToCurrentPosition(state)
+                remoteKeys?.nextKey?.minus(1) ?: GITHUB_STARTING_PAGE_INDEX
+            }
+            LoadType.START -> {
+                val remoteKeys = getRemoteKeyForFirstItem(state)
+                if (remoteKeys == null) {
+                    // The LoadType is START so some data was loaded before,
+                    // so we should have been able to get remote keys
+                    // If the remoteKeys are null, then we're an invalid state and we have a bug
+                    throw InvalidObjectException("Remote key and the prevKey should not be null")
+                }
+                // If the previous key is null, then we can't request more data
+                val prevKey = remoteKeys.prevKey
+                if (prevKey == null) {
+                    return MediatorResult.Success(canRequestMoreData = false)
+                }
+                remoteKeys.prevKey
+            }
+            LoadType.END -> {
+                val remoteKeys = getRemoteKeyForLastItem(state)
+                if (remoteKeys?.nextKey == null) {
+                    // The LoadType is END, so some data was loaded before,
+                    // so we should have been able to get remote keys
+                    // If the remoteKeys are null, then we're an invalid state and we have a bug
+                    throw InvalidObjectException("Remote key should not be null for $loadType")
+                }
+                remoteKeys.nextKey
+            }
         }
 
-        Log.d("GithubRemoteMediator", "page: $page")
-
         val apiQuery = query + IN_QUALIFIER
+
         try {
             val apiResponse = service.searchRepos(apiQuery, page, state.config.pageSize)
 
             return if (apiResponse.isSuccessful) {
                 val repos = apiResponse.body()?.items ?: emptyList()
                 val canRequestMoreData = repos.isNotEmpty()
-                val newRemoteKeys = RemoteKeys(
-                        prevKey = remoteKeys.nextKey,
-                        nextKey = if (canRequestMoreData) {
-                            (remoteKeys.nextKey ?: GITHUB_STARTING_PAGE_INDEX) + 1
-                        } else {
-                            null
-                        }
-                )
                 repoDatabase.withTransaction {
-                    repoDatabase.remoteKeysDao().replace(newRemoteKeys)
+                    val prevKey = if (page == GITHUB_STARTING_PAGE_INDEX) null else page - 1
+                    val nextKey = if (canRequestMoreData) page + 1 else null
+                    val keys = repos.map {
+                        RemoteKeys(repoId = it.id, prevKey = prevKey, nextKey = nextKey)
+                    }
+                    repoDatabase.remoteKeysDao().insertAll(keys)
                     repoDatabase.reposDao().insert(repos)
                 }
-                Log.d("GithubRemoteMediator", "data: ${repos.size}")
                 MediatorResult.Success(canRequestMoreData = canRequestMoreData)
             } else {
                 MediatorResult.Error(IOException(apiResponse.message()))
@@ -92,4 +117,46 @@ class GithubRemoteMediator(
             return MediatorResult.Error(exception)
         }
     }
+
+    /**
+     * Get the remote keys of on the last item retrieved
+     */
+    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)
+                }
+    }
+
+    /**
+     * Get the remote keys of the first item retrieved
+     */
+    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)
+                }
+    }
+
+    /**
+     * Get the remote keys of the closest item to the anchor position
+     */
+    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 ->
+                // Get the remote keys of the item
+                repoDatabase.remoteKeysDao().remoteKeysRepoId(repoId)
+            }
+        }
+    }
 }

app/src/main/java/com/example/android/codelabs/paging/data/GithubRepository.kt

@@ -20,29 +20,49 @@ import android.util.Log
 import androidx.paging.PagingConfig
 import androidx.paging.PagingData
 import androidx.paging.PagingDataFlow
+import androidx.room.withTransaction
 import com.example.android.codelabs.paging.api.GithubService
 import com.example.android.codelabs.paging.db.RepoDatabase
 import com.example.android.codelabs.paging.model.Repo
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.launch
 
 /**
  * Repository class that works with local and remote data sources.
  */
 @ExperimentalCoroutinesApi
 class GithubRepository(
         private val service: GithubService,
-        private val database: RepoDatabase
+        private val database: RepoDatabase,
+        private val dispatcher: CoroutineDispatcher
 ) {
 
+    private val parentJob = SupervisorJob()
+    private val scope = CoroutineScope(dispatcher + parentJob)
+
     /**
      * Search repositories whose names match the query, exposed as a stream of data that will emit
      * every time we get more data from the network.
      */
     fun getSearchResultStream(query: String): Flow<PagingData<Repo>> {
+        // New query, so clear the database
+        scope.launch {
+            database.withTransaction {
+                database.remoteKeysDao().clearRemoteKeys()
+                database.reposDao().clearRepos()
+            }
+        }
+
         Log.d("GithubRepository", "New query: $query")
 
-        val pagingSourceFactory = database.reposDao().reposByName().asPagingSourceFactory()
+        // 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).asPagingSourceFactory()
+
         return PagingDataFlow(
                 config = PagingConfig(pageSize = NETWORK_PAGE_SIZE),
                 remoteMediator = GithubRemoteMediator(

app/src/main/java/com/example/android/codelabs/paging/db/RemoteKeys.kt

@@ -21,7 +21,8 @@ import androidx.room.PrimaryKey
 
 @Entity(tableName = "remote_keys")
 data class RemoteKeys(
-        @PrimaryKey(autoGenerate = true)
+        @PrimaryKey
+        val repoId: Long,
         val prevKey: Int?,
         val nextKey: Int?
 )

app/src/main/java/com/example/android/codelabs/paging/db/RemoteKeysDao.kt

@@ -19,7 +19,6 @@ package com.example.android.codelabs.paging.db
 import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.Query
-import androidx.room.Transaction
 
 /**
  * Room data access object for accessing the [RemoteKeys] table
@@ -28,16 +27,10 @@ import androidx.room.Transaction
 interface RemoteKeysDao {
 
     @Insert
-    suspend fun insert(remoteKey: RemoteKeys)
+    suspend fun insertAll(remoteKey: List<RemoteKeys>)
 
-    @Query("SELECT * FROM remote_keys LIMIT 1")
-    suspend fun remoteKeys(): RemoteKeys?
-
-    @Transaction
-    suspend fun replace(remoteKey: RemoteKeys) {
-        clearRemoteKeys()
-        insert(remoteKey)
-    }
+    @Query("SELECT * FROM remote_keys WHERE repoId = :repoId")
+    suspend fun remoteKeysRepoId(repoId: Long): RemoteKeys?
 
     @Query("DELETE FROM remote_keys")
     suspend fun clearRemoteKeys()

app/src/main/java/com/example/android/codelabs/paging/db/RepoDao.kt

@@ -30,13 +30,15 @@ import com.example.android.codelabs.paging.model.Repo
 interface RepoDao {
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insert(posts: List<Repo>)
+    suspend fun insert(repos: List<Repo>)
 
     // Do a similar query as the search API:
     // Look for repos that contain the query string in the name or in the description
     // and order those results descending, by the number of stars and then by name
-    @Query("SELECT * FROM repos ORDER BY stars DESC, name ASC")
-    fun reposByName(): DataSource.Factory<Int, Repo>
+    @Query("SELECT * FROM repos WHERE " +
+            "name LIKE :queryString OR description LIKE :queryString " +
+            "ORDER BY stars DESC, name ASC")
+    fun reposByName(queryString: String): DataSource.Factory<Int, Repo>
 
     @Query("DELETE FROM repos")
     suspend fun clearRepos()

app/src/main/java/com/example/android/codelabs/paging/ui/ReposAdapter.kt

@@ -40,7 +40,7 @@ class ReposAdapter : PagingDataAdapter<UiModel, ViewHolder>(UIMODEL_COMPARATOR)
         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")
+            null -> throw UnsupportedOperationException("Unknown view for position $position")
         }
     }
 

app/src/main/java/com/example/android/codelabs/paging/ui/SearchRepositoriesActivity.kt

@@ -130,7 +130,6 @@ class SearchRepositoriesActivity : AppCompatActivity() {
         searchJob?.cancel()
         searchJob = lifecycleScope.launch {
             viewModel.searchRepo(query).collect {
-                Log.d("SearchRepositoriesActivity", "query: $query, collecting $it")
                 adapter.presentData(it)
             }
         }

build.gradle

@@ -35,7 +35,7 @@ allprojects {
     repositories {
         google()
         jcenter()
-        maven { url 'https://androidx-dev-prod.appspot.com/snapshots/builds/6397162/artifacts/repository' }
+        maven { url 'https://androidx-dev-prod.appspot.com/snapshots/builds/6416866/artifacts/repository' }
     }
 }