blob: b7513909a45fe674ddbc47ef7d7d86a8be0e7df7 [file] [log] [blame]
/*
* 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.
*/
#include "sdk/android/native_api/peerconnection/peer_connection_factory.h"
#include <memory>
#include "api/rtc_event_log/rtc_event_log_factory.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "media/base/media_engine.h"
#include "media/engine/internal_decoder_factory.h"
#include "media/engine/internal_encoder_factory.h"
#include "media/engine/webrtc_media_engine.h"
#include "media/engine/webrtc_media_engine_defaults.h"
#include "rtc_base/logging.h"
#include "rtc_base/physical_socket_server.h"
#include "rtc_base/thread.h"
#include "sdk/android/generated_native_unittests_jni/PeerConnectionFactoryInitializationHelper_jni.h"
#include "sdk/android/native_api/audio_device_module/audio_device_android.h"
#include "sdk/android/native_api/jni/jvm.h"
#include "sdk/android/native_api/jni/application_context_provider.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "test/gtest.h"
namespace webrtc {
namespace test {
namespace {
// Create native peer connection factory, that will be wrapped by java one
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> CreateTestPCF(
JNIEnv* jni,
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread) {
// 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/rtc_base/ are convoluted, we simply wrap here to avoid having to
// think about ramifications of auto-wrapping there.
rtc::ThreadManager::Instance()->WrapCurrentThread();
PeerConnectionFactoryDependencies pcf_deps;
pcf_deps.network_thread = network_thread;
pcf_deps.worker_thread = worker_thread;
pcf_deps.signaling_thread = signaling_thread;
pcf_deps.task_queue_factory = CreateDefaultTaskQueueFactory();
pcf_deps.call_factory = CreateCallFactory();
pcf_deps.event_log_factory =
std::make_unique<RtcEventLogFactory>(pcf_deps.task_queue_factory.get());
cricket::MediaEngineDependencies media_deps;
media_deps.task_queue_factory = pcf_deps.task_queue_factory.get();
media_deps.adm =
CreateJavaAudioDeviceModule(jni, GetAppContext(jni).obj());
media_deps.video_encoder_factory =
std::make_unique<webrtc::InternalEncoderFactory>();
media_deps.video_decoder_factory =
std::make_unique<webrtc::InternalDecoderFactory>();
SetMediaEngineDefaults(&media_deps);
pcf_deps.media_engine = cricket::CreateMediaEngine(std::move(media_deps));
RTC_LOG(LS_INFO) << "Media engine created: " << pcf_deps.media_engine.get();
auto factory = CreateModularPeerConnectionFactory(std::move(pcf_deps));
RTC_LOG(LS_INFO) << "PeerConnectionFactory created: " << factory.get();
RTC_CHECK(factory) << "Failed to create the peer connection factory; "
"WebRTC/libjingle init likely failed on this device";
return factory;
}
TEST(PeerConnectionFactoryTest, NativeToJavaPeerConnectionFactory) {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
RTC_LOG(LS_INFO) << "Initializing java peer connection factory.";
jni::Java_PeerConnectionFactoryInitializationHelper_initializeFactoryForTests(
jni);
RTC_LOG(LS_INFO) << "Java peer connection factory initialized.";
auto socket_server = std::make_unique<rtc::PhysicalSocketServer>();
// Create threads.
auto network_thread = std::make_unique<rtc::Thread>(socket_server.get());
network_thread->SetName("network_thread", nullptr);
RTC_CHECK(network_thread->Start()) << "Failed to start thread";
std::unique_ptr<rtc::Thread> worker_thread = rtc::Thread::Create();
worker_thread->SetName("worker_thread", nullptr);
RTC_CHECK(worker_thread->Start()) << "Failed to start thread";
std::unique_ptr<rtc::Thread> signaling_thread = rtc::Thread::Create();
signaling_thread->SetName("signaling_thread", NULL);
RTC_CHECK(signaling_thread->Start()) << "Failed to start thread";
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory =
CreateTestPCF(jni, network_thread.get(), worker_thread.get(),
signaling_thread.get());
jobject java_factory = NativeToJavaPeerConnectionFactory(
jni, factory, std::move(socket_server), std::move(network_thread),
std::move(worker_thread), std::move(signaling_thread));
RTC_LOG(LS_INFO) << java_factory;
EXPECT_NE(java_factory, nullptr);
}
} // namespace
} // namespace test
} // namespace webrtc