Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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