Move MediaCodecAdapter out of MediaCodecRenderer

Move MediaCodeAdapter and implementations to separate
files and add unit tests for AsynchronousMediaCodecAdapter.

PiperOrigin-RevId: 284537185

library/core/src/main/java/com/google/android/exoplayer2/mediacodec/AsynchronousMediaCodecAdapter.java

+/*
+ * Copyright (C) 2019 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.google.android.exoplayer2.mediacodec;
+
+import android.media.MediaCodec;
+import android.media.MediaFormat;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.exoplayer2.util.Assertions;
+
+/**
+ * A {@link MediaCodecAdapter} that operates the {@link MediaCodec} in asynchronous mode.
+ *
+ * <p>The AsynchronousMediaCodecAdapter routes callbacks to the current Thread's {@link Looper}
+ * obtained via {@link Looper#myLooper()}
+ */
+@RequiresApi(21)
+/* package */ final class AsynchronousMediaCodecAdapter implements MediaCodecAdapter {
+  private MediaCodecAsyncCallback mediaCodecAsyncCallback;
+  private final Handler handler;
+  private final MediaCodec codec;
+  @Nullable private IllegalStateException internalException;
+  private boolean flushing;
+  private Runnable onCodecStart;
+
+  /**
+   * Create a new {@code AsynchronousMediaCodecAdapter}.
+   *
+   * @param codec the {@link MediaCodec} to wrap.
+   */
+  public AsynchronousMediaCodecAdapter(MediaCodec codec) {
+    this(codec, Assertions.checkNotNull(Looper.myLooper()));
+  }
+
+  @VisibleForTesting
+  /* package */ AsynchronousMediaCodecAdapter(MediaCodec codec, Looper looper) {
+    this.mediaCodecAsyncCallback = new MediaCodecAsyncCallback();
+    handler = new Handler(looper);
+    this.codec = codec;
+    this.codec.setCallback(mediaCodecAsyncCallback);
+    onCodecStart = () -> codec.start();
+  }
+
+  @Override
+  public int dequeueInputBufferIndex() {
+    if (flushing) {
+      return MediaCodec.INFO_TRY_AGAIN_LATER;
+    } else {
+      maybeThrowException();
+      return mediaCodecAsyncCallback.dequeueInputBufferIndex();
+    }
+  }
+
+  @Override
+  public int dequeueOutputBufferIndex(MediaCodec.BufferInfo bufferInfo) {
+    if (flushing) {
+      return MediaCodec.INFO_TRY_AGAIN_LATER;
+    } else {
+      maybeThrowException();
+      return mediaCodecAsyncCallback.dequeueOutputBufferIndex(bufferInfo);
+    }
+  }
+
+  @Override
+  public MediaFormat getOutputFormat() {
+    return mediaCodecAsyncCallback.getOutputFormat();
+  }
+
+  @Override
+  public void flush() {
+    clearPendingFlushState();
+    flushing = true;
+    codec.flush();
+    handler.post(this::onCompleteFlush);
+  }
+
+  @Override
+  public void shutdown() {
+    clearPendingFlushState();
+  }
+
+  @VisibleForTesting
+  /* package */ MediaCodec.Callback getMediaCodecCallback() {
+    return mediaCodecAsyncCallback;
+  }
+
+  private void onCompleteFlush() {
+    flushing = false;
+    mediaCodecAsyncCallback.flush();
+    try {
+      onCodecStart.run();
+    } catch (IllegalStateException e) {
+      // Catch IllegalStateException directly so that we don't have to wrap it.
+      internalException = e;
+    } catch (Exception e) {
+      internalException = new IllegalStateException(e);
+    }
+  }
+
+  @VisibleForTesting
+  /* package */ void setOnCodecStart(Runnable onCodecStart) {
+    this.onCodecStart = onCodecStart;
+  }
+
+  private void maybeThrowException() throws IllegalStateException {
+    maybeThrowInternalException();
+    mediaCodecAsyncCallback.maybeThrowMediaCodecException();
+  }
+
+  private void maybeThrowInternalException() {
+    if (internalException != null) {
+      IllegalStateException e = internalException;
+      internalException = null;
+      throw e;
+    }
+  }
+
+  /** Clear state related to pending flush events. */
+  private void clearPendingFlushState() {
+    handler.removeCallbacksAndMessages(null);
+    internalException = null;
+  }
+}

library/core/src/main/java/com/google/android/exoplayer2/mediacodec/MediaCodecAdapter.java

