Session based capturing for Camera2Capturer.

webrtc/api/androidtests/src/org/webrtc/CameraVideoCapturerTestFixtures.java

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 package org.webrtc;
@@ skipping 173 matching lines @@
       }
     }
   }
 
   static class CameraEvents implements
       CameraVideoCapturer.CameraEventsHandler {
     public boolean onCameraOpeningCalled;
     public boolean onFirstFrameAvailableCalled;
     public final Object onCameraFreezedLock = new Object();
     private String onCameraFreezedDescription;
+    public final Object cameraClosedLock = new Object();
+    private boolean cameraClosed = true;
 
     @Override
     public void onCameraError(String errorDescription) {
+      Logging.w(TAG, "Camera error: " + errorDescription);
+      cameraClosed = true;
     }
 
     @Override
     public void onCameraFreezed(String errorDescription) {
       synchronized (onCameraFreezedLock) {
         onCameraFreezedDescription = errorDescription;
         onCameraFreezedLock.notifyAll();
       }
     }
 
     @Override
     public void onCameraOpening(int cameraId) {
       onCameraOpeningCalled = true;
+      synchronized (cameraClosedLock) {
+        cameraClosed = false;
+      }
     }
 
     @Override
     public void onFirstFrameAvailable() {
       onFirstFrameAvailableCalled = true;
     }
 
     @Override
-    public void onCameraClosed() { }
+    public void onCameraClosed() {
+      synchronized (cameraClosedLock) {
+        cameraClosed = true;
+        cameraClosedLock.notifyAll();
+      }
+    }
 
     public String waitForCameraFreezed() throws InterruptedException {
       Logging.d(TAG, "Waiting for the camera to freeze");
       synchronized (onCameraFreezedLock) {
         onCameraFreezedLock.wait();
         return onCameraFreezedDescription;
       }
     }
+
+    public void waitForCameraClosed() throws InterruptedException {
+      synchronized (cameraClosedLock) {
+        while (!cameraClosed) {
+          Logging.d(TAG, "Waiting for the camera to close.");
+          cameraClosedLock.wait();
+        }
+      }
+    }
   }
 
   /**
    * Class to collect all classes related to single capturer instance.
    */
   static private class CapturerInstance {
     public CameraVideoCapturer capturer;
     public CameraEvents cameraEvents;
     public SurfaceTextureHelper surfaceTextureHelper;
     public FakeCapturerObserver observer;
@@ skipping 88 matching lines @@
     instance.observer = new FakeCapturerObserver();
     if (initialize) {
       instance.capturer.initialize(
           instance.surfaceTextureHelper, testObjectFactory.getAppContext(), instance.observer);
     }
     instance.supportedFormats = instance.capturer.getSupportedFormats();
     return instance;
   }
 
   private CapturerInstance createCapturer(boolean initialize) {
-    return createCapturer("", initialize);
+    String name = testObjectFactory.cameraEnumerator.getDeviceNames()[0];
+    return createCapturer(name, initialize);
   }
 
   private void startCapture(CapturerInstance instance) {
     startCapture(instance, 0);
   }
 
   private void startCapture(CapturerInstance instance, int formatIndex) {
     final CameraEnumerationAndroid.CaptureFormat format =
         instance.supportedFormats.get(formatIndex);
 
     instance.capturer.startCapture(format.width, format.height, format.framerate.max);
     instance.format = format;
   }
 
