diff --git a/sdk/android/api/org/webrtc/PeerConnectionFactory.java b/sdk/android/api/org/webrtc/PeerConnectionFactory.java index c66b16b46d..b68c816990 100644 --- a/sdk/android/api/org/webrtc/PeerConnectionFactory.java +++ b/sdk/android/api/org/webrtc/PeerConnectionFactory.java @@ -29,11 +29,17 @@ public class PeerConnectionFactory { private static final String TAG = "PeerConnectionFactory"; private static final String VIDEO_CAPTURER_THREAD_NAME = "VideoCapturerThread"; - private long nativeFactory; private static volatile boolean internalTracerInitialized; - @Nullable private static Thread networkThread; - @Nullable private static Thread workerThread; - @Nullable private static Thread signalingThread; + + // Remove these once deprecated static printStackTrace() is gone. + @Nullable private static Thread staticNetworkThread; + @Nullable private static Thread staticWorkerThread; + @Nullable private static Thread staticSignalingThread; + + private long nativeFactory; + @Nullable private volatile Thread networkThread; + @Nullable private volatile Thread workerThread; + @Nullable private volatile Thread signalingThread; public static class InitializationOptions { final Context applicationContext; @@ -218,9 +224,17 @@ public class PeerConnectionFactory { } public PeerConnectionFactory createPeerConnectionFactory() { - return new PeerConnectionFactory(options, audioDeviceModule, audioEncoderFactoryFactory, - audioDecoderFactoryFactory, videoEncoderFactory, videoDecoderFactory, - audioProcessingFactory, fecControllerFactoryFactory, mediaTransportFactoryFactory); + checkInitializeHasBeenCalled(); + return nativeCreatePeerConnectionFactory(ContextUtils.getApplicationContext(), options, + audioDeviceModule == null ? 0 : audioDeviceModule.getNativeAudioDeviceModulePointer(), + audioEncoderFactoryFactory.createNativeAudioEncoderFactory(), + audioDecoderFactoryFactory.createNativeAudioDecoderFactory(), videoEncoderFactory, + videoDecoderFactory, + audioProcessingFactory == null ? 0 : audioProcessingFactory.createNative(), + fecControllerFactoryFactory == null ? 0 : fecControllerFactoryFactory.createNative(), + mediaTransportFactoryFactory == null + ? 0 + : mediaTransportFactoryFactory.createNativeMediaTransportFactory()); } } @@ -253,7 +267,7 @@ public class PeerConnectionFactory { } } - private void checkInitializeHasBeenCalled() { + private static void checkInitializeHasBeenCalled() { if (!NativeLibrary.isLoaded() || ContextUtils.getApplicationContext() == null) { throw new IllegalStateException( "PeerConnectionFactory.initialize was not called before creating a " @@ -298,30 +312,6 @@ public class PeerConnectionFactory { nativeStopInternalTracingCapture(); } - private PeerConnectionFactory(Options options, @Nullable AudioDeviceModule audioDeviceModule, - AudioEncoderFactoryFactory audioEncoderFactoryFactory, - AudioDecoderFactoryFactory audioDecoderFactoryFactory, - @Nullable VideoEncoderFactory videoEncoderFactory, - @Nullable VideoDecoderFactory videoDecoderFactory, - @Nullable AudioProcessingFactory audioProcessingFactory, - @Nullable FecControllerFactoryFactoryInterface fecControllerFactoryFactory, - @Nullable MediaTransportFactoryFactory mediaTransportFactoryFactory) { - checkInitializeHasBeenCalled(); - nativeFactory = nativeCreatePeerConnectionFactory(ContextUtils.getApplicationContext(), options, - audioDeviceModule == null ? 0 : audioDeviceModule.getNativeAudioDeviceModulePointer(), - audioEncoderFactoryFactory.createNativeAudioEncoderFactory(), - audioDecoderFactoryFactory.createNativeAudioDecoderFactory(), videoEncoderFactory, - videoDecoderFactory, - audioProcessingFactory == null ? 0 : audioProcessingFactory.createNative(), - fecControllerFactoryFactory == null ? 0 : fecControllerFactoryFactory.createNative(), - mediaTransportFactoryFactory == null - ? 0 - : mediaTransportFactoryFactory.createNativeMediaTransportFactory()); - if (nativeFactory == 0) { - throw new RuntimeException("Failed to initialize PeerConnectionFactory!"); - } - } - @CalledByNative PeerConnectionFactory(long nativeFactory) { checkInitializeHasBeenCalled(); @@ -463,11 +453,6 @@ public class PeerConnectionFactory { nativeFactory = 0; } - public void threadsCallbacks() { - checkPeerConnectionFactoryExists(); - nativeInvokeThreadsCallbacks(nativeFactory); - } - /** Returns a pointer to the native webrtc::PeerConnectionFactoryInterface. */ public long getNativePeerConnectionFactory() { checkPeerConnectionFactoryExists(); @@ -498,27 +483,43 @@ public class PeerConnectionFactory { } } + /** Deprecated, use non-static version instead. */ + @Deprecated public static void printStackTraces() { - printStackTrace(networkThread, "Network thread"); - printStackTrace(workerThread, "Worker thread"); + printStackTrace(staticNetworkThread, "Network thread"); + printStackTrace(staticWorkerThread, "Worker thread"); + printStackTrace(staticSignalingThread, "Signaling thread"); + } + + /** + * Print the Java stack traces for the critical threads used by PeerConnectionFactory, namely; + * signaling thread, worker thread, and network thread. If printNativeStackTraces is true, also + * attempt to print the C++ stack traces for these threads. + */ + public void printInternalStackTraces(boolean printNativeStackTraces) { printStackTrace(signalingThread, "Signaling thread"); + printStackTrace(workerThread, "Worker thread"); + printStackTrace(networkThread, "Network thread"); } @CalledByNative - private static void onNetworkThreadReady() { + private void onNetworkThreadReady() { networkThread = Thread.currentThread(); + staticNetworkThread = networkThread; Logging.d(TAG, "onNetworkThreadReady"); } @CalledByNative - private static void onWorkerThreadReady() { + private void onWorkerThreadReady() { workerThread = Thread.currentThread(); + staticWorkerThread = workerThread; Logging.d(TAG, "onWorkerThreadReady"); } @CalledByNative - private static void onSignalingThreadReady() { + private void onSignalingThreadReady() { signalingThread = Thread.currentThread(); + staticSignalingThread = signalingThread; Logging.d(TAG, "onSignalingThreadReady"); } @@ -534,10 +535,11 @@ public class PeerConnectionFactory { private static native boolean nativeStartInternalTracingCapture(String tracingFilename); private static native void nativeStopInternalTracingCapture(); - private static native long nativeCreatePeerConnectionFactory(Context context, Options options, - long nativeAudioDeviceModule, long audioEncoderFactory, long audioDecoderFactory, - VideoEncoderFactory encoderFactory, VideoDecoderFactory decoderFactory, - long nativeAudioProcessor, long nativeFecControllerFactory, long mediaTransportFactory); + private static native PeerConnectionFactory nativeCreatePeerConnectionFactory(Context context, + Options options, long nativeAudioDeviceModule, long audioEncoderFactory, + long audioDecoderFactory, VideoEncoderFactory encoderFactory, + VideoDecoderFactory decoderFactory, long nativeAudioProcessor, + long nativeFecControllerFactory, long mediaTransportFactory); private static native long nativeCreatePeerConnection(long factory, PeerConnection.RTCConfiguration rtcConfig, MediaConstraints constraints, long nativeObserver, @@ -552,7 +554,6 @@ public class PeerConnectionFactory { private static native boolean nativeStartAecDump( long factory, int file_descriptor, int filesize_limit_bytes); private static native void nativeStopAecDump(long factory); - private static native void nativeInvokeThreadsCallbacks(long factory); private static native void nativeFreeFactory(long factory); private static native long nativeGetNativePeerConnectionFactory(long factory); private static native void nativeInjectLoggable(JNILogging jniLogging, int severity); diff --git a/sdk/android/src/jni/pc/owned_factory_and_threads.cc b/sdk/android/src/jni/pc/owned_factory_and_threads.cc index 5d7a0bb94b..e42b117e57 100644 --- a/sdk/android/src/jni/pc/owned_factory_and_threads.cc +++ b/sdk/android/src/jni/pc/owned_factory_and_threads.cc @@ -11,21 +11,16 @@ #include "sdk/android/src/jni/pc/owned_factory_and_threads.h" #include "sdk/android/src/jni/jni_helpers.h" -#include "sdk/android/src/jni/pc/peer_connection_factory.h" namespace webrtc { namespace jni { -PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) { - return reinterpret_cast(j_p)->factory(); -} - OwnedFactoryAndThreads::OwnedFactoryAndThreads( std::unique_ptr network_thread, std::unique_ptr worker_thread, std::unique_ptr signaling_thread, rtc::NetworkMonitorFactory* network_monitor_factory, - PeerConnectionFactoryInterface* factory) + const rtc::scoped_refptr& factory) : network_thread_(std::move(network_thread)), worker_thread_(std::move(worker_thread)), signaling_thread_(std::move(signaling_thread)), @@ -33,21 +28,10 @@ OwnedFactoryAndThreads::OwnedFactoryAndThreads( factory_(factory) {} OwnedFactoryAndThreads::~OwnedFactoryAndThreads() { - factory_->Release(); if (network_monitor_factory_ != nullptr) { rtc::NetworkMonitorFactory::ReleaseFactory(network_monitor_factory_); } } -void OwnedFactoryAndThreads::InvokeJavaCallbacksOnFactoryThreads() { - RTC_LOG(LS_INFO) << "InvokeJavaCallbacksOnFactoryThreads."; - network_thread_->Invoke(RTC_FROM_HERE, - &PeerConnectionFactoryNetworkThreadReady); - worker_thread_->Invoke(RTC_FROM_HERE, - &PeerConnectionFactoryWorkerThreadReady); - signaling_thread_->Invoke(RTC_FROM_HERE, - &PeerConnectionFactorySignalingThreadReady); -} - } // namespace jni } // namespace webrtc diff --git a/sdk/android/src/jni/pc/owned_factory_and_threads.h b/sdk/android/src/jni/pc/owned_factory_and_threads.h index cc71001be7..845d4dbd70 100644 --- a/sdk/android/src/jni/pc/owned_factory_and_threads.h +++ b/sdk/android/src/jni/pc/owned_factory_and_threads.h @@ -21,8 +21,6 @@ namespace webrtc { namespace jni { -PeerConnectionFactoryInterface* factoryFromJava(jlong j_p); - // Helper struct for working around the fact that CreatePeerConnectionFactory() // comes in two flavors: either entirely automagical (constructing its own // threads and deleting them on teardown, but no external codec factory support) @@ -31,15 +29,16 @@ PeerConnectionFactoryInterface* factoryFromJava(jlong j_p); // single thing for Java to hold and eventually free. class OwnedFactoryAndThreads { public: - OwnedFactoryAndThreads(std::unique_ptr network_thread, - std::unique_ptr worker_thread, - std::unique_ptr signaling_thread, - rtc::NetworkMonitorFactory* network_monitor_factory, - PeerConnectionFactoryInterface* factory); + OwnedFactoryAndThreads( + std::unique_ptr network_thread, + std::unique_ptr worker_thread, + std::unique_ptr signaling_thread, + rtc::NetworkMonitorFactory* network_monitor_factory, + const rtc::scoped_refptr& factory); ~OwnedFactoryAndThreads(); - PeerConnectionFactoryInterface* factory() { return factory_; } + PeerConnectionFactoryInterface* factory() { return factory_.get(); } rtc::Thread* network_thread() { return network_thread_.get(); } rtc::Thread* signaling_thread() { return signaling_thread_.get(); } rtc::Thread* worker_thread() { return worker_thread_.get(); } @@ -47,14 +46,13 @@ class OwnedFactoryAndThreads { return network_monitor_factory_; } void clear_network_monitor_factory() { network_monitor_factory_ = nullptr; } - void InvokeJavaCallbacksOnFactoryThreads(); private: const std::unique_ptr network_thread_; const std::unique_ptr worker_thread_; const std::unique_ptr signaling_thread_; rtc::NetworkMonitorFactory* network_monitor_factory_; - PeerConnectionFactoryInterface* factory_; // Const after ctor except dtor. + const rtc::scoped_refptr factory_; }; } // namespace jni diff --git a/sdk/android/src/jni/pc/peer_connection_factory.cc b/sdk/android/src/jni/pc/peer_connection_factory.cc index 293031ff88..040753dd25 100644 --- a/sdk/android/src/jni/pc/peer_connection_factory.cc +++ b/sdk/android/src/jni/pc/peer_connection_factory.cc @@ -43,21 +43,70 @@ namespace jni { namespace { -PeerConnectionFactoryInterface::Options +// Take ownership of the jlong reference and cast it into an rtc::scoped_refptr. +template +rtc::scoped_refptr TakeOwnershipOfRefPtr(jlong j_pointer) { + T* ptr = reinterpret_cast(j_pointer); + rtc::scoped_refptr refptr; + refptr.swap(&ptr); + return refptr; +} + +// Take ownership of the jlong reference and cast it into a std::unique_ptr. +template +std::unique_ptr TakeOwnershipOfUniquePtr(jlong native_pointer) { + return std::unique_ptr(reinterpret_cast(native_pointer)); +} + +typedef void (*JavaMethodPointer)(JNIEnv*, const JavaRef&); + +// Post a message on the given queue that will call the Java method on the given +// Java object. +void PostJavaCallback(JNIEnv* env, + rtc::MessageQueue* queue, + const rtc::Location& posted_from, + const JavaRef& j_object, + JavaMethodPointer java_method_pointer) { + // One-off message handler that calls the Java method on the specified Java + // object before deleting itself. + class JavaAsyncCallback : public rtc::MessageHandler { + public: + JavaAsyncCallback(JNIEnv* env, + const JavaRef& j_object, + JavaMethodPointer java_method_pointer) + : j_object_(env, j_object), java_method_pointer_(java_method_pointer) {} + + void OnMessage(rtc::Message*) override { + java_method_pointer_(AttachCurrentThreadIfNeeded(), j_object_); + // The message has been delivered, clean up after ourself. + delete this; + } + + private: + ScopedJavaGlobalRef j_object_; + JavaMethodPointer java_method_pointer_; + }; + + queue->Post(posted_from, + new JavaAsyncCallback(env, j_object, java_method_pointer)); +} + +absl::optional JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, - const JavaRef& options) { - int network_ignore_mask = Java_Options_getNetworkIgnoreMask(jni, options); - bool disable_encryption = Java_Options_getDisableEncryption(jni, options); - bool disable_network_monitor = - Java_Options_getDisableNetworkMonitor(jni, options); + const JavaRef& j_options) { + if (j_options.is_null()) + return absl::nullopt; 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; + native_options.network_ignore_mask = + Java_Options_getNetworkIgnoreMask(jni, j_options); + native_options.disable_encryption = + Java_Options_getDisableEncryption(jni, j_options); + native_options.disable_network_monitor = + Java_Options_getDisableNetworkMonitor(jni, j_options); return native_options; } @@ -76,6 +125,34 @@ StaticObjectContainer& GetStaticObjects() { return *static_objects; } +ScopedJavaLocalRef NativeToScopedJavaPeerConnectionFactory( + JNIEnv* env, + rtc::scoped_refptr pcf, + std::unique_ptr network_thread, + std::unique_ptr worker_thread, + std::unique_ptr signaling_thread, + rtc::NetworkMonitorFactory* network_monitor_factory) { + OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads( + std::move(network_thread), std::move(worker_thread), + std::move(signaling_thread), network_monitor_factory, pcf); + + ScopedJavaLocalRef j_pcf = Java_PeerConnectionFactory_Constructor( + env, NativeToJavaPointer(owned_factory)); + + PostJavaCallback(env, owned_factory->network_thread(), RTC_FROM_HERE, j_pcf, + &Java_PeerConnectionFactory_onNetworkThreadReady); + PostJavaCallback(env, owned_factory->worker_thread(), RTC_FROM_HERE, j_pcf, + &Java_PeerConnectionFactory_onWorkerThreadReady); + PostJavaCallback(env, owned_factory->signaling_thread(), RTC_FROM_HERE, j_pcf, + &Java_PeerConnectionFactory_onSignalingThreadReady); + + return j_pcf; +} + +PeerConnectionFactoryInterface* PeerConnectionFactoryFromJava(jlong j_p) { + return reinterpret_cast(j_p)->factory(); +} + } // namespace // Note: Some of the video-specific PeerConnectionFactory methods are @@ -87,23 +164,6 @@ StaticObjectContainer& GetStaticObjects() { // Set in PeerConnectionFactory_initializeAndroidGlobals(). static bool factory_static_initialized = false; -void PeerConnectionFactoryNetworkThreadReady() { - RTC_LOG(LS_INFO) << "Network thread JavaCallback"; - JNIEnv* env = AttachCurrentThreadIfNeeded(); - Java_PeerConnectionFactory_onNetworkThreadReady(env); -} - -void PeerConnectionFactoryWorkerThreadReady() { - RTC_LOG(LS_INFO) << "Worker thread JavaCallback"; - JNIEnv* env = AttachCurrentThreadIfNeeded(); - Java_PeerConnectionFactory_onWorkerThreadReady(env); -} - -void PeerConnectionFactorySignalingThreadReady() { - RTC_LOG(LS_INFO) << "Signaling thread JavaCallback"; - JNIEnv* env = AttachCurrentThreadIfNeeded(); - Java_PeerConnectionFactory_onSignalingThreadReady(env); -} jobject NativeToJavaPeerConnectionFactory( JNIEnv* jni, @@ -112,13 +172,9 @@ jobject NativeToJavaPeerConnectionFactory( std::unique_ptr worker_thread, std::unique_ptr signaling_thread, rtc::NetworkMonitorFactory* network_monitor_factory) { - jni::OwnedFactoryAndThreads* owned_factory = new jni::OwnedFactoryAndThreads( - std::move(network_thread), std::move(worker_thread), - std::move(signaling_thread), network_monitor_factory, pcf.release()); - owned_factory->InvokeJavaCallbacksOnFactoryThreads(); - - return Java_PeerConnectionFactory_Constructor( - jni, NativeToJavaPointer(owned_factory)) + return NativeToScopedJavaPeerConnectionFactory( + jni, pcf, std::move(network_thread), std::move(worker_thread), + std::move(signaling_thread), network_monitor_factory) .Release(); } @@ -183,7 +239,7 @@ static void JNI_PeerConnectionFactory_ShutdownInternalTracer(JNIEnv* jni) { // Following parameters are optional: // |audio_device_module|, |jencoder_factory|, |jdecoder_factory|, // |audio_processor|, |media_transport_factory|, |fec_controller_factory|. -jlong CreatePeerConnectionFactoryForJava( +ScopedJavaLocalRef CreatePeerConnectionFactoryForJava( JNIEnv* jni, const JavaParamRef& jcontext, const JavaParamRef& joptions, @@ -217,15 +273,12 @@ jlong CreatePeerConnectionFactoryForJava( rtc::NetworkMonitorFactory* network_monitor_factory = nullptr; - PeerConnectionFactoryInterface::Options options; - bool has_options = !joptions.is_null(); - if (has_options) { - options = JavaToNativePeerConnectionFactoryOptions(jni, joptions); - } + const absl::optional options = + JavaToNativePeerConnectionFactoryOptions(jni, joptions); // 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)) { + if (!(options && options->disable_network_monitor)) { network_monitor_factory = new AndroidNetworkMonitorFactory(); rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory); } @@ -259,17 +312,16 @@ jlong CreatePeerConnectionFactoryForJava( << "WebRTC/libjingle init likely failed on this device"; // TODO(honghaiz): Maybe put the options as the argument of // CreatePeerConnectionFactory. - if (has_options) { - factory->SetOptions(options); - } - OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads( - std::move(network_thread), std::move(worker_thread), - std::move(signaling_thread), network_monitor_factory, factory.release()); - owned_factory->InvokeJavaCallbacksOnFactoryThreads(); - return jlongFromPointer(owned_factory); + if (options) + factory->SetOptions(*options); + + return NativeToScopedJavaPeerConnectionFactory( + jni, factory, std::move(network_thread), std::move(worker_thread), + std::move(signaling_thread), network_monitor_factory); } -static jlong JNI_PeerConnectionFactory_CreatePeerConnectionFactory( +static ScopedJavaLocalRef +JNI_PeerConnectionFactory_CreatePeerConnectionFactory( JNIEnv* jni, const JavaParamRef& jcontext, const JavaParamRef& joptions, @@ -283,30 +335,17 @@ static jlong JNI_PeerConnectionFactory_CreatePeerConnectionFactory( jlong native_media_transport_factory) { rtc::scoped_refptr audio_processor = reinterpret_cast(native_audio_processor); - AudioEncoderFactory* audio_encoder_factory_ptr = - reinterpret_cast(native_audio_encoder_factory); - rtc::scoped_refptr audio_encoder_factory( - audio_encoder_factory_ptr); - // Release the caller's reference count. - audio_encoder_factory->Release(); - AudioDecoderFactory* audio_decoder_factory_ptr = - reinterpret_cast(native_audio_decoder_factory); - rtc::scoped_refptr audio_decoder_factory( - audio_decoder_factory_ptr); - // Release the caller's reference count. - audio_decoder_factory->Release(); - std::unique_ptr fec_controller_factory( - reinterpret_cast( - native_fec_controller_factory)); - std::unique_ptr media_transport_factory( - reinterpret_cast(native_media_transport_factory)); return CreatePeerConnectionFactoryForJava( jni, jcontext, joptions, reinterpret_cast(native_audio_device_module), - audio_encoder_factory, audio_decoder_factory, jencoder_factory, - jdecoder_factory, + TakeOwnershipOfRefPtr(native_audio_encoder_factory), + TakeOwnershipOfRefPtr(native_audio_decoder_factory), + jencoder_factory, jdecoder_factory, audio_processor ? audio_processor : CreateAudioProcessing(), - std::move(fec_controller_factory), std::move(media_transport_factory)); + TakeOwnershipOfUniquePtr( + native_fec_controller_factory), + TakeOwnershipOfUniquePtr( + native_media_transport_factory)); } static void JNI_PeerConnectionFactory_FreeFactory(JNIEnv*, @@ -316,22 +355,13 @@ static void JNI_PeerConnectionFactory_FreeFactory(JNIEnv*, GetStaticObjects().field_trials_init_string = nullptr; } -static void JNI_PeerConnectionFactory_InvokeThreadsCallbacks( - JNIEnv*, - jlong j_p) { - OwnedFactoryAndThreads* factory = - reinterpret_cast(j_p); - factory->InvokeJavaCallbacksOnFactoryThreads(); -} - static jlong JNI_PeerConnectionFactory_CreateLocalMediaStream( JNIEnv* jni, jlong native_factory, const JavaParamRef& label) { - rtc::scoped_refptr factory( - factoryFromJava(native_factory)); rtc::scoped_refptr stream( - factory->CreateLocalMediaStream(JavaToStdString(jni, label))); + PeerConnectionFactoryFromJava(native_factory) + ->CreateLocalMediaStream(JavaToStdString(jni, label))); return jlongFromPointer(stream.release()); } @@ -341,12 +371,11 @@ static jlong JNI_PeerConnectionFactory_CreateAudioSource( const JavaParamRef& j_constraints) { std::unique_ptr constraints = JavaToNativeMediaConstraints(jni, j_constraints); - rtc::scoped_refptr factory( - factoryFromJava(native_factory)); cricket::AudioOptions options; CopyConstraintsIntoAudioOptions(constraints.get(), &options); rtc::scoped_refptr source( - factory->CreateAudioSource(options)); + PeerConnectionFactoryFromJava(native_factory) + ->CreateAudioSource(options)); return jlongFromPointer(source.release()); } @@ -355,11 +384,11 @@ jlong JNI_PeerConnectionFactory_CreateAudioTrack( jlong native_factory, const JavaParamRef& id, jlong native_source) { - rtc::scoped_refptr factory( - factoryFromJava(native_factory)); - rtc::scoped_refptr track(factory->CreateAudioTrack( - JavaToStdString(jni, id), - reinterpret_cast(native_source))); + rtc::scoped_refptr track( + PeerConnectionFactoryFromJava(native_factory) + ->CreateAudioTrack( + JavaToStdString(jni, id), + reinterpret_cast(native_source))); return jlongFromPointer(track.release()); } @@ -368,16 +397,13 @@ static jboolean JNI_PeerConnectionFactory_StartAecDump( jlong native_factory, jint file, jint filesize_limit_bytes) { - rtc::scoped_refptr factory( - factoryFromJava(native_factory)); - return factory->StartAecDump(file, filesize_limit_bytes); + return PeerConnectionFactoryFromJava(native_factory) + ->StartAecDump(file, filesize_limit_bytes); } static void JNI_PeerConnectionFactory_StopAecDump(JNIEnv* jni, jlong native_factory) { - rtc::scoped_refptr factory( - factoryFromJava(native_factory)); - factory->StopAecDump(); + PeerConnectionFactoryFromJava(native_factory)->StopAecDump(); } static jlong JNI_PeerConnectionFactory_CreatePeerConnection( @@ -387,9 +413,6 @@ static jlong JNI_PeerConnectionFactory_CreatePeerConnection( const JavaParamRef& j_constraints, jlong observer_p, const JavaParamRef& j_sslCertificateVerifier) { - rtc::scoped_refptr f( - reinterpret_cast( - factoryFromJava(factory))); std::unique_ptr observer( reinterpret_cast(observer_p)); @@ -426,11 +449,11 @@ static jlong JNI_PeerConnectionFactory_CreatePeerConnection( jni, j_sslCertificateVerifier); } - rtc::scoped_refptr pc(f->CreatePeerConnection( - rtc_config, std::move(peer_connection_dependencies))); - if (pc == nullptr) { + rtc::scoped_refptr pc = + PeerConnectionFactoryFromJava(factory)->CreatePeerConnection( + rtc_config, std::move(peer_connection_dependencies)); + if (!pc) return 0; - } return jlongFromPointer( new OwnedPeerConnection(pc, std::move(observer), std::move(constraints))); @@ -453,18 +476,18 @@ static jlong JNI_PeerConnectionFactory_CreateVideoTrack( jlong native_factory, const JavaParamRef& id, jlong native_source) { - rtc::scoped_refptr factory( - factoryFromJava(native_factory)); - rtc::scoped_refptr track(factory->CreateVideoTrack( - JavaToStdString(jni, id), - reinterpret_cast(native_source))); + rtc::scoped_refptr track = + PeerConnectionFactoryFromJava(native_factory) + ->CreateVideoTrack( + JavaToStdString(jni, id), + reinterpret_cast(native_source)); return jlongFromPointer(track.release()); } static jlong JNI_PeerConnectionFactory_GetNativePeerConnectionFactory( JNIEnv* jni, jlong native_factory) { - return jlongFromPointer(factoryFromJava(native_factory)); + return jlongFromPointer(PeerConnectionFactoryFromJava(native_factory)); } static void JNI_PeerConnectionFactory_InjectLoggable( diff --git a/sdk/android/src/jni/pc/peer_connection_factory.h b/sdk/android/src/jni/pc/peer_connection_factory.h index ba8dbe6871..904352f425 100644 --- a/sdk/android/src/jni/pc/peer_connection_factory.h +++ b/sdk/android/src/jni/pc/peer_connection_factory.h @@ -18,10 +18,6 @@ namespace webrtc { namespace jni { -void PeerConnectionFactoryNetworkThreadReady(); -void PeerConnectionFactoryWorkerThreadReady(); -void PeerConnectionFactorySignalingThreadReady(); - // Creates java PeerConnectionFactory with specified |pcf|. jobject NativeToJavaPeerConnectionFactory( JNIEnv* jni,