+/*
+ * Copyright (C) 2019 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.google.android.exoplayer2.mediacodec;
+
+import android.media.MediaCodec;
+import android.media.MediaFormat;
+
+/**
+ * Abstracts {@link MediaCodec} operations.
+ *
+ * <p>{@code MediaCodecAdapter} offers a common interface to interact with a {@link MediaCodec}
+ * regardless of the {@link
+ * com.google.android.exoplayer2.mediacodec.MediaCodecRenderer.MediaCodecOperationMode} the {@link
+ * MediaCodec} is operating in.
+ *
+ * @see com.google.android.exoplayer2.mediacodec.MediaCodecRenderer.MediaCodecOperationMode
+ */
+/* package */ interface MediaCodecAdapter {
+
+  /**
+   * Returns the next available input buffer index from the underlying {@link MediaCodec} or {@link
+   * MediaCodec#INFO_TRY_AGAIN_LATER} if no such buffer exists.
+   *
+   * @throws {@link IllegalStateException} if the underlying {@link MediaCodec} raised an error.
+   */
+  int dequeueInputBufferIndex();
+
+  /**
+   * Returns the next available output buffer index from the underlying {@link MediaCodec}. If the
+   * next available output is a MediaFormat change, it will return {@link
+   * MediaCodec#INFO_OUTPUT_FORMAT_CHANGED} and you should call {@link #getOutputFormat()} to get
+   * the format. If there is no available output, this method will return {@link
+   * MediaCodec#INFO_TRY_AGAIN_LATER}.
+   *
+   * @throws {@link IllegalStateException} if the underlying {@link MediaCodec} raised an error.
+   */
+  int dequeueOutputBufferIndex(MediaCodec.BufferInfo bufferInfo);
+
+  /**
+   * Gets the {@link MediaFormat} that was output from the {@link MediaCodec}.
+   *
+   * <p>Call this method if a previous call to {@link #dequeueOutputBufferIndex} returned {@link
+   * MediaCodec#INFO_OUTPUT_FORMAT_CHANGED}.
+   */
+  MediaFormat getOutputFormat();
+
+  /**
+   * Flushes the {@code MediaCodecAdapter}.
+   *
+   * <p>Note: {@link #flush()} should also call any {@link MediaCodec} methods needed to flush the
+   * {@link MediaCodec}, i.e., {@link MediaCodec#flush()} and <em>optionally</em> {@link
+   * MediaCodec#start()}, if the {@link MediaCodec} operates in asynchronous mode.
+   */
+  void flush();
+
+  /**
+   * Shutdown the {@code MediaCodecAdapter}.
+   *
+   * <p>Note: This method does not release the underlying {@link MediaCodec}. Make sure to call
+   * {@link #shutdown()} before stopping or releasing the underlying {@link MediaCodec} to ensure
+   * the adapter is fully shutdown before the {@link MediaCodec} stops executing. Otherwise, there
+   * is a risk the adapter might interact with a stopped or released {@link MediaCodec}.
+   */
+  void shutdown();
+}

library/core/src/main/java/com/google/android/exoplayer2/mediacodec/SynchronousMediaCodecAdapter.java

+/*
+ * Copyright (C) 2019 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.google.android.exoplayer2.mediacodec;
+
+import android.media.MediaCodec;
+import android.media.MediaFormat;
+
+/**
+ * A {@link MediaCodecAdapter} that operates the underlying {@link MediaCodec} in synchronous mode.
+ */
+/* package */ final class SynchronousMediaCodecAdapter implements MediaCodecAdapter {
+  private final MediaCodec codec;
+  private final long dequeueOutputBufferTimeoutMs;
+
+  public SynchronousMediaCodecAdapter(MediaCodec mediaCodec, long dequeueOutputBufferTimeoutMs) {
+    this.codec = mediaCodec;
+    this.dequeueOutputBufferTimeoutMs = dequeueOutputBufferTimeoutMs;
+  }
+
+  @Override
+  public int dequeueInputBufferIndex() {
+    return codec.dequeueInputBuffer(0);
+  }
+
+  @Override
+  public int dequeueOutputBufferIndex(MediaCodec.BufferInfo bufferInfo) {
+    return codec.dequeueOutputBuffer(bufferInfo, dequeueOutputBufferTimeoutMs);
+  }
+
+  @Override
+  public MediaFormat getOutputFormat() {
+    return codec.getOutputFormat();
+  }
+
+  @Override
+  public void flush() {
+    codec.flush();
+  }
+
+  @Override
+  public void shutdown() {}
+}

