Merge "PayloadToggle domain layer preview data population" into main

18 files changed, 1074 insertions, 9 deletions

diff --git a/java/src/com/android/intentresolver/contentpreview/PreviewViewModel.kt b/java/src/com/android/intentresolver/contentpreview/PreviewViewModel.kt
index d694c6ff..2468bb57 100644
--- a/java/src/com/android/intentresolver/contentpreview/PreviewViewModel.kt
+++ b/java/src/com/android/intentresolver/contentpreview/PreviewViewModel.kt
@@ -114,7 +114,7 @@ class PreviewViewModel(
                     chooserIntent
                 )
             },
-            UriMetadataReader(contentResolver, DefaultMimeTypeClassifier),
+            UriMetadataReaderImpl(contentResolver, DefaultMimeTypeClassifier)::getMetadata,
             TargetIntentModifier(targetIntent, getUri = { uri }, getMimeType = { mimeType }),
             SelectionChangeCallback(contentProviderUri, chooserIntent, contentResolver)
         )
diff --git a/java/src/com/android/intentresolver/contentpreview/UriMetadataReader.kt b/java/src/com/android/intentresolver/contentpreview/UriMetadataReader.kt
index 45515e25..b5361889 100644
--- a/java/src/com/android/intentresolver/contentpreview/UriMetadataReader.kt
+++ b/java/src/com/android/intentresolver/contentpreview/UriMetadataReader.kt
@@ -20,12 +20,24 @@ import android.content.ContentInterface
 import android.media.MediaMetadata
 import android.net.Uri
 import android.provider.DocumentsContract
+import dagger.Binds
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Inject
 
