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 <magjed@webrtc.org>
Reviewed-by: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26329}diff --git a/sdk/android/api/org/webrtc/PeerConnectionFactory.java b/sdk/android/api/org/webrtc/PeerConnectionFactory.java
index c66b16b..b68c816 100644
--- a/sdk/android/api/org/webrtc/PeerConnectionFactory.java
+++ b/sdk/android/api/org/webrtc/PeerConnectionFactory.java
@@ -29,11 +29,17 @@
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 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 @@
}
}
- 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 @@
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 @@
nativeFactory = 0;
}
- public void threadsCallbacks() {
- checkPeerConnectionFactoryExists();
- nativeInvokeThreadsCallbacks(nativeFactory);
- }
-
/** Returns a pointer to the native webrtc::PeerConnectionFactoryInterface. */
public long getNativePeerConnectionFactory() {
checkPeerConnectionFactoryExists();
@@ -498,27 +483,43 @@
}
}
+ /** 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 @@
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 @@
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 5d7a0bb..e42b117 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<OwnedFactoryAndThreads*>(j_p)->factory();
-}
-
OwnedFactoryAndThreads::OwnedFactoryAndThreads(
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread,
rtc::NetworkMonitorFactory* network_monitor_factory,
- PeerConnectionFactoryInterface* factory)
+ const rtc::scoped_refptr<PeerConnectionFactoryInterface>& factory)
: network_thread_(std::move(network_thread)),
worker_thread_(std::move(worker_thread)),
signaling_thread_(std::move(signaling_thread)),
@@ -33,21 +28,10 @@
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<void>(RTC_FROM_HERE,
- &PeerConnectionFactoryNetworkThreadReady);
- worker_thread_->Invoke<void>(RTC_FROM_HERE,
- &PeerConnectionFactoryWorkerThreadReady);
- signaling_thread_->Invoke<void>(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 cc71001..845d4db 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 @@
// single thing for Java to hold and eventually free.
class OwnedFactoryAndThreads {
public:
- OwnedFactoryAndThreads(std::unique_ptr<rtc::Thread> network_thread,
- std::unique_ptr<rtc::Thread> worker_thread,
- std::unique_ptr<rtc::Thread> signaling_thread,
- rtc::NetworkMonitorFactory* network_monitor_factory,
- PeerConnectionFactoryInterface* factory);
+ OwnedFactoryAndThreads(
+ std::unique_ptr<rtc::Thread> network_thread,
+ std::unique_ptr<rtc::Thread> worker_thread,
+ std::unique_ptr<rtc::Thread> signaling_thread,
+ rtc::NetworkMonitorFactory* network_monitor_factory,
+ const rtc::scoped_refptr<PeerConnectionFactoryInterface>& 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 @@
return network_monitor_factory_;
}
void clear_network_monitor_factory() { network_monitor_factory_ = nullptr; }
- void InvokeJavaCallbacksOnFactoryThreads();
private:
const std::unique_ptr<rtc::Thread> network_thread_;
const std::unique_ptr<rtc::Thread> worker_thread_;
const std::unique_ptr<rtc::Thread> signaling_thread_;
rtc::NetworkMonitorFactory* network_monitor_factory_;
- PeerConnectionFactoryInterface* factory_; // Const after ctor except dtor.
+ const rtc::scoped_refptr<PeerConnectionFactoryInterface> 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 293031f..040753d 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 {
-PeerConnectionFactoryInterface::Options
+// Take ownership of the jlong reference and cast it into an rtc::scoped_refptr.
+template <typename T>
+rtc::scoped_refptr<T> TakeOwnershipOfRefPtr(jlong j_pointer) {
+ T* ptr = reinterpret_cast<T*>(j_pointer);
+ rtc::scoped_refptr<T> refptr;
+ refptr.swap(&ptr);
+ return refptr;
+}
+
+// Take ownership of the jlong reference and cast it into a std::unique_ptr.
+template <typename T>
+std::unique_ptr<T> TakeOwnershipOfUniquePtr(jlong native_pointer) {
+ return std::unique_ptr<T>(reinterpret_cast<T*>(native_pointer));
+}
+
+typedef void (*JavaMethodPointer)(JNIEnv*, const JavaRef<jobject>&);
+
+// 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<jobject>& 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<jobject>& 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<jobject> j_object_;
+ JavaMethodPointer java_method_pointer_;
+ };
+
+ queue->Post(posted_from,
+ new JavaAsyncCallback(env, j_object, java_method_pointer));
+}
+
+absl::optional<PeerConnectionFactoryInterface::Options>
JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni,
- const JavaRef<jobject>& 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<jobject>& 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 @@
return *static_objects;
}
+ScopedJavaLocalRef<jobject> NativeToScopedJavaPeerConnectionFactory(
+ JNIEnv* env,
+ rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf,
+ std::unique_ptr<rtc::Thread> network_thread,
+ std::unique_ptr<rtc::Thread> worker_thread,
+ std::unique_ptr<rtc::Thread> 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<jobject> 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<OwnedFactoryAndThreads*>(j_p)->factory();
+}
+
} // namespace
// Note: Some of the video-specific PeerConnectionFactory methods are
@@ -87,23 +164,6 @@
// 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 @@
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> 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 @@
// Following parameters are optional:
// |audio_device_module|, |jencoder_factory|, |jdecoder_factory|,
// |audio_processor|, |media_transport_factory|, |fec_controller_factory|.
-jlong CreatePeerConnectionFactoryForJava(
+ScopedJavaLocalRef<jobject> CreatePeerConnectionFactoryForJava(
JNIEnv* jni,
const JavaParamRef<jobject>& jcontext,
const JavaParamRef<jobject>& joptions,
@@ -217,15 +273,12 @@
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<PeerConnectionFactoryInterface::Options> 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 @@
<< "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<jobject>
+JNI_PeerConnectionFactory_CreatePeerConnectionFactory(
JNIEnv* jni,
const JavaParamRef<jobject>& jcontext,
const JavaParamRef<jobject>& joptions,
@@ -283,30 +335,17 @@
jlong native_media_transport_factory) {
rtc::scoped_refptr<AudioProcessing> audio_processor =
reinterpret_cast<AudioProcessing*>(native_audio_processor);
- AudioEncoderFactory* audio_encoder_factory_ptr =
- reinterpret_cast<AudioEncoderFactory*>(native_audio_encoder_factory);
- rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory(
- audio_encoder_factory_ptr);
- // Release the caller's reference count.
- audio_encoder_factory->Release();
- AudioDecoderFactory* audio_decoder_factory_ptr =
- reinterpret_cast<AudioDecoderFactory*>(native_audio_decoder_factory);
- rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory(
- audio_decoder_factory_ptr);
- // Release the caller's reference count.
- audio_decoder_factory->Release();
- std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory(
- reinterpret_cast<FecControllerFactoryInterface*>(
- native_fec_controller_factory));
- std::unique_ptr<MediaTransportFactory> media_transport_factory(
- reinterpret_cast<MediaTransportFactory*>(native_media_transport_factory));
return CreatePeerConnectionFactoryForJava(
jni, jcontext, joptions,
reinterpret_cast<AudioDeviceModule*>(native_audio_device_module),
- audio_encoder_factory, audio_decoder_factory, jencoder_factory,
- jdecoder_factory,
+ TakeOwnershipOfRefPtr<AudioEncoderFactory>(native_audio_encoder_factory),
+ TakeOwnershipOfRefPtr<AudioDecoderFactory>(native_audio_decoder_factory),
+ jencoder_factory, jdecoder_factory,
audio_processor ? audio_processor : CreateAudioProcessing(),
- std::move(fec_controller_factory), std::move(media_transport_factory));
+ TakeOwnershipOfUniquePtr<FecControllerFactoryInterface>(
+ native_fec_controller_factory),
+ TakeOwnershipOfUniquePtr<MediaTransportFactory>(
+ native_media_transport_factory));
}
static void JNI_PeerConnectionFactory_FreeFactory(JNIEnv*,
@@ -316,22 +355,13 @@
GetStaticObjects().field_trials_init_string = nullptr;
}
-static void JNI_PeerConnectionFactory_InvokeThreadsCallbacks(
- JNIEnv*,
- jlong j_p) {
- OwnedFactoryAndThreads* factory =
- reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
- factory->InvokeJavaCallbacksOnFactoryThreads();
-}
-
static jlong JNI_PeerConnectionFactory_CreateLocalMediaStream(
JNIEnv* jni,
jlong native_factory,
const JavaParamRef<jstring>& label) {
- rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
- factoryFromJava(native_factory));
rtc::scoped_refptr<MediaStreamInterface> stream(
- factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
+ PeerConnectionFactoryFromJava(native_factory)
+ ->CreateLocalMediaStream(JavaToStdString(jni, label)));
return jlongFromPointer(stream.release());
}
@@ -341,12 +371,11 @@
const JavaParamRef<jobject>& j_constraints) {
std::unique_ptr<MediaConstraintsInterface> constraints =
JavaToNativeMediaConstraints(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));
+ PeerConnectionFactoryFromJava(native_factory)
+ ->CreateAudioSource(options));
return jlongFromPointer(source.release());
}
@@ -355,11 +384,11 @@
jlong native_factory,
const JavaParamRef<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)));
+ rtc::scoped_refptr<AudioTrackInterface> track(
+ PeerConnectionFactoryFromJava(native_factory)
+ ->CreateAudioTrack(
+ JavaToStdString(jni, id),
+ reinterpret_cast<AudioSourceInterface*>(native_source)));
return jlongFromPointer(track.release());
}
@@ -368,16 +397,13 @@
jlong native_factory,
jint file,
jint filesize_limit_bytes) {
- rtc::scoped_refptr<PeerConnectionFactoryInterface> 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<PeerConnectionFactoryInterface> factory(
- factoryFromJava(native_factory));
- factory->StopAecDump();
+ PeerConnectionFactoryFromJava(native_factory)->StopAecDump();
}
static jlong JNI_PeerConnectionFactory_CreatePeerConnection(
@@ -387,9 +413,6 @@
const JavaParamRef<jobject>& j_constraints,
jlong observer_p,
const JavaParamRef<jobject>& j_sslCertificateVerifier) {
- rtc::scoped_refptr<PeerConnectionFactoryInterface> f(
- reinterpret_cast<PeerConnectionFactoryInterface*>(
- factoryFromJava(factory)));
std::unique_ptr<PeerConnectionObserver> observer(
reinterpret_cast<PeerConnectionObserver*>(observer_p));
@@ -426,11 +449,11 @@
jni, j_sslCertificateVerifier);
}
- rtc::scoped_refptr<PeerConnectionInterface> pc(f->CreatePeerConnection(
- rtc_config, std::move(peer_connection_dependencies)));
- if (pc == nullptr) {
+ rtc::scoped_refptr<PeerConnectionInterface> 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 @@
jlong native_factory,
const JavaParamRef<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)));
+ rtc::scoped_refptr<VideoTrackInterface> track =
+ PeerConnectionFactoryFromJava(native_factory)
+ ->CreateVideoTrack(
+ JavaToStdString(jni, id),
+ reinterpret_cast<VideoTrackSourceInterface*>(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 ba8dbe6..904352f 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,
