From fad089368893be639df1cd2c317ad4e5d4262b6b Mon Sep 17 00:00:00 2001 From: Magnus Jedvert Date: Sun, 20 Jan 2019 12:43:00 +0100 Subject: [PATCH] Android: Remove static thread references from PeerconnectionFactory This CL prepares for adding stack trace capability to the native part of the Android PeerConnectionFactory code. The main blocker this CL removes is the static printStackTrace() function. We need this function to be non-static since the C++ counterpart of PCF is non-static. This Cl also performs various other cleanups in surrounding code. This CL: * Removes static thread references from PeerconnectionFactory and turns them into non-static member variables. * Adds a non-static alternative to PeerconnectionFactory.printStackTraces(). * Removes the rtc::Thread::Invoke() calls, and turns them into asynchronous posts. * Consolidates the two different Java PCF ctors into one, so that there is one shared path used by both native API and Java API. Bug: webrtc:10168 Change-Id: I05dbf5b17069d4a115d9adafc25faa121f23b945 Reviewed-on: https://webrtc-review.googlesource.com/c/115961 Commit-Queue: Magnus Jedvert Reviewed-by: Tommi Cr-Commit-Position: refs/heads/master@{#26329} --- .../api/org/webrtc/PeerConnectionFactory.java | 95 +++---- .../src/jni/pc/owned_factory_and_threads.cc | 18 +- .../src/jni/pc/owned_factory_and_threads.h | 18 +- .../src/jni/pc/peer_connection_factory.cc | 237 ++++++++++-------- .../src/jni/pc/peer_connection_factory.h | 4 - 5 files changed, 187 insertions(+), 185 deletions(-) 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,