VideoCapturerAndroid: Fix threading issues

talk/app/webrtc/androidtests/src/org/webrtc/VideoCapturerAndroidTest.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 11 matching lines @@
  * 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.hardware.Camera;
 import android.test.ActivityTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
+import android.test.suitebuilder.annotation.MediumTest;
 import android.util.Size;
 
 import org.webrtc.CameraEnumerationAndroid.CaptureFormat;
 import org.webrtc.VideoRenderer.I420Frame;
 
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.CountDownLatch;
 
 @SuppressWarnings("deprecation")
 public class VideoCapturerAndroidTest extends ActivityTestCase {
   static class RendererCallbacks implements VideoRenderer.Callbacks {
     private int framesRendered = 0;
     private Object frameLock = 0;
 
     @Override
     public void renderFrame(I420Frame frame) {
       synchronized (frameLock) {
         ++framesRendered;
         frameLock.notify();
       }
       VideoRenderer.renderFrameDone(frame);
     }
 
     public int WaitForNextFrameToRender() throws InterruptedException {
       synchronized (frameLock) {
         frameLock.wait();
         return framesRendered;
       }
     }
   }
 
-  static class AsyncRenderer implements VideoRenderer.Callbacks {
+  static class FakeAsyncRenderer implements VideoRenderer.Callbacks {
     private final List<I420Frame> pendingFrames = new ArrayList<I420Frame>();
 
     @Override
     public void renderFrame(I420Frame frame) {
       synchronized (pendingFrames) {
         pendingFrames.add(frame);
         pendingFrames.notifyAll();
       }
     }
 
     // Wait until at least one frame have been received, before returning them.
-    public List<I420Frame> WaitForFrames() {
+    public List<I420Frame> waitForPendingFrames() throws InterruptedException {
       synchronized (pendingFrames) {
         while (pendingFrames.isEmpty()) {
-          try {
-            pendingFrames.wait();
-          } catch (InterruptedException e) {
-            // Ignore.
-          }
+          pendingFrames.wait();
         }
-        final List<I420Frame> frames = new ArrayList<I420Frame>(pendingFrames);
-        pendingFrames.clear();
-        return frames;
+        return new ArrayList<I420Frame>(pendingFrames);
       }
     }
   }
 
   static class FakeCapturerObserver implements
       VideoCapturerAndroid.CapturerObserver {
     private int framesCaptured = 0;
     private int frameSize = 0;
     private Object frameLock = 0;
     private Object capturerStartLock = 0;
@@ skipping 63 matching lines @@
         VideoCapturerAndroid.create(deviceName, null);
     VideoSource source =
         factory.createVideoSource(capturer, new MediaConstraints());
     VideoTrack track = factory.createVideoTrack("dummy", source);
     RendererCallbacks callbacks = new RendererCallbacks();
     track.addRenderer(new VideoRenderer(callbacks));
     assertTrue(callbacks.WaitForNextFrameToRender() > 0);
     track.dispose();
     source.dispose();
     factory.dispose();
+    assertTrue(capturer.isReleased());
   }
 
   @Override
   protected void setUp() {
     assertTrue(PeerConnectionFactory.initializeAndroidGlobals(
         getInstrumentation().getContext(), true, true, true));
   }
 
   @SmallTest
   // Test that enumerating formats using android.hardware.camera2 will give the same formats as
@@ skipping 24 matching lines @@
         }
       }
     }
   }
 
   @SmallTest
   public void testCreateAndRelease() throws Exception {
     VideoCapturerAndroid capturer = VideoCapturerAndroid.create("", null);
     assertNotNull(capturer);
     capturer.dispose();
+    assertTrue(capturer.isReleased());
   }
 
   @SmallTest
   public void testCreateNonExistingCamera() throws Exception {
     VideoCapturerAndroid capturer = VideoCapturerAndroid.create(
         "non-existing camera", null);
     assertNull(capturer);
   }
 
   @SmallTest
@@ skipping 17 matching lines @@
   // to a Java video renderer using the back facing video capturer.
   // It tests both the Java and the C++ layer.
   public void testStartBackFacingVideoCapturer() throws Exception {
     if (!HaveTwoCameras()) {
       return;
     }
     startCapturerAndRender(CameraEnumerationAndroid.getNameOfBackFacingDevice());
   }
 
   @SmallTest
