Refactor VideoCapturerAndroid tests in WebRTC.

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

Index: webrtc/api/androidtests/src/org/webrtc/Camera1CapturerUsingByteBufferTest.java
diff --git a/webrtc/api/androidtests/src/org/webrtc/Camera1CapturerUsingByteBufferTest.java b/webrtc/api/androidtests/src/org/webrtc/Camera1CapturerUsingByteBufferTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd73fb0a6836888e63667be678c9a2c4f9b0f264
--- /dev/null
+++ b/webrtc/api/androidtests/src/org/webrtc/Camera1CapturerUsingByteBufferTest.java
@@ -0,0 +1,194 @@
+/*
+ *  Copyright 2016 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 android.content.Context;
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.test.suitebuilder.annotation.MediumTest;
+import android.test.suitebuilder.annotation.LargeTest;
+
+import org.webrtc.CameraEnumerationAndroid.CaptureFormat;
+
+public class Camera1CapturerUsingByteBufferTest extends InstrumentationTestCase {
+  static final String TAG = "Camera1CapturerUsingByteBufferTest";
+
+  private class TestObjectFactory
+      implements CameraVideoCapturerTestFixtures.TestObjectFactory {
+    @Override
+    public CameraVideoCapturer createCapturer(
+        String name,
+        CameraVideoCapturer.CameraEventsHandler eventsHandler) {
+      return new VideoCapturerAndroid(name, eventsHandler, isCapturingToTexture());
+    }
+
+    @Override
+    public String getNameOfFrontFacingDevice() {
+      return CameraEnumerationAndroid.getNameOfFrontFacingDevice();
+    }
+
+    @Override
+    public String getNameOfBackFacingDevice() {
+      return CameraEnumerationAndroid.getNameOfBackFacingDevice();
+    }
+
+    // Return true if the device under test have at least two cameras.
+    @SuppressWarnings("deprecation")
+    @Override
+    public boolean haveTwoCameras() {
+      return (android.hardware.Camera.getNumberOfCameras() >= 2);
+    }
+
+    @Override
+    public boolean isCapturingToTexture() {
+      return false;
+    }
+
+    @Override
+    public Context getAppContext() {
+      return getInstrumentation().getTargetContext();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public Object rawOpenCamera(String cameraId) {

[perkj_webrtc, 2016/06/14 06:02:34]

You use a String here. Why did you change getCameraId to return a String instead
of int? Can we switch back? 

[sakal, 2016/06/14 08:40:55]

I use String here because in Camera2 API camera ids are strings. For the Nexus
devices I've tried, they have been strings "0" for back camera and "1" for front
camera but I don't think we should rely on that.

+      return android.hardware.Camera.open(Integer.parseInt(cameraId));
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public void rawCloseCamera(Object camera) {
+      ((android.hardware.Camera) camera).release();
+    }
+  }
+
+  private CameraVideoCapturerTestFixtures fixtures;
+
+  @Override
+  protected void setUp() {
+    fixtures = new CameraVideoCapturerTestFixtures(new TestObjectFactory());
+  }
+
+  @Override
+  protected void tearDown() {
+    fixtures.dispose();
+  }
+
+  @SmallTest
+  public void testCreateAndDispose() {
+    fixtures.createCapturerAndDispose();
+  }
+
+  @SmallTest
+  public void testCreateNonExistingCamera() {
+    fixtures.createNonExistingCamera();
+  }
+
+  // This test that the camera can be started and that the frames are forwarded
+  // to a Java video renderer using a "default" capturer.
+  // It tests both the Java and the C++ layer.
+  @MediumTest
+  public void testCreateCapturerAndRender() throws InterruptedException {
+    fixtures.createCapturerAndRender();
+  }
+
+  // This test that the camera can be started and that the frames are forwarded
+  // to a Java video renderer using the front facing video capturer.
+  // It tests both the Java and the C++ layer.
+  @MediumTest
+  public void testStartFrontFacingVideoCapturer() throws InterruptedException {
+    fixtures.createFrontFacingCapturerAndRender();
+  }
+
+  // This test that the camera can be started and that the frames are forwarded
+  // to a Java video renderer using the back facing video capturer.
+  // It tests both the Java and the C++ layer.
+  @MediumTest
+  public void testStartBackFacingVideoCapturer() throws InterruptedException {
+    fixtures.createBackFacingCapturerAndRender();
+  }
+
+  // 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.
+  @MediumTest
+  public void testSwitchVideoCapturer() throws InterruptedException {
+    fixtures.switchCamera();
+  }
+
+  @MediumTest
+  public void testCameraEvents() throws InterruptedException {
+    fixtures.cameraEventsInvoked();
+  }
+
+  // Test what happens when attempting to call e.g. switchCamera() after camera has been stopped.
+  @MediumTest
+  public void testCameraCallsAfterStop() throws InterruptedException {
+    fixtures.cameraCallsAfterStop();
+  }
+
+  // This test that the VideoSource that the CameraVideoCapturer is connected to can
+  // be stopped and restarted. It tests both the Java and the C++ layer.
+  @LargeTest
+  public void testStopRestartVideoSource() throws InterruptedException {
+    fixtures.stopRestartVideoSource();
+  }
+
+  // This test that the camera can be started at different resolutions.
+  // It does not test or use the C++ layer.
+  @LargeTest
+  public void testStartStopWithDifferentResolutions() throws InterruptedException {
+    fixtures.startStopWithDifferentResolutions();
+  }
+
+  // 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.
+  @LargeTest
+  public void testReturnBufferLate() throws InterruptedException {
+    fixtures.returnBufferLateEndToEnd();
+  }
+
+  // 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.
+  @MediumTest
+  public void testReturnBufferLateEndToEnd() throws InterruptedException {
+    fixtures.returnBufferLateEndToEnd();
+  }
+
+  // This test that frames forwarded to a renderer is scaled if onOutputFormatRequest is
+  // called. This test both Java and C++ parts of of the stack.
+  @MediumTest
+  public void testScaleCameraOutput() throws InterruptedException {
+    fixtures.scaleCameraOutput();
+  }
+
+  // This test that an error is reported if the camera is already opened
+  // when CameraVideoCapturer is started.
+  @LargeTest
+  public void testStartWhileCameraIsAlreadyOpen() throws InterruptedException {
+    fixtures.startWhileCameraIsAlreadyOpen();
+  }
+
+  // This test that CameraVideoCapturer can be started, even if the camera is already opened
+  // if the camera is closed while CameraVideoCapturer is re-trying to start.
+  @LargeTest
+  public void testStartWhileCameraIsAlreadyOpenAndCloseCamera() throws InterruptedException {
+    fixtures.startWhileCameraIsAlreadyOpenAndCloseCamera();
+  }
+
+  // This test that CameraVideoCapturer.stop can be called while CameraVideoCapturer is
+  // re-trying to start.
+  @MediumTest
+  public void testStartWhileCameraIsAlreadyOpenAndStop() throws InterruptedException {
+    fixtures.startWhileCameraIsAlreadyOpenAndStop();
+  }
+}