Build WebRTC with data channel only.

webrtc/sdk/android/src/jni/peerconnection_jni.cc

 /*
  *  Copyright 2013 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.
  */
 
@@ skipping 43 matching lines @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event_tracer.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/logsinks.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/rtccertificategenerator.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/media/base/videocapturer.h"
-#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
-#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
+
+// Adding 'nogncheck' to disable the gn include header check. We don't want to
+// depend on audio and video related targets when build the datachannel only
+// targets.
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
+#include "webrtc/media/engine/webrtcvideodecoderfactory.h"  // nogncheck
+#include "webrtc/media/engine/webrtcvideoencoderfactory.h"  // nogncheck
+#endif
+
 #include "webrtc/modules/utility/include/jvm_android.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/pc/webrtcsdp.h"
-#include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h"
-#include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
+
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
+#include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h"  // nogncheck
+#include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"  // nogncheck
+#endif
+
 #include "webrtc/sdk/android/src/jni/androidnetworkmonitor_jni.h"
-#include "webrtc/sdk/android/src/jni/androidvideotracksource.h"
+
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
+#include "webrtc/sdk/android/src/jni/androidvideotracksource.h"  // nogncheck
+#endif
+
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 #include "webrtc/sdk/android/src/jni/jni_helpers.h"
-#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
+
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
+#include "webrtc/sdk/android/src/jni/native_handle_impl.h"  // nogncheck
+#endif
+
 #include "webrtc/sdk/android/src/jni/rtcstatscollectorcallbackwrapper.h"
 // Adding 'nogncheck' to disable the gn include headers check.
 // We don't want to depend on 'system_wrappers:field_trial_default' because
 // clients should be able to provide their own implementation.
 #include "webrtc/system_wrappers/include/field_trial_default.h" // nogncheck
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
 #include "webrtc/system_wrappers/include/trace.h"
-#include "webrtc/voice_engine/include/voe_base.h"
+#include "webrtc/voice_engine/include/voe_base.h"  // nogncheck
 
 using cricket::WebRtcVideoDecoderFactory;
 using cricket::WebRtcVideoEncoderFactory;
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::CreateSessionDescriptionObserver;
@@ skipping 819 matching lines @@
     jni()->SetObjectArrayElement(planes, 2, v_buffer);
     return jni()->NewObject(
         *j_frame_class_, j_i420_frame_ctor_id_,
         frame->width(), frame->height(),
         static_cast<int>(frame->rotation()),
         strides, planes, javaShallowCopy(frame));
   }
 
   // Return a VideoRenderer.I420Frame referring texture object in |frame|.
   jobject CricketToJavaTextureFrame(const webrtc::VideoFrame* frame) {
+    jfloatArray sampling_matrix;
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
     NativeHandleImpl* handle = reinterpret_cast<NativeHandleImpl*>(
         frame->video_frame_buffer()->native_handle());
-    jfloatArray sampling_matrix = handle->sampling_matrix.ToJava(jni());
-
+    sampling_matrix = handle->sampling_matrix.ToJava(jni());
     return jni()->NewObject(
-        *j_frame_class_, j_texture_frame_ctor_id_,
-        frame->width(), frame->height(),
-        static_cast<int>(frame->rotation()),
+        *j_frame_class_, j_texture_frame_ctor_id_, frame->width(),
+        frame->height(), static_cast<int>(frame->rotation()),
         handle->oes_texture_id, sampling_matrix, javaShallowCopy(frame));
+#else
+    jint texture_id = 0;
+    sampling_matrix = jni()->NewFloatArray(16);
+    return jni()->NewObject(*j_frame_class_, j_texture_frame_ctor_id_,
+                            frame->width(), frame->height(),
+                            static_cast<int>(frame->rotation()), texture_id,
+                            sampling_matrix, javaShallowCopy(frame));
+#endif
   }
 
   JNIEnv* jni() {
     return AttachCurrentThreadIfNeeded();
   }
 
   ScopedGlobalRef<jobject> j_callbacks_;
   jmethodID j_render_frame_id_;
   ScopedGlobalRef<jclass> j_frame_class_;
   jmethodID j_i420_frame_ctor_id_;
@@ skipping 404 matching lines @@
   WebRtcVideoEncoderFactory* encoder_factory = nullptr;
   WebRtcVideoDecoderFactory* decoder_factory = nullptr;
   rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;
 
   PeerConnectionFactoryInterface::Options options;
   bool has_options = joptions != NULL;
   if (has_options) {
     options = ParseOptionsFromJava(jni, joptions);
   }
 
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
   if (video_hw_acceleration_enabled) {
     encoder_factory = new MediaCodecVideoEncoderFactory();
     decoder_factory = new MediaCodecVideoDecoderFactory();
   }
