Make suspend function versions of ViewCapture/WindowCapture/DeviceCapture and rename existing functions as per androidx async API guidelines

PiperOrigin-RevId: 627863823

Author: brettchabot

WORKSPACE

@@ -91,6 +91,7 @@ maven_install(
         "androidx.annotation:annotation-experimental:jar:" + ANDROIDX_ANNOTATION_EXPERIMENTAL_VERSION,
         "androidx.appcompat:appcompat:" + ANDROIDX_COMPAT_VERSION,
         "androidx.concurrent:concurrent-futures:" + ANDROIDX_CONCURRENT_VERSION,
+        "androidx.concurrent:concurrent-futures-ktx:" + ANDROIDX_CONCURRENT_VERSION,
         "androidx.core:core:" + ANDROIDX_CORE_VERSION,
         "androidx.cursoradapter:cursoradapter:" + ANDROIDX_CURSOR_ADAPTER_VERSION,
         "androidx.drawerlayout:drawerlayout:" + ANDROIDX_DRAWER_LAYOUT_VERSION,
@@ -174,6 +175,8 @@ maven_install(
         "org.pantsbuild:jarjar:1.7.2",
         "org.jetbrains.kotlin:kotlin-stdlib:%s" % KOTLIN_VERSION,
         "org.jetbrains.kotlinx:kotlinx-coroutines-core:%s" % KOTLINX_COROUTINES_VERSION,
+        "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:%s" % KOTLINX_COROUTINES_VERSION,
+        "org.jetbrains.kotlinx:kotlinx-coroutines-android:%s" % KOTLINX_COROUTINES_VERSION,
         maven.artifact(
             artifact = "robolectric",
             exclusions = [

build_extensions/axt_deps_versions.bzl

@@ -22,7 +22,9 @@ ORCHESTRATOR_ARTIFACT = "androidx.test:orchestrator:%s" % ORCHESTRATOR_VERSION
 ANDROIDX_ANNOTATION_VERSION = "1.7.0-beta01"
 ANDROIDX_ANNOTATION_EXPERIMENTAL_VERSION = "1.1.0"
 ANDROIDX_COMPAT_VERSION = "1.3.1"
-ANDROIDX_CONCURRENT_VERSION = "1.1.0"
+
+# TODO(i336855276): update to beta/stable release when available
+ANDROIDX_CONCURRENT_VERSION = "1.2.0-alpha03"
 ANDROIDX_CORE_VERSION = "1.6.0"
 ANDROIDX_FRAGMENT_VERSION = "1.3.6"
 ANDROIDX_CURSOR_ADAPTER_VERSION = "1.0.0"

core/CHANGELOG.md

@@ -15,9 +15,11 @@
 **API Changes**
 
 * Added ApplicationInfoBuilder.setFlags(int)
+* Make suspend function versions of ViewCapture/WindowCapture/DeviceCapture APIs
 * Make Bitmap.writeToTestStorage use the registered PlatformTestStorage instead of hardcoding TestStorage
 * Add *Async variants of capture*ToBitmap methods
 
+
 **Breaking API Changes**
 
 **Known Issues**

core/java/androidx/test/core/BUILD

@@ -49,9 +49,10 @@ kt_android_library(
         "//annotation",
         "//opensource/androidx:annotation",
         "//runner/monitor",
-        "@maven//:androidx_concurrent_concurrent_futures",
+        "@maven//:androidx_concurrent_concurrent_futures_ktx",
         "@maven//:androidx_lifecycle_lifecycle_common",
         "@maven//:androidx_tracing_tracing",
+        "@maven//:org_jetbrains_kotlinx_kotlinx_coroutines_core_jvm",
         "@maven_listenablefuture//:com_google_guava_listenablefuture",
     ],
 )

core/java/androidx/test/core/app/DeviceCapture.kt

@@ -17,25 +17,27 @@
 
 package androidx.test.core.app
 
+import android.app.UiAutomation
 import android.graphics.Bitmap
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
 import android.view.Choreographer
 import androidx.annotation.RestrictTo
-import androidx.concurrent.futures.ResolvableFuture
 import androidx.test.annotation.ExperimentalTestApi
 import androidx.test.core.internal.os.HandlerExecutor
 import androidx.test.core.view.forceRedraw
 import androidx.test.internal.util.Checks
 import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
 import androidx.test.platform.graphics.HardwareRendererCompat
 import androidx.test.platform.view.inspector.WindowInspectorCompat
-import com.google.common.util.concurrent.ListenableFuture
 import java.lang.RuntimeException
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.Executor
-import java.util.concurrent.TimeUnit
+import kotlin.coroutines.resumeWithException
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withTimeout
 
 /**
  * Returns false if calling [takeScreenshot] will fail.
@@ -96,61 +98,63 @@ fun takeScreenshot(): Bitmap {
 fun takeScreenshotNoSync(): Bitmap {
   Checks.checkState(canTakeScreenshot())
 
-  val mainExecutor = HandlerExecutor(Handler(Looper.getMainLooper()))
+  var bitmap: Bitmap? = null
+  var exception: Exception? = null
+  val mainHandlerDispatcher =
+    HandlerExecutor(Handler(Looper.getMainLooper())).asCoroutineDispatcher()
   val uiAutomation = getInstrumentation().uiAutomation
   if (uiAutomation == null) {
     throw RuntimeException("uiautomation is null")
   }
 
-  val origIsDrawingEnabled = HardwareRendererCompat.isDrawingEnabled()
-  try {
-    if (!origIsDrawingEnabled) {
-      HardwareRendererCompat.setDrawingEnabled(true)
-    }
-
-    try {
-      forceRedrawGlobalWindowViews(mainExecutor).get(5, TimeUnit.SECONDS)
-    } catch (e: Exception) {
-      Log.w("takeScreenshot", "force redraw failed. Proceeding with screenshot", e)
-    }
+  val hardwareDrawingEnabled = HardwareRendererCompat.isDrawingEnabled()
+  HardwareRendererCompat.setDrawingEnabled(true)
 
-    // wait on the next frame to increase probability the draw from previous step is
-    // committed
-    // TODO(b/289244795): use a transaction callback instead
-    val latch = CountDownLatch(1)
-    mainExecutor.execute { Choreographer.getInstance().postFrameCallback { latch.countDown() } }
-
-    if (!latch.await(1, TimeUnit.SECONDS)) {
-      Log.w(
-        "takeScreenshot",
-        "frame callback did not occur in 1 seconds. Proceeding with screenshot",
-      )
+  return runBlocking(mainHandlerDispatcher) {
+    withTimeout(5.seconds) {
+      forceRedrawGlobalWindowViews()
+      bitmap = takeScreenshotOnNextFrame(uiAutomation, hardwareDrawingEnabled)
+      exception?.let { throw it }
+      bitmap!!
     }
+  }
+}
 
-    // do multiple retries of uiAutomation.takeScreenshot because it is known to return null
-    // on API 31+ b/257274080
-    for (i in 1..3) {
-      val bitmap = uiAutomation.takeScreenshot()
-      if (bitmap != null) {
-        return bitmap
-      }
-    }
-    throw RuntimeException("uiAutomation.takeScreenshot failed to return a bitmap")
-  } finally {
-    HardwareRendererCompat.setDrawingEnabled(origIsDrawingEnabled)
+private suspend fun forceRedrawGlobalWindowViews() {
+  val views = WindowInspectorCompat.getGlobalWindowViews()
+  Log.d("DeviceCapture", "Found ${views.size} global views to redraw")
+  for (view in views) {
+    view.forceRedraw()
   }
 }
 
-private fun forceRedrawGlobalWindowViews(mainExecutor: Executor): ListenableFuture<List<Void>> {
-  val future: ResolvableFuture<List<Void>> = ResolvableFuture.create()
-  mainExecutor.execute {
-    val views = WindowInspectorCompat.getGlobalWindowViews()
-    val viewFutures: MutableList<ListenableFuture<Void>> = mutableListOf()
-    for (view in views) {
-      viewFutures.add(view.forceRedraw())
+private suspend fun takeScreenshotOnNextFrame(
+  uiAutomation: UiAutomation,
+  hardwareDrawingEnabled: Boolean,
+): Bitmap {
+  // wait on the next frame to increase probability the draw from previous step is
+  // committed
+  // TODO(b/289244795): use a transaction callback instead
+
+  return suspendCancellableCoroutine<Bitmap> { cont ->
+    Choreographer.getInstance().postFrameCallback {
+      // do multiple retries of uiAutomation.takeScreenshot because it is known to return null
+      // on API 31+ b/257274080
+      var bitmap: Bitmap? = null
+      for (i in 1..3) {
+        bitmap = uiAutomation.takeScreenshot()
+        if (bitmap != null) {
+          Log.i("DeviceCapture", "got bitmap, returning")
+          break
+        }
+      }
+      HardwareRendererCompat.setDrawingEnabled(hardwareDrawingEnabled)
+      if (bitmap == null) {
+        Log.w("DeviceCapture", "failed to get bitmap, returning exception")
+        cont.resumeWithException(RuntimeException("uiAutomation.takeScreenshot returned null"))
+      } else {
+        cont.resume(bitmap, {})
+      }
     }
-    Log.d("takeScreenshot", "Found ${views.size} global views to redraw")
-    future.setFuture(ListFuture<Void>(viewFutures, true, mainExecutor))
   }
-  return future
 }