From 4e5074e0d2d9193aaea5c3dbf16b43225c5ec50a Mon Sep 17 00:00:00 2001 From: "Piotr (Peter) Slatala" Date: Tue, 16 Oct 2018 08:22:58 -0700 Subject: [PATCH] Add MediaTransportInterface factory to the Jni bindings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Java apps currently have no way of setting MediaTransportInterface on the PeerConnectionFactory. This change adds that ability. Bug: webrtc:9719 Change-Id: I312893a153b5b3d978912cba4db60cd97001c8f3 Reviewed-on: https://webrtc-review.googlesource.com/c/105740 Commit-Queue: Peter Slatala Reviewed-by: Sami Kalliomäki Cr-Commit-Position: refs/heads/master@{#25217} --- sdk/android/BUILD.gn | 1 + .../webrtc/MediaTransportFactoryFactory.java | 22 +++++++++++++++ .../api/org/webrtc/PeerConnectionFactory.java | 20 ++++++++++--- .../src/jni/pc/peerconnectionfactory.cc | 28 ++++++++++++++----- 4 files changed, 60 insertions(+), 11 deletions(-) create mode 100644 sdk/android/api/org/webrtc/MediaTransportFactoryFactory.java diff --git a/sdk/android/BUILD.gn b/sdk/android/BUILD.gn index 9890c0cbb1..cc686be440 100644 --- a/sdk/android/BUILD.gn +++ b/sdk/android/BUILD.gn @@ -279,6 +279,7 @@ if (is_android) { "api/org/webrtc/DataChannel.java", "api/org/webrtc/DtmfSender.java", "api/org/webrtc/FecControllerFactoryFactoryInterface.java", + "api/org/webrtc/MediaTransportFactoryFactory.java", "api/org/webrtc/FrameDecryptor.java", "api/org/webrtc/FrameEncryptor.java", "api/org/webrtc/IceCandidate.java", diff --git a/sdk/android/api/org/webrtc/MediaTransportFactoryFactory.java b/sdk/android/api/org/webrtc/MediaTransportFactoryFactory.java new file mode 100644 index 0000000000..c16a37a6d7 --- /dev/null +++ b/sdk/android/api/org/webrtc/MediaTransportFactoryFactory.java @@ -0,0 +1,22 @@ +/* + * Copyright 2018 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. + */ + +package org.webrtc; + +/** + * Factory for creating webrtc::MediaTransportFactory instances. + */ +public interface MediaTransportFactoryFactory { + /** + * Dynamically allocates a webrtc::MediaTransportFactory instance and returns a pointer to it. + * The caller takes ownership of the object. + */ + public long createNativeMediaTransportFactory(); +} diff --git a/sdk/android/api/org/webrtc/PeerConnectionFactory.java b/sdk/android/api/org/webrtc/PeerConnectionFactory.java index eb98e923f6..7c67ca3d16 100644 --- a/sdk/android/api/org/webrtc/PeerConnectionFactory.java +++ b/sdk/android/api/org/webrtc/PeerConnectionFactory.java @@ -158,6 +158,7 @@ public class PeerConnectionFactory { private @Nullable VideoDecoderFactory decoderFactory; private @Nullable AudioProcessingFactory audioProcessingFactory; private @Nullable FecControllerFactoryFactoryInterface fecControllerFactoryFactory; + private @Nullable MediaTransportFactoryFactory mediaTransportFactoryFactory; private Builder() {} @@ -196,9 +197,16 @@ public class PeerConnectionFactory { return this; } + /** Sets a MediaTransportFactoryFactory for a PeerConnectionFactory. */ + public Builder setMediaTransportFactoryFactory( + MediaTransportFactoryFactory mediaTransportFactoryFactory) { + this.mediaTransportFactoryFactory = mediaTransportFactoryFactory; + return this; + } + public PeerConnectionFactory createPeerConnectionFactory() { return new PeerConnectionFactory(options, audioDeviceModule, encoderFactory, decoderFactory, - audioProcessingFactory, fecControllerFactoryFactory); + audioProcessingFactory, fecControllerFactoryFactory, mediaTransportFactoryFactory); } } @@ -279,13 +287,17 @@ public class PeerConnectionFactory { private PeerConnectionFactory(Options options, @Nullable AudioDeviceModule audioDeviceModule, @Nullable VideoEncoderFactory encoderFactory, @Nullable VideoDecoderFactory decoderFactory, @Nullable AudioProcessingFactory audioProcessingFactory, - @Nullable FecControllerFactoryFactoryInterface fecControllerFactoryFactory) { + @Nullable FecControllerFactoryFactoryInterface fecControllerFactoryFactory, + @Nullable MediaTransportFactoryFactory mediaTransportFactoryFactory) { checkInitializeHasBeenCalled(); nativeFactory = nativeCreatePeerConnectionFactory(ContextUtils.getApplicationContext(), options, audioDeviceModule == null ? 0 : audioDeviceModule.getNativeAudioDeviceModulePointer(), encoderFactory, decoderFactory, audioProcessingFactory == null ? 0 : audioProcessingFactory.createNative(), - fecControllerFactoryFactory == null ? 0 : fecControllerFactoryFactory.createNative()); + fecControllerFactoryFactory == null ? 0 : fecControllerFactoryFactory.createNative(), + mediaTransportFactoryFactory == null + ? 0 + : mediaTransportFactoryFactory.createNativeMediaTransportFactory()); if (nativeFactory == 0) { throw new RuntimeException("Failed to initialize PeerConnectionFactory!"); } @@ -489,7 +501,7 @@ public class PeerConnectionFactory { private static native long nativeCreatePeerConnectionFactory(Context context, Options options, long nativeAudioDeviceModule, VideoEncoderFactory encoderFactory, VideoDecoderFactory decoderFactory, long nativeAudioProcessor, - long nativeFecControllerFactory); + long nativeFecControllerFactory, long mediaTransportFactory); private static native long nativeCreatePeerConnection(long factory, PeerConnection.RTCConfiguration rtcConfig, MediaConstraints constraints, long nativeObserver, SSLCertificateVerifier sslCertificateVerifier); diff --git a/sdk/android/src/jni/pc/peerconnectionfactory.cc b/sdk/android/src/jni/pc/peerconnectionfactory.cc index 049858a139..83591cb8bb 100644 --- a/sdk/android/src/jni/pc/peerconnectionfactory.cc +++ b/sdk/android/src/jni/pc/peerconnectionfactory.cc @@ -199,6 +199,9 @@ static void JNI_PeerConnectionFactory_ShutdownInternalTracer( rtc::tracing::ShutdownInternalTracer(); } +// Following parameters are optional: +// |audio_device_module|, |jencoder_factory|, |jdecoder_factory|, +// |audio_processor|, |media_transport_factory|, |fec_controller_factory|. jlong CreatePeerConnectionFactoryForJava( JNIEnv* jni, const JavaParamRef& jcontext, @@ -207,7 +210,8 @@ jlong CreatePeerConnectionFactoryForJava( const JavaParamRef& jencoder_factory, const JavaParamRef& jdecoder_factory, rtc::scoped_refptr audio_processor, - std::unique_ptr fec_controller_factory) { + std::unique_ptr fec_controller_factory, + std::unique_ptr media_transport_factory) { // 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 @@ -257,12 +261,19 @@ jlong CreatePeerConnectionFactoryForJava( std::unique_ptr( CreateVideoDecoderFactory(jni, jdecoder_factory)), audio_mixer, audio_processor)); + PeerConnectionFactoryDependencies dependencies; + dependencies.network_thread = network_thread.get(); + dependencies.worker_thread = worker_thread.get(); + dependencies.signaling_thread = signaling_thread.get(); + dependencies.media_engine = std::move(media_engine); + dependencies.call_factory = std::move(call_factory); + dependencies.event_log_factory = std::move(rtc_event_log_factory); + dependencies.fec_controller_factory = std::move(fec_controller_factory); + dependencies.media_transport_factory = std::move(media_transport_factory); rtc::scoped_refptr factory( - CreateModularPeerConnectionFactory( - network_thread.get(), worker_thread.get(), signaling_thread.get(), - std::move(media_engine), std::move(call_factory), - std::move(rtc_event_log_factory), std::move(fec_controller_factory))); + CreateModularPeerConnectionFactory(std::move(dependencies))); + RTC_CHECK(factory) << "Failed to create the peer connection factory; " << "WebRTC/libjingle init likely failed on this device"; // TODO(honghaiz): Maybe put the options as the argument of @@ -286,18 +297,21 @@ static jlong JNI_PeerConnectionFactory_CreatePeerConnectionFactory( const JavaParamRef& jencoder_factory, const JavaParamRef& jdecoder_factory, jlong native_audio_processor, - jlong native_fec_controller_factory) { + jlong native_fec_controller_factory, + jlong native_media_transport_factory) { rtc::scoped_refptr audio_processor = reinterpret_cast(native_audio_processor); 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), jencoder_factory, jdecoder_factory, audio_processor ? audio_processor : CreateAudioProcessing(), - std::move(fec_controller_factory)); + std::move(fec_controller_factory), std::move(media_transport_factory)); } static void JNI_PeerConnectionFactory_FreeFactory(JNIEnv*,