+#endif
   // Do not create network_monitor_factory only if the options are
   // provided and disable_network_monitor therein is set to true.
   if (!(has_options && options.disable_network_monitor)) {
     network_monitor_factory = new AndroidNetworkMonitorFactory();
     rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);
   }
 
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(
           network_thread.get(), worker_thread.get(), signaling_thread.get(),
@@ skipping 39 matching lines @@
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<MediaStreamInterface> stream(
       factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
   return (jlong)stream.release();
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource)
 (JNIEnv* jni, jclass, jlong native_factory, jobject j_egl_context,
     jboolean is_screencast) {
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
   OwnedFactoryAndThreads* factory =
       reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
 
   rtc::scoped_refptr<webrtc::AndroidVideoTrackSource> source(
       new rtc::RefCountedObject<webrtc::AndroidVideoTrackSource>(
           factory->signaling_thread(), jni, j_egl_context, is_screencast));
   rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
       webrtc::VideoTrackSourceProxy::Create(factory->signaling_thread(),
                                             factory->worker_thread(), source);
 
   return (jlong)proxy_source.release();
+#else
+  return (jlong)0;
+#endif
 }
 
 JOW(void, PeerConnectionFactory_nativeInitializeVideoCapturer)
 (JNIEnv* jni,
  jclass,
  jlong native_factory,
  jobject j_video_capturer,
  jlong native_source,
  jobject j_frame_observer) {
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
   LOG(LS_INFO) << "PeerConnectionFactory_nativeInitializeVideoCapturer";
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   auto proxy_source =
       reinterpret_cast<webrtc::VideoTrackSourceProxy*>(native_source);
   auto source = reinterpret_cast<webrtc::AndroidVideoTrackSource*>(
       proxy_source->internal());
   rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper =
       source->surface_texture_helper();
   jni->CallVoidMethod(
       j_video_capturer,
       GetMethodID(jni, FindClass(jni, "org/webrtc/VideoCapturer"), "initialize",
                   "(Lorg/webrtc/SurfaceTextureHelper;Landroid/content/"
                   "Context;Lorg/webrtc/VideoCapturer$CapturerObserver;)V"),
       surface_texture_helper
           ? surface_texture_helper->GetJavaSurfaceTextureHelper()
           : nullptr,
       j_application_context, j_frame_observer);
   CHECK_EXCEPTION(jni) << "error during VideoCapturer.initialize()";
+#endif
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateVideoTrack)(
     JNIEnv* jni, jclass, jlong native_factory, jstring id,
     jlong native_source) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<VideoTrackInterface> track(factory->CreateVideoTrack(
       JavaToStdString(jni, id),
       reinterpret_cast<VideoTrackSourceInterface*>(native_source)));
@@ skipping 54 matching lines @@
       rtc::NetworkMonitorFactory::ReleaseFactory(
           owner->network_monitor_factory());
       owner->clear_network_monitor_factory();
     }
   }
 }
 
 JOW(void, PeerConnectionFactory_nativeSetVideoHwAccelerationOptions)(
     JNIEnv* jni, jclass, jlong native_factory, jobject local_egl_context,
     jobject remote_egl_context) {
+#if defined(HAVE_WEBRTC_VOICE) && defined(HAVE_WEBRTC_VIDEO)
   OwnedFactoryAndThreads* owned_factory =
       reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
 
   jclass j_eglbase14_context_class =
       FindClass(jni, "org/webrtc/EglBase14$Context");
 
   MediaCodecVideoEncoderFactory* encoder_factory =
       static_cast<MediaCodecVideoEncoderFactory*>
           (owned_factory->encoder_factory());
   if (encoder_factory &&
       jni->IsInstanceOf(local_egl_context, j_eglbase14_context_class)) {
     LOG(LS_INFO) << "Set EGL context for HW encoding.";
     encoder_factory->SetEGLContext(jni, local_egl_context);
   }
 
   MediaCodecVideoDecoderFactory* decoder_factory =
       static_cast<MediaCodecVideoDecoderFactory*>
           (owned_factory->decoder_factory());
   if (decoder_factory) {
     LOG(LS_INFO) << "Set EGL context for HW decoding.";
     decoder_factory->SetEGLContext(jni, remote_egl_context);
   }
+#endif
 }
 
 static PeerConnectionInterface::IceTransportsType
 JavaIceTransportsTypeToNativeType(JNIEnv* jni, jobject j_ice_transports_type) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$IceTransportsType",
       j_ice_transports_type);
 
   if (enum_name == "ALL")
     return PeerConnectionInterface::kAll;
@@ skipping 1177 matching lines @@
   return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
       ->inter_tone_gap();
 }
 
 JOW(void, DtmfSender_free)
 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) {
   reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)->Release();
 }
 
 }  // namespace webrtc_jni