-  // This test that the default camera can be started and but the camera can
+  // This test that the default camera can be started and that the camera can
   // later be switched to another camera.
   // It tests both the Java and the C++ layer.
   public void testSwitchVideoCapturer() throws Exception {
     PeerConnectionFactory factory = new PeerConnectionFactory();
     VideoCapturerAndroid capturer = VideoCapturerAndroid.create("", null);
     VideoSource source =
         factory.createVideoSource(capturer, new MediaConstraints());
     VideoTrack track = factory.createVideoTrack("dummy", source);
 
-    if (HaveTwoCameras())
-      assertTrue(capturer.switchCamera(null));
-    else
-      assertFalse(capturer.switchCamera(null));
+    // Array with one element to avoid final problem in nested classes.
+    final boolean[] cameraSwitchSuccessful = new boolean[1];
+    final CountDownLatch barrier = new CountDownLatch(1);
+    capturer.switchCamera(new VideoCapturerAndroid.CameraSwitchHandler() {
+      @Override
+      public void onCameraSwitchDone(boolean isFrontCamera) {
+        cameraSwitchSuccessful[0] = true;
+        barrier.countDown();
+      }
+      @Override
+      public void onCameraSwitchError(String errorDescription) {
+        cameraSwitchSuccessful[0] = false;
+        barrier.countDown();
+      }
+    });
+    // Wait until the camera has been switched.
+    barrier.await();
 
-    // Wait until the camera have been switched.
-    capturer.runCameraThreadUntilIdle();
-
+    // Check result.
+    if (HaveTwoCameras()) {
+      assertTrue(cameraSwitchSuccessful[0]);
+    } else {
+      assertFalse(cameraSwitchSuccessful[0]);
+    }
     // Ensure that frames are received.
     RendererCallbacks callbacks = new RendererCallbacks();
     track.addRenderer(new VideoRenderer(callbacks));
     assertTrue(callbacks.WaitForNextFrameToRender() > 0);
     track.dispose();
     source.dispose();
     factory.dispose();
+    assertTrue(capturer.isReleased());
   }
 
   @SmallTest
   // This test that the VideoSource that the VideoCapturer is connected to can
   // be stopped and restarted. It tests both the Java and the C++ layer.
   public void testStopRestartVideoSource() throws Exception {
     PeerConnectionFactory factory = new PeerConnectionFactory();
     VideoCapturerAndroid capturer = VideoCapturerAndroid.create("", null);
     VideoSource source =
         factory.createVideoSource(capturer, new MediaConstraints());
     VideoTrack track = factory.createVideoTrack("dummy", source);
     RendererCallbacks callbacks = new RendererCallbacks();
     track.addRenderer(new VideoRenderer(callbacks));
     assertTrue(callbacks.WaitForNextFrameToRender() > 0);
     assertEquals(MediaSource.State.LIVE, source.state());
 
     source.stop();
     assertEquals(MediaSource.State.ENDED, source.state());
 
     source.restart();
     assertTrue(callbacks.WaitForNextFrameToRender() > 0);
     assertEquals(MediaSource.State.LIVE, source.state());
     track.dispose();
     source.dispose();
     factory.dispose();
+    assertTrue(capturer.isReleased());
   }
 
   @SmallTest
   // This test that the camera can be started at different resolutions.
   // It does not test or use the C++ layer.
   public void testStartStopWithDifferentResolutions() throws Exception {
     FakeCapturerObserver observer = new FakeCapturerObserver();
 
     String deviceName = CameraEnumerationAndroid.getDeviceName(0);
     List<CaptureFormat> formats = CameraEnumerationAndroid.getSupportedFormats(0);
     VideoCapturerAndroid capturer =
         VideoCapturerAndroid.create(deviceName, null);
 
     for(int i = 0; i < 3 ; ++i) {
       CameraEnumerationAndroid.CaptureFormat format = formats.get(i);
       capturer.startCapture(format.width, format.height, format.maxFramerate,
           getInstrumentation().getContext(), observer);
       assertTrue(observer.WaitForCapturerToStart());
       observer.WaitForNextCapturedFrame();
       // Check the frame size.
       assertEquals(format.frameSize(), observer.frameSize());
       capturer.stopCapture();
+      for (long timestamp : observer.getCopyAndResetListOftimeStamps()) {
+        capturer.returnBuffer(timestamp);
+      }
     }
     capturer.dispose();
+    assertTrue(capturer.isReleased());
   }
 
   @SmallTest
   // This test what happens if buffers are returned after the capturer have
   // been stopped and restarted. It does not test or use the C++ layer.
   public void testReturnBufferLate() throws Exception {
     FakeCapturerObserver observer = new FakeCapturerObserver();
 
     String deviceName = CameraEnumerationAndroid.getDeviceName(0);
     List<CaptureFormat> formats = CameraEnumerationAndroid.getSupportedFormats(0);
@@ skipping 21 matching lines @@
     }
 
     observer.WaitForNextCapturedFrame();
     capturer.stopCapture();
 
     listOftimestamps = observer.getCopyAndResetListOftimeStamps();
     assertTrue(listOftimestamps.size() >= 2);
     for (Long timeStamp : listOftimestamps) {
       capturer.returnBuffer(timeStamp);
     }
