Call MediaCodec.stop() on separate thread.

talk/app/webrtc/java/android/org/webrtc/ThreadUtils.java

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 10 matching lines @@
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package org.webrtc;
 
 import android.os.Handler;
+import android.os.SystemClock;
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
 final class ThreadUtils {
   /**
    * Utility class to be used for checking that a method is called on the correct thread.
    */
   public static class ThreadChecker {
     private Thread thread = Thread.currentThread();
 
     public void checkIsOnValidThread() {
       if (thread == null) {
@@ skipping 53 matching lines @@
 
   public static void awaitUninterruptibly(final CountDownLatch latch) {
     executeUninterruptibly(new BlockingOperation() {
       @Override
       public void run() throws InterruptedException {
         latch.await();
       }
     });
   }
 
+  public static boolean awaitUninterruptibly(CountDownLatch barrier, long timeoutMs) {
+    final long startTimeMs = SystemClock.elapsedRealtime();
+    long timeRemainingMs = timeoutMs;
+    boolean wasInterrupted = false;
+    boolean result = false;
+    do {
+      try {
+        result = barrier.await(timeRemainingMs, TimeUnit.MILLISECONDS);
+        break;
+      } catch (InterruptedException e) {
+        // Someone is asking us to return early at our convenience. We can't cancel this operation,
+        // but we should preserve the information and pass it along.
+        wasInterrupted = true;
+        final long elapsedTimeMs = SystemClock.elapsedRealtime() - startTimeMs;
+        timeRemainingMs = timeoutMs - elapsedTimeMs;
+      }
+    } while (timeRemainingMs > 0);
+    // Pass interruption information along.
+    if (wasInterrupted) {
+      Thread.currentThread().interrupt();
+    }
+    return result;
+  }
+
   /**
    * Post |callable| to |handler| and wait for the result.
    */
   public static <V> V invokeUninterruptibly(final Handler handler, final Callable<V> callable) {
     class Result {
       public V value;
     }
     final Result result = new Result();
     final CountDownLatch barrier = new CountDownLatch(1);
     handler.post(new Runnable() {
@@ skipping 17 matching lines @@
     final CountDownLatch barrier = new CountDownLatch(1);
     handler.post(new Runnable() {
       @Override public void run() {
           runner.run();
         barrier.countDown();
       }
     });
     awaitUninterruptibly(barrier);
   }
 }