Add Android Camera To Unity Plugin

webrtc/examples/unityplugin/simple_peer_connection.cc

 /*
  *  Copyright (c) 2017 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.
  */
 
 #include "webrtc/examples/unityplugin/simple_peer_connection.h"
 
 #include <utility>
 
 #include "webrtc/api/test/fakeconstraints.h"
+#include "webrtc/api/videosourceproxy.h"
 #include "webrtc/media/engine/webrtcvideocapturerfactory.h"
 #include "webrtc/modules/video_capture/video_capture_factory.h"
 
+#if defined(WEBRTC_ANDROID)
+#include "webrtc/examples/unityplugin/classreferenceholder.h"
+#include "webrtc/sdk/android/src/jni/androidvideotracksource.h"
+#include "webrtc/sdk/android/src/jni/jni_helpers.h"
+#endif
+
 // Names used for media stream labels.
 const char kAudioLabel[] = "audio_label";
 const char kVideoLabel[] = "video_label";
 const char kStreamLabel[] = "stream_label";
 
 namespace {
 static int g_peer_count = 0;
 static std::unique_ptr<rtc::Thread> g_worker_thread;
 static std::unique_ptr<rtc::Thread> g_signaling_thread;
 static rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
     g_peer_connection_factory;
+#if defined(WEBRTC_ANDROID)
+// Android case: the video track does not own the capturer, and it
+// relies on the app to dispose the capturer when the peerconnection
+// shuts down.
+static jobject g_camera = nullptr;
+#endif
 
 std::string GetEnvVarOrDefault(const char* env_var_name,
                                const char* default_value) {
   std::string value;
   const char* env_var = getenv(env_var_name);
   if (env_var)
     value = env_var;
 
   if (value.empty())
     value = default_value;
@@ skipping 102 matching lines @@
 
   peer_connection_ = g_peer_connection_factory->CreatePeerConnection(
       config_, &constraints, nullptr, nullptr, this);
 
   return peer_connection_.get() != nullptr;
 }
 
 void SimplePeerConnection::DeletePeerConnection() {
   g_peer_count--;
 
+#if defined(WEBRTC_ANDROID)
+  if (g_camera) {
+    JNIEnv* env = webrtc_jni::GetEnv();
+    jclass pc_factory_class =
+        unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
+    jmethodID stop_camera_method = webrtc_jni::GetStaticMethodID(
+        env, pc_factory_class, "StopCamera", "(Lorg/webrtc/VideoCapturer;)V");
+
+    env->CallStaticVoidMethod(pc_factory_class, stop_camera_method, g_camera);
+    CHECK_EXCEPTION(env);
+
+    g_camera = nullptr;
+  }
+#endif
+
   CloseDataChannel();
   peer_connection_ = nullptr;
   active_streams_.clear();
 
   if (g_peer_count == 0) {
     g_peer_connection_factory = nullptr;
     g_signaling_thread.reset();
     g_worker_thread.reset();
   }
 }
@@ skipping 211 matching lines @@
   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
       g_peer_connection_factory->CreateLocalMediaStream(kStreamLabel);
 
   rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
       g_peer_connection_factory->CreateAudioTrack(
           kAudioLabel, g_peer_connection_factory->CreateAudioSource(nullptr)));
   std::string id = audio_track->id();
   stream->AddTrack(audio_track);
 
   if (!audio_only) {
+#if defined(WEBRTC_ANDROID)
+    JNIEnv* env = webrtc_jni::GetEnv();
+    jclass pc_factory_class =
+        unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
+    jmethodID load_texture_helper_method = webrtc_jni::GetStaticMethodID(
+        env, pc_factory_class, "LoadSurfaceTextureHelper",
+        "()Lorg/webrtc/SurfaceTextureHelper;");
+    jobject texture_helper = env->CallStaticObjectMethod(
+        pc_factory_class, load_texture_helper_method);
+    CHECK_EXCEPTION(env);
+    RTC_DCHECK(texture_helper != nullptr)
+        << "Cannot get the Surface Texture Helper.";
+
+    rtc::scoped_refptr<webrtc::AndroidVideoTrackSource> source(
+        new rtc::RefCountedObject<webrtc::AndroidVideoTrackSource>(
+            g_signaling_thread.get(), env, texture_helper, false));
+    rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
+        webrtc::VideoTrackSourceProxy::Create(g_signaling_thread.get(),
+                                              g_worker_thread.get(), source);
+
+    // link with VideoCapturer (Camera);
+    jmethodID link_camera_method = webrtc_jni::GetStaticMethodID(
+        env, pc_factory_class, "LinkCamera",
+        "(JLorg/webrtc/SurfaceTextureHelper;)Lorg/webrtc/VideoCapturer;");
+    jobject camera_tmp =
+        env->CallStaticObjectMethod(pc_factory_class, link_camera_method,
+                                    (jlong)proxy_source.get(), texture_helper);
+    CHECK_EXCEPTION(env);
+    g_camera = (jobject)env->NewGlobalRef(camera_tmp);
+
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+        g_peer_connection_factory->CreateVideoTrack(kVideoLabel,
+                                                    proxy_source.release()));
+    stream->AddTrack(video_track);
+#else
     std::unique_ptr<cricket::VideoCapturer> capture = OpenVideoCaptureDevice();
     if (capture) {
       rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
           g_peer_connection_factory->CreateVideoTrack(
               kVideoLabel, g_peer_connection_factory->CreateVideoSource(
                                std::move(capture), nullptr)));
 
       stream->AddTrack(video_track);
-      if (local_video_observer_ && !stream->GetVideoTracks().empty()) {
-        stream->GetVideoTracks()[0]->AddOrUpdateSink(
-            local_video_observer_.get(), rtc::VideoSinkWants());
-      }
+    }
+#endif
+    if (local_video_observer_ && !stream->GetVideoTracks().empty()) {
+      stream->GetVideoTracks()[0]->AddOrUpdateSink(local_video_observer_.get(),
+                                                   rtc::VideoSinkWants());
     }
   }
 
   if (!peer_connection_->AddStream(stream)) {
     LOG(LS_ERROR) << "Adding stream to PeerConnection failed";
   }
 
   typedef std::pair<std::string,
                     rtc::scoped_refptr<webrtc::MediaStreamInterface>>
       MediaStreamPair;
@@ skipping 87 matching lines @@
 
     for (const auto& param : params) {
       uint32_t ssrc = param.ssrc.value_or(0);
       if (ssrc > 0)
         ssrcs.push_back(ssrc);
     }
   }
 
   return ssrcs;
 }