-  private void disposeCapturer(CapturerInstance instance) {
-    try {
-      instance.capturer.stopCapture();
-    } catch (InterruptedException e) {
-      // TODO(sakal): Remove this once stopCapture no longer throws InterruptedException
-    }
+  private void disposeCapturer(CapturerInstance instance) throws InterruptedException {
+    instance.capturer.stopCapture();
+    instance.cameraEvents.waitForCameraClosed();
     instance.capturer.dispose();
     instance.surfaceTextureHelper.returnTextureFrame();
     instance.surfaceTextureHelper.dispose();
   }
 
   private VideoTrackWithRenderer createVideoTrackWithRenderer(CameraVideoCapturer capturer,
       VideoRenderer.Callbacks rendererCallbacks) {
     VideoTrackWithRenderer videoTrackWithRenderer = new VideoTrackWithRenderer();
     videoTrackWithRenderer.source = peerConnectionFactory.createVideoSource(capturer);
     capturer.startCapture(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FPS);
@@ skipping 43 matching lines @@
 
     final CapturerInstance capturerInstance = createCapturer(name, false /* initialize */);
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithRenderer(capturerInstance.capturer);
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
     disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
   }
 
   // Test methods
-  public void createCapturerAndDispose() {
+  public void createCapturerAndDispose() throws InterruptedException {
     disposeCapturer(createCapturer(true /* initialize */));
   }
 
-  public void createNonExistingCamera() {
+  public void createNonExistingCamera() throws InterruptedException {
     try {
       disposeCapturer(createCapturer("non-existing camera", false /* initialize */));
     } catch (IllegalArgumentException e) {
       return;
     }
 
     fail("Expected illegal argument exception when creating non-existing camera.");
   }
 
   public void createCapturerAndRender() throws InterruptedException  {
-    createCapturerAndRender("");
+    String name = testObjectFactory.cameraEnumerator.getDeviceNames()[0];
+    createCapturerAndRender(name);
   }
 
   public void createFrontFacingCapturerAndRender() throws InterruptedException {
     createCapturerAndRender(testObjectFactory.getNameOfFrontFacingDevice());
   }
 
   public void createBackFacingCapturerAndRender() throws InterruptedException {
     createCapturerAndRender(testObjectFactory.getNameOfBackFacingDevice());
   }
 
   public void switchCamera() throws InterruptedException {
     if (!testObjectFactory.haveTwoCameras()) {
       Logging.w(TAG,
           "Skipping test switch video capturer because the device doesn't have two cameras.");
       return;
     }
 
     final CapturerInstance capturerInstance = createCapturer(false /* initialize */);
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithRenderer(capturerInstance.capturer);
+    // Wait for the camera to start so we can switch it
+    assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
 
     // Array with one element to avoid final problem in nested classes.
     final boolean[] cameraSwitchSuccessful = new boolean[1];
     final CountDownLatch barrier = new CountDownLatch(1);
     capturerInstance.capturer.switchCamera(new CameraVideoCapturer.CameraSwitchHandler() {
       @Override
       public void onCameraSwitchDone(boolean isFrontCamera) {
         cameraSwitchSuccessful[0] = true;
         barrier.countDown();
       }
@@ skipping 13 matching lines @@
     disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
   }
 
   public void cameraEventsInvoked() throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(true /* initialize */);
     startCapture(capturerInstance);
     // Make sure camera is started and first frame is received and then stop it.
     assertTrue(capturerInstance.observer.waitForCapturerToStart());
     capturerInstance.observer.waitForNextCapturedFrame();
-    capturerInstance.capturer.stopCapture();
     disposeCapturer(capturerInstance);
 
     assertTrue(capturerInstance.cameraEvents.onCameraOpeningCalled);
     assertTrue(capturerInstance.cameraEvents.onFirstFrameAvailableCalled);
   }
 
   public void cameraCallsAfterStop() throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(true /* initialize */);
     startCapture(capturerInstance);
     // Make sure camera is started and then stop it.
@@ skipping 164 matching lines @@
     // At this point camera is not actually opened.
     final CapturerInstance capturerInstance = createCapturer(cameraName, true /* initialize */);
 
     final Object competingCamera = testObjectFactory.rawOpenCamera(cameraName);
 
     startCapture(capturerInstance);
 
     if (android.os.Build.VERSION.SDK_INT > android.os.Build.VERSION_CODES.LOLLIPOP_MR1) {
       // The first opened camera client will be evicted.
       assertTrue(capturerInstance.observer.waitForCapturerToStart());
-      capturerInstance.capturer.stopCapture();
     } else {
       assertFalse(capturerInstance.observer.waitForCapturerToStart());
     }
 
     testObjectFactory.rawCloseCamera(competingCamera);
     disposeCapturer(capturerInstance);
   }
 
   public void startWhileCameraIsAlreadyOpenAndCloseCamera() throws InterruptedException {
     final String cameraName = testObjectFactory.getNameOfBackFacingDevice();
     // At this point camera is not actually opened.
     final CapturerInstance capturerInstance = createCapturer(cameraName, false /* initialize */);
 
     Logging.d(TAG, "startWhileCameraIsAlreadyOpenAndCloseCamera: Opening competing camera.");
     final Object competingCamera = testObjectFactory.rawOpenCamera(cameraName);
 
     Logging.d(TAG, "startWhileCameraIsAlreadyOpenAndCloseCamera: Opening camera.");
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithRenderer(capturerInstance.capturer);
     waitUntilIdle(capturerInstance);
 
     Logging.d(TAG, "startWhileCameraIsAlreadyOpenAndCloseCamera: Closing competing camera.");
     testObjectFactory.rawCloseCamera(competingCamera);
 
     // Make sure camera is started and first frame is received and then stop it.
     Logging.d(TAG, "startWhileCameraIsAlreadyOpenAndCloseCamera: Waiting for capture to start.");
     videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender();
     Logging.d(TAG, "startWhileCameraIsAlreadyOpenAndCloseCamera: Stopping capture.");
-    capturerInstance.capturer.stopCapture();
     disposeCapturer(capturerInstance);
   }
 
   public void startWhileCameraIsAlreadyOpenAndStop() throws InterruptedException {
     final String cameraName = testObjectFactory.getNameOfBackFacingDevice();
     // At this point camera is not actually opened.
     final CapturerInstance capturerInstance = createCapturer(cameraName, true /* initialize */);
 
     final Object competingCamera = testObjectFactory.rawOpenCamera(cameraName);
 
     startCapture(capturerInstance);
-
-    capturerInstance.capturer.stopCapture();
     disposeCapturer(capturerInstance);
 
     testObjectFactory.rawCloseCamera(competingCamera);
   }
 }