1 files changed, 121 insertions, 0 deletions
diff --git a/dom/media/systemservices/android_video_capture/java/src/org/webrtc/videoengine/VideoCaptureDeviceInfoAndroid.java b/dom/media/systemservices/android_video_capture/java/src/org/webrtc/videoengine/VideoCaptureDeviceInfoAndroid.java
new file mode 100644
index 0000000000..8ad8453955
--- /dev/null
+++ b/dom/media/systemservices/android_video_capture/java/src/org/webrtc/videoengine/VideoCaptureDeviceInfoAndroid.java
@@ -0,0 +1,121 @@
+/*
+ *  Copyright (c) 2012 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.videoengine;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Context;
+import android.util.Log;
+
+import org.mozilla.gecko.GeckoAppShell;
+import org.mozilla.gecko.annotation.WebRTCJNITarget;
+
+import org.webrtc.CameraEnumerator;
+import org.webrtc.CameraEnumerationAndroid.CaptureFormat;
+import org.webrtc.Camera1Enumerator;
+import org.webrtc.Camera2Enumerator;
+
+public class VideoCaptureDeviceInfoAndroid {
+  private final static String TAG = "WEBRTC-JC";
+
+  // Returns information about all cameras on the device.
+  // Since this reflects static information about the hardware present, there is
+  // no need to call this function more than once in a single process.  It is
+  // marked "private" as it is only called by native code.
+  @WebRTCJNITarget
+  private static CaptureCapabilityAndroid[] getDeviceInfo() {
+      final Context context = GeckoAppShell.getApplicationContext();
+
+      if (Camera2Enumerator.isSupported(context)) {
+          return createDeviceList(new Camera2Enumerator(context));
+      } else {
+          return createDeviceList(new Camera1Enumerator());
+      }
+  }
+
+  private static CaptureCapabilityAndroid[] createDeviceList(CameraEnumerator enumerator) {
+
+      ArrayList<CaptureCapabilityAndroid> allDevices = new ArrayList<CaptureCapabilityAndroid>();
+      ArrayList<CaptureCapabilityAndroid> IRDevices = new ArrayList<CaptureCapabilityAndroid>();
+
+      for (String camera: enumerator.getDeviceNames()) {
+          List<CaptureFormat> formats = enumerator.getSupportedFormats(camera);
+          int numFormats = formats.size();
+          if (numFormats <= 0) {
+            continue;
+          }
+
+          CaptureCapabilityAndroid device = new CaptureCapabilityAndroid();
+
+          // The only way to plumb through whether the device is front facing
+          // or not is by the name, but the name we receive depends upon the
+          // camera API in use. For the Camera1 API, this information is
+          // already present, but that is not the case when using Camera2.
+          // Later on, we look up the camera by name, so we have to use a
+          // format this is easy to undo. Ideally, libwebrtc would expose
+          // camera facing in VideoCaptureCapability and none of this would be
+          // necessary.
+          device.name = "Facing " + (enumerator.isFrontFacing(camera) ? "front" : "back") + ":" + camera;
+
+
+          boolean ir = enumerator.isInfrared(camera);
+          device.infrared = ir;
+          if (ir) {
+            device.name += " (infrared)";
+          }
+
+          // This isn't part of the new API, but we don't call
+          // GetDeviceOrientation() anywhere, so this value is unused.
+          device.orientation = 0;
+
+          device.width  = new int[numFormats];
+          device.height = new int[numFormats];
+          device.minMilliFPS = formats.get(0).framerate.min;
+          device.maxMilliFPS = formats.get(0).framerate.max;
+          int i = 0;
+          for (CaptureFormat format: formats) {
+              device.width[i] = format.width;
+              device.height[i] = format.height;
+              if (format.framerate.min < device.minMilliFPS) {
+                device.minMilliFPS = format.framerate.min;
+              }
+              if (format.framerate.max > device.maxMilliFPS) {
+                device.maxMilliFPS = format.framerate.max;
+              }
+              i++;
+          }
+          device.frontFacing = enumerator.isFrontFacing(camera);
+          // Infrared devices always last (but front facing ones before
+          // non-front-facing ones), front-facing non IR first, other in
+          // the middle.
+          if (!device.infrared) {
+            if (device.frontFacing) {
+              allDevices.add(0, device);
+            } else {
+              allDevices.add(device);
+            }
+          } else {
+            if (device.frontFacing) {
+              IRDevices.add(0, device);
+            } else {
+              IRDevices.add(device);
+            }
+          }
+      }
+
+      allDevices.addAll(IRDevices);
+
+      return allDevices.toArray(new CaptureCapabilityAndroid[0]);
+  }
+}