Refactor Interrogator MessageQueue access to a TestLooperManagerCompat class.

An upcoming TestLooperManager change will add the ability for Espresso's Interrogator class
to use it directly, replacing the use of reflection to access MessageQueue internals.

This commit prepares for this change by refactoring MessageQueue access to a
TestLooperManagerCompat container class. A future change will enhance
TestLooperManagerCompat to use the public TestLooperManager API when the Android
runtime environment supports it.

PiperOrigin-RevId: 712968907

Author: brettchabot

espresso/CHANGELOG.md

@@ -17,6 +17,7 @@ The following artifacts were released:
 **Bug Fixes**
 
 * Fix deadlock in espresso in Robolectric INSTRUMENTATION_TEST + paused looper.
+* Refactor espresso's MessageQueue access into a TestLooperManagerCompat class
 
 **New Features**
 

espresso/core/java/androidx/test/espresso/base/BUILD

@@ -25,6 +25,7 @@ android_library(
             "IdlingResourceRegistry.java",
             "Interrogator.java",
             "LooperIdlingResourceInterrogationHandler.java",
+            "TestLooperManagerCompat.java",
             "ViewHierarchyExceptionHandler.java",
         ],
     ),
@@ -64,6 +65,7 @@ android_library(
         "IdlingResourceRegistry.java",
         "Interrogator.java",
         "LooperIdlingResourceInterrogationHandler.java",
+        "TestLooperManagerCompat.java",
     ],
     deps = [
         "//espresso/core/java/androidx/test/espresso:interface",

espresso/core/java/androidx/test/espresso/base/Interrogator.java

@@ -16,29 +16,22 @@
 
 package androidx.test.espresso.base;
 
-import static androidx.test.espresso.util.Throwables.throwIfUnchecked;
 import static androidx.test.internal.util.Checks.checkNotNull;
 import static androidx.test.internal.util.Checks.checkState;
 
 import android.os.Binder;
 import android.os.Looper;
 import android.os.Message;
-import android.os.MessageQueue;
 import android.os.SystemClock;
 import android.util.Log;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
+import androidx.annotation.VisibleForTesting;
 
 /** Isolates the nasty details of touching the message queue. */
 final class Interrogator {
 
   private static final String TAG = "Interrogator";
-  private static final Method messageQueueNextMethod;
-  private static final Field messageQueueHeadField;
-  private static final Method recycleUncheckedMethod;
 
-  private static final int LOOKAHEAD_MILLIS = 15;
+  @VisibleForTesting static final int LOOKAHEAD_MILLIS = 15;
   private static final ThreadLocal<Boolean> interrogating =
       new ThreadLocal<Boolean>() {
         @Override
@@ -47,30 +40,7 @@ public Boolean initialValue() {
         }
       };
 
-  static {
-    try {
-      // TODO(b/112000181): remove the hidden api access here
-      messageQueueNextMethod = MessageQueue.class.getDeclaredMethod("next");
-      messageQueueNextMethod.setAccessible(true);
 
-      messageQueueHeadField = MessageQueue.class.getDeclaredField("mMessages");
-      messageQueueHeadField.setAccessible(true);
-    } catch (IllegalArgumentException
-        | NoSuchFieldException
-        | SecurityException
-        | NoSuchMethodException e) {
-      Log.e(TAG, "Could not initialize interrogator!", e);
-      throw new RuntimeException("Could not initialize interrogator!", e);
-    }
-
-    Method recycleUnchecked = null;
-    try {
-      recycleUnchecked = Message.class.getDeclaredMethod("recycleUnchecked");
-      recycleUnchecked.setAccessible(true);
-    } catch (NoSuchMethodException expectedOnLowerApiLevels) {
-    }
-    recycleUncheckedMethod = recycleUnchecked;
-  }
 
   /** Informed of the state of the queue and controls whether to continue interrogation or quit. */
   interface QueueInterrogationHandler<R> {
@@ -133,17 +103,18 @@ static <R> R loopAndInterrogate(InterrogationHandler<R> handler) {
     checkSanity();
     interrogating.set(Boolean.TRUE);
     boolean stillInterested = true;
-    MessageQueue q = Looper.myQueue();
+    TestLooperManagerCompat testLooperManager = TestLooperManagerCompat.acquire(Looper.myLooper());
+
     // We may have an identity when we're called - we want to restore it at the end of the fn.
     final long entryIdentity = Binder.clearCallingIdentity();
     try {
       // this identity should not get changed by dispatching the loop until the observer is happy.
       final long threadIdentity = Binder.clearCallingIdentity();
       while (stillInterested) {
         // run until the observer is no longer interested.
-        stillInterested = interrogateQueueState(q, handler);
+        stillInterested = interrogateQueueState(testLooperManager, handler);
         if (stillInterested) {
-          Message m = getNextMessage();
+          Message m = testLooperManager.next();
 
           // the observer cannot stop us from dispatching this message - but we need to let it know
           // that we're about to dispatch.
@@ -153,7 +124,7 @@ static <R> R loopAndInterrogate(InterrogationHandler<R> handler) {
           }
           stillInterested = handler.beforeTaskDispatch();
           handler.setMessage(m);
-          m.getTarget().dispatchMessage(m);
+          testLooperManager.execute(m);
 
           // ensure looper invariants
           final long newIdentity = Binder.clearCallingIdentity();
@@ -172,48 +143,17 @@ static <R> R loopAndInterrogate(InterrogationHandler<R> handler) {
                     + " what="
                     + m.what);
           }
-          recycle(m);
+          testLooperManager.recycle(m);
         }
       }
     } finally {
       Binder.restoreCallingIdentity(entryIdentity);
       interrogating.set(Boolean.FALSE);
+      testLooperManager.release();
     }
     return handler.get();
   }
 
-  private static void recycle(Message m) {
-    if (recycleUncheckedMethod != null) {
-      try {
-        recycleUncheckedMethod.invoke(m);
-      } catch (IllegalAccessException | IllegalArgumentException | SecurityException e) {
-        throwIfUnchecked(e);
-        throw new RuntimeException(e);
-      } catch (InvocationTargetException ite) {
-        if (ite.getCause() != null) {
-          throwIfUnchecked(ite.getCause());
-          throw new RuntimeException(ite.getCause());
-        } else {
-          throw new RuntimeException(ite);
-        }
-      }
-    } else {
-      m.recycle();
-    }
-  }
-
-  private static Message getNextMessage() {
-    try {
-      return (Message) messageQueueNextMethod.invoke(Looper.myQueue());
-    } catch (IllegalAccessException
-        | IllegalArgumentException
-        | InvocationTargetException
-        | SecurityException e) {
-      throwIfUnchecked(e);
-      throw new RuntimeException(e);
-    }
-  }
-
   /**
    * Allows caller to see if the message queue is empty, has a task due soon / long, or has a
    * barrier.
@@ -228,36 +168,40 @@ private static Message getNextMessage() {
    *     queueEmpty(), taskDueSoon(), taskDueLong() or barrierUp(). once and only once.
    * @return the result of handler.get()
    */
-  static <R> R peekAtQueueState(MessageQueue q, QueueInterrogationHandler<R> handler) {
-    checkNotNull(q);
+  static <R> R peekAtQueueState(
+      TestLooperManagerCompat testLooperManager, QueueInterrogationHandler<R> handler) {
+    checkNotNull(testLooperManager);
     checkNotNull(handler);
     checkState(
-        !interrogateQueueState(q, handler),
+        !interrogateQueueState(testLooperManager, handler),
         "It is expected that %s would stop interrogation after a single peak at the queue.",
         handler);
     return handler.get();
   }
 
+  static <R> R peekAtQueueState(Looper looper, QueueInterrogationHandler<R> handler) {
+    TestLooperManagerCompat testLooperManager = TestLooperManagerCompat.acquire(looper);
+    try {
+      return peekAtQueueState(testLooperManager, handler);
+    } finally {
+      testLooperManager.release();
+    }
+  }
+
   private static boolean interrogateQueueState(
-      MessageQueue q, QueueInterrogationHandler<?> handler) {
-    synchronized (q) {
-      final Message head;
-      try {
-        head = (Message) messageQueueHeadField.get(q);
-      } catch (IllegalAccessException e) {
-        throw new RuntimeException(e);
-      }
-      if (null == head) {
-        // no messages pending - AT ALL!
-        return handler.queueEmpty();
-      } else if (null == head.getTarget()) {
-        // null target is a sync barrier token.
-        if (Log.isLoggable(TAG, Log.DEBUG)) {
-          Log.d(TAG, "barrier is up");
+      TestLooperManagerCompat testLooperManager, QueueInterrogationHandler<?> handler) {
+    synchronized (testLooperManager.getQueue()) {
+      Long headWhen = testLooperManager.peekWhen();
+      if (headWhen == null) {
+        if (testLooperManager.isBlockedOnSyncBarrier()) {
+          if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "barrier is up");
+          }
+          return handler.barrierUp();
         }
-        return handler.barrierUp();
+        return handler.queueEmpty();
       }
-      long headWhen = head.getWhen();
+
       long nowFuz = SystemClock.uptimeMillis() + LOOKAHEAD_MILLIS;
       if (Log.isLoggable(TAG, Log.DEBUG)) {
         Log.d(

espresso/core/java/androidx/test/espresso/base/LooperIdlingResourceInterrogationHandler.java

@@ -19,7 +19,6 @@
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
-import android.os.MessageQueue;
 import androidx.test.espresso.IdlingResource;
 import java.util.Locale;
 import java.util.concurrent.ConcurrentHashMap;
@@ -69,7 +68,7 @@ public boolean barrierUp() {
 
   // read on main - written on looper
   private volatile boolean started = false;
-  private volatile MessageQueue queue = null;
+  private volatile Looper looper = null;
   private volatile boolean idle = true;
 
   // written on main - read on looper
@@ -97,7 +96,7 @@ static LooperIdlingResourceInterrogationHandler forLooper(Looper l) {
             new Runnable() {
               @Override
               public void run() {
-                ir.queue = Looper.myQueue();
+                ir.looper = Looper.myLooper();
                 ir.started = true;
                 Interrogator.loopAndInterrogate(ir);
               }
@@ -163,7 +162,7 @@ public boolean isIdleNow() {
       // make sure nothing has arrived in the queue while the looper thread is waiting to pull a
       // new task out of it. There can be some delay between a new message entering the queue and
       // the looper thread pulling it out and processing it.
-      return Boolean.FALSE.equals(Interrogator.peekAtQueueState(queue, queueHasNewTasks));
+      return Boolean.FALSE.equals(Interrogator.peekAtQueueState(looper, queueHasNewTasks));
     }
     return false;
   }

espresso/core/java/androidx/test/espresso/base/TestLooperManagerCompat.java

@@ -0,0 +1,99 @@
+package androidx.test.espresso.base;
+
+import android.os.Looper;
+import android.os.Message;
+import android.os.MessageQueue;
+import androidx.annotation.Nullable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * Compat class that supports the {@link android.os.TestLooperManager} Baklava+ functionality on
+ * older Android SDKs.
+ *
+ * <p>Unlike the real TestLooperManager this only supports being used from the Looper's thread.
+ */
+class TestLooperManagerCompat {
+
+  private static final Method messageQueueNextMethod;
+  private static final Field messageQueueHeadField;
+  private static final Method recycleUncheckedMethod;
+
+  static {
+    try {
+      messageQueueNextMethod = MessageQueue.class.getDeclaredMethod("next");
+      messageQueueNextMethod.setAccessible(true);
+      messageQueueHeadField = MessageQueue.class.getDeclaredField("mMessages");
+      messageQueueHeadField.setAccessible(true);
+      recycleUncheckedMethod = Message.class.getDeclaredMethod("recycleUnchecked");
+      recycleUncheckedMethod.setAccessible(true);
+    } catch (ReflectiveOperationException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private final MessageQueue queue;
+
+  private TestLooperManagerCompat(MessageQueue queue) {
+    this.queue = queue;
+  }
+
+  static TestLooperManagerCompat acquire(Looper looper) {
+    return new TestLooperManagerCompat(looper.getQueue());
+  }
+
+  @Nullable
+  Long peekWhen() {
+    Message msg = legacyPeek();
+    if (msg != null && msg.getTarget() == null) {
+      return null;
+    }
+    return msg == null ? null : msg.getWhen();
+  }
+
+  @Nullable
+  private Message legacyPeek() {
+    // the legacy MessageQueue implementation synchronizes on itself,
+    // so this uses the same lock
+    synchronized (queue) {
+      try {
+        return (Message) messageQueueHeadField.get(queue);
+      } catch (IllegalAccessException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  void execute(Message message) {
+    message.getTarget().dispatchMessage(message);
+  }
+
+  void release() {
+    // ignore for now
+  }
+
+  boolean isBlockedOnSyncBarrier() {
+    Message msg = legacyPeek();
+    return msg != null && msg.getTarget() == null;
+  }
+
+  Message next() {
+    try {
+      return (Message) messageQueueNextMethod.invoke(queue);
+    } catch (ReflectiveOperationException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  void recycle(Message m) {
+    try {
+      recycleUncheckedMethod.invoke(m);
+    } catch (ReflectiveOperationException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  MessageQueue getQueue() {
+    return queue;
+  }
+}

espresso/core/javatests/androidx/test/espresso/base/BUILD

@@ -288,3 +288,16 @@ axt_android_library_test(
         "@maven//:org_mockito_mockito_core",
     ],
 )
+
+axt_android_library_test(
+    name = "EspressoIdleTest",
+    srcs = ["EspressoIdleTest.java"],
+    deps = [
+        "//espresso/core",
+        "//espresso/core/java/androidx/test/espresso/base:idling_resource_registry",
+        "//ext/junit",
+        "//runner/android_junit_runner",
+        "@maven//:com_google_truth_truth",
+        "@maven//:junit_junit",
+    ],
+)