blob: 2ad95bcf8d034d56a66cc2d908190e4b3a5ccb85 [file] [log] [blame]
/*
* 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( \
RTC_FROM_HERE, \
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::AsyncSocket> socket(
thread->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
if (!socket) {
RTC_LOG_ERR(LERROR) << "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_NOTREACHED();
return -1;
}
} // namespace
namespace webrtc_examples {
bool 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_.
return voip_thread_->Invoke<bool>(RTC_FROM_HERE, [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));
if (!voip_engine_) {
RTC_LOG(LS_ERROR) << "VoipEngine creation failed";
return false;
}
return true;
});
}
AndroidVoipClient::~AndroidVoipClient() {
voip_thread_->Invoke<void>(RTC_FROM_HERE, [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));
if (!voip_client->Init(env, application_context)) {
return nullptr;
}
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) {
voip_engine_->Codec().SetSendCodec(
*channel_, GetPayloadType(codec.format.name), codec.format);
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(
RTC_FROM_HERE, [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});
}
}
voip_engine_->Codec().SetReceiveCodecs(*channel_, decoder_specs);
}
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(
RTC_FROM_HERE, [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(RTC_FROM_HERE, [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(RTC_FROM_HERE, [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);
channel_ = voip_engine_->Base().CreateChannel(this, absl::nullopt);
if (!channel_) {
RTC_LOG(LS_ERROR) << "Channel creation failed";
Java_VoipClient_onStartSessionCompleted(env_, j_voip_client_,
/*isSuccessful=*/false);
return;
}
rtp_socket_.reset(rtc::AsyncUDPSocket::Create(voip_thread_->socketserver(),
rtp_local_address_));
if (!rtp_socket_) {
RTC_LOG_ERR(LERROR) << "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(LERROR) << "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_) ||
!voip_engine_->Base().StopPlayout(*channel_)) {
Java_VoipClient_onStopSessionCompleted(env_, j_voip_client_,
/*isSuccessful=*/false);
return;
}
rtp_socket_->Close();
rtcp_socket_->Close();
voip_engine_->Base().ReleaseChannel(*channel_);
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;
}
Java_VoipClient_onStartSendCompleted(
env_, j_voip_client_, voip_engine_->Base().StartSend(*channel_));
}
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;
}
Java_VoipClient_onStopSendCompleted(env_, j_voip_client_,
voip_engine_->Base().StopSend(*channel_));
}
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;
}
Java_VoipClient_onStartPlayoutCompleted(
env_, j_voip_client_, voip_engine_->Base().StartPlayout(*channel_));
}
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;
}
Java_VoipClient_onStopPlayoutCompleted(
env_, j_voip_client_, voip_engine_->Base().StopPlayout(*channel_));
}
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(const uint8_t* packet,
size_t length,
const webrtc::PacketOptions& options) {
std::vector<uint8_t> packet_copy(packet, packet + length);
voip_thread_->PostTask(RTC_FROM_HERE,
[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(const uint8_t* packet, size_t length) {
std::vector<uint8_t> packet_copy(packet, packet + length);
voip_thread_->PostTask(RTC_FROM_HERE,
[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;
}
voip_engine_->Network().ReceivedRTPPacket(
*channel_,
rtc::ArrayView<const uint8_t>(packet_copy.data(), packet_copy.size()));
}
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(RTC_FROM_HERE,
[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;
}
voip_engine_->Network().ReceivedRTCPPacket(
*channel_,
rtc::ArrayView<const uint8_t>(packet_copy.data(), packet_copy.size()));
}
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(RTC_FROM_HERE,
[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