library/core/src/test/java/com/google/android/exoplayer2/mediacodec/AsynchronousMediaCodecAdapterTest.java

+/*
+ * Copyright (C) 2019 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.google.android.exoplayer2.mediacodec;
+
+import static com.google.android.exoplayer2.mediacodec.MediaCodecTestUtils.areEqual;
+import static com.google.android.exoplayer2.mediacodec.MediaCodecTestUtils.waitUntilAllEventsAreExecuted;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import android.media.MediaCodec;
+import android.media.MediaFormat;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Unit tests for {@link AsynchronousMediaCodecAdapter}. */
+@RunWith(AndroidJUnit4.class)
+public class AsynchronousMediaCodecAdapterTest {
+  private AsynchronousMediaCodecAdapter adapter;
+  private MediaCodec codec;
+  private HandlerThread handlerThread;
+  private Looper looper;
+  private MediaCodec.BufferInfo bufferInfo;
+
+  @Before
+  public void setup() throws IOException {
+    handlerThread = new HandlerThread("TestHandlerThread");
+    handlerThread.start();
+    looper = handlerThread.getLooper();
+    codec = MediaCodec.createByCodecName("h264");
+    adapter = new AsynchronousMediaCodecAdapter(codec, looper);
+    bufferInfo = new MediaCodec.BufferInfo();
+  }
+
+  @After
+  public void tearDown() {
+    handlerThread.quit();
+  }
+
+  @Test
+  public void dequeueInputBufferIndex_withoutInputBuffer_returnsTryAgainLater() {
+    assertThat(adapter.dequeueInputBufferIndex()).isEqualTo(MediaCodec.INFO_TRY_AGAIN_LATER);
+  }
+
+  @Test
+  public void dequeueInputBufferIndex_withInputBuffer_returnsInputBuffer() {
+    adapter.getMediaCodecCallback().onInputBufferAvailable(codec, /* index=*/ 0);
+
+    assertThat(adapter.dequeueInputBufferIndex()).isEqualTo(0);
+  }
+
+  @Test
+  public void dequeueInputBufferIndex_whileFlushing_returnsTryAgainLater() {
+    adapter.getMediaCodecCallback().onInputBufferAvailable(codec, /* index=*/ 0);
+    adapter.flush();
+    adapter.getMediaCodecCallback().onInputBufferAvailable(codec, /* index=*/ 1);
+
+    assertThat(adapter.dequeueInputBufferIndex()).isEqualTo(MediaCodec.INFO_TRY_AGAIN_LATER);
+  }
+
+  @Test
+  public void dequeueInputBufferIndex_afterFlushCompletes_returnsNextInputBuffer()
+      throws InterruptedException {
+    // Disable calling codec.start() after flush() completes to avoid receiving buffers from the
+    // shadow codec impl
+    adapter.setOnCodecStart(() -> {});
+    Handler handler = new Handler(looper);
+    handler.post(
+        () -> adapter.getMediaCodecCallback().onInputBufferAvailable(codec, /* index=*/ 0));
+    adapter.flush(); // enqueues a flush event on the looper
+    handler.post(
+        () -> adapter.getMediaCodecCallback().onInputBufferAvailable(codec, /* index=*/ 1));
+
+    assertThat(waitUntilAllEventsAreExecuted(looper, /* time= */ 5, TimeUnit.SECONDS)).isTrue();
+    assertThat(adapter.dequeueInputBufferIndex()).isEqualTo(1);
+  }
+
+  @Test
+  public void dequeueInputBufferIndex_afterFlushCompletesWithError_throwsException()
+      throws InterruptedException {
+    adapter.setOnCodecStart(
+        () -> {
+          throw new IllegalStateException("codec#start() exception");
+        });
+    adapter.flush();
+
+    assertThat(waitUntilAllEventsAreExecuted(looper, /* time= */ 5, TimeUnit.SECONDS)).isTrue();
+    try {
+      adapter.dequeueInputBufferIndex();
+      fail();
+    } catch (IllegalStateException expected) {
+    }
+  }
+
+  @Test
+  public void dequeueOutputBufferIndex_withoutOutputBuffer_returnsTryAgainLater() {
+    assertThat(adapter.dequeueOutputBufferIndex(bufferInfo))
+        .isEqualTo(MediaCodec.INFO_TRY_AGAIN_LATER);
+  }
+
+  @Test
+  public void dequeueOutputBufferIndex_withOutputBuffer_returnsOutputBuffer() {
+    MediaCodec.BufferInfo outBufferInfo = new MediaCodec.BufferInfo();
+    outBufferInfo.presentationTimeUs = 10;
+    adapter.getMediaCodecCallback().onOutputBufferAvailable(codec, /* index=*/ 0, outBufferInfo);
+
+    assertThat(adapter.dequeueOutputBufferIndex(bufferInfo)).isEqualTo(0);
+    assertThat(areEqual(bufferInfo, outBufferInfo)).isTrue();
+  }
+
+  @Test
+  public void dequeueOutputBufferIndex_whileFlushing_returnsTryAgainLater() {
+    adapter.getMediaCodecCallback().onOutputBufferAvailable(codec, /* index=*/ 0, bufferInfo);
+    adapter.flush();
+    adapter.getMediaCodecCallback().onOutputBufferAvailable(codec, /* index=*/ 1, bufferInfo);
+
+    assertThat(adapter.dequeueOutputBufferIndex(bufferInfo))
+        .isEqualTo(MediaCodec.INFO_TRY_AGAIN_LATER);
+  }
+
+  @Test
+  public void dequeueOutputBufferIndex_afterFlushCompletes_returnsNextOutputBuffer()
+      throws InterruptedException {
+    // Disable calling codec.start() after flush() completes to avoid receiving buffers from the
+    // shadow codec impl
+    adapter.setOnCodecStart(() -> {});
+    Handler handler = new Handler(looper);
+    MediaCodec.BufferInfo info0 = new MediaCodec.BufferInfo();
+    handler.post(
+        () -> adapter.getMediaCodecCallback().onOutputBufferAvailable(codec, /* index=*/ 0, info0));
+    adapter.flush(); // enqueues a flush event on the looper
+    MediaCodec.BufferInfo info1 = new MediaCodec.BufferInfo();
+    info1.presentationTimeUs = 1;
+    handler.post(
+        () -> adapter.getMediaCodecCallback().onOutputBufferAvailable(codec, /* index=*/ 1, info1));
+
+    assertThat(waitUntilAllEventsAreExecuted(looper, /* time= */ 5, TimeUnit.SECONDS)).isTrue();
+    assertThat(adapter.dequeueOutputBufferIndex(bufferInfo)).isEqualTo(1);
+    assertThat(areEqual(bufferInfo, info1)).isTrue();
+  }
+
+  @Test
+  public void dequeueOutputBufferIndex_afterFlushCompletesWithError_throwsException()
+      throws InterruptedException {
+    adapter.setOnCodecStart(
+        () -> {
+          throw new RuntimeException("codec#start() exception");
+        });
+    adapter.flush();
+
+    assertThat(waitUntilAllEventsAreExecuted(looper, /* time= */ 5, TimeUnit.SECONDS)).isTrue();
+    try {
+      adapter.dequeueOutputBufferIndex(bufferInfo);
+      fail();
+    } catch (IllegalStateException expected) {
+    }
+  }
+
+  @Test
+  public void getOutputFormat_withoutFormat_throwsException() {
+    try {
+      adapter.getOutputFormat();
+      fail();
+    } catch (IllegalStateException expected) {
+    }
+  }
+
+  @Test
+  public void getOutputFormat_withMultipleFormats_returnsFormatsInCorrectOrder() {
+    MediaFormat[] formats = new MediaFormat[10];
+    MediaCodec.Callback mediaCodecCallback = adapter.getMediaCodecCallback();
+    for (int i = 0; i < formats.length; i++) {
+      formats[i] = new MediaFormat();
+      mediaCodecCallback.onOutputFormatChanged(codec, formats[i]);
+    }
+
+    for (MediaFormat format : formats) {
+      assertThat(adapter.dequeueOutputBufferIndex(bufferInfo))
+          .isEqualTo(MediaCodec.INFO_OUTPUT_FORMAT_CHANGED);
+      assertThat(adapter.getOutputFormat()).isEqualTo(format);
+      // Call it again to ensure same format is returned
+      assertThat(adapter.getOutputFormat()).isEqualTo(format);
+    }
+    // Obtain next output buffer
+    assertThat(adapter.dequeueOutputBufferIndex(bufferInfo))
+        .isEqualTo(MediaCodec.INFO_TRY_AGAIN_LATER);
+    // Format should remain as is
+    assertThat(adapter.getOutputFormat()).isEqualTo(formats[formats.length - 1]);
+  }
+
+  @Test
+  public void getOutputFormat_afterFlush_returnsPreviousFormat() throws InterruptedException {
+    MediaFormat format = new MediaFormat();
+    adapter.getMediaCodecCallback().onOutputFormatChanged(codec, format);
+    adapter.dequeueOutputBufferIndex(bufferInfo);
+    adapter.flush();
+
+    assertThat(waitUntilAllEventsAreExecuted(looper, /* time= */ 5, TimeUnit.SECONDS)).isTrue();
+    assertThat(adapter.getOutputFormat()).isEqualTo(format);
+  }
+
+  @Test
+  public void shutdown_withPendingFlush_cancelsFlush() throws InterruptedException {
+    AtomicBoolean onCodecStartCalled = new AtomicBoolean(false);
+    Runnable onCodecStart = () -> onCodecStartCalled.set(true);
+    adapter.setOnCodecStart(onCodecStart);
+    adapter.flush();
+    adapter.shutdown();
+
+    assertThat(waitUntilAllEventsAreExecuted(looper, /* time= */ 5, TimeUnit.SECONDS)).isTrue();
+    assertThat(onCodecStartCalled.get()).isFalse();
+  }
+}

