summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/examples/androidvoip/jni
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /third_party/libwebrtc/examples/androidvoip/jni
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/examples/androidvoip/jni')
-rw-r--r--third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.cc514
-rw-r--r--third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.h188
-rw-r--r--third_party/libwebrtc/examples/androidvoip/jni/onload.cc28
3 files changed, 730 insertions, 0 deletions
diff --git a/third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.cc b/third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.cc
new file mode 100644
index 0000000000..8a0a3badb9
--- /dev/null
+++ b/third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.cc
@@ -0,0 +1,514 @@
+/*
+ * Copyright 2020 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 "examples/androidvoip/jni/android_voip_client.h"
+
+#include <errno.h>
+#include <sys/socket.h>
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
+#include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/voip/voip_codec.h"
+#include "api/voip/voip_engine_factory.h"
+#include "api/voip/voip_network.h"
+#include "examples/androidvoip/generated_jni/VoipClient_jni.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/network.h"
+#include "rtc_base/socket_server.h"
+#include "sdk/android/native_api/audio_device_module/audio_device_android.h"
+#include "sdk/android/native_api/jni/java_types.h"
+#include "sdk/android/native_api/jni/jvm.h"
+#include "sdk/android/native_api/jni/scoped_java_ref.h"
+
+namespace {
+
+#define RUN_ON_VOIP_THREAD(method, ...) \
+ if (!voip_thread_->IsCurrent()) { \
+ voip_thread_->PostTask( \
+ std::bind(&AndroidVoipClient::method, this, ##__VA_ARGS__)); \
+ return; \
+ } \
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+// Connects a UDP socket to a public address and returns the local
+// address associated with it. Since it binds to the "any" address
+// internally, it returns the default local address on a multi-homed
+// endpoint. Implementation copied from
+// BasicNetworkManager::QueryDefaultLocalAddress.
+rtc::IPAddress QueryDefaultLocalAddress(int family) {
+ const char kPublicIPv4Host[] = "8.8.8.8";
+ const char kPublicIPv6Host[] = "2001:4860:4860::8888";
+ const int kPublicPort = 53;
+ std::unique_ptr<rtc::Thread> thread = rtc::Thread::CreateWithSocketServer();
+
+ RTC_DCHECK(thread->socketserver() != nullptr);
+ RTC_DCHECK(family == AF_INET || family == AF_INET6);
+
+ std::unique_ptr<rtc::Socket> socket(
+ thread->socketserver()->CreateSocket(family, SOCK_DGRAM));
+ if (!socket) {
+ RTC_LOG_ERR(LS_ERROR) << "Socket creation failed";
+ return rtc::IPAddress();
+ }
+
+ auto host = family == AF_INET ? kPublicIPv4Host : kPublicIPv6Host;
+ if (socket->Connect(rtc::SocketAddress(host, kPublicPort)) < 0) {
+ if (socket->GetError() != ENETUNREACH &&
+ socket->GetError() != EHOSTUNREACH) {
+ RTC_LOG(LS_INFO) << "Connect failed with " << socket->GetError();
+ }
+ return rtc::IPAddress();
+ }
+ return socket->GetLocalAddress().ipaddr();
+}
+
+// Assigned payload type for supported built-in codecs. PCMU, PCMA,
+// and G722 have set payload types. Whereas opus, ISAC, and ILBC
+// have dynamic payload types.
+enum class PayloadType : int {
+ kPcmu = 0,
+ kPcma = 8,
+ kG722 = 9,
+ kOpus = 96,
+ kIsac = 97,
+ kIlbc = 98,
+};
+
+// Returns the payload type corresponding to codec_name. Only
+// supports the built-in codecs.
+int GetPayloadType(const std::string& codec_name) {
+ RTC_DCHECK(codec_name == "PCMU" || codec_name == "PCMA" ||
+ codec_name == "G722" || codec_name == "opus" ||
+ codec_name == "ISAC" || codec_name == "ILBC");
+
+ if (codec_name == "PCMU") {
+ return static_cast<int>(PayloadType::kPcmu);
+ } else if (codec_name == "PCMA") {
+ return static_cast<int>(PayloadType::kPcma);
+ } else if (codec_name == "G722") {
+ return static_cast<int>(PayloadType::kG722);
+ } else if (codec_name == "opus") {
+ return static_cast<int>(PayloadType::kOpus);
+ } else if (codec_name == "ISAC") {
+ return static_cast<int>(PayloadType::kIsac);
+ } else if (codec_name == "ILBC") {
+ return static_cast<int>(PayloadType::kIlbc);
+ }
+
+ RTC_DCHECK_NOTREACHED();
+ return -1;
+}
+
+} // namespace
+
+namespace webrtc_examples {
+
+void AndroidVoipClient::Init(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& application_context) {
+ webrtc::VoipEngineConfig config;
+ config.encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
+ config.decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
+ config.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
+ config.audio_device_module =
+ webrtc::CreateJavaAudioDeviceModule(env, application_context.obj());
+ config.audio_processing = webrtc::AudioProcessingBuilder().Create();
+
+ voip_thread_->Start();
+
+ // Due to consistent thread requirement on
+ // modules/audio_device/android/audio_device_template.h,
+ // code is invoked in the context of voip_thread_.
+ voip_thread_->BlockingCall([this, &config] {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ supported_codecs_ = config.encoder_factory->GetSupportedEncoders();
+ env_ = webrtc::AttachCurrentThreadIfNeeded();
+ voip_engine_ = webrtc::CreateVoipEngine(std::move(config));
+ });
+}
+
+AndroidVoipClient::~AndroidVoipClient() {
+ voip_thread_->BlockingCall([this] {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ JavaVM* jvm = nullptr;
+ env_->GetJavaVM(&jvm);
+ if (!jvm) {
+ RTC_LOG(LS_ERROR) << "Failed to retrieve JVM";
+ return;
+ }
+ jint res = jvm->DetachCurrentThread();
+ if (res != JNI_OK) {
+ RTC_LOG(LS_ERROR) << "DetachCurrentThread failed: " << res;
+ }
+ });
+
+ voip_thread_->Stop();
+}
+
+AndroidVoipClient* AndroidVoipClient::Create(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& application_context,
+ const webrtc::JavaParamRef<jobject>& j_voip_client) {
+ // Using `new` to access a non-public constructor.
+ auto voip_client =
+ absl::WrapUnique(new AndroidVoipClient(env, j_voip_client));
+ voip_client->Init(env, application_context);
+ return voip_client.release();
+}
+
+void AndroidVoipClient::GetSupportedCodecs(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(GetSupportedCodecs, env);
+
+ std::vector<std::string> names;
+ for (const webrtc::AudioCodecSpec& spec : supported_codecs_) {
+ names.push_back(spec.format.name);
+ }
+ webrtc::ScopedJavaLocalRef<jstring> (*convert_function)(
+ JNIEnv*, const std::string&) = &webrtc::NativeToJavaString;
+ Java_VoipClient_onGetSupportedCodecsCompleted(
+ env_, j_voip_client_, NativeToJavaList(env_, names, convert_function));
+}
+
+void AndroidVoipClient::GetLocalIPAddress(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(GetLocalIPAddress, env);
+
+ std::string local_ip_address;
+ rtc::IPAddress ipv4_address = QueryDefaultLocalAddress(AF_INET);
+ if (!ipv4_address.IsNil()) {
+ local_ip_address = ipv4_address.ToString();
+ } else {
+ rtc::IPAddress ipv6_address = QueryDefaultLocalAddress(AF_INET6);
+ if (!ipv6_address.IsNil()) {
+ local_ip_address = ipv6_address.ToString();
+ }
+ }
+ Java_VoipClient_onGetLocalIPAddressCompleted(
+ env_, j_voip_client_, webrtc::NativeToJavaString(env_, local_ip_address));
+}
+
+void AndroidVoipClient::SetEncoder(const std::string& encoder) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ return;
+ }
+ for (const webrtc::AudioCodecSpec& codec : supported_codecs_) {
+ if (codec.format.name == encoder) {
+ webrtc::VoipResult result = voip_engine_->Codec().SetSendCodec(
+ *channel_, GetPayloadType(codec.format.name), codec.format);
+ RTC_CHECK(result == webrtc::VoipResult::kOk);
+ return;
+ }
+ }
+}
+
+void AndroidVoipClient::SetEncoder(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jstring>& j_encoder_string) {
+ const std::string& chosen_encoder =
+ webrtc::JavaToNativeString(env, j_encoder_string);
+ voip_thread_->PostTask(
+ [this, chosen_encoder] { SetEncoder(chosen_encoder); });
+}
+
+void AndroidVoipClient::SetDecoders(const std::vector<std::string>& decoders) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ return;
+ }
+ std::map<int, webrtc::SdpAudioFormat> decoder_specs;
+ for (const webrtc::AudioCodecSpec& codec : supported_codecs_) {
+ if (std::find(decoders.begin(), decoders.end(), codec.format.name) !=
+ decoders.end()) {
+ decoder_specs.insert({GetPayloadType(codec.format.name), codec.format});
+ }
+ }
+
+ webrtc::VoipResult result =
+ voip_engine_->Codec().SetReceiveCodecs(*channel_, decoder_specs);
+ RTC_CHECK(result == webrtc::VoipResult::kOk);
+}
+
+void AndroidVoipClient::SetDecoders(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& j_decoder_strings) {
+ const std::vector<std::string>& chosen_decoders =
+ webrtc::JavaListToNativeVector<std::string, jstring>(
+ env, j_decoder_strings, &webrtc::JavaToNativeString);
+ voip_thread_->PostTask(
+ [this, chosen_decoders] { SetDecoders(chosen_decoders); });
+}
+
+void AndroidVoipClient::SetLocalAddress(const std::string& ip_address,
+ const int port_number) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ rtp_local_address_ = rtc::SocketAddress(ip_address, port_number);
+ rtcp_local_address_ = rtc::SocketAddress(ip_address, port_number + 1);
+}
+
+void AndroidVoipClient::SetLocalAddress(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jstring>& j_ip_address_string,
+ jint j_port_number_int) {
+ const std::string& ip_address =
+ webrtc::JavaToNativeString(env, j_ip_address_string);
+ voip_thread_->PostTask([this, ip_address, j_port_number_int] {
+ SetLocalAddress(ip_address, j_port_number_int);
+ });
+}
+
+void AndroidVoipClient::SetRemoteAddress(const std::string& ip_address,
+ const int port_number) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ rtp_remote_address_ = rtc::SocketAddress(ip_address, port_number);
+ rtcp_remote_address_ = rtc::SocketAddress(ip_address, port_number + 1);
+}
+
+void AndroidVoipClient::SetRemoteAddress(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jstring>& j_ip_address_string,
+ jint j_port_number_int) {
+ const std::string& ip_address =
+ webrtc::JavaToNativeString(env, j_ip_address_string);
+ voip_thread_->PostTask([this, ip_address, j_port_number_int] {
+ SetRemoteAddress(ip_address, j_port_number_int);
+ });
+}
+
+void AndroidVoipClient::StartSession(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(StartSession, env);
+
+ // CreateChannel guarantees to return valid channel id.
+ channel_ = voip_engine_->Base().CreateChannel(this, absl::nullopt);
+
+ rtp_socket_.reset(rtc::AsyncUDPSocket::Create(voip_thread_->socketserver(),
+ rtp_local_address_));
+ if (!rtp_socket_) {
+ RTC_LOG_ERR(LS_ERROR) << "Socket creation failed";
+ Java_VoipClient_onStartSessionCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+ rtp_socket_->SignalReadPacket.connect(
+ this, &AndroidVoipClient::OnSignalReadRTPPacket);
+
+ rtcp_socket_.reset(rtc::AsyncUDPSocket::Create(voip_thread_->socketserver(),
+ rtcp_local_address_));
+ if (!rtcp_socket_) {
+ RTC_LOG_ERR(LS_ERROR) << "Socket creation failed";
+ Java_VoipClient_onStartSessionCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+ rtcp_socket_->SignalReadPacket.connect(
+ this, &AndroidVoipClient::OnSignalReadRTCPPacket);
+ Java_VoipClient_onStartSessionCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/true);
+}
+
+void AndroidVoipClient::StopSession(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(StopSession, env);
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ Java_VoipClient_onStopSessionCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+ if (voip_engine_->Base().StopSend(*channel_) != webrtc::VoipResult::kOk ||
+ voip_engine_->Base().StopPlayout(*channel_) != webrtc::VoipResult::kOk) {
+ Java_VoipClient_onStopSessionCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+
+ rtp_socket_->Close();
+ rtcp_socket_->Close();
+
+ webrtc::VoipResult result = voip_engine_->Base().ReleaseChannel(*channel_);
+ RTC_CHECK(result == webrtc::VoipResult::kOk);
+
+ channel_ = absl::nullopt;
+ Java_VoipClient_onStopSessionCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/true);
+}
+
+void AndroidVoipClient::StartSend(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(StartSend, env);
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ Java_VoipClient_onStartSendCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+ bool sending_started =
+ (voip_engine_->Base().StartSend(*channel_) == webrtc::VoipResult::kOk);
+ Java_VoipClient_onStartSendCompleted(env_, j_voip_client_, sending_started);
+}
+
+void AndroidVoipClient::StopSend(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(StopSend, env);
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ Java_VoipClient_onStopSendCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+ bool sending_stopped =
+ (voip_engine_->Base().StopSend(*channel_) == webrtc::VoipResult::kOk);
+ Java_VoipClient_onStopSendCompleted(env_, j_voip_client_, sending_stopped);
+}
+
+void AndroidVoipClient::StartPlayout(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(StartPlayout, env);
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ Java_VoipClient_onStartPlayoutCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+ bool playout_started =
+ (voip_engine_->Base().StartPlayout(*channel_) == webrtc::VoipResult::kOk);
+ Java_VoipClient_onStartPlayoutCompleted(env_, j_voip_client_,
+ playout_started);
+}
+
+void AndroidVoipClient::StopPlayout(JNIEnv* env) {
+ RUN_ON_VOIP_THREAD(StopPlayout, env);
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ Java_VoipClient_onStopPlayoutCompleted(env_, j_voip_client_,
+ /*isSuccessful=*/false);
+ return;
+ }
+ bool playout_stopped =
+ (voip_engine_->Base().StopPlayout(*channel_) == webrtc::VoipResult::kOk);
+ Java_VoipClient_onStopPlayoutCompleted(env_, j_voip_client_, playout_stopped);
+}
+
+void AndroidVoipClient::Delete(JNIEnv* env) {
+ delete this;
+}
+
+void AndroidVoipClient::SendRtpPacket(const std::vector<uint8_t>& packet_copy) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ if (!rtp_socket_->SendTo(packet_copy.data(), packet_copy.size(),
+ rtp_remote_address_, rtc::PacketOptions())) {
+ RTC_LOG(LS_ERROR) << "Failed to send RTP packet";
+ }
+}
+
+bool AndroidVoipClient::SendRtp(rtc::ArrayView<const uint8_t> packet,
+ const webrtc::PacketOptions& options) {
+ std::vector<uint8_t> packet_copy(packet.begin(), packet.end());
+ voip_thread_->PostTask([this, packet_copy = std::move(packet_copy)] {
+ SendRtpPacket(packet_copy);
+ });
+ return true;
+}
+
+void AndroidVoipClient::SendRtcpPacket(
+ const std::vector<uint8_t>& packet_copy) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ if (!rtcp_socket_->SendTo(packet_copy.data(), packet_copy.size(),
+ rtcp_remote_address_, rtc::PacketOptions())) {
+ RTC_LOG(LS_ERROR) << "Failed to send RTCP packet";
+ }
+}
+
+bool AndroidVoipClient::SendRtcp(rtc::ArrayView<const uint8_t> packet) {
+ std::vector<uint8_t> packet_copy(packet.begin(), packet.end());
+ voip_thread_->PostTask([this, packet_copy = std::move(packet_copy)] {
+ SendRtcpPacket(packet_copy);
+ });
+ return true;
+}
+
+void AndroidVoipClient::ReadRTPPacket(const std::vector<uint8_t>& packet_copy) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ return;
+ }
+ webrtc::VoipResult result = voip_engine_->Network().ReceivedRTPPacket(
+ *channel_,
+ rtc::ArrayView<const uint8_t>(packet_copy.data(), packet_copy.size()));
+ RTC_CHECK(result == webrtc::VoipResult::kOk);
+}
+
+void AndroidVoipClient::OnSignalReadRTPPacket(rtc::AsyncPacketSocket* socket,
+ const char* rtp_packet,
+ size_t size,
+ const rtc::SocketAddress& addr,
+ const int64_t& timestamp) {
+ std::vector<uint8_t> packet_copy(rtp_packet, rtp_packet + size);
+ voip_thread_->PostTask([this, packet_copy = std::move(packet_copy)] {
+ ReadRTPPacket(packet_copy);
+ });
+}
+
+void AndroidVoipClient::ReadRTCPPacket(
+ const std::vector<uint8_t>& packet_copy) {
+ RTC_DCHECK_RUN_ON(voip_thread_.get());
+
+ if (!channel_) {
+ RTC_LOG(LS_ERROR) << "Channel has not been created";
+ return;
+ }
+ webrtc::VoipResult result = voip_engine_->Network().ReceivedRTCPPacket(
+ *channel_,
+ rtc::ArrayView<const uint8_t>(packet_copy.data(), packet_copy.size()));
+ RTC_CHECK(result == webrtc::VoipResult::kOk);
+}
+
+void AndroidVoipClient::OnSignalReadRTCPPacket(rtc::AsyncPacketSocket* socket,
+ const char* rtcp_packet,
+ size_t size,
+ const rtc::SocketAddress& addr,
+ const int64_t& timestamp) {
+ std::vector<uint8_t> packet_copy(rtcp_packet, rtcp_packet + size);
+ voip_thread_->PostTask([this, packet_copy = std::move(packet_copy)] {
+ ReadRTCPPacket(packet_copy);
+ });
+}
+
+static jlong JNI_VoipClient_CreateClient(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& application_context,
+ const webrtc::JavaParamRef<jobject>& j_voip_client) {
+ return webrtc::NativeToJavaPointer(
+ AndroidVoipClient::Create(env, application_context, j_voip_client));
+}
+
+} // namespace webrtc_examples
diff --git a/third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.h b/third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.h
new file mode 100644
index 0000000000..e2f1c64590
--- /dev/null
+++ b/third_party/libwebrtc/examples/androidvoip/jni/android_voip_client.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2020 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.
+ */
+
+#ifndef EXAMPLES_ANDROIDVOIP_JNI_ANDROID_VOIP_CLIENT_H_
+#define EXAMPLES_ANDROIDVOIP_JNI_ANDROID_VOIP_CLIENT_H_
+
+#include <jni.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "api/audio_codecs/audio_format.h"
+#include "api/call/transport.h"
+#include "api/voip/voip_base.h"
+#include "api/voip/voip_engine.h"
+#include "rtc_base/async_packet_socket.h"
+#include "rtc_base/async_udp_socket.h"
+#include "rtc_base/socket_address.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
+#include "rtc_base/thread.h"
+#include "sdk/android/native_api/jni/scoped_java_ref.h"
+
+namespace webrtc_examples {
+
+// AndroidVoipClient facilitates the use of the VoIP API defined in
+// api/voip/voip_engine.h. One instance of AndroidVoipClient should
+// suffice for most VoIP applications. AndroidVoipClient implements
+// webrtc::Transport to send RTP/RTCP packets to the remote endpoint.
+// It also creates methods (slots) for sockets to connect to in
+// order to receive RTP/RTCP packets. AndroidVoipClient does all
+// operations with rtc::Thread (voip_thread_), this is to comply
+// with consistent thread usage requirement with ProcessThread used
+// within VoipEngine, as well as providing asynchronicity to the
+// caller. AndroidVoipClient is meant to be used by Java through JNI.
+class AndroidVoipClient : public webrtc::Transport,
+ public sigslot::has_slots<> {
+ public:
+ // Returns a pointer to an AndroidVoipClient object. Clients should
+ // use this factory method to create AndroidVoipClient objects. The
+ // method will return a nullptr in case of initialization errors.
+ // It is the client's responsibility to delete the pointer when
+ // they are done with it (this class provides a Delete() method).
+ static AndroidVoipClient* Create(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& application_context,
+ const webrtc::JavaParamRef<jobject>& j_voip_client);
+
+ ~AndroidVoipClient() override;
+
+ // Provides client with a Java List of Strings containing names of
+ // the built-in supported codecs through callback.
+ void GetSupportedCodecs(JNIEnv* env);
+
+ // Provides client with a Java String of the default local IPv4 address
+ // through callback. If IPv4 address is not found, provide the default
+ // local IPv6 address. If IPv6 address is not found, provide an empty
+ // string.
+ void GetLocalIPAddress(JNIEnv* env);
+
+ // Sets the encoder used by the VoIP API.
+ void SetEncoder(JNIEnv* env,
+ const webrtc::JavaParamRef<jstring>& j_encoder_string);
+
+ // Sets the decoders used by the VoIP API.
+ void SetDecoders(JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& j_decoder_strings);
+
+ // Sets two local/remote addresses, one for RTP packets, and another for
+ // RTCP packets. The RTP address will have IP address j_ip_address_string
+ // and port number j_port_number_int, the RTCP address will have IP address
+ // j_ip_address_string and port number j_port_number_int+1.
+ void SetLocalAddress(JNIEnv* env,
+ const webrtc::JavaParamRef<jstring>& j_ip_address_string,
+ jint j_port_number_int);
+ void SetRemoteAddress(
+ JNIEnv* env,
+ const webrtc::JavaParamRef<jstring>& j_ip_address_string,
+ jint j_port_number_int);
+
+ // Starts a VoIP session, then calls a callback method with a boolean
+ // value indicating if the session has started successfully. The VoIP
+ // operations below can only be used after a session has already started.
+ void StartSession(JNIEnv* env);
+
+ // Stops the current session, then calls a callback method with a
+ // boolean value indicating if the session has stopped successfully.
+ void StopSession(JNIEnv* env);
+
+ // Starts sending RTP/RTCP packets to the remote endpoint, then calls
+ // a callback method with a boolean value indicating if sending
+ // has started successfully.
+ void StartSend(JNIEnv* env);
+
+ // Stops sending RTP/RTCP packets to the remote endpoint, then calls
+ // a callback method with a boolean value indicating if sending
+ // has stopped successfully.
+ void StopSend(JNIEnv* env);
+
+ // Starts playing out the voice data received from the remote endpoint,
+ // then calls a callback method with a boolean value indicating if
+ // playout has started successfully.
+ void StartPlayout(JNIEnv* env);
+
+ // Stops playing out the voice data received from the remote endpoint,
+ // then calls a callback method with a boolean value indicating if
+ // playout has stopped successfully.
+ void StopPlayout(JNIEnv* env);
+
+ // Deletes this object. Used by client when they are done.
+ void Delete(JNIEnv* env);
+
+ // Implementation for Transport.
+ bool SendRtp(rtc::ArrayView<const uint8_t> packet,
+ const webrtc::PacketOptions& options) override;
+ bool SendRtcp(rtc::ArrayView<const uint8_t> packet) override;
+
+ // Slots for sockets to connect to.
+ void OnSignalReadRTPPacket(rtc::AsyncPacketSocket* socket,
+ const char* rtp_packet,
+ size_t size,
+ const rtc::SocketAddress& addr,
+ const int64_t& timestamp);
+ void OnSignalReadRTCPPacket(rtc::AsyncPacketSocket* socket,
+ const char* rtcp_packet,
+ size_t size,
+ const rtc::SocketAddress& addr,
+ const int64_t& timestamp);
+
+ private:
+ AndroidVoipClient(JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& j_voip_client)
+ : voip_thread_(rtc::Thread::CreateWithSocketServer()),
+ j_voip_client_(env, j_voip_client) {}
+
+ void Init(JNIEnv* env,
+ const webrtc::JavaParamRef<jobject>& application_context);
+
+ // Overloaded methods having native C++ variables as arguments.
+ void SetEncoder(const std::string& encoder);
+ void SetDecoders(const std::vector<std::string>& decoders);
+ void SetLocalAddress(const std::string& ip_address, int port_number);
+ void SetRemoteAddress(const std::string& ip_address, int port_number);
+
+ // Methods to send and receive RTP/RTCP packets. Takes in a
+ // copy of a packet as a vector to prolong the lifetime of
+ // the packet as these methods will be called asynchronously.
+ void SendRtpPacket(const std::vector<uint8_t>& packet_copy);
+ void SendRtcpPacket(const std::vector<uint8_t>& packet_copy);
+ void ReadRTPPacket(const std::vector<uint8_t>& packet_copy);
+ void ReadRTCPPacket(const std::vector<uint8_t>& packet_copy);
+
+ // Used to invoke operations and send/receive RTP/RTCP packets.
+ std::unique_ptr<rtc::Thread> voip_thread_;
+ // Reference to the VoipClient java instance used to
+ // invoke callbacks when operations are finished.
+ webrtc::ScopedJavaGlobalRef<jobject> j_voip_client_
+ RTC_GUARDED_BY(voip_thread_);
+ // A list of AudioCodecSpec supported by the built-in
+ // encoder/decoder factories.
+ std::vector<webrtc::AudioCodecSpec> supported_codecs_
+ RTC_GUARDED_BY(voip_thread_);
+ // A JNI context used by the voip_thread_.
+ JNIEnv* env_ RTC_GUARDED_BY(voip_thread_);
+ // The entry point to all VoIP APIs.
+ std::unique_ptr<webrtc::VoipEngine> voip_engine_ RTC_GUARDED_BY(voip_thread_);
+ // Used by the VoIP API to facilitate a VoIP session.
+ absl::optional<webrtc::ChannelId> channel_ RTC_GUARDED_BY(voip_thread_);
+ // Members below are used for network related operations.
+ std::unique_ptr<rtc::AsyncUDPSocket> rtp_socket_ RTC_GUARDED_BY(voip_thread_);
+ std::unique_ptr<rtc::AsyncUDPSocket> rtcp_socket_
+ RTC_GUARDED_BY(voip_thread_);
+ rtc::SocketAddress rtp_local_address_ RTC_GUARDED_BY(voip_thread_);
+ rtc::SocketAddress rtcp_local_address_ RTC_GUARDED_BY(voip_thread_);
+ rtc::SocketAddress rtp_remote_address_ RTC_GUARDED_BY(voip_thread_);
+ rtc::SocketAddress rtcp_remote_address_ RTC_GUARDED_BY(voip_thread_);
+};
+
+} // namespace webrtc_examples
+
+#endif // EXAMPLES_ANDROIDVOIP_JNI_ANDROID_VOIP_CLIENT_H_
diff --git a/third_party/libwebrtc/examples/androidvoip/jni/onload.cc b/third_party/libwebrtc/examples/androidvoip/jni/onload.cc
new file mode 100644
index 0000000000..b952de348b
--- /dev/null
+++ b/third_party/libwebrtc/examples/androidvoip/jni/onload.cc
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2020 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 <jni.h>
+
+#include "rtc_base/ssl_adapter.h"
+#include "sdk/android/native_api/base/init.h"
+
+namespace webrtc_examples {
+
+extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM* jvm, void* reserved) {
+ webrtc::InitAndroid(jvm);
+ RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
+ return JNI_VERSION_1_6;
+}
+
+extern "C" void JNIEXPORT JNICALL JNI_OnUnLoad(JavaVM* jvm, void* reserved) {
+ RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
+}
+
+} // namespace webrtc_examples