+    capturer.dispose();
+    assertTrue(capturer.isReleased());
   }
 
-  @SmallTest
-  // This test that we can capture frames, stop capturing, keep the frames for rendering, and then
-  // return the frames. It tests both the Java and the C++ layer.
-  public void testCaptureAndAsyncRender() {
+  @MediumTest
+  // This test that we can capture frames, keep the frames in a local renderer, stop capturing,
+  // and then return the frames. The difference between the test testReturnBufferLate() is that we
+  // also test the JNI and C++ AndroidVideoCapturer parts.
+  public void testReturnBufferLateEndToEnd() throws InterruptedException {
     final VideoCapturerAndroid capturer = VideoCapturerAndroid.create("", null);
-    // Helper class that sets everything up, captures at least one frame, and then shuts
-    // everything down.
-    class CaptureFramesRunnable implements Runnable {
-      public List<I420Frame> frames;
+    final PeerConnectionFactory factory = new PeerConnectionFactory();
+    final VideoSource source = factory.createVideoSource(capturer, new MediaConstraints());
+    final VideoTrack track = factory.createVideoTrack("dummy", source);
+    final FakeAsyncRenderer renderer = new FakeAsyncRenderer();
+    track.addRenderer(new VideoRenderer(renderer));
+    // Wait for at least one frame that has not been returned.
+    assertFalse(renderer.waitForPendingFrames().isEmpty());
 
+    capturer.stopCapture();
+
+    // Dispose source and |capturer|.
+    track.dispose();
+    source.dispose();
+    // The pending frames should keep the JNI parts and |capturer| alive.
+    assertFalse(capturer.isReleased());
+
+    // Return the frame(s), on a different thread out of spite.
+    final List<I420Frame> pendingFrames = renderer.waitForPendingFrames();
+    final Thread returnThread = new Thread(new Runnable() {
       @Override
       public void run() {
-        PeerConnectionFactory factory = new PeerConnectionFactory();
-        VideoSource source = factory.createVideoSource(capturer, new MediaConstraints());
-        VideoTrack track = factory.createVideoTrack("dummy", source);
-        AsyncRenderer renderer = new AsyncRenderer();
-        track.addRenderer(new VideoRenderer(renderer));
+        for (I420Frame frame : pendingFrames) {
+          VideoRenderer.renderFrameDone(frame);
+        }
+      }
+    });
+    returnThread.start();
+    returnThread.join();
 
-        // Wait until we get at least one frame.
-        frames = renderer.WaitForFrames();
+    // Check that frames have successfully returned. This will cause |capturer| to be released.
+    assertTrue(capturer.isReleased());
 
-        // Stop everything.
-        track.dispose();
-        source.dispose();
-        factory.dispose();
-      }
-    }
-
-    // Capture frames on a separate thread.
-    CaptureFramesRunnable captureFramesRunnable = new CaptureFramesRunnable();
-    Thread captureThread = new Thread(captureFramesRunnable);
-    captureThread.start();
-
-    // Wait until frames are captured, and then kill the thread.
-    try {
-      captureThread.join();
-    } catch (InterruptedException e) {
-      fail("Capture thread was interrupted");
-    }
-    captureThread = null;
-
-    // Assert that we have frames that have not been returned.
-    assertTrue(!captureFramesRunnable.frames.isEmpty());
-    // Return the frame(s).
-    for (I420Frame frame : captureFramesRunnable.frames) {
-      VideoRenderer.renderFrameDone(frame);
-    }
-    assertEquals(capturer.pendingFramesTimeStamps(), "[]");
+    factory.dispose();
   }
 }