Convert Android camera tests to use the new createVideoSource API.

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;
 
 import static junit.framework.Assert.*;
 
 import org.webrtc.CameraEnumerationAndroid.CaptureFormat;
 import org.webrtc.VideoRenderer.I420Frame;
 
 import android.content.Context;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 
 class CameraVideoCapturerTestFixtures {
   static final String TAG = "CameraVideoCapturerTestFixtures";
+  // Default values used for starting capturing
+  static final int DEFAULT_WIDTH = 640;
+  static final int DEFAULT_HEIGHT = 480;
+  static final int DEFAULT_FPS = 15;
 
   static private class RendererCallbacks implements VideoRenderer.Callbacks {
     private int framesRendered = 0;
     private Object frameLock = 0;
     private int width = 0;
     private int height = 0;
 
     @Override
     public void renderFrame(I420Frame frame) {
       synchronized (frameLock) {
@@ skipping 302 matching lines @@
 
   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
+    }
     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, new MediaConstraints());
+        peerConnectionFactory.createVideoSource(capturer);

[magjed_webrtc, 2016/07/26 09:15:13]

This fits on the line above now.

[sakal, 2016/07/26 11:50:48]

Done.

+    capturer.startCapture(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FPS);
     videoTrackWithRenderer.track =
         peerConnectionFactory.createVideoTrack("dummy", videoTrackWithRenderer.source);
     videoTrackWithRenderer.track.addRenderer(new VideoRenderer(rendererCallbacks));
     return videoTrackWithRenderer;
   }
 
   private VideoTrackWithRenderer createVideoTrackWithRenderer(CameraVideoCapturer capturer) {
     RendererCallbacks rendererCallbacks = new RendererCallbacks();
     VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithRenderer(capturer, rendererCallbacks);
@@ skipping 28 matching lines @@
   private void createCapturerAndRender(String name) throws InterruptedException {
     if (name == null) {
       Logging.w(TAG, "Skipping video capturer test because device name is null.");
       return;
     }
 
     final CapturerInstance capturerInstance = createCapturer(name, false /* initialize */);
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithRenderer(capturerInstance.capturer);
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
   }
 
   // Test methods
   public void createCapturerAndDispose() {
     disposeCapturer(createCapturer(true /* initialize */));
   }
 
   public void createNonExistingCamera() {
     try {
       disposeCapturer(createCapturer("non-existing camera", false /* initialize */));
@@ skipping 42 matching lines @@
         barrier.countDown();
       }
     });
     // Wait until the camera has been switched.
     barrier.await();
 
     // Check result.
     assertTrue(cameraSwitchSuccessful[0]);
     // Ensure that frames are received.
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
   }
 
   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.
     assertTrue(capturerInstance.observer.waitForCapturerToStart());
     capturerInstance.capturer.stopCapture();
     capturerInstance.surfaceTextureHelper.returnTextureFrame();
 
     // We can't change |capturer| at this point, but we should not crash.
     capturerInstance.capturer.switchCamera(null /* switchEventsHandler */);
-    capturerInstance.capturer.onOutputFormatRequest(640, 480, 15);
-    capturerInstance.capturer.changeCaptureFormat(640, 480, 15);
+    capturerInstance.capturer.onOutputFormatRequest(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FPS);
+    capturerInstance.capturer.changeCaptureFormat(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FPS);
 
     disposeCapturer(capturerInstance);
   }
 
   public void stopRestartVideoSource() throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(false /* initialize */);
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithRenderer(capturerInstance.capturer);
 
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
     assertEquals(MediaSource.State.LIVE, videoTrackWithRenderer.source.state());
 
-    videoTrackWithRenderer.source.stop();
+    capturerInstance.capturer.stopCapture();
     assertEquals(MediaSource.State.ENDED, videoTrackWithRenderer.source.state());
 
-    videoTrackWithRenderer.source.restart();
+    startCapture(capturerInstance);
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
     assertEquals(MediaSource.State.LIVE, videoTrackWithRenderer.source.state());
 
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
   }
 
   public void startStopWithDifferentResolutions() throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(true /* initialize */);
 
     for(int i = 0; i < 3 ; ++i) {
       startCapture(capturerInstance, i);
       assertTrue(capturerInstance.observer.waitForCapturerToStart());
       capturerInstance.observer.waitForNextCapturedFrame();
 
@@ skipping 49 matching lines @@
       throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(false /* initialize */);
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithFakeAsyncRenderer(capturerInstance.capturer);
     // Wait for at least one frame that has not been returned.
     assertFalse(videoTrackWithRenderer.fakeAsyncRenderer.waitForPendingFrames().isEmpty());
 
     capturerInstance.capturer.stopCapture();
 
     // Dispose everything.
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
 
     // Return the frame(s), on a different thread out of spite.
     final List<I420Frame> pendingFrames =
         videoTrackWithRenderer.fakeAsyncRenderer.waitForPendingFrames();
     final Thread returnThread = new Thread(new Runnable() {
       @Override
       public void run() {
         for (I420Frame frame : pendingFrames) {
           VideoRenderer.renderFrameDone(frame);
         }
@@ skipping 36 matching lines @@
     int numberOfInspectedFrames = 0;
 
     do {
       videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender();
       ++numberOfInspectedFrames;
 
       gotExpectedResolution = (videoTrackWithRenderer.rendererCallbacks.frameWidth() == scaledWidth
           &&  videoTrackWithRenderer.rendererCallbacks.frameHeight() == scaledHeight);
     } while (!gotExpectedResolution && numberOfInspectedFrames < 30);
 
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
 
     assertTrue(gotExpectedResolution);
   }
 
   public void startWhileCameraIsAlreadyOpen() 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);
@@ skipping 44 matching lines @@
     final Object competingCamera = testObjectFactory.rawOpenCamera(cameraName);
 
     startCapture(capturerInstance);
 
     capturerInstance.capturer.stopCapture();
     disposeCapturer(capturerInstance);
 
     testObjectFactory.rawCloseCamera(competingCamera);
   }
 }