-class UriMetadataReader(
+fun interface UriMetadataReader {
+    fun getMetadata(uri: Uri): FileInfo
+}
+
+class UriMetadataReaderImpl
+@Inject
+constructor(
     private val contentResolver: ContentInterface,
     private val typeClassifier: MimeTypeClassifier,
-) : (Uri) -> FileInfo {
-    fun getMetadata(uri: Uri): FileInfo {
+) : UriMetadataReader {
+    override fun getMetadata(uri: Uri): FileInfo {
         val builder = FileInfo.Builder(uri)
         val mimeType = contentResolver.getTypeSafe(uri)
         builder.withMimeType(mimeType)
@@ -44,8 +56,6 @@ class UriMetadataReader(
         return builder.build()
     }
 
-    override fun invoke(uri: Uri): FileInfo = getMetadata(uri)
-
     private fun ContentInterface.supportsImageType(uri: Uri): Boolean =
         getStreamTypesSafe(uri).firstOrNull { typeClassifier.isImageType(it) } != null
 
@@ -64,3 +74,14 @@ class UriMetadataReader(
             }
         }
 }
+
+@Module
+@InstallIn(SingletonComponent::class)
+interface UriMetadataReaderModule {
+
+    @Binds fun bind(impl: UriMetadataReaderImpl): UriMetadataReader
+
+    companion object {
+        @Provides fun classifier(): MimeTypeClassifier = DefaultMimeTypeClassifier
+    }
+}
diff --git a/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/cursor/CursorResolver.kt b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/cursor/CursorResolver.kt
new file mode 100644
index 00000000..3aa0d567
--- /dev/null
+++ b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/cursor/CursorResolver.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.contentpreview.payloadtoggle.domain.cursor
+
+import com.android.intentresolver.util.cursor.CursorView
+
+/** Asynchronously retrieves a [CursorView]. */
+fun interface CursorResolver<out T> {
+    suspend fun getCursor(): CursorView<T>?
+}
diff --git a/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/cursor/PayloadToggleCursorResolver.kt b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/cursor/PayloadToggleCursorResolver.kt
new file mode 100644
index 00000000..286891d1
--- /dev/null
+++ b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/cursor/PayloadToggleCursorResolver.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.contentpreview.payloadtoggle.domain.cursor
+
+import android.content.ContentResolver
+import android.content.Intent
+import android.net.Uri
+import android.service.chooser.AdditionalContentContract.Columns.URI
+import com.android.intentresolver.inject.AdditionalContent
+import com.android.intentresolver.inject.ChooserIntent
+import com.android.intentresolver.util.Bundle
+import com.android.intentresolver.util.cursor.CursorView
+import com.android.intentresolver.util.cursor.viewBy
+import com.android.intentresolver.util.withCancellationSignal
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ViewModelComponent
+import javax.inject.Inject
+import javax.inject.Qualifier
+
+/** [CursorResolver] for the [CursorView] underpinning Shareousel. */
+class PayloadToggleCursorResolver
+@Inject
+constructor(
+    private val contentResolver: ContentResolver,
+    @AdditionalContent private val cursorUri: Uri,
+    @ChooserIntent private val chooserIntent: Intent,
+) : CursorResolver<Uri?> {
+    override suspend fun getCursor(): CursorView<Uri?>? = withCancellationSignal { signal ->
+        runCatching {
+                contentResolver.query(
+                    cursorUri,
+                    arrayOf(URI),
+                    Bundle { putParcelable(Intent.EXTRA_INTENT, chooserIntent) },
+                    signal,
+                )
+            }
+            .getOrNull()
+            ?.viewBy {
+                getString(0)?.let(Uri::parse)?.takeIf { it.authority != cursorUri.authority }
+            }
+    }
+
+    @Module
+    @InstallIn(ViewModelComponent::class)
+    interface Binding {
+        @Binds
+        @PayloadToggle
+        fun bind(cursorResolver: PayloadToggleCursorResolver): CursorResolver<Uri?>
+    }
+}
+
+/** [CursorResolver] for the [CursorView] underpinning Shareousel. */
+@Qualifier @MustBeDocumented @Retention(AnnotationRetention.RUNTIME) annotation class PayloadToggle
diff --git a/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/CursorPreviewsInteractor.kt b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/CursorPreviewsInteractor.kt
new file mode 100644
index 00000000..f642f420
--- /dev/null
+++ b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/CursorPreviewsInteractor.kt
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package com.android.intentresolver.contentpreview.payloadtoggle.domain.interactor
+
+import android.net.Uri
+import android.service.chooser.AdditionalContentContract.CursorExtraKeys.POSITION
+import com.android.intentresolver.contentpreview.UriMetadataReader
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.LoadDirection
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.LoadedWindow
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.expandWindowLeft
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.expandWindowRight
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.numLoadedPages
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.shiftWindowLeft
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.shiftWindowRight
+import com.android.intentresolver.contentpreview.payloadtoggle.shared.model.PreviewModel
+import com.android.intentresolver.inject.FocusedItemIndex
+import com.android.intentresolver.util.cursor.CursorView
+import com.android.intentresolver.util.cursor.PagedCursor
+import com.android.intentresolver.util.cursor.get
+import com.android.intentresolver.util.cursor.paged
+import com.android.intentresolver.util.mapParallel
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+import javax.inject.Qualifier
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.mapLatest
+
+/** Queries data from a remote cursor, and caches it locally for presentation in Shareousel. */
+class CursorPreviewsInteractor
+@Inject
+constructor(
+    private val interactor: SetCursorPreviewsInteractor,
+    @FocusedItemIndex private val focusedItemIdx: Int,
+    private val uriMetadataReader: UriMetadataReader,
+    @PageSize private val pageSize: Int,
+    @MaxLoadedPages private val maxLoadedPages: Int,
+) {
+
+    init {
+        check(pageSize > 0) { "pageSize must be greater than zero" }
+    }
+
+    /** Start reading data from [uriCursor], and listen for requests to load more. */
+    suspend fun launch(uriCursor: CursorView<Uri?>, initialPreviews: Iterable<PreviewModel>) {
+        // Unclaimed values from the initial selection set. Entries will be removed as the cursor is
+        // read, and any still present are inserted at the start / end of the cursor when it is
+        // reached by the user.
+        val unclaimedRecords: MutableUnclaimedMap =
+            initialPreviews
+                .asSequence()
+                .mapIndexed { i, m -> Pair(m.uri, Pair(i, m)) }
+                .toMap(ConcurrentHashMap())
+        val pagedCursor: PagedCursor<Uri?> = uriCursor.paged(pageSize)
+        val startPosition = uriCursor.extras?.getInt(POSITION, 0) ?: 0
+        val state = readInitialState(pagedCursor, startPosition, unclaimedRecords)
+        processLoadRequests(state, pagedCursor, unclaimedRecords)
+    }
+
+    /** Loop forever, processing any loading requests from the UI and updating local cache. */
+    private suspend fun processLoadRequests(
+        initialState: CursorWindow,
+        pagedCursor: PagedCursor<Uri?>,
+        unclaimedRecords: MutableUnclaimedMap,
+    ) {
+        var state = initialState
+        while (true) {
+            // Design note: in order to prevent load requests from the UI when it was displaying a
+            // previously-published dataset being accidentally associated with a recently-published
+            // one, we generate a new Flow of load requests for each dataset and only listen to
+            // those.
+            val loadingState: Flow<LoadDirection?> =
+                interactor.setPreviews(
+                    previewsByKey = state.merged.values.toSet(),
+                    startIndex = 0, // TODO: actually track this as the window changes?
+                    hasMoreLeft = state.hasMoreLeft,
+                    hasMoreRight = state.hasMoreRight,
+                )
+            state = loadingState.handleOneLoadRequest(state, pagedCursor, unclaimedRecords)
+        }
+    }
+
+    /**
+     * Suspends until a single loading request has been handled, returning the new [CursorWindow]
+     * with the loaded data incorporated.
+     */
+    private suspend fun Flow<LoadDirection?>.handleOneLoadRequest(
+        state: CursorWindow,
+        pagedCursor: PagedCursor<Uri?>,
+        unclaimedRecords: MutableUnclaimedMap,
+    ): CursorWindow =
+        mapLatest { loadDirection ->
+                loadDirection?.let {
+                    when (loadDirection) {
+                        LoadDirection.Left -> state.loadMoreLeft(pagedCursor, unclaimedRecords)
+                        LoadDirection.Right -> state.loadMoreRight(pagedCursor, unclaimedRecords)
+                    }
+                }
+            }
+            .filterNotNull()
+            .first()
+
+    /**
+     * Returns the initial [CursorWindow], with a single page loaded that contains the given
+     * [startPosition].
+     */
+    private suspend fun readInitialState(
+        cursor: PagedCursor<Uri?>,
+        startPosition: Int,
+        unclaimedRecords: MutableUnclaimedMap,
+    ): CursorWindow {
+        val startPageIdx = startPosition / pageSize
+        val hasMoreLeft = startPageIdx > 0
+        val hasMoreRight = startPageIdx < cursor.count - 1
+        val page: PreviewMap = buildMap {
+            if (!hasMoreLeft) {
+                // First read the initial page; this might claim some unclaimed Uris
+                val page =
+                    cursor.getPageUris(startPageIdx)?.toPage(mutableMapOf(), unclaimedRecords)
+                // Now that unclaimed Uris are up-to-date, add them first.
+                putAllUnclaimedLeft(unclaimedRecords)
+                // Then add the loaded page
+                page?.let(::putAll)
+            } else {
+                cursor.getPageUris(startPageIdx)?.toPage(this, unclaimedRecords)
+            }
+            // Finally, add the remainder of the unclaimed Uris.
+            if (!hasMoreRight) {
+                putAllUnclaimedRight(unclaimedRecords)
+            }
+        }
+        return CursorWindow(
+            firstLoadedPageNum = startPageIdx,
+            lastLoadedPageNum = startPageIdx,
+            pages = listOf(page.keys),
+            merged = page,
+            hasMoreLeft = hasMoreLeft,
+            hasMoreRight = hasMoreRight,
+        )
+    }
+
+    private suspend fun CursorWindow.loadMoreRight(
+        cursor: PagedCursor<Uri?>,
+        unclaimedRecords: MutableUnclaimedMap,
+    ): CursorWindow {
+        val pageNum = lastLoadedPageNum + 1
+        val hasMoreRight = pageNum < cursor.count - 1
+        val newPage: PreviewMap = buildMap {
+            readAndPutPage(this@loadMoreRight, cursor, pageNum, unclaimedRecords)
+            if (!hasMoreRight) {
+                putAllUnclaimedRight(unclaimedRecords)
+            }
+        }
+        return if (numLoadedPages < maxLoadedPages) {
+            expandWindowRight(newPage, hasMoreRight)
+        } else {
+            shiftWindowRight(newPage, hasMoreRight)
+        }
+    }
+
+    private suspend fun CursorWindow.loadMoreLeft(
+        cursor: PagedCursor<Uri?>,
+        unclaimedRecords: MutableUnclaimedMap,
+    ): CursorWindow {
+        val pageNum = firstLoadedPageNum - 1
+        val hasMoreLeft = pageNum > 0
+        val newPage: PreviewMap = buildMap {
+            if (!hasMoreLeft) {
+                // First read the page; this might claim some unclaimed Uris
+                val page = readPage(this@loadMoreLeft, cursor, pageNum, unclaimedRecords)
+                // Now that unclaimed URIs are up-to-date, add them first
+                putAllUnclaimedLeft(unclaimedRecords)
+                // Then add the loaded page
+                putAll(page)
+            } else {
+                readAndPutPage(this@loadMoreLeft, cursor, pageNum, unclaimedRecords)
+            }
+        }
+        return if (numLoadedPages < maxLoadedPages) {
+            expandWindowLeft(newPage, hasMoreLeft)
+        } else {
+            shiftWindowLeft(newPage, hasMoreLeft)
+        }
+    }
+
+    private suspend fun readPage(
+        state: CursorWindow,
+        pagedCursor: PagedCursor<Uri?>,
+        pageNum: Int,
+        unclaimedRecords: MutableUnclaimedMap,
+    ): PreviewMap =
+        mutableMapOf<Uri, PreviewModel>()
+            .readAndPutPage(state, pagedCursor, pageNum, unclaimedRecords)
+
+    private suspend fun <M : MutablePreviewMap> M.readAndPutPage(
+        state: CursorWindow,
+        pagedCursor: PagedCursor<Uri?>,
+        pageNum: Int,
+        unclaimedRecords: MutableUnclaimedMap,
+    ): M =
+        pagedCursor
+            .getPageUris(pageNum) // TODO: what do we do if the load fails?
+            ?.filter { it !in state.merged }
+            ?.toPage(this, unclaimedRecords)
+            ?: this
+
+    private suspend fun <M : MutablePreviewMap> Sequence<Uri>.toPage(
+        destination: M,
+        unclaimedRecords: MutableUnclaimedMap,
+    ): M =
+        // Restrict parallelism so as to not overload the metadata reader; anecdotally, too
+        // many parallel queries causes failures.
+        mapParallel(parallelism = 4) { uri -> createPreviewModel(uri, unclaimedRecords) }
+            .associateByTo(destination) { it.uri }
+
+    private fun createPreviewModel(uri: Uri, unclaimedRecords: MutableUnclaimedMap): PreviewModel =
+        unclaimedRecords.remove(uri)?.second
+            ?: PreviewModel(
+                uri = uri,
+                mimeType = uriMetadataReader.getMetadata(uri).mimeType,
+            )
+
+    private fun <M : MutablePreviewMap> M.putAllUnclaimedRight(unclaimed: UnclaimedMap): M =
+        putAllUnclaimedWhere(unclaimed) { it >= focusedItemIdx }
+
+    private fun <M : MutablePreviewMap> M.putAllUnclaimedLeft(unclaimed: UnclaimedMap): M =
+        putAllUnclaimedWhere(unclaimed) { it < focusedItemIdx }
+}
+
+private typealias CursorWindow = LoadedWindow<Uri, PreviewModel>
+
+/**
+ * Values from the initial selection set that have not yet appeared within the Cursor. These values
+ * are appended to the start/end of the cursor dataset, depending on their position relative to the
+ * initially focused value.
+ */
+private typealias UnclaimedMap = Map<Uri, Pair<Int, PreviewModel>>
+
+/** Mutable version of [UnclaimedMap]. */
+private typealias MutableUnclaimedMap = MutableMap<Uri, Pair<Int, PreviewModel>>
+
+private typealias MutablePreviewMap = MutableMap<Uri, PreviewModel>
+
+private typealias PreviewMap = Map<Uri, PreviewModel>
+
+private fun <M : MutablePreviewMap> M.putAllUnclaimedWhere(
+    unclaimedRecords: UnclaimedMap,
+    predicate: (Int) -> Boolean,
+): M =
+    unclaimedRecords
+        .asSequence()
+        .filter { predicate(it.value.first) }
+        .map { it.key to it.value.second }
+        .toMap(this)
+
+private fun PagedCursor<Uri?>.getPageUris(pageNum: Int): Sequence<Uri>? =
+    get(pageNum)?.filterNotNull()
+
+@Qualifier @MustBeDocumented @Retention(AnnotationRetention.RUNTIME) annotation class PageSize
+
+@Qualifier
+@MustBeDocumented
+@Retention(AnnotationRetention.RUNTIME)
+annotation class MaxLoadedPages
+
+@Module
+@InstallIn(SingletonComponent::class)
+object ShareouselConstants {
+    @Provides @PageSize fun pageSize(): Int = 16
+
+    @Provides @MaxLoadedPages fun maxLoadedPages(): Int = 3
+}
diff --git a/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/FetchPreviewsInteractor.kt b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/FetchPreviewsInteractor.kt
new file mode 100644
index 00000000..032692cd
--- /dev/null
+++ b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/FetchPreviewsInteractor.kt
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.contentpreview.payloadtoggle.domain.interactor
+
+import android.net.Uri
+import com.android.intentresolver.contentpreview.UriMetadataReader
+import com.android.intentresolver.contentpreview.payloadtoggle.data.repository.PreviewSelectionsRepository
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.cursor.CursorResolver
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.cursor.PayloadToggle
+import com.android.intentresolver.contentpreview.payloadtoggle.shared.model.PreviewModel
+import com.android.intentresolver.inject.ContentUris
+import com.android.intentresolver.inject.FocusedItemIndex
+import com.android.intentresolver.util.mapParallel
+import javax.inject.Inject
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+
+/** Populates the data displayed in Shareousel. */
+class FetchPreviewsInteractor
+@Inject
+constructor(
+    private val setCursorPreviews: SetCursorPreviewsInteractor,
+    private val selectionRepository: PreviewSelectionsRepository,
+    private val cursorInteractor: CursorPreviewsInteractor,
+    @FocusedItemIndex private val focusedItemIdx: Int,
+    @ContentUris private val selectedItems: List<@JvmSuppressWildcards Uri>,
+    private val uriMetadataReader: UriMetadataReader,
+    @PayloadToggle private val cursorResolver: CursorResolver<@JvmSuppressWildcards Uri?>,
+) {
+    suspend fun launch() = coroutineScope {
+        val cursor = async { cursorResolver.getCursor() }
+        val initialPreviewMap: Set<PreviewModel> = getInitialPreviews()
+        selectionRepository.selections.value = initialPreviewMap
+        setCursorPreviews.setPreviews(
+            previewsByKey = initialPreviewMap,
+            startIndex = focusedItemIdx,
+            hasMoreLeft = false,
+            hasMoreRight = false,
+        )
+        cursorInteractor.launch(cursor.await() ?: return@coroutineScope, initialPreviewMap)
+    }
+
+    private suspend fun getInitialPreviews(): Set<PreviewModel> =
+        selectedItems
+            // Restrict parallelism so as to not overload the metadata reader; anecdotally, too
+            // many parallel queries causes failures.
+            .mapParallel(parallelism = 4) { uri ->
+                PreviewModel(uri = uri, mimeType = uriMetadataReader.getMetadata(uri).mimeType)
+            }
+            .toSet()
+}
diff --git a/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/SetCursorPreviewsInteractor.kt b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/SetCursorPreviewsInteractor.kt
new file mode 100644
index 00000000..21a599fa
--- /dev/null
+++ b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/interactor/SetCursorPreviewsInteractor.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.contentpreview.payloadtoggle.domain.interactor
+
+import com.android.intentresolver.contentpreview.payloadtoggle.data.repository.CursorPreviewsRepository
+import com.android.intentresolver.contentpreview.payloadtoggle.domain.model.LoadDirection
+import com.android.intentresolver.contentpreview.payloadtoggle.shared.model.PreviewModel
+import com.android.intentresolver.contentpreview.payloadtoggle.shared.model.PreviewsModel
+import javax.inject.Inject
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/** Updates [CursorPreviewsRepository] with new previews. */
+class SetCursorPreviewsInteractor
+@Inject
+constructor(private val previewsRepo: CursorPreviewsRepository) {
+    /** Stores new [previewsByKey], and returns a flow of load requests triggered by Shareousel. */
+    fun setPreviews(
+        previewsByKey: Set<PreviewModel>,
+        startIndex: Int,
+        hasMoreLeft: Boolean,
+        hasMoreRight: Boolean,
+    ): Flow<LoadDirection?> {
+        val loadingState = MutableStateFlow<LoadDirection?>(null)
+        previewsRepo.previewsModel.value =
+            PreviewsModel(
+                previewModels = previewsByKey,
+                startIdx = startIndex,
+                loadMoreLeft =
+                    if (hasMoreLeft) {
+                        ({ loadingState.value = LoadDirection.Left })
+                    } else {
+                        null
+                    },
+                loadMoreRight =
+                    if (hasMoreRight) {
+                        ({ loadingState.value = LoadDirection.Right })
+                    } else {
+                        null
+                    },
+            )
+        return loadingState.asStateFlow()
+    }
+}
diff --git a/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/model/LoadDirection.kt b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/model/LoadDirection.kt
new file mode 100644
index 00000000..23510f15
--- /dev/null
+++ b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/model/LoadDirection.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.contentpreview.payloadtoggle.domain.model
+
+/** Specifies which side of the dataset is being loaded. */
+enum class LoadDirection {
+    Left,
+    Right,
+}
diff --git a/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/model/LoadedWindow.kt b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/model/LoadedWindow.kt
new file mode 100644
index 00000000..e2e69852
--- /dev/null
+++ b/java/src/com/android/intentresolver/contentpreview/payloadtoggle/domain/model/LoadedWindow.kt
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.contentpreview.payloadtoggle.domain.model
+
+/** A window of data loaded from a cursor. */
+data class LoadedWindow<K, V>(
+    /** First cursor page index loaded within this window. */
+    val firstLoadedPageNum: Int,
+    /** Last cursor page index loaded within this window. */
+    val lastLoadedPageNum: Int,
+    /** Keys of cursor data within this window, grouped by loaded page. */
+    val pages: List<Set<K>>,
+    /** Merged set of all cursor data within this window. */
+    val merged: Map<K, V>,
+    /** Is there more data to the left of this window? */
+    val hasMoreLeft: Boolean,
+    /** Is there more data to the right of this window? */
+    val hasMoreRight: Boolean,
+)
+
+/** Number of loaded pages stored within this [LoadedWindow]. */
+val LoadedWindow<*, *>.numLoadedPages: Int
+    get() = (lastLoadedPageNum - firstLoadedPageNum) + 1
+
+/** Inserts [newPage] to the right, and removes the leftmost page from the window. */
+fun <K, V> LoadedWindow<K, V>.shiftWindowRight(
+    newPage: Map<K, V>,
+    hasMore: Boolean,
+): LoadedWindow<K, V> =
+    LoadedWindow(
+        firstLoadedPageNum = firstLoadedPageNum + 1,
+        lastLoadedPageNum = lastLoadedPageNum + 1,
+        pages = pages.drop(1) + listOf(newPage.keys),
+        merged =
+            buildMap {
+                putAll(merged)
+                pages.first().forEach(::remove)
+                putAll(newPage)
+            },
+        hasMoreLeft = true,
+        hasMoreRight = hasMore,
+    )
+
+/** Inserts [newPage] to the right, increasing the size of the window to accommodate it. */
+fun <K, V> LoadedWindow<K, V>.expandWindowRight(
+    newPage: Map<K, V>,
+    hasMore: Boolean,
+): LoadedWindow<K, V> =
+    LoadedWindow(
+        firstLoadedPageNum = firstLoadedPageNum,
+        lastLoadedPageNum = lastLoadedPageNum + 1,
+        pages = pages + listOf(newPage.keys),
+        merged = merged + newPage,
+        hasMoreLeft = hasMoreLeft,
+        hasMoreRight = hasMore,
+    )
+
+/** Inserts [newPage] to the left, and removes the rightmost page from the window. */
+fun <K, V> LoadedWindow<K, V>.shiftWindowLeft(
+    newPage: Map<K, V>,
+    hasMore: Boolean,
+): LoadedWindow<K, V> =
+    LoadedWindow(
+        firstLoadedPageNum = firstLoadedPageNum - 1,
+        lastLoadedPageNum = lastLoadedPageNum - 1,
+        pages = listOf(newPage.keys) + pages.dropLast(1),
+        merged =
+            buildMap {
+                putAll(newPage)
+                putAll(merged - pages.last())
+            },
+        hasMoreLeft = hasMore,
+        hasMoreRight = true,
+    )
+
+/** Inserts [newPage] to the left, increasing the size olf the window to accommodate it. */
+fun <K, V> LoadedWindow<K, V>.expandWindowLeft(
+    newPage: Map<K, V>,
+    hasMore: Boolean,
+): LoadedWindow<K, V> =
+    LoadedWindow(
+        firstLoadedPageNum = firstLoadedPageNum - 1,
+        lastLoadedPageNum = lastLoadedPageNum,
+        pages = listOf(newPage.keys) + pages,
+        merged = newPage + merged,
+        hasMoreLeft = hasMore,
+        hasMoreRight = hasMoreRight,
+    )
diff --git a/java/src/com/android/intentresolver/inject/ActivityModelModule.kt b/java/src/com/android/intentresolver/inject/ActivityModelModule.kt
index 9a8b8768..c08c7f4c 100644
--- a/java/src/com/android/intentresolver/inject/ActivityModelModule.kt
+++ b/java/src/com/android/intentresolver/inject/ActivityModelModule.kt
@@ -17,8 +17,10 @@
 package com.android.intentresolver.inject
 
 import android.content.Intent
+import android.net.Uri
 import android.service.chooser.ChooserAction
 import androidx.lifecycle.SavedStateHandle
+import com.android.intentresolver.util.ownedByCurrentUser
 import com.android.intentresolver.v2.ui.model.ActivityModel
 import com.android.intentresolver.v2.ui.model.ChooserRequest
 import com.android.intentresolver.v2.ui.viewmodel.readChooserRequest
@@ -41,6 +43,10 @@ object ActivityModelModule {
         }
 
     @Provides
+    @ChooserIntent
+    fun chooserIntent(activityModel: ActivityModel): Intent = activityModel.intent
+
+    @Provides
     @ViewModelScoped
     fun provideChooserRequest(
         activityModel: ActivityModel,
@@ -57,6 +63,57 @@ object ActivityModelModule {
         requireNotNull((chooserReq as? Valid)?.value?.chooserActions) {
             "no chooser actions available"
         }
+
+    @Provides
+    @ViewModelScoped
+    @ContentUris
+    fun selectedUris(chooserRequest: ValidationResult<ChooserRequest>): List<Uri> =
+        requireNotNull((chooserRequest as? Valid)?.value?.targetIntent?.contentUris?.toList()) {
+            "no selected uris available"
+        }
+
+    @Provides
+    @FocusedItemIndex
+    fun focusedItemIndex(chooserReq: ValidationResult<ChooserRequest>): Int =
+        requireNotNull((chooserReq as? Valid)?.value?.focusedItemPosition) {
+            "no focused item position available"
+        }
+
+    @Provides
+    @AdditionalContent
+    fun additionalContentUri(chooserReq: ValidationResult<ChooserRequest>): Uri =
+        requireNotNull((chooserReq as? Valid)?.value?.additionalContentUri) {
+            "no additional content uri available"
+        }
 }
 
+@Qualifier
+@MustBeDocumented
+@Retention(AnnotationRetention.RUNTIME)
+annotation class FocusedItemIndex
+
+@Qualifier
+@MustBeDocumented
+@Retention(AnnotationRetention.RUNTIME)
+annotation class AdditionalContent
+
+@Qualifier @MustBeDocumented @Retention(AnnotationRetention.RUNTIME) annotation class ChooserIntent
+
+@Qualifier @MustBeDocumented @Retention(AnnotationRetention.RUNTIME) annotation class ContentUris
+
 @Qualifier @MustBeDocumented @Retention(AnnotationRetention.RUNTIME) annotation class TargetIntent
+
+private val Intent.contentUris: Sequence<Uri>
+    get() = sequence {
+        if (Intent.ACTION_SEND == action) {
+            getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
+                ?.takeIf { it.ownedByCurrentUser }
+                ?.let { yield(it) }
+        } else {
+            getParcelableArrayListExtra(Intent.EXTRA_STREAM, Uri::class.java)?.forEach { uri ->
+                if (uri.ownedByCurrentUser) {
+                    yield(uri)
+                }
+            }
+        }
+    }
diff --git a/java/src/com/android/intentresolver/inject/SystemServices.kt b/java/src/com/android/intentresolver/inject/SystemServices.kt
index 32894d43..4762f4a1 100644
--- a/java/src/com/android/intentresolver/inject/SystemServices.kt
+++ b/java/src/com/android/intentresolver/inject/SystemServices.kt
@@ -18,12 +18,15 @@ package com.android.intentresolver.inject
 import android.app.ActivityManager
 import android.app.admin.DevicePolicyManager
 import android.content.ClipboardManager
+import android.content.ContentInterface
+import android.content.ContentResolver
 import android.content.Context
 import android.content.pm.LauncherApps
 import android.content.pm.ShortcutManager
 import android.os.UserManager
 import android.view.WindowManager
 import androidx.core.content.getSystemService
+import dagger.Binds
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -52,9 +55,13 @@ class ClipboardManagerModule {
 
 @Module
 @InstallIn(SingletonComponent::class)
-class ContentResolverModule {
-    @Provides
-    fun contentResolver(@ApplicationContext ctx: Context) = requireNotNull(ctx.contentResolver)
+interface ContentResolverModule {
+    @Binds fun bindContentInterface(cr: ContentResolver): ContentInterface
+
+    companion object {
+        @Provides
+        fun contentResolver(@ApplicationContext ctx: Context) = requireNotNull(ctx.contentResolver)
+    }
 }
 
 @Module
diff --git a/java/src/com/android/intentresolver/util/BundleUtils.kt b/java/src/com/android/intentresolver/util/BundleUtils.kt
new file mode 100644
index 00000000..da06afef
--- /dev/null
+++ b/java/src/com/android/intentresolver/util/BundleUtils.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.util
+
+import android.os.Bundle
+
+/** Shorthand for `Bundle().apply { ... } */
+inline fun Bundle(block: Bundle.() -> Unit): Bundle = Bundle().apply(block)
diff --git a/java/src/com/android/intentresolver/util/CancellationSignalUtils.kt b/java/src/com/android/intentresolver/util/CancellationSignalUtils.kt
new file mode 100644
index 00000000..e89cb5ca
--- /dev/null
+++ b/java/src/com/android/intentresolver/util/CancellationSignalUtils.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.util
+
+import android.os.CancellationSignal
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.awaitCancellation
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+
+/**
+ * Invokes [block] with a [CancellationSignal] that is bound to this coroutine's lifetime; if this
+ * coroutine is cancelled, then [CancellationSignal.cancel] is promptly invoked.
+ */
+suspend fun <R> withCancellationSignal(block: suspend (signal: CancellationSignal) -> R): R =
+    coroutineScope {
+        val signal = CancellationSignal()
+        val signalJob =
+            launch(start = CoroutineStart.UNDISPATCHED) {
+                try {
+                    awaitCancellation()
+                } finally {
+                    signal.cancel()
+                }
+            }
+        block(signal).also { signalJob.cancel() }
+    }
diff --git a/java/src/com/android/intentresolver/util/ParallelIteration.kt b/java/src/com/android/intentresolver/util/ParallelIteration.kt
new file mode 100644
index 00000000..70c46c47
--- /dev/null
+++ b/java/src/com/android/intentresolver/util/ParallelIteration.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.util
+
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.yield
+
+/** Like [Iterable.map] but executes each [block] invocation in a separate coroutine. */
+suspend fun <A, B> Iterable<A>.mapParallel(
+    parallelism: Int? = null,
+    block: suspend (A) -> B,
+): List<B> =
+    parallelism?.let { permits ->
+        withSemaphore(permits = permits) { mapParallel { withPermit { block(it) } } }
+    }
+        ?: mapParallel(block)
+
+/** Like [Iterable.map] but executes each [block] invocation in a separate coroutine. */
+suspend fun <A, B> Sequence<A>.mapParallel(
+    parallelism: Int? = null,
+    block: suspend (A) -> B,
+): List<B> = asIterable().mapParallel(parallelism, block)
+
+private suspend fun <A, B> Iterable<A>.mapParallel(block: suspend (A) -> B): List<B> =
+    coroutineScope {
+        map {
+                async {
+                    yield()
+                    block(it)
+                }
+            }
+            .awaitAll()
+    }
diff --git a/java/src/com/android/intentresolver/util/SyncUtils.kt b/java/src/com/android/intentresolver/util/SyncUtils.kt
new file mode 100644
index 00000000..eaebc6ea
--- /dev/null
+++ b/java/src/com/android/intentresolver/util/SyncUtils.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.util
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.Semaphore
+
+/**
+ * Constructs a [Semaphore] for usage within [block], useful for launching a lot of work in parallel
+ * that needs some synchronization.
+ */
+inline fun <R> withSemaphore(permits: Int, block: Semaphore.() -> R): R =
+    Semaphore(permits).run(block)
+
+/**
+ * Constructs a [Mutex] for usage within [block], useful for launching a lot of work in parallel
+ * that needs some synchronization.
+ */
+inline fun <R> withMutex(block: Mutex.() -> R): R = Mutex().run(block)
diff --git a/java/src/com/android/intentresolver/util/cursor/CursorView.kt b/java/src/com/android/intentresolver/util/cursor/CursorView.kt
new file mode 100644
index 00000000..eca7d335
--- /dev/null
+++ b/java/src/com/android/intentresolver/util/cursor/CursorView.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.util.cursor
+
+import android.database.Cursor
+
+/** A [Cursor] that holds values of [E] for each row. */
+interface CursorView<out E> : Cursor {
+    /**
+     * Reads the current row from this [CursorView]. A result of `null` indicates that the row could
+     * not be read / value could not be produced.
+     */
+    fun readRow(): E?
+}
+
+/**
+ * Returns a [CursorView] from the given [Cursor], and a function [readRow] used to produce the
+ * value for a single row.
+ */
+fun <E> Cursor.viewBy(readRow: Cursor.() -> E): CursorView<E> =
+    object : CursorView<E>, Cursor by this@viewBy {
+        override fun readRow(): E? = immobilized().readRow()
+    }
+
+/** Returns a [CursorView] that begins (index 0) at [newStartIndex] of the given cursor. */
+fun <E> CursorView<E>.startAt(newStartIndex: Int): CursorView<E> =
+    object : CursorView<E>, Cursor by (this@startAt as Cursor).startAt(newStartIndex) {
+        override fun readRow(): E? = this@startAt.readRow()
+    }
+
+/** Returns a [CursorView] that is truncated to contain only [count] elements. */
+fun <E> CursorView<E>.limit(count: Int): CursorView<E> =
+    object : CursorView<E>, Cursor by (this@limit as Cursor).limit(count) {
+        override fun readRow(): E? = this@limit.readRow()
+    }
+
+/** Retrieves a single row at index [idx] from the [CursorView]. */
+operator fun <E> CursorView<E>.get(idx: Int): E? = if (moveToPosition(idx)) readRow() else null
+
+/** Returns a [Sequence] that iterates over the [CursorView] returning each row. */
+fun <E> CursorView<E>.asSequence(): Sequence<E?> = sequence {
+    for (i in 0 until count) {
+        yield(get(i))
+    }
+}
diff --git a/java/src/com/android/intentresolver/util/cursor/Cursors.kt b/java/src/com/android/intentresolver/util/cursor/Cursors.kt
new file mode 100644
index 00000000..ce768f3b
--- /dev/null
+++ b/java/src/com/android/intentresolver/util/cursor/Cursors.kt
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.util.cursor
+
+import android.database.Cursor
+import android.database.CursorWrapper
+
+/** Returns a Cursor that is truncated to contain only [count] elements. */
+fun Cursor.limit(count: Int): Cursor =
+    object : CursorWrapper(this) {
+        override fun getCount(): Int = minOf(count, super.getCount())
+
+        override fun getPosition(): Int = super.getPosition().coerceAtMost(count)
+
+        override fun moveToLast(): Boolean = super.moveToPosition(getCount() - 1)
+
+        override fun isFirst(): Boolean = getCount() != 0 && super.isFirst()
+
+        override fun isLast(): Boolean = getCount() != 0 && super.getPosition() == getCount() - 1
+
+        override fun isAfterLast(): Boolean = getCount() == 0 || super.getPosition() >= getCount()
+
+        override fun isBeforeFirst(): Boolean = getCount() == 0 || super.isBeforeFirst()
+
+        override fun moveToNext(): Boolean = super.moveToNext() && position < getCount()
+
+        override fun moveToPosition(position: Int): Boolean =
+            super.moveToPosition(position) && position < getCount()
+    }
+
+/** Returns a Cursor that begins (index 0) at [newStartIndex] of the given Cursor. */
+fun Cursor.startAt(newStartIndex: Int): Cursor =
+    object : CursorWrapper(this) {
+        override fun getCount(): Int = (super.getCount() - newStartIndex).coerceAtLeast(0)
+
+        override fun getPosition(): Int = (super.getPosition() - newStartIndex).coerceAtLeast(-1)
+
+        override fun moveToFirst(): Boolean = super.moveToPosition(newStartIndex)
+
+        override fun moveToNext(): Boolean = super.moveToNext() && position < count
+
+        override fun moveToPrevious(): Boolean = super.moveToPrevious() && position >= 0
+
+        override fun moveToPosition(position: Int): Boolean =
+            super.moveToPosition(position + newStartIndex) && position >= 0
+
+        override fun isFirst(): Boolean = count != 0 && super.getPosition() == newStartIndex
+
+        override fun isLast(): Boolean = count != 0 && super.isLast()
+
+        override fun isBeforeFirst(): Boolean = count == 0 || super.getPosition() < newStartIndex
+
+        override fun isAfterLast(): Boolean = count == 0 || super.isAfterLast()
+    }
+
+/** Returns a read-only non-movable view into the given Cursor. */
+fun Cursor.immobilized(): Cursor =
+    object : CursorWrapper(this) {
+        private val unsupported: Nothing
+            get() = error("unsupported")
+
+        override fun moveToFirst(): Boolean = unsupported
+
+        override fun moveToLast(): Boolean = unsupported
+
+        override fun move(offset: Int): Boolean = unsupported
+
+        override fun moveToPosition(position: Int): Boolean = unsupported
+
+        override fun moveToNext(): Boolean = unsupported
+
+        override fun moveToPrevious(): Boolean = unsupported
+    }
diff --git a/java/src/com/android/intentresolver/util/cursor/PagedCursor.kt b/java/src/com/android/intentresolver/util/cursor/PagedCursor.kt
new file mode 100644
index 00000000..6e4318dc
--- /dev/null
+++ b/java/src/com/android/intentresolver/util/cursor/PagedCursor.kt
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.intentresolver.util.cursor
+
+import android.database.Cursor
+
+/** A [CursorView] that produces chunks/pages from an underlying cursor. */
+interface PagedCursor<out E> : CursorView<Sequence<E?>> {
+    /** The configured size of each page produced by this cursor. */
+    val pageSize: Int
+}
+
+/** Returns a [PagedCursor] that produces pages of data from the given [CursorView]. */
+fun <E> CursorView<E>.paged(pageSize: Int): PagedCursor<E> =
+    object : PagedCursor<E>, Cursor by this@paged {
+
+        init {
+            check(pageSize > 0) { "pageSize must be greater than 0" }
+        }
+
+        override val pageSize: Int = pageSize
+
+        override fun getCount(): Int =
+            this@paged.count.let { it / pageSize + minOf(1, it % pageSize) }
+
+        override fun getPosition(): Int =
+            (this@paged.position / pageSize).let { if (this@paged.position < 0) it - 1 else it }
+
+        override fun moveToNext(): Boolean = moveToPosition(position + 1)
+
+        override fun moveToPrevious(): Boolean = moveToPosition(position - 1)
+
+        override fun moveToPosition(position: Int): Boolean =
+            this@paged.moveToPosition(position * pageSize)
+
+        override fun readRow(): Sequence<E?> =
+            this@paged.startAt(position * pageSize).limit(pageSize).asSequence()
+    }