library/core/src/test/java/com/google/android/exoplayer2/mediacodec/MediaCodecAsyncCallbackTest.java

@@ -15,6 +15,7 @@
  */
 package com.google.android.exoplayer2.mediacodec;
 
+import static com.google.android.exoplayer2.mediacodec.MediaCodecTestUtils.areEqual;
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
@@ -204,17 +205,4 @@ public class MediaCodecAsyncCallbackTest {
 
     mediaCodecAsyncCallback.maybeThrowMediaCodecException();
   }
-
-  /**
-   * Compares if two {@link android.media.MediaCodec.BufferInfo} are equal by inspecting {@link
-   * android.media.MediaCodec.BufferInfo#flags}, {@link android.media.MediaCodec.BufferInfo#size},
-   * {@link android.media.MediaCodec.BufferInfo#presentationTimeUs} and {@link
-   * android.media.MediaCodec.BufferInfo#offset}.
-   */
-  private static boolean areEqual(MediaCodec.BufferInfo lhs, MediaCodec.BufferInfo rhs) {
-    return lhs.flags == rhs.flags
-        && lhs.offset == rhs.offset
-        && lhs.presentationTimeUs == rhs.presentationTimeUs
-        && lhs.size == rhs.size;
-  }
 }

library/core/src/test/java/com/google/android/exoplayer2/mediacodec/MediaCodecTestUtils.java

