Merge "Move copy and edit actions into preview space." into udc-dev am: bc22d1898d am: 1f7a7a6a43

Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/modules/IntentResolver/+/23376460

Change-Id: If9708f3afe72a187aee5cafebe2bbbbb7751f80b
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

4 files changed, 75 insertions, 143 deletions

diff --git a/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java b/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java
index c2212bc2..99564ae3 100644
--- a/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java
+++ b/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java
@@ -868,8 +868,8 @@ public class UnbundledChooserActivityTest {
                 mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
         waitForIdle();
 
-        onView(withId(com.android.internal.R.id.chooser_copy_button)).check(matches(isDisplayed()));
-        onView(withId(com.android.internal.R.id.chooser_copy_button)).perform(click());
+        onView(withId(R.id.copy)).check(matches(isDisplayed()));
+        onView(withId(R.id.copy)).perform(click());
         ClipboardManager clipboard = (ClipboardManager) activity.getSystemService(
                 Context.CLIPBOARD_SERVICE);
         ClipData clipData = clipboard.getPrimaryClip();
@@ -892,8 +892,8 @@ public class UnbundledChooserActivityTest {
                 mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
         waitForIdle();
 
-        onView(withId(com.android.internal.R.id.chooser_copy_button)).check(matches(isDisplayed()));
-        onView(withId(com.android.internal.R.id.chooser_copy_button)).perform(click());
+        onView(withId(R.id.copy)).check(matches(isDisplayed()));
+        onView(withId(R.id.copy)).perform(click());
 
         ChooserActivityLogger logger = activity.getChooserActivityLogger();
         verify(logger, times(1)).logActionSelected(eq(ChooserActivityLogger.SELECTION_TYPE_COPY));
diff --git a/java/tests/src/com/android/intentresolver/contentpreview/ChooserContentPreviewUiTest.kt b/java/tests/src/com/android/intentresolver/contentpreview/ChooserContentPreviewUiTest.kt
index c62f36ce..9bfd2052 100644
--- a/java/tests/src/com/android/intentresolver/contentpreview/ChooserContentPreviewUiTest.kt
+++ b/java/tests/src/com/android/intentresolver/contentpreview/ChooserContentPreviewUiTest.kt
@@ -51,8 +51,8 @@ class ChooserContentPreviewUiTest {
         }
     private val actionFactory =
         object : ActionFactory {
-            override fun createCopyButton() = ActionRow.Action(label = "Copy", icon = null) {}
-            override fun createEditButton(): ActionRow.Action? = null
+            override fun getCopyButtonRunnable(): Runnable? = null
+            override fun getEditButtonRunnable(): Runnable? = null
             override fun createCustomActions(): List<ActionRow.Action> = emptyList()
             override fun getModifyShareAction(): ActionRow.Action? = null
             override fun getExcludeSharedTextAction(): Consumer<Boolean> = Consumer<Boolean> {}
@@ -103,12 +103,7 @@ class ChooserContentPreviewUiTest {
         whenever(previewData.previewType).thenReturn(ContentPreviewType.CONTENT_PREVIEW_IMAGE)
         whenever(previewData.uriCount).thenReturn(2)
         whenever(previewData.firstFileInfo)
-            .thenReturn(
-                FileInfo.Builder(uri)
-                    .withPreviewUri(uri)
-                    .withMimeType("image/png")
-                    .build()
-            )
+            .thenReturn(FileInfo.Builder(uri).withPreviewUri(uri).withMimeType("image/png").build())
         val testSubject =
             ChooserContentPreviewUi(
                 lifecycle,
@@ -131,12 +126,7 @@ class ChooserContentPreviewUiTest {
         whenever(previewData.previewType).thenReturn(ContentPreviewType.CONTENT_PREVIEW_IMAGE)
         whenever(previewData.uriCount).thenReturn(2)
         whenever(previewData.firstFileInfo)
-            .thenReturn(
-                FileInfo.Builder(uri)
-                    .withPreviewUri(uri)
-                    .withMimeType("image/png")
-                    .build()
-            )
+            .thenReturn(FileInfo.Builder(uri).withPreviewUri(uri).withMimeType("image/png").build())
         val testSubject =
             ChooserContentPreviewUi(
                 lifecycle,
diff --git a/java/tests/src/com/android/intentresolver/contentpreview/ContentPreviewUiTest.kt b/java/tests/src/com/android/intentresolver/contentpreview/ContentPreviewUiTest.kt
index 6c30fc9e..6db53a9e 100644
--- a/java/tests/src/com/android/intentresolver/contentpreview/ContentPreviewUiTest.kt
+++ b/java/tests/src/com/android/intentresolver/contentpreview/ContentPreviewUiTest.kt
@@ -16,41 +16,18 @@
 
 package com.android.intentresolver.contentpreview
 
-import android.content.res.Resources
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import com.android.intentresolver.widget.ActionRow
 import com.android.intentresolver.widget.ScrollableImagePreviewView.PreviewType
 import com.google.common.truth.Truth.assertThat
 import org.junit.Test
 
 class ContentPreviewUiTest {
-    private class TestablePreview() : ContentPreviewUi() {
-        override fun getType() = 0
-
-        override fun display(
-            resources: Resources?,
-            layoutInflater: LayoutInflater?,
-            parent: ViewGroup?
-        ): ViewGroup {
-            throw IllegalStateException()
-        }
-
-        // exposing for testing
-        fun makeActions(
-            system: List<ActionRow.Action>,
-            custom: List<ActionRow.Action>
-        ): List<ActionRow.Action> {
-            return createActions(system, custom)
-        }
-    }
-
     @Test
     fun testPreviewTypes() {
-        val typeClassifier = object : MimeTypeClassifier {
-            override fun isImageType(type: String?) = (type == "image")
-            override fun isVideoType(type: String?) = (type == "video")
-        }
+        val typeClassifier =
+            object : MimeTypeClassifier {
+                override fun isImageType(type: String?) = (type == "image")
+                override fun isVideoType(type: String?) = (type == "video")
+            }
 
         assertThat(ContentPreviewUi.getPreviewType(typeClassifier, "image"))
             .isEqualTo(PreviewType.Image)
@@ -61,15 +38,4 @@ class ContentPreviewUiTest {
         assertThat(ContentPreviewUi.getPreviewType(typeClassifier, null))
             .isEqualTo(PreviewType.File)
     }
-
-    @Test
-    fun testCreateActions() {
-        val preview = TestablePreview()
-
-        val system = listOf(ActionRow.Action(label="system", icon=null) {})
-        val custom = listOf(ActionRow.Action(label="custom", icon=null) {})
-
-        assertThat(preview.makeActions(system, custom)).isEqualTo(custom)
-        assertThat(preview.makeActions(system, listOf())).isEqualTo(system)
-    }
 }
diff --git a/java/tests/src/com/android/intentresolver/widget/BatchPreviewLoaderTest.kt b/java/tests/src/com/android/intentresolver/widget/BatchPreviewLoaderTest.kt
index c1d7451f..e65cba5f 100644
--- a/java/tests/src/com/android/intentresolver/widget/BatchPreviewLoaderTest.kt
+++ b/java/tests/src/com/android/intentresolver/widget/BatchPreviewLoaderTest.kt
@@ -18,29 +18,29 @@ package com.android.intentresolver.widget
 
 import android.graphics.Bitmap
 import android.net.Uri
+import com.android.intentresolver.captureMany
+import com.android.intentresolver.mock
 import com.android.intentresolver.widget.ScrollableImagePreviewView.BatchPreviewLoader
 import com.android.intentresolver.widget.ScrollableImagePreviewView.Preview
 import com.android.intentresolver.widget.ScrollableImagePreviewView.PreviewType
+import com.android.intentresolver.withArgCaptor
+import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
-import org.junit.Test
-import com.android.intentresolver.mock
-import com.android.intentresolver.captureMany
-import com.android.intentresolver.withArgCaptor
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.setMain
 import org.junit.After
 import org.junit.Before
+import org.junit.Test
 import org.mockito.Mockito.atLeast
 import org.mockito.Mockito.times
 import org.mockito.Mockito.verify
-import com.google.common.truth.Truth.assertThat
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class BatchPreviewLoaderTest {
@@ -67,22 +67,21 @@ class BatchPreviewLoaderTest {
         val uriOne = createUri(1)
         val uriTwo = createUri(2)
         imageLoader.setUriLoadingOrder(succeed(uriTwo), succeed(uriOne))
-        val testSubject = BatchPreviewLoader(
-            imageLoader,
-            previews(uriOne, uriTwo),
-            0,
-            onReset,
-            onUpdate,
-            onCompletion
-        )
+        val testSubject =
+            BatchPreviewLoader(
+                imageLoader,
+                previews(uriOne, uriTwo),
+                0,
+                onReset,
+                onUpdate,
+                onCompletion
+            )
         testSubject.loadAspectRatios(200) { _, _, _ -> 100 }
         dispatcher.scheduler.advanceUntilIdle()
 
         verify(onCompletion, times(1)).invoke()
         verify(onReset, times(1)).invoke(2)
-        val list = withArgCaptor {
-            verify(onUpdate, times(1)).invoke(capture())
-        }.map { it.uri }
+        val list = withArgCaptor { verify(onUpdate, times(1)).invoke(capture()) }.map { it.uri }
         assertThat(list).containsExactly(uriOne, uriTwo).inOrder()
     }
 
@@ -93,22 +92,21 @@ class BatchPreviewLoaderTest {
         val uriTwo = createUri(2)
         val uriThree = createUri(3)
         imageLoader.setUriLoadingOrder(succeed(uriThree), fail(uriTwo), succeed(uriOne))
-        val testSubject = BatchPreviewLoader(
-            imageLoader,
-            previews(uriOne, uriTwo, uriThree),
-            0,
-            onReset,
-            onUpdate,
-            onCompletion
-        )
+        val testSubject =
+            BatchPreviewLoader(
+                imageLoader,
+                previews(uriOne, uriTwo, uriThree),
+                0,
+                onReset,
+                onUpdate,
+                onCompletion
+            )
         testSubject.loadAspectRatios(200) { _, _, _ -> 100 }
         dispatcher.scheduler.advanceUntilIdle()
 
         verify(onCompletion, times(1)).invoke()
         verify(onReset, times(1)).invoke(3)
-        val list = withArgCaptor {
-            verify(onUpdate, times(1)).invoke(capture())
-        }.map { it.uri }
+        val list = withArgCaptor { verify(onUpdate, times(1)).invoke(capture()) }.map { it.uri }
         assertThat(list).containsExactly(uriOne, uriThree).inOrder()
     }
 
@@ -116,35 +114,28 @@ class BatchPreviewLoaderTest {
     fun test_imagesLoadedNotInOrder_updatedInOrder() {
         val imageLoader = TestImageLoader(testScope)
         val uris = Array(10) { createUri(it) }
-        val loadingOrder = Array(uris.size) { i ->
-            val uriIdx = when {
-                i % 2 == 1 -> i - 1
-                i % 2 == 0 && i < uris.size - 1 -> i + 1
-                else -> i
+        val loadingOrder =
+            Array(uris.size) { i ->
+                val uriIdx =
+                    when {
+                        i % 2 == 1 -> i - 1
+                        i % 2 == 0 && i < uris.size - 1 -> i + 1
+                        else -> i
+                    }
+                succeed(uris[uriIdx])
             }
-            succeed(uris[uriIdx])
-        }
         imageLoader.setUriLoadingOrder(*loadingOrder)
-        val testSubject = BatchPreviewLoader(
-            imageLoader,
-            previews(*uris),
-            0,
-            onReset,
-            onUpdate,
-            onCompletion
-        )
+        val testSubject =
+            BatchPreviewLoader(imageLoader, previews(*uris), 0, onReset, onUpdate, onCompletion)
         testSubject.loadAspectRatios(200) { _, _, _ -> 100 }
         dispatcher.scheduler.advanceUntilIdle()
 
         verify(onCompletion, times(1)).invoke()
         verify(onReset, times(1)).invoke(uris.size)
-        val list = captureMany {
-            verify(onUpdate, atLeast(1)).invoke(capture())
-        }.fold(ArrayList<Preview>()) { acc, update ->
-            acc.apply {
-                addAll(update)
-            }
-        }.map { it.uri }
+        val list =
+            captureMany { verify(onUpdate, atLeast(1)).invoke(capture()) }
+                .fold(ArrayList<Preview>()) { acc, update -> acc.apply { addAll(update) } }
+                .map { it.uri }
         assertThat(list).containsExactly(*uris).inOrder()
     }
 
@@ -152,36 +143,29 @@ class BatchPreviewLoaderTest {
     fun test_imagesLoadedNotInOrderSomeFailed_updatedInOrder() {
         val imageLoader = TestImageLoader(testScope)
         val uris = Array(10) { createUri(it) }
-        val loadingOrder = Array(uris.size) { i ->
-            val uriIdx = when {
-                i % 2 == 1 -> i - 1
-                i % 2 == 0 && i < uris.size - 1 -> i + 1
-                else -> i
+        val loadingOrder =
+            Array(uris.size) { i ->
+                val uriIdx =
+                    when {
+                        i % 2 == 1 -> i - 1
+                        i % 2 == 0 && i < uris.size - 1 -> i + 1
+                        else -> i
+                    }
+                if (uriIdx % 2 == 0) fail(uris[uriIdx]) else succeed(uris[uriIdx])
             }
-            if (uriIdx % 2 == 0) fail(uris[uriIdx]) else succeed(uris[uriIdx])
-        }
         val expectedUris = Array(uris.size / 2) { createUri(it * 2 + 1) }
         imageLoader.setUriLoadingOrder(*loadingOrder)
-        val testSubject = BatchPreviewLoader(
-            imageLoader,
-            previews(*uris),
-            0,
-            onReset,
-            onUpdate,
-            onCompletion
-        )
+        val testSubject =
+            BatchPreviewLoader(imageLoader, previews(*uris), 0, onReset, onUpdate, onCompletion)
         testSubject.loadAspectRatios(200) { _, _, _ -> 100 }
         dispatcher.scheduler.advanceUntilIdle()
 
         verify(onCompletion, times(1)).invoke()
         verify(onReset, times(1)).invoke(uris.size)
-        val list = captureMany {
-            verify(onUpdate, atLeast(1)).invoke(capture())
-        }.fold(ArrayList<Preview>()) { acc, update ->
-            acc.apply {
-                addAll(update)
-            }
-        }.map { it.uri }
+        val list =
+            captureMany { verify(onUpdate, atLeast(1)).invoke(capture()) }
+                .fold(ArrayList<Preview>()) { acc, update -> acc.apply { addAll(update) } }
+                .map { it.uri }
         assertThat(list).containsExactly(*expectedUris).inOrder()
     }
 
@@ -191,21 +175,15 @@ class BatchPreviewLoaderTest {
     private fun succeed(uri: Uri) = uri to true
     private fun previews(vararg uris: Uri) =
         uris.fold(ArrayList<Preview>(uris.size)) { acc, uri ->
-            acc.apply {
-                add(Preview(PreviewType.Image, uri))
-            }
+            acc.apply { add(Preview(PreviewType.Image, uri, editAction = null)) }
         }
 }
 
-private class TestImageLoader(
-    scope: CoroutineScope
-) : suspend (Uri, Boolean) -> Bitmap? {
+private class TestImageLoader(scope: CoroutineScope) : suspend (Uri, Boolean) -> Bitmap? {
     private val loadingOrder = ArrayDeque<Pair<Uri, Boolean>>()
     private val pendingRequests = LinkedHashMap<Uri, CompletableDeferred<Bitmap?>>()
     private val flow = MutableSharedFlow<Unit>(replay = 1)
-    private val bitmap by lazy {
-        Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
-    }
+    private val bitmap by lazy { Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888) }
 
     init {
         scope.launch {
@@ -217,9 +195,7 @@ private class TestImageLoader(
                     deferred.complete(if (isLoaded) bitmap else null)
                 }
                 if (loadingOrder.isEmpty()) {
-                    pendingRequests.forEach { (uri, deferred) ->
-                        deferred.complete(bitmap)
-                    }
+                    pendingRequests.forEach { (uri, deferred) -> deferred.complete(bitmap) }
                     pendingRequests.clear()
                 }
             }