Camera2 in AppRTC Android Demo.

webrtc/examples/androidapp/src/org/appspot/apprtc/PeerConnectionClient.java

 /*
  *  Copyright 2014 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.appspot.apprtc;
 
 import android.content.Context;
 import android.os.ParcelFileDescriptor;
 import android.os.Environment;
 import android.util.Log;
 
 import org.appspot.apprtc.AppRTCClient.SignalingParameters;
 import org.webrtc.AudioTrack;
+import org.webrtc.Camera1Enumerator;
+import org.webrtc.Camera2Enumerator;
+import org.webrtc.CameraEnumerator;
 import org.webrtc.CameraEnumerationAndroid;
+import org.webrtc.CameraVideoCapturer;
 import org.webrtc.DataChannel;
 import org.webrtc.EglBase;
 import org.webrtc.IceCandidate;
 import org.webrtc.Logging;
 import org.webrtc.MediaCodecVideoEncoder;
 import org.webrtc.MediaConstraints;
 import org.webrtc.MediaConstraints.KeyValuePair;
 import org.webrtc.MediaStream;
 import org.webrtc.PeerConnection;
 import org.webrtc.PeerConnection.IceConnectionState;
 import org.webrtc.PeerConnectionFactory;
 import org.webrtc.SdpObserver;
 import org.webrtc.SessionDescription;
 import org.webrtc.StatsObserver;
 import org.webrtc.StatsReport;
-import org.webrtc.VideoCapturerAndroid;
+import org.webrtc.VideoCapturer;
 import org.webrtc.VideoRenderer;
 import org.webrtc.VideoSource;
 import org.webrtc.VideoTrack;
 import org.webrtc.voiceengine.WebRtcAudioManager;
 import org.webrtc.voiceengine.WebRtcAudioUtils;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.EnumSet;
 import java.util.LinkedList;
@@ skipping 39 matching lines @@
   private static final int HD_VIDEO_HEIGHT = 720;
   private static final int MAX_VIDEO_WIDTH = 1280;
   private static final int MAX_VIDEO_HEIGHT = 1280;
   private static final int MAX_VIDEO_FPS = 30;
 
   private static final PeerConnectionClient instance = new PeerConnectionClient();
   private final PCObserver pcObserver = new PCObserver();
   private final SDPObserver sdpObserver = new SDPObserver();
   private final ScheduledExecutorService executor;
 
+  private Context context;
   private PeerConnectionFactory factory;
   private PeerConnection peerConnection;
   PeerConnectionFactory.Options options = null;
   private VideoSource videoSource;
   private boolean videoCallEnabled;
   private boolean preferIsac;
   private String preferredVideoCodec;
   private boolean videoSourceStopped;
   private boolean isError;
   private Timer statsTimer;
   private VideoRenderer.Callbacks localRender;
   private VideoRenderer.Callbacks remoteRender;
   private SignalingParameters signalingParameters;
   private MediaConstraints pcConstraints;
   private MediaConstraints videoConstraints;
   private MediaConstraints audioConstraints;
   private ParcelFileDescriptor aecDumpFileDescriptor;
   private MediaConstraints sdpMediaConstraints;
   private PeerConnectionParameters peerConnectionParameters;
   // Queued remote ICE candidates are consumed only after both local and
   // remote descriptions are set. Similarly local ICE candidates are sent to
   // remote peer after both local and remote description are set.
   private LinkedList<IceCandidate> queuedRemoteCandidates;
   private PeerConnectionEvents events;
   private boolean isInitiator;
   private SessionDescription localSdp; // either offer or answer SDP
   private MediaStream mediaStream;
   private int numberOfCameras;
-  private VideoCapturerAndroid videoCapturer;
+  private CameraVideoCapturer videoCapturer;
   // enableVideo is set to true if video should be rendered and sent.
   private boolean renderVideo;
   private VideoTrack localVideoTrack;
   private VideoTrack remoteVideoTrack;
   // enableAudio is set to true if audio should be sent.
   private boolean enableAudio;
   private AudioTrack localAudioTrack;
 
   /**
    * Peer connection parameters.
    */
   public static class PeerConnectionParameters {
     public final boolean videoCallEnabled;
     public final boolean loopback;
     public final boolean tracing;
+    public final boolean camera2Enabled;
+    public final boolean camera1Enabled;
     public final int videoWidth;
     public final int videoHeight;
     public final int videoFps;
     public final int videoStartBitrate;
     public final String videoCodec;
     public final boolean videoCodecHwAcceleration;
     public final boolean captureToTexture;
     public final int audioStartBitrate;
     public final String audioCodec;
     public final boolean noAudioProcessing;
     public final boolean aecDump;
     public final boolean useOpenSLES;
     public final boolean disableBuiltInAEC;
 
     public PeerConnectionParameters(
-        boolean videoCallEnabled, boolean loopback, boolean tracing,
-        int videoWidth, int videoHeight, int videoFps, int videoStartBitrate,
-        String videoCodec, boolean videoCodecHwAcceleration, boolean captureToTexture,
-        int audioStartBitrate, String audioCodec,
+        boolean videoCallEnabled, boolean loopback, boolean tracing, boolean camera2Enabled,
+        boolean camera1Enabled, int videoWidth, int videoHeight, int videoFps,
+        int videoStartBitrate, String videoCodec, boolean videoCodecHwAcceleration,
+        boolean captureToTexture, int audioStartBitrate, String audioCodec,
         boolean noAudioProcessing, boolean aecDump, boolean useOpenSLES,
         boolean disableBuiltInAEC) {
       this.videoCallEnabled = videoCallEnabled;
+      this.camera2Enabled = camera2Enabled;
+      this.camera1Enabled = camera1Enabled;
       this.loopback = loopback;
       this.tracing = tracing;
       this.videoWidth = videoWidth;
       this.videoHeight = videoHeight;
       this.videoFps = videoFps;
       this.videoStartBitrate = videoStartBitrate;
       this.videoCodec = videoCodec;
       this.videoCodecHwAcceleration = videoCodecHwAcceleration;
       this.captureToTexture = captureToTexture;
       this.audioStartBitrate = audioStartBitrate;
@@ skipping 68 matching lines @@
   }
 
   public void createPeerConnectionFactory(
       final Context context,
       final PeerConnectionParameters peerConnectionParameters,
       final PeerConnectionEvents events) {
     this.peerConnectionParameters = peerConnectionParameters;
     this.events = events;
     videoCallEnabled = peerConnectionParameters.videoCallEnabled;
     // Reset variables to initial states.
+    this.context = null;
     factory = null;
     peerConnection = null;
     preferIsac = false;
     videoSourceStopped = false;
     isError = false;
     queuedRemoteCandidates = null;
     localSdp = null; // either offer or answer SDP
     mediaStream = null;
     videoCapturer = null;
     renderVideo = true;
@@ skipping 97 matching lines @@
     }
 
     // Create peer connection factory.
     if (!PeerConnectionFactory.initializeAndroidGlobals(context, true, true,
         peerConnectionParameters.videoCodecHwAcceleration)) {
       events.onPeerConnectionError("Failed to initializeAndroidGlobals");
     }
     if (options != null) {
       Log.d(TAG, "Factory networkIgnoreMask option: " + options.networkIgnoreMask);
     }
+    this.context = context;
     factory = new PeerConnectionFactory(options);
     Log.d(TAG, "Peer connection factory created.");
   }
 
   private void createMediaConstraintsInternal() {
     // Create peer connection constraints.
     pcConstraints = new MediaConstraints();
     // Enable DTLS for normal calls and disable for loopback calls.
     if (peerConnectionParameters.loopback) {
       pcConstraints.optional.add(
@@ skipping 69 matching lines @@
         "OfferToReceiveAudio", "true"));
     if (videoCallEnabled || peerConnectionParameters.loopback) {
       sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
           "OfferToReceiveVideo", "true"));
     } else {
       sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
           "OfferToReceiveVideo", "false"));
     }
   }
 
