Enable the Java wrapper to load different .so library.

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 105 matching lines @@
 using webrtc::VideoTrackSourceInterface;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackVector;
 using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
 // Field trials initialization string
 static char *field_trials_init_string = NULL;
 
-// Set in PeerConnectionFactory_initializeAndroidGlobals().
+// Set in PeerConnectionFactoryBase_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool video_hw_acceleration_enabled = true;
 static jobject j_application_context = nullptr;
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 // |state_class_fragment| is something like "MediaSource$State".
 static jobject JavaEnumFromIndex(
     JNIEnv* jni, const std::string& state_class_fragment, int index) {
   const std::string state_class = "org/webrtc/" + state_class_fragment;
   return JavaEnumFromIndex(jni, FindClass(jni, state_class.c_str()),
@@ skipping 987 matching lines @@
 
 JOW(jstring, MediaStream_nativeLabel)(JNIEnv* jni, jclass, jlong j_p) {
   return JavaStringFromStdString(
       jni, reinterpret_cast<MediaStreamInterface*>(j_p)->label());
 }
 
 JOW(void, MediaStream_free)(JNIEnv*, jclass, jlong j_p) {
   CHECK_RELEASE(reinterpret_cast<MediaStreamInterface*>(j_p));
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateObserver)(
-    JNIEnv * jni, jclass, jobject j_observer) {
+JOW(jlong, PeerConnectionFactoryBase_nativeCreateObserver)
+(JNIEnv* jni, jclass, jobject j_observer) {
   return (jlong)new PCOJava(jni, j_observer);
 }
 
-JOW(void, PeerConnectionFactory_initializeAndroidGlobals)
+JOW(void, PeerConnectionFactoryBase_initializeAndroidGlobals)
 (JNIEnv* jni,
  jclass,
  jobject context,
  jboolean video_hw_acceleration) {
   video_hw_acceleration_enabled = video_hw_acceleration;
   AndroidNetworkMonitor::SetAndroidContext(jni, context);
   if (!factory_static_initialized) {
     RTC_DCHECK(j_application_context == nullptr);
     j_application_context = NewGlobalRef(jni, context);
     webrtc::JVM::Initialize(GetJVM(), context);
     factory_static_initialized = true;
   }
 }
 
-JOW(void, PeerConnectionFactory_initializeFieldTrials)(
-    JNIEnv* jni, jclass, jstring j_trials_init_string) {
+JOW(void, PeerConnectionFactoryBase_initializeFieldTrials)
+(JNIEnv* jni, jclass, jstring j_trials_init_string) {
   field_trials_init_string = NULL;
   if (j_trials_init_string != NULL) {
     const char* init_string =
         jni->GetStringUTFChars(j_trials_init_string, NULL);
     int init_string_length = jni->GetStringUTFLength(j_trials_init_string);
     field_trials_init_string = new char[init_string_length + 1];
     rtc::strcpyn(field_trials_init_string, init_string_length + 1, init_string);
     jni->ReleaseStringUTFChars(j_trials_init_string, init_string);
     LOG(LS_INFO) << "initializeFieldTrials: " << field_trials_init_string;
   }
   webrtc::field_trial::InitFieldTrialsFromString(field_trials_init_string);
 }
 
-JOW(void, PeerConnectionFactory_initializeInternalTracer)(JNIEnv* jni, jclass) {
+JOW(void, PeerConnectionFactoryBase_initializeInternalTracer)
+(JNIEnv* jni, jclass) {
   rtc::tracing::SetupInternalTracer();
 }
 
-JOW(jstring, PeerConnectionFactory_nativeFieldTrialsFindFullName)
+JOW(jstring, PeerConnectionFactoryBase_nativeFieldTrialsFindFullName)
 (JNIEnv* jni, jclass, jstring j_name) {
   return JavaStringFromStdString(
       jni, webrtc::field_trial::FindFullName(JavaToStdString(jni, j_name)));
 }
 
-JOW(jboolean, PeerConnectionFactory_startInternalTracingCapture)(
-    JNIEnv* jni, jclass, jstring j_event_tracing_filename) {
+JOW(jboolean, PeerConnectionFactoryBase_startInternalTracingCapture)
+(JNIEnv* jni, jclass, jstring j_event_tracing_filename) {
   if (!j_event_tracing_filename)
     return false;
 
   const char* init_string =
       jni->GetStringUTFChars(j_event_tracing_filename, NULL);
   LOG(LS_INFO) << "Starting internal tracing to: " << init_string;
   bool ret = rtc::tracing::StartInternalCapture(init_string);
   jni->ReleaseStringUTFChars(j_event_tracing_filename, init_string);
   return ret;
 }
 
-JOW(void, PeerConnectionFactory_stopInternalTracingCapture)(
-    JNIEnv* jni, jclass) {
+JOW(void, PeerConnectionFactoryBase_stopInternalTracingCapture)
+(JNIEnv* jni, jclass) {
   rtc::tracing::StopInternalCapture();
 }
 
-JOW(void, PeerConnectionFactory_shutdownInternalTracer)(JNIEnv* jni, jclass) {
+JOW(void, PeerConnectionFactoryBase_shutdownInternalTracer)
+(JNIEnv* jni, jclass) {
   rtc::tracing::ShutdownInternalTracer();
 }
 
 JOW(void, AudioTrack_nativeSetVolume)
 (JNIEnv*, jclass, jlong j_p, jdouble volume) {
   rtc::scoped_refptr<AudioSourceInterface> source(
       reinterpret_cast<AudioTrackInterface*>(j_p)->GetSource());
   source->SetVolume(volume);
 }
 
@@ skipping 105 matching lines @@
   PeerConnectionFactoryInterface::Options native_options;
 
   // This doesn't necessarily match the c++ version of this struct; feel free
   // to add more parameters as necessary.
   native_options.network_ignore_mask = network_ignore_mask;
   native_options.disable_encryption = disable_encryption;
   native_options.disable_network_monitor = disable_network_monitor;
   return native_options;
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnectionFactory)(
-    JNIEnv* jni, jclass, jobject joptions) {
+JOW(jlong, PeerConnectionFactoryBase_nativeCreatePeerConnectionFactory)
+(JNIEnv* jni, jclass, jobject joptions) {
   // talk/ assumes pretty widely that the current Thread is ThreadManager'd, but
   // ThreadManager only WrapCurrentThread()s the thread where it is first
   // created.  Since the semantics around when auto-wrapping happens in
   // webrtc/base/ are convoluted, we simply wrap here to avoid having to think
   // about ramifications of auto-wrapping there.
   rtc::ThreadManager::Instance()->WrapCurrentThread();
   webrtc::Trace::CreateTrace();
 
   std::unique_ptr<Thread> network_thread =
       rtc::Thread::CreateWithSocketServer();
@@ skipping 41 matching lines @@
     factory->SetOptions(options);
   }
   OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads(
       std::move(network_thread), std::move(worker_thread),
       std::move(signaling_thread), encoder_factory, decoder_factory,
       network_monitor_factory, factory.release());
   owned_factory->InvokeJavaCallbacksOnFactoryThreads();
   return jlongFromPointer(owned_factory);
 }
 
-JOW(void, PeerConnectionFactory_nativeFreeFactory)(JNIEnv*, jclass, jlong j_p) {
+JOW(void, PeerConnectionFactoryBase_nativeFreeFactory)
+(JNIEnv*, jclass, jlong j_p) {
   delete reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
   if (field_trials_init_string) {
     webrtc::field_trial::InitFieldTrialsFromString(NULL);
     delete field_trials_init_string;
     field_trials_init_string = NULL;
   }
   webrtc::Trace::ReturnTrace();
 }
 
 static PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
   return reinterpret_cast<OwnedFactoryAndThreads*>(j_p)->factory();
 }
 
-JOW(void, PeerConnectionFactory_nativeThreadsCallbacks)(
-    JNIEnv*, jclass, jlong j_p) {
+JOW(void, PeerConnectionFactoryBase_nativeThreadsCallbacks)
+(JNIEnv*, jclass, jlong j_p) {
   OwnedFactoryAndThreads *factory =
       reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
   factory->InvokeJavaCallbacksOnFactoryThreads();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateLocalMediaStream)(
-    JNIEnv* jni, jclass, jlong native_factory, jstring label) {
+JOW(jlong, PeerConnectionFactoryBase_nativeCreateLocalMediaStream)
+(JNIEnv* jni, jclass, jlong native_factory, jstring label) {
   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)
+JOW(jlong, PeerConnectionFactoryBase_nativeCreateVideoSource)
 (JNIEnv* jni, jclass, jlong native_factory, jobject j_egl_context,
     jboolean is_screencast) {
   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();
 }
 
-JOW(void, PeerConnectionFactory_nativeInitializeVideoCapturer)
+JOW(void, PeerConnectionFactoryBase_nativeInitializeVideoCapturer)
 (JNIEnv* jni,
  jclass,
  jlong native_factory,
  jobject j_video_capturer,
  jlong native_source,
  jobject j_frame_observer) {
-  LOG(LS_INFO) << "PeerConnectionFactory_nativeInitializeVideoCapturer";
+  LOG(LS_INFO) << "PeerConnectionFactoryBase_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()";
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateVideoTrack)(
-    JNIEnv* jni, jclass, jlong native_factory, jstring id,
-    jlong native_source) {
+JOW(jlong, PeerConnectionFactoryBase_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)));
   return (jlong)track.release();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)(
-    JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) {
+JOW(jlong, PeerConnectionFactoryBase_nativeCreateAudioSource)
+(JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) {
   std::unique_ptr<ConstraintsWrapper> constraints(
       new ConstraintsWrapper(jni, j_constraints));
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   cricket::AudioOptions options;
   CopyConstraintsIntoAudioOptions(constraints.get(), &options);
   rtc::scoped_refptr<AudioSourceInterface> source(
       factory->CreateAudioSource(options));
   return (jlong)source.release();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateAudioTrack)(
-    JNIEnv* jni, jclass, jlong native_factory, jstring id,
-    jlong native_source) {
+JOW(jlong, PeerConnectionFactoryBase_nativeCreateAudioTrack)
+(JNIEnv* jni, jclass, jlong native_factory, jstring id, jlong native_source) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack(
       JavaToStdString(jni, id),
       reinterpret_cast<AudioSourceInterface*>(native_source)));
   return (jlong)track.release();
 }
 
-JOW(jboolean, PeerConnectionFactory_nativeStartAecDump)(
-    JNIEnv* jni, jclass, jlong native_factory, jint file,
-    jint filesize_limit_bytes) {
+JOW(jboolean, PeerConnectionFactoryBase_nativeStartAecDump)
+(JNIEnv* jni,
+ jclass,
+ jlong native_factory,
+ jint file,
+ jint filesize_limit_bytes) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   return factory->StartAecDump(file, filesize_limit_bytes);
 }
 
-JOW(void, PeerConnectionFactory_nativeStopAecDump)(
-    JNIEnv* jni, jclass, jlong native_factory) {
+JOW(void, PeerConnectionFactoryBase_nativeStopAecDump)
+(JNIEnv* jni, jclass, jlong native_factory) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   factory->StopAecDump();
 }
 
-JOW(void, PeerConnectionFactory_nativeSetOptions)(
-    JNIEnv* jni, jclass, jlong native_factory, jobject options) {
+JOW(void, PeerConnectionFactoryBase_nativeSetOptions)
+(JNIEnv* jni, jclass, jlong native_factory, jobject options) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   PeerConnectionFactoryInterface::Options options_to_set =
       ParseOptionsFromJava(jni, options);
   factory->SetOptions(options_to_set);
 
   if (options_to_set.disable_network_monitor) {
     OwnedFactoryAndThreads* owner =
         reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
     if (owner->network_monitor_factory()) {
       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) {
+JOW(void, PeerConnectionFactoryBase_nativeSetVideoHwAccelerationOptions)
+(JNIEnv* jni,
+ jclass,
+ jlong native_factory,
+ jobject local_egl_context,
+ jobject remote_egl_context) {
   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 &&
@@ skipping 289 matching lines @@
   if (!IsNull(jni, j_ice_check_min_interval)) {
     int ice_check_min_interval_value =
         jni->CallIntMethod(j_ice_check_min_interval, int_value_id);
     rtc_config->ice_check_min_interval =
         rtc::Optional<int>(ice_check_min_interval_value);
   }
   rtc_config->disable_ipv6_on_wifi =
       GetBooleanField(jni, j_rtc_config, j_disable_ipv6_on_wifi_id);
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnection)(
-    JNIEnv *jni, jclass, jlong factory, jobject j_rtc_config,
-    jobject j_constraints, jlong observer_p) {
+JOW(jlong, PeerConnectionFactoryBase_nativeCreatePeerConnection)
+(JNIEnv* jni,
+ jclass,
+ jlong factory,
+ jobject j_rtc_config,
+ jobject j_constraints,
+ jlong observer_p) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> f(
       reinterpret_cast<PeerConnectionFactoryInterface*>(
           factoryFromJava(factory)));
 
   PeerConnectionInterface::RTCConfiguration rtc_config(
       PeerConnectionInterface::RTCConfigurationType::kAggressive);
   JavaRTCConfigurationToJsepRTCConfiguration(jni, j_rtc_config, &rtc_config);
 
   jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
   jfieldID j_key_type_id = GetFieldID(jni, j_rtc_config_class, "keyType",
@@ skipping 887 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