+/*
+ * Copyright (C) 2019 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.google.android.exoplayer2.mediacodec;
+
+import static org.robolectric.Shadows.shadowOf;
+
+import android.media.MediaCodec;
+import android.os.Handler;
+import android.os.Looper;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/** Testing utilities for MediaCodec related test classes */
+public class MediaCodecTestUtils {
+  /**
+   * Compares if two {@link android.media.MediaCodec.BufferInfo} are equal by inspecting {@link
+   * android.media.MediaCodec.BufferInfo#flags}, {@link android.media.MediaCodec.BufferInfo#size},
+   * {@link android.media.MediaCodec.BufferInfo#presentationTimeUs} and {@link
+   * android.media.MediaCodec.BufferInfo#offset}.
+   */
+  public static boolean areEqual(MediaCodec.BufferInfo lhs, MediaCodec.BufferInfo rhs) {
+    return lhs.flags == rhs.flags
+        && lhs.offset == rhs.offset
+        && lhs.presentationTimeUs == rhs.presentationTimeUs
+        && lhs.size == rhs.size;
+  }
+
+  /**
+   * Blocks until all events of a shadow looper are executed or the specified time elapses.
+   *
+   * @param looper the shadow looper
+   * @param time the time to wait
+   * @param unit the time units
+   * @return true if all events are executed, false if the time elapsed.
+   * @throws InterruptedException if the Thread was interrupted while waiting.
+   */
+  public static boolean waitUntilAllEventsAreExecuted(Looper looper, long time, TimeUnit unit)
+      throws InterruptedException {
+    Handler handler = new Handler(looper);
+    CountDownLatch latch = new CountDownLatch(1);
+    handler.post(() -> latch.countDown());
+    shadowOf(looper).idle();
+    return latch.await(time, unit);
+  }
+}