+  private void createCapturer(CameraEnumerator enumerator) {
+    final String[] deviceNames = enumerator.getDeviceNames();
+
+    // First, try to find front facing camera
+    Logging.d(TAG, "Looking for front facing cameras.");
+    for (String deviceName : deviceNames) {
+      if (enumerator.isFrontFacing(deviceName)) {
+        Logging.d(TAG, "Creating front facing camera capturer.");
+        videoCapturer = enumerator.createCapturer(deviceName, null);
+
+        if (videoCapturer != null) {

[magjed_webrtc, 2016/06/29 13:36:45]

There is no need for this null check (with the current code), so I would remove
it, but keep it if you think it will make the code more future proof.

[sakal, 2016/06/30 09:14:52]

I'd rather keep it. It used to be Camera2Enumerator createCapturer returned null
if the device only reported legacy support. We might add that back in the
future.

+          return;
+        }
+      }
+    }
+
+    // Front facing camera not found, try something else
+    Logging.d(TAG, "Looking for other cameras.");
+    for (String deviceName : deviceNames) {
+      if (!enumerator.isFrontFacing(deviceName)) {
+        Logging.d(TAG, "Creating other camera capturer.");
+        videoCapturer = enumerator.createCapturer(deviceName, null);
+
+        if (videoCapturer != null) {
+          return;
+        }
+      }
+    }
+  }
+
   private void createPeerConnectionInternal(EglBase.Context renderEGLContext) {
     if (factory == null || isError) {
       Log.e(TAG, "Peerconnection factory is not created");
       return;
     }
     Log.d(TAG, "Create peer connection.");
 
     Log.d(TAG, "PCConstraints: " + pcConstraints.toString());
     if (videoConstraints != null) {
       Log.d(TAG, "VideoConstraints: " + videoConstraints.toString());
@@ skipping 22 matching lines @@
 
     // Set default WebRTC tracing and INFO libjingle logging.
     // NOTE: this _must_ happen while |factory| is alive!
     Logging.enableTracing(
         "logcat:",
         EnumSet.of(Logging.TraceLevel.TRACE_DEFAULT),
         Logging.Severity.LS_INFO);
 
     mediaStream = factory.createLocalMediaStream("ARDAMS");
     if (videoCallEnabled) {
-      String cameraDeviceName = CameraEnumerationAndroid.getDeviceName(0);
-      String frontCameraDeviceName =
-          CameraEnumerationAndroid.getNameOfFrontFacingDevice();
-      if (numberOfCameras > 1 && frontCameraDeviceName != null) {
-        cameraDeviceName = frontCameraDeviceName;
+      if (Camera2Enumerator.isSupported() && peerConnectionParameters.camera2Enabled) {
+        Logging.d(TAG, "Creating capturer using camera2 API.");
+        createCapturer(new Camera2Enumerator(context));
       }
-      Log.d(TAG, "Opening camera: " + cameraDeviceName);
-      videoCapturer = VideoCapturerAndroid.create(cameraDeviceName, null,
-          peerConnectionParameters.captureToTexture);
+
+      if (videoCapturer == null && peerConnectionParameters.camera1Enabled) {
+        Logging.d(TAG, "Creating capturer using camera1 API.");
+        createCapturer(new Camera1Enumerator());
+      }
+
       if (videoCapturer == null) {
         reportError("Failed to open camera");
         return;
       }
       mediaStream.addTrack(createVideoTrack(videoCapturer));
     }
 
     mediaStream.addTrack(createAudioTrack());
     peerConnection.addStream(mediaStream);
 
@@ skipping 260 matching lines @@
   }
 
   private AudioTrack createAudioTrack() {
     localAudioTrack = factory.createAudioTrack(
         AUDIO_TRACK_ID,
         factory.createAudioSource(audioConstraints));
     localAudioTrack.setEnabled(enableAudio);
     return localAudioTrack;
   }
 
-  private VideoTrack createVideoTrack(VideoCapturerAndroid capturer) {
+  private VideoTrack createVideoTrack(VideoCapturer capturer) {
     videoSource = factory.createVideoSource(capturer, videoConstraints);
 
     localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
     localVideoTrack.setEnabled(renderVideo);
     localVideoTrack.addRenderer(new VideoRenderer(localRender));
     return localVideoTrack;
   }
 
   private static String setStartBitrate(String codec, boolean isVideoCodec,
       String sdpDescription, int bitrateKbps) {
@@ skipping 344 matching lines @@
     public void onCreateFailure(final String error) {
       reportError("createSDP error: " + error);
     }
 
     @Override
     public void onSetFailure(final String error) {
       reportError("setSDP error: " + error);
     }
   }
 }