mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-20 09:07:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Reland "Remove jni_zero type aliases in jni_generator_helper.h."

Browse source 
This is a reland of commit 6cb7b3a424

Original change's description:
> Reland "Remove jni_zero type aliases in jni_generator_helper.h."
>
> This is a reland of commit 9fcaa034bc
>
> Original change's description:
> > Remove jni_zero type aliases in jni_generator_helper.h.
> >
> > This CL removes some type alias from
> > sdk/android/src/jni/jni_generator_helper.h and make sure all the
> > jni_zero types are referred to using the jni_zero:: namespace.
> >
> > The goal is to remove sdk/android/src/jni/jni_generator_helper.h
> > in future CLs.
> >
> > Bug: b/319078685, b/351773023
> > Change-Id: Ief60fce3e8f301f09ac5392d143aa5a82a445bcb
> > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/356882
> > Reviewed-by: Zoé Lepaul <xalep@webrtc.org>
> > Reviewed-by: Jeremy Leconte <jleconte@google.com>
> > Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
> > Cr-Commit-Position: refs/heads/main@{#42618}
>
> No-Presubmit: True
> Bug: b/319078685, b/351773023
> Change-Id: I605a726788ee84efdbdc9e75098b404cbd7c1f30
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/358922
> Reviewed-by: Zoé Lepaul <xalep@webrtc.org>
> Reviewed-by: Christoffer Dewerin <jansson@webrtc.org>
> Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#42751}

No-Presubmit: True
Bug: b/319078685, b/351773023
Change-Id: I8294d8c5c49bc330d8158684a60fd4e6c88627d8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/359320
Reviewed-by: Zoé Lepaul <xalep@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Mohamed Heikal <mheikal@google.com>
Reviewed-by: Christoffer Dewerin <jansson@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42768}
This commit is contained in:
Mirko Bonadei 2024-08-09 09:35:11 +00:00 committed by WebRTC LUCI CQ
parent d224ff2c08
commit 1ceff3d442
43 changed files with 598 additions and 503 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
examples/androidvoip/DEPS
View file

@ -1,3 +1,4 @@
include_rules = [
"+sdk/android/native_api",
"+third_party/jni_zero",
]

20
examples/androidvoip/jni/android_voip_client.cc
View file

@ -122,7 +122,7 @@ namespace webrtc_examples {
void AndroidVoipClient::Init(
JNIEnv* env,
const webrtc::JavaParamRef<jobject>& application_context) {
const jni_zero::JavaParamRef<jobject>& application_context) {
webrtc::VoipEngineConfig config;
config.encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
config.decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
@ -166,8 +166,8 @@ AndroidVoipClient::~AndroidVoipClient() {
AndroidVoipClient* AndroidVoipClient::Create(
JNIEnv* env,
const webrtc::JavaParamRef<jobject>& application_context,
const webrtc::JavaParamRef<jobject>& j_voip_client) {
const jni_zero::JavaParamRef<jobject>& application_context,
const jni_zero::JavaParamRef<jobject>& j_voip_client) {
// Using `new` to access a non-public constructor.
auto voip_client =
absl::WrapUnique(new AndroidVoipClient(env, j_voip_client));
@ -182,7 +182,7 @@ void AndroidVoipClient::GetSupportedCodecs(JNIEnv* env) {
for (const webrtc::AudioCodecSpec& spec : supported_codecs_) {
names.push_back(spec.format.name);
}
webrtc::ScopedJavaLocalRef<jstring> (*convert_function)(
jni_zero::ScopedJavaLocalRef<jstring> (*convert_function)(
JNIEnv*, const std::string&) = &webrtc::NativeToJavaString;
Java_VoipClient_onGetSupportedCodecsCompleted(
env_, j_voip_client_,
@ -225,7 +225,7 @@ void AndroidVoipClient::SetEncoder(const std::string& encoder) {
void AndroidVoipClient::SetEncoder(
JNIEnv* env,
const webrtc::JavaParamRef<jstring>& j_encoder_string) {
const jni_zero::JavaParamRef<jstring>& j_encoder_string) {
const std::string& chosen_encoder =
webrtc::JavaToNativeString(env, j_encoder_string);
voip_thread_->PostTask(
@ -254,7 +254,7 @@ void AndroidVoipClient::SetDecoders(const std::vector<std::string>& decoders) {
void AndroidVoipClient::SetDecoders(
JNIEnv* env,
const webrtc::JavaParamRef<jobject>& j_decoder_strings) {
const jni_zero::JavaParamRef<jobject>& j_decoder_strings) {
const std::vector<std::string>& chosen_decoders =
webrtc::JavaListToNativeVector<std::string, jstring>(
env, j_decoder_strings, &webrtc::JavaToNativeString);
@ -272,7 +272,7 @@ void AndroidVoipClient::SetLocalAddress(const std::string& ip_address,
void AndroidVoipClient::SetLocalAddress(
JNIEnv* env,
const webrtc::JavaParamRef<jstring>& j_ip_address_string,
const jni_zero::JavaParamRef<jstring>& j_ip_address_string,
jint j_port_number_int) {
const std::string& ip_address =
webrtc::JavaToNativeString(env, j_ip_address_string);
@ -291,7 +291,7 @@ void AndroidVoipClient::SetRemoteAddress(const std::string& ip_address,
void AndroidVoipClient::SetRemoteAddress(
JNIEnv* env,
const webrtc::JavaParamRef<jstring>& j_ip_address_string,
const jni_zero::JavaParamRef<jstring>& j_ip_address_string,
jint j_port_number_int) {
const std::string& ip_address =
webrtc::JavaToNativeString(env, j_ip_address_string);
@ -508,8 +508,8 @@ void AndroidVoipClient::OnSignalReadRTCPPacket(
static jlong JNI_VoipClient_CreateClient(
JNIEnv* env,
const webrtc::JavaParamRef<jobject>& application_context,
const webrtc::JavaParamRef<jobject>& j_voip_client) {
const jni_zero::JavaParamRef<jobject>& application_context,
const jni_zero::JavaParamRef<jobject>& j_voip_client) {
return webrtc::NativeToJavaPointer(
AndroidVoipClient::Create(env, application_context, j_voip_client));
}

23
examples/androidvoip/jni/android_voip_client.h
View file

@ -49,8 +49,8 @@ class AndroidVoipClient : public webrtc::Transport {
// 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);
const jni_zero::JavaParamRef<jobject>& application_context,
const jni_zero::JavaParamRef<jobject>& j_voip_client);
~AndroidVoipClient() override;
@ -66,22 +66,23 @@ class AndroidVoipClient : public webrtc::Transport {
// Sets the encoder used by the VoIP API.
void SetEncoder(JNIEnv* env,
const webrtc::JavaParamRef<jstring>& j_encoder_string);
const jni_zero::JavaParamRef<jstring>& j_encoder_string);
// Sets the decoders used by the VoIP API.
void SetDecoders(JNIEnv* env,
const webrtc::JavaParamRef<jobject>& j_decoder_strings);
const jni_zero::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 SetLocalAddress(
JNIEnv* env,
const jni_zero::JavaParamRef<jstring>& j_ip_address_string,
jint j_port_number_int);
void SetRemoteAddress(
JNIEnv* env,
const webrtc::JavaParamRef<jstring>& j_ip_address_string,
const jni_zero::JavaParamRef<jstring>& j_ip_address_string,
jint j_port_number_int);
// Starts a VoIP session, then calls a callback method with a boolean
@ -128,12 +129,12 @@ class AndroidVoipClient : public webrtc::Transport {
private:
AndroidVoipClient(JNIEnv* env,
const webrtc::JavaParamRef<jobject>& j_voip_client)
const jni_zero::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);
const jni_zero::JavaParamRef<jobject>& application_context);
// Overloaded methods having native C++ variables as arguments.
void SetEncoder(const std::string& encoder);
@ -153,7 +154,7 @@ class AndroidVoipClient : public webrtc::Transport {
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_
jni_zero::ScopedJavaGlobalRef<jobject> j_voip_client_
RTC_GUARDED_BY(voip_thread_);
// A list of AudioCodecSpec supported by the built-in
// encoder/decoder factories.

11
sdk/android/BUILD.gn
View file

@ -589,6 +589,7 @@ if (current_os == "linux" || is_android) {
"../../system_wrappers:metrics",
"//third_party/abseil-cpp/absl/strings:string_view",
"//third_party/abseil-cpp/absl/types:optional",
"//third_party/jni_zero",
]
}
@ -690,6 +691,7 @@ if (current_os == "linux" || is_android) {
"../../rtc_base/synchronization:mutex",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
"//third_party/jni_zero",
"//third_party/libyuv",
]
}
@ -810,6 +812,7 @@ if (current_os == "linux" || is_android) {
"../../system_wrappers:field_trial",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
"//third_party/jni_zero",
]
}
@ -822,6 +825,7 @@ if (current_os == "linux" || is_android) {
":base_jni",
":generated_java_audio_jni",
":java_audio_device_module",
"//third_party/jni_zero",
]
}
@ -917,6 +921,7 @@ if (current_os == "linux" || is_android) {
"../../api/video_codecs:builtin_video_decoder_factory",
"../../api/video_codecs:builtin_video_encoder_factory",
"../../api/video_codecs:video_codecs_api",
"//third_party/jni_zero",
]
}
@ -996,6 +1001,7 @@ if (current_os == "linux" || is_android) {
"../../rtc_base:refcount",
"../../system_wrappers",
"../../system_wrappers:metrics",
"//third_party/jni_zero",
]
if (rtc_enable_android_aaudio) {
deps += [ ":aaudio_audio_device_module" ]
@ -1018,6 +1024,7 @@ if (current_os == "linux" || is_android) {
":video_jni",
"//api/video_codecs:video_codecs_api",
"//rtc_base:checks",
"//third_party/jni_zero",
]
}
@ -1031,6 +1038,7 @@ if (current_os == "linux" || is_android) {
deps = [
":base_jni",
"../../rtc_base:threading",
"//third_party/jni_zero",
]
}
@ -1090,6 +1098,7 @@ if (current_os == "linux" || is_android) {
"//api:media_stream_interface",
"//api/video:video_frame",
"//api/video:video_rtp_headers",
"//third_party/jni_zero",
]
}
@ -1209,6 +1218,7 @@ if (current_os == "linux" || is_android) {
"../../system_wrappers:field_trial",
"../../system_wrappers:metrics",
"//third_party/abseil-cpp/absl/types:optional",
"//third_party/jni_zero",
]
}
@ -1601,6 +1611,7 @@ if (is_android) {
":videoframe_jni",
"../../api/video:video_frame",
"../../rtc_base:logging",
"//third_party/jni_zero",
]
}

3
sdk/android/instrumentationtests/DEPS Normal file
View file

@ -0,0 +1,3 @@
include_rules = [
"+third_party/jni_zero",
]

3
sdk/android/instrumentationtests/loggable_test.cc
View file

@ -13,6 +13,7 @@
#include "rtc_base/logging.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -23,7 +24,7 @@ JNI_FUNCTION_DECLARATION(void,
jclass,
jstring j_message) {
std::string message =
JavaToNativeString(jni, JavaParamRef<jstring>(jni, j_message));
JavaToNativeString(jni, jni_zero::JavaParamRef<jstring>(jni, j_message));
RTC_LOG(LS_INFO) << message;
}

6
sdk/android/instrumentationtests/video_frame_buffer_test.cc
View file

@ -12,6 +12,7 @@
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/video_frame.h"
#include "sdk/android/src/jni/wrapped_native_i420_buffer.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -21,7 +22,8 @@ JNI_FUNCTION_DECLARATION(jint,
JNIEnv* jni,
jclass,
jobject video_frame_buffer) {
const JavaParamRef<jobject> j_video_frame_buffer(jni, video_frame_buffer);
const jni_zero::JavaParamRef<jobject> j_video_frame_buffer(
jni, video_frame_buffer);
rtc::scoped_refptr<VideoFrameBuffer> buffer =
JavaToNativeFrameBuffer(jni, j_video_frame_buffer);
return static_cast<jint>(buffer->type());
@ -32,7 +34,7 @@ JNI_FUNCTION_DECLARATION(jobject,
JNIEnv* jni,
jclass,
jobject i420_buffer) {
const JavaParamRef<jobject> j_i420_buffer(jni, i420_buffer);
const jni_zero::JavaParamRef<jobject> j_i420_buffer(jni, i420_buffer);
rtc::scoped_refptr<VideoFrameBuffer> buffer =
JavaToNativeFrameBuffer(jni, j_i420_buffer);
const I420BufferInterface* inputBuffer = buffer->GetI420();

17
sdk/android/native_api/audio_device_module/audio_device_android.cc
View file

@ -31,6 +31,7 @@
#include "sdk/android/src/jni/audio_device/opensles_recorder.h"
#include "sdk/android/src/jni/jvm.h"
#include "system_wrappers/include/metrics.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
@ -40,8 +41,8 @@ void GetDefaultAudioParameters(JNIEnv* env,
jobject application_context,
AudioParameters* input_parameters,
AudioParameters* output_parameters) {
const JavaParamRef<jobject> j_context(env, application_context);
const ScopedJavaLocalRef<jobject> j_audio_manager =
const jni_zero::JavaParamRef<jobject> j_context(env, application_context);
const jni_zero::ScopedJavaLocalRef<jobject> j_audio_manager =
jni::GetAudioManager(env, j_context);
const int input_sample_rate = jni::GetDefaultSampleRate(env, j_audio_manager);
const int output_sample_rate =
@ -78,8 +79,8 @@ CreateJavaInputAndAAudioOutputAudioDeviceModule(JNIEnv* env,
jobject application_context) {
RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get default audio input/output parameters.
const JavaParamRef<jobject> j_context(env, application_context);
const ScopedJavaLocalRef<jobject> j_audio_manager =
const jni_zero::JavaParamRef<jobject> j_context(env, application_context);
const jni_zero::ScopedJavaLocalRef<jobject> j_audio_manager =
jni::GetAudioManager(env, j_context);
AudioParameters input_parameters;
AudioParameters output_parameters;
@ -104,8 +105,8 @@ rtc::scoped_refptr<AudioDeviceModule> CreateJavaAudioDeviceModule(
jobject application_context) {
RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get default audio input/output parameters.
const JavaParamRef<jobject> j_context(env, application_context);
const ScopedJavaLocalRef<jobject> j_audio_manager =
const jni_zero::JavaParamRef<jobject> j_context(env, application_context);
const jni_zero::ScopedJavaLocalRef<jobject> j_audio_manager =
jni::GetAudioManager(env, j_context);
AudioParameters input_parameters;
AudioParameters output_parameters;
@ -155,8 +156,8 @@ CreateJavaInputAndOpenSLESOutputAudioDeviceModule(JNIEnv* env,
jobject application_context) {
RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get default audio input/output parameters.
const JavaParamRef<jobject> j_context(env, application_context);
const ScopedJavaLocalRef<jobject> j_audio_manager =
const jni_zero::JavaParamRef<jobject> j_context(env, application_context);
const jni_zero::ScopedJavaLocalRef<jobject> j_audio_manager =
jni::GetAudioManager(env, j_context);
AudioParameters input_parameters;
AudioParameters output_parameters;

9
sdk/android/native_api/codecs/wrapper.cc
View file

@ -17,33 +17,34 @@
#include "sdk/android/src/jni/video_decoder_factory_wrapper.h"
#include "sdk/android/src/jni/video_encoder_factory_wrapper.h"
#include "sdk/android/src/jni/video_encoder_wrapper.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
SdpVideoFormat JavaToNativeVideoCodecInfo(JNIEnv* jni, jobject codec_info) {
return jni::VideoCodecInfoToSdpVideoFormat(
jni, JavaParamRef<jobject>(jni, codec_info));
jni, jni_zero::JavaParamRef<jobject>(jni, codec_info));
}
std::unique_ptr<VideoDecoderFactory> JavaToNativeVideoDecoderFactory(
JNIEnv* jni,
jobject decoder_factory) {
return std::make_unique<jni::VideoDecoderFactoryWrapper>(
jni, JavaParamRef<jobject>(jni, decoder_factory));
jni, jni_zero::JavaParamRef<jobject>(jni, decoder_factory));
}
std::unique_ptr<VideoEncoderFactory> JavaToNativeVideoEncoderFactory(
JNIEnv* jni,
jobject encoder_factory) {
return std::make_unique<jni::VideoEncoderFactoryWrapper>(
jni, JavaParamRef<jobject>(jni, encoder_factory));
jni, jni_zero::JavaParamRef<jobject>(jni, encoder_factory));
}
std::vector<VideoEncoder::ResolutionBitrateLimits>
JavaToNativeResolutionBitrateLimits(JNIEnv* jni,
const jobjectArray j_bitrate_limits_array) {
return jni::JavaToNativeResolutionBitrateLimits(
jni, JavaParamRef<jobjectArray>(jni, j_bitrate_limits_array));
jni, jni_zero::JavaParamRef<jobjectArray>(jni, j_bitrate_limits_array));
}
} // namespace webrtc

91
sdk/android/native_api/jni/java_types.cc
View file

@ -25,10 +25,11 @@
#include "sdk/android/generated_external_classes_jni/Long_jni.h"
#include "sdk/android/generated_external_classes_jni/Map_jni.h"
#include "sdk/android/generated_native_api_jni/JniHelper_jni.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
Iterable::Iterable(JNIEnv* jni, const JavaRef<jobject>& iterable)
Iterable::Iterable(JNIEnv* jni, const jni_zero::JavaRef<jobject>& iterable)
: jni_(jni), iterable_(jni, iterable) {}
Iterable::Iterable(Iterable&& other) = default;
@ -39,7 +40,8 @@ Iterable::~Iterable() = default;
Iterable::Iterator::Iterator() = default;
// Creates an iterator pointing to the beginning of the specified collection.
Iterable::Iterator::Iterator(JNIEnv* jni, const JavaRef<jobject>& iterable)
Iterable::Iterator::Iterator(JNIEnv* jni,
const jni_zero::JavaRef<jobject>& iterable)
: jni_(jni) {
iterator_ = JNI_Iterable::Java_Iterable_iterator(jni, iterable);
RTC_CHECK(!iterator_.is_null());
@ -99,36 +101,40 @@ bool Iterable::Iterator::AtEnd() const {
return jni_ == nullptr || IsNull(jni_, iterator_);
}
bool IsNull(JNIEnv* jni, const JavaRef<jobject>& obj) {
bool IsNull(JNIEnv* jni, const jni_zero::JavaRef<jobject>& obj) {
return jni->IsSameObject(obj.obj(), nullptr);
}
std::string GetJavaEnumName(JNIEnv* jni, const JavaRef<jobject>& j_enum) {
std::string GetJavaEnumName(JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_enum) {
return JavaToStdString(jni, JNI_Enum::Java_Enum_name(jni, j_enum));
}
Iterable GetJavaMapEntrySet(JNIEnv* jni, const JavaRef<jobject>& j_map) {
Iterable GetJavaMapEntrySet(JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_map) {
return Iterable(jni, JNI_Map::Java_Map_entrySet(jni, j_map));
}
ScopedJavaLocalRef<jobject> GetJavaMapEntryKey(
JNIEnv* jni,
const JavaRef<jobject>& j_entry) {
const jni_zero::JavaRef<jobject>& j_entry) {
return jni::Java_JniHelper_getKey(jni, j_entry);
}
ScopedJavaLocalRef<jobject> GetJavaMapEntryValue(
JNIEnv* jni,
const JavaRef<jobject>& j_entry) {
const jni_zero::JavaRef<jobject>& j_entry) {
return jni::Java_JniHelper_getValue(jni, j_entry);
}
int64_t JavaToNativeLong(JNIEnv* env, const JavaRef<jobject>& j_long) {
int64_t JavaToNativeLong(JNIEnv* env,
const jni_zero::JavaRef<jobject>& j_long) {
return JNI_Long::Java_Long_longValue(env, j_long);
}
absl::optional<bool> JavaToNativeOptionalBool(JNIEnv* jni,
const JavaRef<jobject>& boolean) {
absl::optional<bool> JavaToNativeOptionalBool(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& boolean) {
if (IsNull(jni, boolean))
return absl::nullopt;
return JNI_Boolean::Java_Boolean_booleanValue(jni, boolean);
@ -136,7 +142,7 @@ absl::optional<bool> JavaToNativeOptionalBool(JNIEnv* jni,
absl::optional<double> JavaToNativeOptionalDouble(
JNIEnv* jni,
const JavaRef<jobject>& j_double) {
const jni_zero::JavaRef<jobject>& j_double) {
if (IsNull(jni, j_double))
return absl::nullopt;
return JNI_Double::Java_Double_doubleValue(jni, j_double);
@ -144,15 +150,16 @@ absl::optional<double> JavaToNativeOptionalDouble(
absl::optional<int32_t> JavaToNativeOptionalInt(
JNIEnv* jni,
const JavaRef<jobject>& integer) {
const jni_zero::JavaRef<jobject>& integer) {
if (IsNull(jni, integer))
return absl::nullopt;
return JNI_Integer::Java_Integer_intValue(jni, integer);
}
// Given a jstring, reinterprets it to a new native string.
std::string JavaToNativeString(JNIEnv* jni, const JavaRef<jstring>& j_string) {
const ScopedJavaLocalRef<jbyteArray> j_byte_array =
std::string JavaToNativeString(JNIEnv* jni,
const jni_zero::JavaRef<jstring>& j_string) {
const jni_zero::ScopedJavaLocalRef<jbyteArray> j_byte_array =
jni::Java_JniHelper_getStringBytes(jni, j_string);
const size_t len = jni->GetArrayLength(j_byte_array.obj());
@ -166,11 +173,11 @@ std::string JavaToNativeString(JNIEnv* jni, const JavaRef<jstring>& j_string) {
std::map<std::string, std::string> JavaToNativeStringMap(
JNIEnv* jni,
const JavaRef<jobject>& j_map) {
const jni_zero::JavaRef<jobject>& j_map) {
return JavaToNativeMap<std::string, std::string>(
jni, j_map,
[](JNIEnv* env, JavaRef<jobject> const& key,
JavaRef<jobject> const& value) {
[](JNIEnv* env, jni_zero::JavaRef<jobject> const& key,
jni_zero::JavaRef<jobject> const& value) {
return std::make_pair(
JavaToNativeString(env, static_java_ref_cast<jstring>(env, key)),
JavaToNativeString(env, static_java_ref_cast<jstring>(env, value)));
@ -196,7 +203,7 @@ ScopedJavaLocalRef<jobject> NativeToJavaLong(JNIEnv* env, int64_t u) {
ScopedJavaLocalRef<jstring> NativeToJavaString(JNIEnv* env, const char* str) {
jstring j_str = env->NewStringUTF(str);
CHECK_EXCEPTION(env) << "error during NewStringUTF";
return ScopedJavaLocalRef<jstring>(env, j_str);
return jni_zero::ScopedJavaLocalRef<jstring>(env, j_str);
}
ScopedJavaLocalRef<jstring> NativeToJavaString(JNIEnv* jni,
@ -225,8 +232,8 @@ ScopedJavaLocalRef<jstring> NativeToJavaString(
ScopedJavaLocalRef<jbyteArray> NativeToJavaByteArray(
JNIEnv* env,
rtc::ArrayView<int8_t> container) {
ScopedJavaLocalRef<jbyteArray> jarray(env,
env->NewByteArray(container.size()));
jni_zero::ScopedJavaLocalRef<jbyteArray> jarray(
env, env->NewByteArray(container.size()));
int8_t* array_ptr =
env->GetByteArrayElements(jarray.obj(), /*isCopy=*/nullptr);
memcpy(array_ptr, container.data(), container.size() * sizeof(int8_t));
@ -237,7 +244,8 @@ ScopedJavaLocalRef<jbyteArray> NativeToJavaByteArray(
ScopedJavaLocalRef<jintArray> NativeToJavaIntArray(
JNIEnv* env,
rtc::ArrayView<int32_t> container) {
ScopedJavaLocalRef<jintArray> jarray(env, env->NewIntArray(container.size()));
jni_zero::ScopedJavaLocalRef<jintArray> jarray(
env, env->NewIntArray(container.size()));
int32_t* array_ptr =
env->GetIntArrayElements(jarray.obj(), /*isCopy=*/nullptr);
memcpy(array_ptr, container.data(), container.size() * sizeof(int32_t));
@ -245,8 +253,9 @@ ScopedJavaLocalRef<jintArray> NativeToJavaIntArray(
return jarray;
}
std::vector<int8_t> JavaToNativeByteArray(JNIEnv* env,
const JavaRef<jbyteArray>& jarray) {
std::vector<int8_t> JavaToNativeByteArray(
JNIEnv* env,
const jni_zero::JavaRef<jbyteArray>& jarray) {
int8_t* array_ptr =
env->GetByteArrayElements(jarray.obj(), /*isCopy=*/nullptr);
size_t array_length = env->GetArrayLength(jarray.obj());
@ -255,8 +264,9 @@ std::vector<int8_t> JavaToNativeByteArray(JNIEnv* env,
return container;
}
std::vector<int32_t> JavaToNativeIntArray(JNIEnv* env,
const JavaRef<jintArray>& jarray) {
std::vector<int32_t> JavaToNativeIntArray(
JNIEnv* env,
const jni_zero::JavaRef<jintArray>& jarray) {
int32_t* array_ptr =
env->GetIntArrayElements(jarray.obj(), /*isCopy=*/nullptr);
size_t array_length = env->GetArrayLength(jarray.obj());
@ -265,8 +275,9 @@ std::vector<int32_t> JavaToNativeIntArray(JNIEnv* env,
return container;
}
std::vector<float> JavaToNativeFloatArray(JNIEnv* env,
const JavaRef<jfloatArray>& jarray) {
std::vector<float> JavaToNativeFloatArray(
JNIEnv* env,
const jni_zero::JavaRef<jfloatArray>& jarray) {
// jfloat is a "machine-dependent native type" which represents a 32-bit
// float. C++ makes no guarantees about the size of floating point types, and
// some exotic architectures don't even have 32-bit floats (or even binary
@ -290,7 +301,7 @@ ScopedJavaLocalRef<jobjectArray> NativeToJavaBooleanArray(
ScopedJavaLocalRef<jobjectArray> NativeToJavaDoubleArray(
JNIEnv* env,
const std::vector<double>& container) {
ScopedJavaLocalRef<jobject> (*convert_function)(JNIEnv*, double) =
jni_zero::ScopedJavaLocalRef<jobject> (*convert_function)(JNIEnv*, double) =
&NativeToJavaDouble;
return NativeToJavaObjectArray(env, container, java_lang_Double_clazz(env),
convert_function);
@ -299,7 +310,7 @@ ScopedJavaLocalRef<jobjectArray> NativeToJavaDoubleArray(
ScopedJavaLocalRef<jobjectArray> NativeToJavaIntegerArray(
JNIEnv* env,
const std::vector<int32_t>& container) {
ScopedJavaLocalRef<jobject> (*convert_function)(JNIEnv*, int32_t) =
jni_zero::ScopedJavaLocalRef<jobject> (*convert_function)(JNIEnv*, int32_t) =
&NativeToJavaInteger;
return NativeToJavaObjectArray(env, container, java_lang_Integer_clazz(env),
convert_function);
@ -315,8 +326,8 @@ ScopedJavaLocalRef<jobjectArray> NativeToJavaLongArray(
ScopedJavaLocalRef<jobjectArray> NativeToJavaStringArray(
JNIEnv* env,
const std::vector<std::string>& container) {
ScopedJavaLocalRef<jstring> (*convert_function)(JNIEnv*, const std::string&) =
&NativeToJavaString;
jni_zero::ScopedJavaLocalRef<jstring> (*convert_function)(
JNIEnv*, const std::string&) = &NativeToJavaString;
return NativeToJavaObjectArray(
env, container,
static_cast<jclass>(jni::Java_JniHelper_getStringClass(env).obj()),
@ -329,7 +340,7 @@ JavaListBuilder::JavaListBuilder(JNIEnv* env)
JavaListBuilder::~JavaListBuilder() = default;
void JavaListBuilder::add(const JavaRef<jobject>& element) {
void JavaListBuilder::add(const jni_zero::JavaRef<jobject>& element) {
JNI_ArrayList::Java_ArrayList_add(env_, j_list_, element);
}
@ -340,8 +351,8 @@ JavaMapBuilder::JavaMapBuilder(JNIEnv* env)
JavaMapBuilder::~JavaMapBuilder() = default;
void JavaMapBuilder::put(const JavaRef<jobject>& key,
const JavaRef<jobject>& value) {
void JavaMapBuilder::put(const jni_zero::JavaRef<jobject>& key,
const jni_zero::JavaRef<jobject>& value) {
JNI_Map::Java_Map_put(env_, j_map_, key, value);
}
@ -357,13 +368,15 @@ jlong NativeToJavaPointer(const void* ptr) {
}
// Given a list of jstrings, reinterprets it to a new vector of native strings.
std::vector<std::string> JavaToStdVectorStrings(JNIEnv* jni,
const JavaRef<jobject>& list) {
std::vector<std::string> JavaToStdVectorStrings(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& list) {
std::vector<std::string> converted_list;
if (!list.is_null()) {
for (const JavaRef<jobject>& str : Iterable(jni, list)) {
converted_list.push_back(JavaToStdString(
jni, JavaParamRef<jstring>(jni, static_cast<jstring>(str.obj()))));
for (const jni_zero::JavaRef<jobject>& str : Iterable(jni, list)) {
converted_list.push_back(
JavaToStdString(jni, jni_zero::JavaParamRef<jstring>(
jni, static_cast<jstring>(str.obj()))));
}
}
return converted_list;

99
sdk/android/native_api/jni/java_types.h
View file

@ -52,7 +52,7 @@ namespace webrtc {
// Java iterator.
class Iterable {
public:
Iterable(JNIEnv* jni, const JavaRef<jobject>& iterable);
Iterable(JNIEnv* jni, const jni_zero::JavaRef<jobject>& iterable);
Iterable(Iterable&& other);
~Iterable();
@ -66,7 +66,7 @@ class Iterable {
Iterator();
// Creates an iterator pointing to the beginning of the specified
// collection.
Iterator(JNIEnv* jni, const JavaRef<jobject>& iterable);
Iterator(JNIEnv* jni, const jni_zero::JavaRef<jobject>& iterable);
// Move constructor - necessary to be able to return iterator types from
// functions.
@ -93,14 +93,14 @@ class Iterable {
// iterators.
bool operator==(const Iterator& other);
bool operator!=(const Iterator& other) { return !(*this == other); }
ScopedJavaLocalRef<jobject>& operator*();
jni_zero::ScopedJavaLocalRef<jobject>& operator*();
private:
bool AtEnd() const;
JNIEnv* jni_ = nullptr;
ScopedJavaLocalRef<jobject> iterator_;
ScopedJavaLocalRef<jobject> value_;
jni_zero::ScopedJavaLocalRef<jobject> iterator_;
jni_zero::ScopedJavaLocalRef<jobject> value_;
SequenceChecker thread_checker_;
};
@ -109,50 +109,56 @@ class Iterable {
private:
JNIEnv* jni_;
ScopedJavaLocalRef<jobject> iterable_;
jni_zero::ScopedJavaLocalRef<jobject> iterable_;
};
// Returns true if `obj` == null in Java.
bool IsNull(JNIEnv* jni, const JavaRef<jobject>& obj);
bool IsNull(JNIEnv* jni, const jni_zero::JavaRef<jobject>& obj);
// Returns the name of a Java enum.
std::string GetJavaEnumName(JNIEnv* jni, const JavaRef<jobject>& j_enum);
std::string GetJavaEnumName(JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_enum);
Iterable GetJavaMapEntrySet(JNIEnv* jni, const JavaRef<jobject>& j_map);
ScopedJavaLocalRef<jobject> GetJavaMapEntryKey(JNIEnv* jni,
const JavaRef<jobject>& j_entry);
Iterable GetJavaMapEntrySet(JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_map);
ScopedJavaLocalRef<jobject> GetJavaMapEntryKey(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_entry);
ScopedJavaLocalRef<jobject> GetJavaMapEntryValue(
JNIEnv* jni,
const JavaRef<jobject>& j_entry);
const jni_zero::JavaRef<jobject>& j_entry);
// --------------------------------------------------------
// -- Methods for converting Java types to native types. --
// --------------------------------------------------------
int64_t JavaToNativeLong(JNIEnv* env, const JavaRef<jobject>& j_long);
int64_t JavaToNativeLong(JNIEnv* env, const jni_zero::JavaRef<jobject>& j_long);
absl::optional<bool> JavaToNativeOptionalBool(JNIEnv* jni,
const JavaRef<jobject>& boolean);
absl::optional<bool> JavaToNativeOptionalBool(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& boolean);
absl::optional<double> JavaToNativeOptionalDouble(
JNIEnv* jni,
const JavaRef<jobject>& j_double);
const jni_zero::JavaRef<jobject>& j_double);
absl::optional<int32_t> JavaToNativeOptionalInt(
JNIEnv* jni,
const JavaRef<jobject>& integer);
const jni_zero::JavaRef<jobject>& integer);
// Given a (UTF-16) jstring return a new UTF-8 native string.
std::string JavaToNativeString(JNIEnv* jni, const JavaRef<jstring>& j_string);
std::string JavaToNativeString(JNIEnv* jni,
const jni_zero::JavaRef<jstring>& j_string);
template <typename T, typename Convert>
std::vector<T> JavaToNativeVector(JNIEnv* env,
const JavaRef<jobjectArray>& j_container,
Convert convert) {
std::vector<T> JavaToNativeVector(
JNIEnv* env,
const jni_zero::JavaRef<jobjectArray>& j_container,
Convert convert) {
std::vector<T> container;
const size_t size = env->GetArrayLength(j_container.obj());
container.reserve(size);
for (size_t i = 0; i < size; ++i) {
container.emplace_back(convert(
env, ScopedJavaLocalRef<jobject>(
env, jni_zero::ScopedJavaLocalRef<jobject>(
env, env->GetObjectArrayElement(j_container.obj(), i))));
}
CHECK_EXCEPTION(env) << "Error during JavaToNativeVector";
@ -161,7 +167,7 @@ std::vector<T> JavaToNativeVector(JNIEnv* env,
template <typename T, typename Java_T = jobject, typename Convert>
std::vector<T> JavaListToNativeVector(JNIEnv* env,
const JavaRef<jobject>& j_list,
const jni_zero::JavaRef<jobject>& j_list,
Convert convert) {
std::vector<T> native_list;
if (!j_list.is_null()) {
@ -176,7 +182,7 @@ std::vector<T> JavaListToNativeVector(JNIEnv* env,
template <typename Key, typename T, typename Convert>
std::map<Key, T> JavaToNativeMap(JNIEnv* env,
const JavaRef<jobject>& j_map,
const jni_zero::JavaRef<jobject>& j_map,
Convert convert) {
std::map<Key, T> container;
for (auto const& j_entry : GetJavaMapEntrySet(env, j_map)) {
@ -189,7 +195,7 @@ std::map<Key, T> JavaToNativeMap(JNIEnv* env,
// Converts Map<String, String> to std::map<std::string, std::string>.
std::map<std::string, std::string> JavaToNativeStringMap(
JNIEnv* env,
const JavaRef<jobject>& j_map);
const jni_zero::JavaRef<jobject>& j_map);
// --------------------------------------------------------
// -- Methods for converting native types to Java types. --
@ -220,7 +226,7 @@ ScopedJavaLocalRef<jobjectArray> NativeToJavaObjectArray(
const std::vector<T>& container,
jclass clazz,
Convert convert) {
ScopedJavaLocalRef<jobjectArray> j_container(
jni_zero::ScopedJavaLocalRef<jobjectArray> j_container(
env, env->NewObjectArray(container.size(), clazz, nullptr));
int i = 0;
for (const T& element : container) {
@ -238,12 +244,15 @@ ScopedJavaLocalRef<jintArray> NativeToJavaIntArray(
JNIEnv* env,
rtc::ArrayView<int32_t> container);
std::vector<int8_t> JavaToNativeByteArray(JNIEnv* env,
const JavaRef<jbyteArray>& jarray);
std::vector<int32_t> JavaToNativeIntArray(JNIEnv* env,
const JavaRef<jintArray>& jarray);
std::vector<float> JavaToNativeFloatArray(JNIEnv* env,
const JavaRef<jfloatArray>& jarray);
std::vector<int8_t> JavaToNativeByteArray(
JNIEnv* env,
const jni_zero::JavaRef<jbyteArray>& jarray);
std::vector<int32_t> JavaToNativeIntArray(
JNIEnv* env,
const jni_zero::JavaRef<jintArray>& jarray);
std::vector<float> JavaToNativeFloatArray(
JNIEnv* env,
const jni_zero::JavaRef<jfloatArray>& jarray);
ScopedJavaLocalRef<jobjectArray> NativeToJavaBooleanArray(
JNIEnv* env,
@ -267,12 +276,12 @@ class JavaListBuilder {
public:
explicit JavaListBuilder(JNIEnv* env);
~JavaListBuilder();
void add(const JavaRef<jobject>& element);
ScopedJavaLocalRef<jobject> java_list() { return j_list_; }
void add(const jni_zero::JavaRef<jobject>& element);
jni_zero::ScopedJavaLocalRef<jobject> java_list() { return j_list_; }
private:
JNIEnv* env_;
ScopedJavaLocalRef<jobject> j_list_;
jni_zero::ScopedJavaLocalRef<jobject> j_list_;
};
template <typename C, typename Convert>
@ -291,12 +300,13 @@ class JavaMapBuilder {
public:
explicit JavaMapBuilder(JNIEnv* env);
~JavaMapBuilder();
void put(const JavaRef<jobject>& key, const JavaRef<jobject>& value);
ScopedJavaLocalRef<jobject> GetJavaMap() { return j_map_; }
void put(const jni_zero::JavaRef<jobject>& key,
const jni_zero::JavaRef<jobject>& value);
jni_zero::ScopedJavaLocalRef<jobject> GetJavaMap() { return j_map_; }
private:
JNIEnv* env_;
ScopedJavaLocalRef<jobject> j_map_;
jni_zero::ScopedJavaLocalRef<jobject> j_map_;
};
template <typename C, typename Convert>
@ -334,33 +344,34 @@ jlong NativeToJavaPointer(const void* ptr);
// Deprecated. Use JavaToNativeString.
inline std::string JavaToStdString(JNIEnv* jni,
const JavaRef<jstring>& j_string) {
const jni_zero::JavaRef<jstring>& j_string) {
return JavaToNativeString(jni, j_string);
}
// Deprecated. Use scoped jobjects instead.
inline std::string JavaToStdString(JNIEnv* jni, jstring j_string) {
return JavaToStdString(jni, JavaParamRef<jstring>(jni, j_string));
return JavaToStdString(jni, jni_zero::JavaParamRef<jstring>(jni, j_string));
}
// Deprecated. Use JavaListToNativeVector<std::string, jstring> instead.
// Given a List of (UTF-16) jstrings
// return a new vector of UTF-8 native strings.
std::vector<std::string> JavaToStdVectorStrings(JNIEnv* jni,
const JavaRef<jobject>& list);
std::vector<std::string> JavaToStdVectorStrings(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& list);
// Deprecated. Use JavaToNativeStringMap instead.
// Parses Map<String, String> to std::map<std::string, std::string>.
inline std::map<std::string, std::string> JavaToStdMapStrings(
JNIEnv* jni,
const JavaRef<jobject>& j_map) {
const jni_zero::JavaRef<jobject>& j_map) {
return JavaToNativeStringMap(jni, j_map);
}
// Deprecated. Use scoped jobjects instead.
inline std::map<std::string, std::string> JavaToStdMapStrings(JNIEnv* jni,
jobject j_map) {
return JavaToStdMapStrings(jni, JavaParamRef<jobject>(jni, j_map));
return JavaToStdMapStrings(jni, jni_zero::JavaParamRef<jobject>(jni, j_map));
}
} // namespace webrtc

10
sdk/android/native_api/jni/scoped_java_ref.h
View file

@ -28,10 +28,12 @@ using jni_zero::ScopedJavaGlobalRef;
using jni_zero::ScopedJavaLocalRef;
template <typename T>
inline ScopedJavaLocalRef<T> static_java_ref_cast(JNIEnv* env,
JavaRef<jobject> const& ref) {
ScopedJavaLocalRef<jobject> owned_ref(env, ref);
return ScopedJavaLocalRef<T>(env, static_cast<T>(owned_ref.Release()));
inline jni_zero::ScopedJavaLocalRef<T> static_java_ref_cast(
JNIEnv* env,
jni_zero::JavaRef<jobject> const& ref) {
jni_zero::ScopedJavaLocalRef<jobject> owned_ref(env, ref);
return jni_zero::ScopedJavaLocalRef<T>(env,
static_cast<T>(owned_ref.Release()));
}
} // namespace webrtc

3
sdk/android/native_api/network_monitor/network_monitor.cc
View file

@ -13,6 +13,7 @@
#include <memory>
#include "sdk/android/src/jni/android_network_monitor.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
@ -20,7 +21,7 @@ std::unique_ptr<rtc::NetworkMonitorFactory> CreateAndroidNetworkMonitorFactory(
JNIEnv* env,
jobject application_context) {
return std::make_unique<jni::AndroidNetworkMonitorFactory>(
env, JavaParamRef<jobject>(env, application_context));
env, jni_zero::JavaParamRef<jobject>(env, application_context));
}
std::unique_ptr<rtc::NetworkMonitorFactory>

3
sdk/android/native_api/video/wrapper.cc
View file

@ -15,6 +15,7 @@
#include "sdk/android/native_api/jni/scoped_java_ref.h"
#include "sdk/android/src/jni/video_frame.h"
#include "sdk/android/src/jni/video_sink.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
@ -22,7 +23,7 @@ std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> JavaToNativeVideoSink(
JNIEnv* jni,
jobject video_sink) {
return std::make_unique<jni::VideoSinkWrapper>(
jni, JavaParamRef<jobject>(jni, video_sink));
jni, jni_zero::JavaParamRef<jobject>(jni, video_sink));
}
ScopedJavaLocalRef<jobject> NativeToJavaVideoFrame(JNIEnv* jni,

14
sdk/android/src/jni/android_histogram.cc
View file

@ -15,16 +15,18 @@
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "system_wrappers/include/metrics.h"
#include "third_party/jni_zero/jni_zero.h"
// Enables collection of native histograms and creating them.
namespace webrtc {
namespace jni {
static jlong JNI_Histogram_CreateCounts(JNIEnv* jni,
const JavaParamRef<jstring>& j_name,
jint min,
jint max,
jint buckets) {
static jlong JNI_Histogram_CreateCounts(
JNIEnv* jni,
const jni_zero::JavaParamRef<jstring>& j_name,
jint min,
jint max,
jint buckets) {
std::string name = JavaToStdString(jni, j_name);
return jlongFromPointer(
metrics::HistogramFactoryGetCounts(name, min, max, buckets));
@ -32,7 +34,7 @@ static jlong JNI_Histogram_CreateCounts(JNIEnv* jni,
static jlong JNI_Histogram_CreateEnumeration(
JNIEnv* jni,
const JavaParamRef<jstring>& j_name,
const jni_zero::JavaParamRef<jstring>& j_name,
jint max) {
std::string name = JavaToStdString(jni, j_name);
return jlongFromPointer(metrics::HistogramFactoryGetEnumeration(name, max));

20
sdk/android/src/jni/audio_device/audio_record_jni.cc
View file

@ -22,6 +22,7 @@
#include "sdk/android/src/jni/audio_device/audio_common.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "system_wrappers/include/metrics.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
@ -49,15 +50,15 @@ class ScopedHistogramTimer {
ScopedJavaLocalRef<jobject> AudioRecordJni::CreateJavaWebRtcAudioRecord(
JNIEnv* env,
const JavaRef<jobject>& j_context,
const JavaRef<jobject>& j_audio_manager) {
const jni_zero::JavaRef<jobject>& j_context,
const jni_zero::JavaRef<jobject>& j_audio_manager) {
return Java_WebRtcAudioRecord_Constructor(env, j_context, j_audio_manager);
}
AudioRecordJni::AudioRecordJni(JNIEnv* env,
const AudioParameters& audio_parameters,
int total_delay_ms,
const JavaRef<jobject>& j_audio_record)
const jni_zero::JavaRef<jobject>& j_audio_record)
: j_audio_record_(env, j_audio_record),
audio_parameters_(audio_parameters),
total_delay_ms_(total_delay_ms),
@ -229,8 +230,8 @@ int32_t AudioRecordJni::EnableBuiltInNS(bool enable) {
void AudioRecordJni::CacheDirectBufferAddress(
JNIEnv* env,
const JavaParamRef<jobject>& j_caller,
const JavaParamRef<jobject>& byte_buffer) {
const jni_zero::JavaParamRef<jobject>& j_caller,
const jni_zero::JavaParamRef<jobject>& byte_buffer) {
RTC_LOG(LS_INFO) << "OnCacheDirectBufferAddress";
RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_);
@ -242,10 +243,11 @@ void AudioRecordJni::CacheDirectBufferAddress(
// This method is called on a high-priority thread from Java. The name of
// the thread is 'AudioRecordThread'.
void AudioRecordJni::DataIsRecorded(JNIEnv* env,
const JavaParamRef<jobject>& j_caller,
int length,
int64_t capture_timestamp_ns) {
void AudioRecordJni::DataIsRecorded(
JNIEnv* env,
const jni_zero::JavaParamRef<jobject>& j_caller,
int length,
int64_t capture_timestamp_ns) {
RTC_DCHECK(thread_checker_java_.IsCurrent());
if (!audio_device_buffer_) {
RTC_LOG(LS_ERROR) << "AttachAudioBuffer has not been called";

19
sdk/android/src/jni/audio_device/audio_record_jni.h
View file

@ -44,15 +44,15 @@ namespace jni {
// thread is used.
class AudioRecordJni : public AudioInput {
public:
static ScopedJavaLocalRef<jobject> CreateJavaWebRtcAudioRecord(
static jni_zero::ScopedJavaLocalRef<jobject> CreateJavaWebRtcAudioRecord(
JNIEnv* env,
const JavaRef<jobject>& j_context,
const JavaRef<jobject>& j_audio_manager);
const jni_zero::JavaRef<jobject>& j_context,
const jni_zero::JavaRef<jobject>& j_audio_manager);
AudioRecordJni(JNIEnv* env,
const AudioParameters& audio_parameters,
int total_delay_ms,
const JavaRef<jobject>& j_webrtc_audio_record);
const jni_zero::JavaRef<jobject>& j_webrtc_audio_record);
~AudioRecordJni() override;
int32_t Init() override;
@ -78,9 +78,10 @@ class AudioRecordJni : public AudioInput {
// is also stored in `direct_buffer_capacity_in_bytes_`.
// This method will be called by the WebRtcAudioRecord constructor, i.e.,
// on the same thread that this object is created on.
void CacheDirectBufferAddress(JNIEnv* env,
const JavaParamRef<jobject>& j_caller,
const JavaParamRef<jobject>& byte_buffer);
void CacheDirectBufferAddress(
JNIEnv* env,
const jni_zero::JavaParamRef<jobject>& j_caller,
const jni_zero::JavaParamRef<jobject>& byte_buffer);
// Called periodically by the Java based WebRtcAudioRecord object when
// recording has started. Each call indicates that there are `length` new
@ -89,7 +90,7 @@ class AudioRecordJni : public AudioInput {
// This method is called on a high-priority thread from Java. The name of
// the thread is 'AudioRecordThread'.
void DataIsRecorded(JNIEnv* env,
const JavaParamRef<jobject>& j_caller,
const jni_zero::JavaParamRef<jobject>& j_caller,
int length,
int64_t capture_timestamp_ns);
@ -103,7 +104,7 @@ class AudioRecordJni : public AudioInput {
// Wraps the Java specific parts of the AudioRecordJni class.
JNIEnv* env_ = nullptr;
ScopedJavaGlobalRef<jobject> j_audio_record_;
jni_zero::ScopedJavaGlobalRef<jobject> j_audio_record_;
const AudioParameters audio_parameters_;

14
sdk/android/src/jni/audio_device/audio_track_jni.cc
View file

@ -20,6 +20,7 @@
#include "sdk/android/src/jni/jni_helpers.h"
#include "system_wrappers/include/field_trial.h"
#include "system_wrappers/include/metrics.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
@ -27,14 +28,15 @@ namespace jni {
ScopedJavaLocalRef<jobject> AudioTrackJni::CreateJavaWebRtcAudioTrack(
JNIEnv* env,
const JavaRef<jobject>& j_context,
const JavaRef<jobject>& j_audio_manager) {
const jni_zero::JavaRef<jobject>& j_context,
const jni_zero::JavaRef<jobject>& j_audio_manager) {
return Java_WebRtcAudioTrack_Constructor(env, j_context, j_audio_manager);
}
AudioTrackJni::AudioTrackJni(JNIEnv* env,
const AudioParameters& audio_parameters,
const JavaRef<jobject>& j_webrtc_audio_track)
AudioTrackJni::AudioTrackJni(
JNIEnv* env,
const AudioParameters& audio_parameters,
const jni_zero::JavaRef<jobject>& j_webrtc_audio_track)
: j_audio_track_(env, j_webrtc_audio_track),
audio_parameters_(audio_parameters),
direct_buffer_address_(nullptr),
@ -229,7 +231,7 @@ void AudioTrackJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
void AudioTrackJni::CacheDirectBufferAddress(
JNIEnv* env,
const JavaParamRef<jobject>& byte_buffer) {
const jni_zero::JavaParamRef<jobject>& byte_buffer) {
RTC_LOG(LS_INFO) << "OnCacheDirectBufferAddress";
RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_);

15
sdk/android/src/jni/audio_device/audio_track_jni.h
View file

@ -41,14 +41,14 @@ namespace jni {
// thread is used.
class AudioTrackJni : public AudioOutput {
public:
static ScopedJavaLocalRef<jobject> CreateJavaWebRtcAudioTrack(
static jni_zero::ScopedJavaLocalRef<jobject> CreateJavaWebRtcAudioTrack(
JNIEnv* env,
const JavaRef<jobject>& j_context,
const JavaRef<jobject>& j_audio_manager);
const jni_zero::JavaRef<jobject>& j_context,
const jni_zero::JavaRef<jobject>& j_audio_manager);
AudioTrackJni(JNIEnv* env,
const AudioParameters& audio_parameters,
const JavaRef<jobject>& j_webrtc_audio_track);
const jni_zero::JavaRef<jobject>& j_webrtc_audio_track);
~AudioTrackJni() override;
int32_t Init() override;
@ -74,8 +74,9 @@ class AudioTrackJni : public AudioOutput {
// `byte_buffer` in `direct_buffer_address_`. The size of the buffer
// is also stored in `direct_buffer_capacity_in_bytes_`.
// Called on the same thread as the creating thread.
void CacheDirectBufferAddress(JNIEnv* env,
const JavaParamRef<jobject>& byte_buffer);
void CacheDirectBufferAddress(
JNIEnv* env,
const jni_zero::JavaParamRef<jobject>& byte_buffer);
// Called periodically by the Java based WebRtcAudioTrack object when
// playout has started. Each call indicates that `length` new bytes should
// be written to the memory area `direct_buffer_address_` for playout.
@ -93,7 +94,7 @@ class AudioTrackJni : public AudioOutput {
// Wraps the Java specific parts of the AudioTrackJni class.
JNIEnv* env_ = nullptr;
ScopedJavaGlobalRef<jobject> j_audio_track_;
jni_zero::ScopedJavaGlobalRef<jobject> j_audio_track_;
// Contains audio parameters provided to this class at construction by the
// AudioManager.

9
sdk/android/src/jni/audio_device/java_audio_device_module.cc
View file

@ -14,16 +14,17 @@
#include "sdk/android/src/jni/audio_device/audio_record_jni.h"
#include "sdk/android/src/jni/audio_device/audio_track_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
static jlong JNI_JavaAudioDeviceModule_CreateAudioDeviceModule(
JNIEnv* env,
const JavaParamRef<jobject>& j_context,
const JavaParamRef<jobject>& j_audio_manager,
const JavaParamRef<jobject>& j_webrtc_audio_record,
const JavaParamRef<jobject>& j_webrtc_audio_track,
const jni_zero::JavaParamRef<jobject>& j_context,
const jni_zero::JavaParamRef<jobject>& j_audio_manager,
const jni_zero::JavaParamRef<jobject>& j_webrtc_audio_record,
const jni_zero::JavaParamRef<jobject>& j_webrtc_audio_track,
int input_sample_rate,
int output_sample_rate,
jboolean j_use_stereo_input,

5
sdk/android/src/jni/h264_utils.cc
View file

@ -11,14 +11,15 @@
#include "api/video_codecs/h264_profile_level_id.h"
#include "sdk/android/generated_video_jni/H264Utils_jni.h"
#include "sdk/android/src/jni/video_codec_info.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
static jboolean JNI_H264Utils_IsSameH264Profile(
JNIEnv* env,
const JavaParamRef<jobject>& params1,
const JavaParamRef<jobject>& params2) {
const jni_zero::JavaParamRef<jobject>& params1,
const jni_zero::JavaParamRef<jobject>& params2) {
return H264IsSameProfile(JavaToNativeStringMap(env, params1),
JavaToNativeStringMap(env, params2));
}

13
sdk/android/src/jni/java_i420_buffer.cc
View file

@ -10,6 +10,7 @@
#include "rtc_base/checks.h"
#include "sdk/android/generated_video_jni/JavaI420Buffer_jni.h"
#include "third_party/jni_zero/jni_zero.h"
#include "third_party/libyuv/include/libyuv/scale.h"
namespace webrtc {
@ -17,21 +18,21 @@ namespace jni {
static void JNI_JavaI420Buffer_CropAndScaleI420(
JNIEnv* jni,
const JavaParamRef<jobject>& j_src_y,
const jni_zero::JavaParamRef<jobject>& j_src_y,
jint src_stride_y,
const JavaParamRef<jobject>& j_src_u,
const jni_zero::JavaParamRef<jobject>& j_src_u,
jint src_stride_u,
const JavaParamRef<jobject>& j_src_v,
const jni_zero::JavaParamRef<jobject>& j_src_v,
jint src_stride_v,
jint crop_x,
jint crop_y,
jint crop_width,
jint crop_height,
const JavaParamRef<jobject>& j_dst_y,
const jni_zero::JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const JavaParamRef<jobject>& j_dst_u,
const jni_zero::JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const JavaParamRef<jobject>& j_dst_v,
const jni_zero::JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v,
jint scale_width,
jint scale_height) {

8
sdk/android/src/jni/jni_common.cc
View file

@ -11,6 +11,7 @@
#include "rtc_base/ref_count.h"
#include "sdk/android/generated_base_jni/JniCommon_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -25,15 +26,16 @@ static void JNI_JniCommon_ReleaseRef(JNIEnv* jni,
reinterpret_cast<RefCountInterface*>(j_native_ref_counted_pointer)->Release();
}
static ScopedJavaLocalRef<jobject> JNI_JniCommon_AllocateByteBuffer(JNIEnv* jni,
jint size) {
static jni_zero::ScopedJavaLocalRef<jobject> JNI_JniCommon_AllocateByteBuffer(
JNIEnv* jni,
jint size) {
void* new_data = ::operator new(size);
return NewDirectByteBuffer(jni, new_data, size);
}
static void JNI_JniCommon_FreeByteBuffer(
JNIEnv* jni,
const JavaParamRef<jobject>& byte_buffer) {
const jni_zero::JavaParamRef<jobject>& byte_buffer) {
void* data = jni->GetDirectBufferAddress(byte_buffer.obj());
::operator delete(data);
}

20
sdk/android/src/jni/jni_generator_helper.h
View file

@ -32,13 +32,6 @@
#define JNI_GENERATOR_EXPORT extern "C" JNIEXPORT JNICALL
#endif
namespace webrtc {
using jni_zero::JavaParamRef;
using jni_zero::JavaRef;
using jni_zero::ScopedJavaGlobalRef;
using jni_zero::ScopedJavaLocalRef;
} // namespace webrtc
// Re-export helpers in the old jni_generator namespace.
// TODO(b/319078685): Remove once all uses of the jni_generator has been
// updated.
@ -116,17 +109,4 @@ static_assert(sizeof(JniJavaCallContextChecked) ==
} // namespace jni_generator
// Re-export helpers in the namespaces that the old jni_generator script
// expects.
// TODO(b/319078685): Remove once all uses of the jni_generator has been
// updated.
namespace base {
namespace android {
using jni_zero::JavaParamRef;
using jni_zero::JavaRef;
using jni_zero::MethodID;
using jni_zero::ScopedJavaLocalRef;
using jni_zero::internal::LazyGetClass;
} // namespace android
} // namespace base
#endif // SDK_ANDROID_SRC_JNI_JNI_GENERATOR_HELPER_H_

38
sdk/android/src/jni/nv12_buffer.cc
View file

@ -14,30 +14,32 @@
#include "rtc_base/checks.h"
#include "sdk/android/generated_video_jni/NV12Buffer_jni.h"
#include "third_party/jni_zero/jni_zero.h"
#include "third_party/libyuv/include/libyuv/convert.h"
#include "third_party/libyuv/include/libyuv/scale.h"
namespace webrtc {
namespace jni {
static void JNI_NV12Buffer_CropAndScale(JNIEnv* jni,
jint crop_x,
jint crop_y,
jint crop_width,
jint crop_height,
jint scale_width,
jint scale_height,
const JavaParamRef<jobject>& j_src,
jint src_width,
jint src_height,
jint src_stride,
jint src_slice_height,
const JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v) {
static void JNI_NV12Buffer_CropAndScale(
JNIEnv* jni,
jint crop_x,
jint crop_y,
jint crop_width,
jint crop_height,
jint scale_width,
jint scale_height,
const jni_zero::JavaParamRef<jobject>& j_src,
jint src_width,
jint src_height,
jint src_stride,
jint src_slice_height,
const jni_zero::JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const jni_zero::JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const jni_zero::JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v) {
const int src_stride_y = src_stride;
const int src_stride_uv = src_stride;
const int crop_chroma_x = crop_x / 2;

34
sdk/android/src/jni/nv21_buffer.cc
View file

@ -15,28 +15,30 @@
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "rtc_base/checks.h"
#include "sdk/android/generated_video_jni/NV21Buffer_jni.h"
#include "third_party/jni_zero/jni_zero.h"
#include "third_party/libyuv/include/libyuv/convert.h"
#include "third_party/libyuv/include/libyuv/scale.h"
namespace webrtc {
namespace jni {
static void JNI_NV21Buffer_CropAndScale(JNIEnv* jni,
jint crop_x,
jint crop_y,
jint crop_width,
jint crop_height,
jint scale_width,
jint scale_height,
const JavaParamRef<jbyteArray>& j_src,
jint src_width,
jint src_height,
const JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v) {
static void JNI_NV21Buffer_CropAndScale(
JNIEnv* jni,
jint crop_x,
jint crop_y,
jint crop_width,
jint crop_height,
jint scale_width,
jint scale_height,
const jni_zero::JavaParamRef<jbyteArray>& j_src,
jint src_width,
jint src_height,
const jni_zero::JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const jni_zero::JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const jni_zero::JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v) {
const int src_stride_y = src_width;
const int src_stride_uv = src_width;
const int crop_chroma_x = crop_x / 2;

13
sdk/android/src/jni/pc/call_session_file_rotating_log_sink.cc
View file

@ -12,13 +12,14 @@
#include "sdk/android/generated_peerconnection_jni/CallSessionFileRotatingLogSink_jni.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
static jlong JNI_CallSessionFileRotatingLogSink_AddSink(
JNIEnv* jni,
const JavaParamRef<jstring>& j_dirPath,
const jni_zero::JavaParamRef<jstring>& j_dirPath,
jint j_maxFileSize,
jint j_severity) {
std::string dir_path = JavaToStdString(jni, j_dirPath);
@ -44,25 +45,25 @@ static void JNI_CallSessionFileRotatingLogSink_DeleteSink(JNIEnv* jni,
delete sink;
}
static ScopedJavaLocalRef<jbyteArray>
static jni_zero::ScopedJavaLocalRef<jbyteArray>
JNI_CallSessionFileRotatingLogSink_GetLogData(
JNIEnv* jni,
const JavaParamRef<jstring>& j_dirPath) {
const jni_zero::JavaParamRef<jstring>& j_dirPath) {
std::string dir_path = JavaToStdString(jni, j_dirPath);
rtc::CallSessionFileRotatingStreamReader file_reader(dir_path);
size_t log_size = file_reader.GetSize();
if (log_size == 0) {
RTC_LOG_V(rtc::LoggingSeverity::LS_WARNING)
<< "CallSessionFileRotatingStream returns 0 size for path " << dir_path;
return ScopedJavaLocalRef<jbyteArray>(jni, jni->NewByteArray(0));
return jni_zero::ScopedJavaLocalRef<jbyteArray>(jni, jni->NewByteArray(0));
}
// TODO(nisse, sakal): To avoid copying, change api to use ByteBuffer.
std::unique_ptr<jbyte> buffer(static_cast<jbyte*>(malloc(log_size)));
size_t read = file_reader.ReadAll(buffer.get(), log_size);
ScopedJavaLocalRef<jbyteArray> result =
ScopedJavaLocalRef<jbyteArray>(jni, jni->NewByteArray(read));
jni_zero::ScopedJavaLocalRef<jbyteArray> result =
jni_zero::ScopedJavaLocalRef<jbyteArray>(jni, jni->NewByteArray(read));
jni->SetByteArrayRegion(result.obj(), 0, read, buffer.get());
return result;

55
sdk/android/src/jni/pc/data_channel.cc
View file

@ -18,6 +18,7 @@
#include "sdk/android/generated_peerconnection_jni/DataChannel_jni.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -27,7 +28,8 @@ namespace {
// and dispatching the callback from C++ back to Java.
class DataChannelObserverJni : public DataChannelObserver {
public:
DataChannelObserverJni(JNIEnv* jni, const JavaRef<jobject>& j_observer);
DataChannelObserverJni(JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_observer);
~DataChannelObserverJni() override {}
void OnBufferedAmountChange(uint64_t previous_amount) override;
@ -35,12 +37,12 @@ class DataChannelObserverJni : public DataChannelObserver {
void OnMessage(const DataBuffer& buffer) override;
private:
const ScopedJavaGlobalRef<jobject> j_observer_global_;
const jni_zero::ScopedJavaGlobalRef<jobject> j_observer_global_;
};
DataChannelObserverJni::DataChannelObserverJni(
JNIEnv* jni,
const JavaRef<jobject>& j_observer)
const jni_zero::JavaRef<jobject>& j_observer)
: j_observer_global_(jni, j_observer) {}
void DataChannelObserverJni::OnBufferedAmountChange(uint64_t previous_amount) {
@ -56,23 +58,25 @@ void DataChannelObserverJni::OnStateChange() {
void DataChannelObserverJni::OnMessage(const DataBuffer& buffer) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedJavaLocalRef<jobject> byte_buffer = NewDirectByteBuffer(
jni_zero::ScopedJavaLocalRef<jobject> byte_buffer = NewDirectByteBuffer(
env, const_cast<char*>(buffer.data.data<char>()), buffer.data.size());
ScopedJavaLocalRef<jobject> j_buffer =
jni_zero::ScopedJavaLocalRef<jobject> j_buffer =
Java_Buffer_Constructor(env, byte_buffer, buffer.binary);
Java_Observer_onMessage(env, j_observer_global_, j_buffer);
}
DataChannelInterface* ExtractNativeDC(JNIEnv* jni,
const JavaParamRef<jobject>& j_dc) {
DataChannelInterface* ExtractNativeDC(
JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& j_dc) {
return reinterpret_cast<DataChannelInterface*>(
Java_DataChannel_getNativeDataChannel(jni, j_dc));
}
} // namespace
DataChannelInit JavaToNativeDataChannelInit(JNIEnv* env,
const JavaRef<jobject>& j_init) {
DataChannelInit JavaToNativeDataChannelInit(
JNIEnv* env,
const jni_zero::JavaRef<jobject>& j_init) {
DataChannelInit init;
init.ordered = Java_Init_getOrdered(env, j_init);
init.maxRetransmitTime = Java_Init_getMaxRetransmitTimeMs(env, j_init);
@ -94,8 +98,8 @@ ScopedJavaLocalRef<jobject> WrapNativeDataChannel(
static jlong JNI_DataChannel_RegisterObserver(
JNIEnv* jni,
const JavaParamRef<jobject>& j_dc,
const JavaParamRef<jobject>& j_observer) {
const jni_zero::JavaParamRef<jobject>& j_dc,
const jni_zero::JavaParamRef<jobject>& j_observer) {
auto observer = std::make_unique<DataChannelObserverJni>(jni, j_observer);
ExtractNativeDC(jni, j_dc)->RegisterObserver(observer.get());
return jlongFromPointer(observer.release());
@ -103,33 +107,35 @@ static jlong JNI_DataChannel_RegisterObserver(
static void JNI_DataChannel_UnregisterObserver(
JNIEnv* jni,
const JavaParamRef<jobject>& j_dc,
const jni_zero::JavaParamRef<jobject>& j_dc,
jlong native_observer) {
ExtractNativeDC(jni, j_dc)->UnregisterObserver();
delete reinterpret_cast<DataChannelObserverJni*>(native_observer);
}
static ScopedJavaLocalRef<jstring> JNI_DataChannel_Label(
static jni_zero::ScopedJavaLocalRef<jstring> JNI_DataChannel_Label(
JNIEnv* jni,
const JavaParamRef<jobject>& j_dc) {
const jni_zero::JavaParamRef<jobject>& j_dc) {
return NativeToJavaString(jni, ExtractNativeDC(jni, j_dc)->label());
}
static jint JNI_DataChannel_Id(JNIEnv* jni, const JavaParamRef<jobject>& j_dc) {
static jint JNI_DataChannel_Id(JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& j_dc) {
int id = ExtractNativeDC(jni, j_dc)->id();
RTC_CHECK_LE(id, std::numeric_limits<int32_t>::max())
<< "id overflowed jint!";
return static_cast<jint>(id);
}
static ScopedJavaLocalRef<jobject> JNI_DataChannel_State(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_DataChannel_State(
JNIEnv* jni,
const JavaParamRef<jobject>& j_dc) {
const jni_zero::JavaParamRef<jobject>& j_dc) {
return Java_State_fromNativeIndex(jni, ExtractNativeDC(jni, j_dc)->state());
}
static jlong JNI_DataChannel_BufferedAmount(JNIEnv* jni,
const JavaParamRef<jobject>& j_dc) {
static jlong JNI_DataChannel_BufferedAmount(
JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& j_dc) {
uint64_t buffered_amount = ExtractNativeDC(jni, j_dc)->buffered_amount();
RTC_CHECK_LE(buffered_amount, std::numeric_limits<int64_t>::max())
<< "buffered_amount overflowed jlong!";
@ -137,14 +143,15 @@ static jlong JNI_DataChannel_BufferedAmount(JNIEnv* jni,
}
static void JNI_DataChannel_Close(JNIEnv* jni,
const JavaParamRef<jobject>& j_dc) {
const jni_zero::JavaParamRef<jobject>& j_dc) {
ExtractNativeDC(jni, j_dc)->Close();
}
static jboolean JNI_DataChannel_Send(JNIEnv* jni,
const JavaParamRef<jobject>& j_dc,
const JavaParamRef<jbyteArray>& data,
jboolean binary) {
static jboolean JNI_DataChannel_Send(
JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& j_dc,
const jni_zero::JavaParamRef<jbyteArray>& data,
jboolean binary) {
std::vector<int8_t> buffer = JavaToNativeByteArray(jni, data);
bool ret = ExtractNativeDC(jni, j_dc)->Send(
DataBuffer(rtc::CopyOnWriteBuffer(buffer.data(), buffer.size()), binary));

14
sdk/android/src/jni/pc/dtmf_sender.cc
View file

@ -12,6 +12,7 @@
#include "sdk/android/generated_peerconnection_jni/DtmfSender_jni.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -22,16 +23,17 @@ static jboolean JNI_DtmfSender_CanInsertDtmf(JNIEnv* jni,
->CanInsertDtmf();
}
static jboolean JNI_DtmfSender_InsertDtmf(JNIEnv* jni,
jlong j_dtmf_sender_pointer,
const JavaParamRef<jstring>& tones,
jint duration,
jint inter_tone_gap) {
static jboolean JNI_DtmfSender_InsertDtmf(
JNIEnv* jni,
jlong j_dtmf_sender_pointer,
const jni_zero::JavaParamRef<jstring>& tones,
jint duration,
jint inter_tone_gap) {
return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
->InsertDtmf(JavaToStdString(jni, tones), duration, inter_tone_gap);
}
static ScopedJavaLocalRef<jstring> JNI_DtmfSender_Tones(
static jni_zero::ScopedJavaLocalRef<jstring> JNI_DtmfSender_Tones(
JNIEnv* jni,
jlong j_dtmf_sender_pointer) {
return NativeToJavaString(

6
sdk/android/src/jni/pc/logging.cc
View file

@ -14,6 +14,7 @@
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -51,8 +52,9 @@ JNI_FUNCTION_DECLARATION(void,
jstring j_tag,
jstring j_message) {
std::string message =
JavaToStdString(jni, JavaParamRef<jstring>(jni, j_message));
std::string tag = JavaToStdString(jni, JavaParamRef<jstring>(jni, j_tag));
JavaToStdString(jni, jni_zero::JavaParamRef<jstring>(jni, j_message));
std::string tag =
JavaToStdString(jni, jni_zero::JavaParamRef<jstring>(jni, j_tag));
RTC_LOG_TAG(static_cast<rtc::LoggingSeverity>(j_severity), tag.c_str())
<< message;
}

6
sdk/android/src/jni/pc/media_source.cc
View file

@ -10,12 +10,14 @@
#include "api/media_stream_interface.h"
#include "sdk/android/generated_peerconnection_jni/MediaSource_jni.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
static ScopedJavaLocalRef<jobject> JNI_MediaSource_GetState(JNIEnv* jni,
jlong j_p) {
static jni_zero::ScopedJavaLocalRef<jobject> JNI_MediaSource_GetState(
JNIEnv* jni,
jlong j_p) {
return Java_State_fromNativeIndex(
jni, reinterpret_cast<MediaSourceInterface*>(j_p)->state());
}

292
sdk/android/src/jni/pc/peer_connection.cc
View file

@ -58,14 +58,16 @@
#include "sdk/android/src/jni/pc/session_description.h"
#include "sdk/android/src/jni/pc/stats_observer.h"
#include "sdk/android/src/jni/pc/turn_customizer.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
namespace {
PeerConnectionInterface* ExtractNativePC(JNIEnv* jni,
const JavaRef<jobject>& j_pc) {
PeerConnectionInterface* ExtractNativePC(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_pc) {
return reinterpret_cast<OwnedPeerConnection*>(
Java_PeerConnection_getNativeOwnedPeerConnection(jni, j_pc))
->pc();
@ -73,24 +75,25 @@ PeerConnectionInterface* ExtractNativePC(JNIEnv* jni,
PeerConnectionInterface::IceServers JavaToNativeIceServers(
JNIEnv* jni,
const JavaRef<jobject>& j_ice_servers) {
const jni_zero::JavaRef<jobject>& j_ice_servers) {
PeerConnectionInterface::IceServers ice_servers;
for (const JavaRef<jobject>& j_ice_server : Iterable(jni, j_ice_servers)) {
ScopedJavaLocalRef<jobject> j_ice_server_tls_cert_policy =
for (const jni_zero::JavaRef<jobject>& j_ice_server :
Iterable(jni, j_ice_servers)) {
jni_zero::ScopedJavaLocalRef<jobject> j_ice_server_tls_cert_policy =
Java_IceServer_getTlsCertPolicy(jni, j_ice_server);
ScopedJavaLocalRef<jobject> urls =
jni_zero::ScopedJavaLocalRef<jobject> urls =
Java_IceServer_getUrls(jni, j_ice_server);
ScopedJavaLocalRef<jstring> username =
jni_zero::ScopedJavaLocalRef<jstring> username =
Java_IceServer_getUsername(jni, j_ice_server);
ScopedJavaLocalRef<jstring> password =
jni_zero::ScopedJavaLocalRef<jstring> password =
Java_IceServer_getPassword(jni, j_ice_server);
PeerConnectionInterface::TlsCertPolicy tls_cert_policy =
JavaToNativeTlsCertPolicy(jni, j_ice_server_tls_cert_policy);
ScopedJavaLocalRef<jstring> hostname =
jni_zero::ScopedJavaLocalRef<jstring> hostname =
Java_IceServer_getHostname(jni, j_ice_server);
ScopedJavaLocalRef<jobject> tls_alpn_protocols =
jni_zero::ScopedJavaLocalRef<jobject> tls_alpn_protocols =
Java_IceServer_getTlsAlpnProtocols(jni, j_ice_server);
ScopedJavaLocalRef<jobject> tls_elliptic_curves =
jni_zero::ScopedJavaLocalRef<jobject> tls_elliptic_curves =
Java_IceServer_getTlsEllipticCurves(jni, j_ice_server);
PeerConnectionInterface::IceServer server;
server.urls = JavaListToNativeVector<std::string, jstring>(
@ -108,8 +111,9 @@ PeerConnectionInterface::IceServers JavaToNativeIceServers(
return ice_servers;
}
SdpSemantics JavaToNativeSdpSemantics(JNIEnv* jni,
const JavaRef<jobject>& j_sdp_semantics) {
SdpSemantics JavaToNativeSdpSemantics(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_sdp_semantics) {
std::string enum_name = GetJavaEnumName(jni, j_sdp_semantics);
if (enum_name == "PLAN_B")
@ -143,33 +147,33 @@ ScopedJavaLocalRef<jobject> NativeToJavaAdapterType(JNIEnv* env,
void JavaToNativeRTCConfiguration(
JNIEnv* jni,
const JavaRef<jobject>& j_rtc_config,
const jni_zero::JavaRef<jobject>& j_rtc_config,
PeerConnectionInterface::RTCConfiguration* rtc_config) {
ScopedJavaLocalRef<jobject> j_ice_transports_type =
jni_zero::ScopedJavaLocalRef<jobject> j_ice_transports_type =
Java_RTCConfiguration_getIceTransportsType(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_bundle_policy =
jni_zero::ScopedJavaLocalRef<jobject> j_bundle_policy =
Java_RTCConfiguration_getBundlePolicy(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_rtcp_mux_policy =
jni_zero::ScopedJavaLocalRef<jobject> j_rtcp_mux_policy =
Java_RTCConfiguration_getRtcpMuxPolicy(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_rtc_certificate =
jni_zero::ScopedJavaLocalRef<jobject> j_rtc_certificate =
Java_RTCConfiguration_getCertificate(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_tcp_candidate_policy =
jni_zero::ScopedJavaLocalRef<jobject> j_tcp_candidate_policy =
Java_RTCConfiguration_getTcpCandidatePolicy(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_candidate_network_policy =
jni_zero::ScopedJavaLocalRef<jobject> j_candidate_network_policy =
Java_RTCConfiguration_getCandidateNetworkPolicy(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_ice_servers =
jni_zero::ScopedJavaLocalRef<jobject> j_ice_servers =
Java_RTCConfiguration_getIceServers(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_continual_gathering_policy =
jni_zero::ScopedJavaLocalRef<jobject> j_continual_gathering_policy =
Java_RTCConfiguration_getContinualGatheringPolicy(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_turn_port_prune_policy =
jni_zero::ScopedJavaLocalRef<jobject> j_turn_port_prune_policy =
Java_RTCConfiguration_getTurnPortPrunePolicy(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_turn_customizer =
jni_zero::ScopedJavaLocalRef<jobject> j_turn_customizer =
Java_RTCConfiguration_getTurnCustomizer(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_network_preference =
jni_zero::ScopedJavaLocalRef<jobject> j_network_preference =
Java_RTCConfiguration_getNetworkPreference(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_sdp_semantics =
jni_zero::ScopedJavaLocalRef<jobject> j_sdp_semantics =
Java_RTCConfiguration_getSdpSemantics(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_crypto_options =
jni_zero::ScopedJavaLocalRef<jobject> j_crypto_options =
Java_RTCConfiguration_getCryptoOptions(jni, j_rtc_config);
rtc_config->type = JavaToNativeIceTransportsType(jni, j_ice_transports_type);
@ -212,36 +216,38 @@ void JavaToNativeRTCConfiguration(
rtc_config->surface_ice_candidates_on_ice_transport_type_changed =
Java_RTCConfiguration_getSurfaceIceCandidatesOnIceTransportTypeChanged(
jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_ice_check_interval_strong_connectivity =
Java_RTCConfiguration_getIceCheckIntervalStrongConnectivity(jni,
j_rtc_config);
jni_zero::ScopedJavaLocalRef<jobject>
j_ice_check_interval_strong_connectivity =
Java_RTCConfiguration_getIceCheckIntervalStrongConnectivity(
jni, j_rtc_config);
rtc_config->ice_check_interval_strong_connectivity =
JavaToNativeOptionalInt(jni, j_ice_check_interval_strong_connectivity);
ScopedJavaLocalRef<jobject> j_ice_check_interval_weak_connectivity =
jni_zero::ScopedJavaLocalRef<jobject> j_ice_check_interval_weak_connectivity =
Java_RTCConfiguration_getIceCheckIntervalWeakConnectivity(jni,
j_rtc_config);
rtc_config->ice_check_interval_weak_connectivity =
JavaToNativeOptionalInt(jni, j_ice_check_interval_weak_connectivity);
ScopedJavaLocalRef<jobject> j_ice_check_min_interval =
jni_zero::ScopedJavaLocalRef<jobject> j_ice_check_min_interval =
Java_RTCConfiguration_getIceCheckMinInterval(jni, j_rtc_config);
rtc_config->ice_check_min_interval =
JavaToNativeOptionalInt(jni, j_ice_check_min_interval);
ScopedJavaLocalRef<jobject> j_ice_unwritable_timeout =
jni_zero::ScopedJavaLocalRef<jobject> j_ice_unwritable_timeout =
Java_RTCConfiguration_getIceUnwritableTimeout(jni, j_rtc_config);
rtc_config->ice_unwritable_timeout =
JavaToNativeOptionalInt(jni, j_ice_unwritable_timeout);
ScopedJavaLocalRef<jobject> j_ice_unwritable_min_checks =
jni_zero::ScopedJavaLocalRef<jobject> j_ice_unwritable_min_checks =
Java_RTCConfiguration_getIceUnwritableMinChecks(jni, j_rtc_config);
rtc_config->ice_unwritable_min_checks =
JavaToNativeOptionalInt(jni, j_ice_unwritable_min_checks);
ScopedJavaLocalRef<jobject> j_stun_candidate_keepalive_interval =
jni_zero::ScopedJavaLocalRef<jobject> j_stun_candidate_keepalive_interval =
Java_RTCConfiguration_getStunCandidateKeepaliveInterval(jni,
j_rtc_config);
rtc_config->stun_candidate_keepalive_interval =
JavaToNativeOptionalInt(jni, j_stun_candidate_keepalive_interval);
ScopedJavaLocalRef<jobject> j_stable_writable_connection_ping_interval_ms =
Java_RTCConfiguration_getStableWritableConnectionPingIntervalMs(
jni, j_rtc_config);
jni_zero::ScopedJavaLocalRef<jobject>
j_stable_writable_connection_ping_interval_ms =
Java_RTCConfiguration_getStableWritableConnectionPingIntervalMs(
jni, j_rtc_config);
rtc_config->stable_writable_connection_ping_interval_ms =
JavaToNativeOptionalInt(jni,
j_stable_writable_connection_ping_interval_ms);
@ -272,7 +278,7 @@ void JavaToNativeRTCConfiguration(
rtc_config->enable_implicit_rollback =
Java_RTCConfiguration_getEnableImplicitRollback(jni, j_rtc_config);
ScopedJavaLocalRef<jstring> j_turn_logging_id =
jni_zero::ScopedJavaLocalRef<jstring> j_turn_logging_id =
Java_RTCConfiguration_getTurnLoggingId(jni, j_rtc_config);
if (!IsNull(jni, j_turn_logging_id)) {
rtc_config->turn_logging_id = JavaToNativeString(jni, j_turn_logging_id);
@ -282,15 +288,16 @@ void JavaToNativeRTCConfiguration(
Java_RTCConfiguration_getPortAllocatorFlags(jni, j_rtc_config);
}
rtc::KeyType GetRtcConfigKeyType(JNIEnv* env,
const JavaRef<jobject>& j_rtc_config) {
rtc::KeyType GetRtcConfigKeyType(
JNIEnv* env,
const jni_zero::JavaRef<jobject>& j_rtc_config) {
return JavaToNativeKeyType(
env, Java_RTCConfiguration_getKeyType(env, j_rtc_config));
}
PeerConnectionObserverJni::PeerConnectionObserverJni(
JNIEnv* jni,
const JavaRef<jobject>& j_observer)
const jni_zero::JavaRef<jobject>& j_observer)
: j_observer_global_(jni, j_observer) {}
PeerConnectionObserverJni::~PeerConnectionObserverJni() = default;
@ -309,9 +316,11 @@ void PeerConnectionObserverJni::OnIceCandidateError(
int error_code,
const std::string& error_text) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedJavaLocalRef<jobject> event = Java_IceCandidateErrorEvent_Constructor(
env, NativeToJavaString(env, address), port, NativeToJavaString(env, url),
error_code, NativeToJavaString(env, error_text));
jni_zero::ScopedJavaLocalRef<jobject> event =
Java_IceCandidateErrorEvent_Constructor(
env, NativeToJavaString(env, address), port,
NativeToJavaString(env, url), error_code,
NativeToJavaString(env, error_text));
Java_Observer_onIceCandidateError(env, j_observer_global_, event);
}
@ -410,7 +419,7 @@ void PeerConnectionObserverJni::OnAddTrack(
rtc::scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedJavaLocalRef<jobject> j_rtp_receiver =
jni_zero::ScopedJavaLocalRef<jobject> j_rtp_receiver =
NativeToJavaRtpReceiver(env, receiver);
rtp_receivers_.emplace_back(env, j_rtp_receiver);
@ -421,7 +430,7 @@ void PeerConnectionObserverJni::OnAddTrack(
void PeerConnectionObserverJni::OnRemoveTrack(
rtc::scoped_refptr<RtpReceiverInterface> receiver) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedJavaLocalRef<jobject> j_rtp_receiver =
jni_zero::ScopedJavaLocalRef<jobject> j_rtp_receiver =
NativeToJavaRtpReceiver(env, receiver);
rtp_receivers_.emplace_back(env, j_rtp_receiver);
@ -431,7 +440,7 @@ void PeerConnectionObserverJni::OnRemoveTrack(
void PeerConnectionObserverJni::OnTrack(
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedJavaLocalRef<jobject> j_rtp_transceiver =
jni_zero::ScopedJavaLocalRef<jobject> j_rtp_transceiver =
NativeToJavaRtpTransceiver(env, transceiver);
rtp_transceivers_.emplace_back(env, j_rtp_transceiver);
@ -461,7 +470,7 @@ PeerConnectionObserverJni::NativeToJavaMediaStreamArray(
return NativeToJavaObjectArray(
jni, streams, GetMediaStreamClass(jni),
[this](JNIEnv* env, rtc::scoped_refptr<MediaStreamInterface> stream)
-> const ScopedJavaGlobalRef<jobject>& {
-> const jni_zero::ScopedJavaGlobalRef<jobject>& {
return GetOrCreateJavaStream(env, stream).j_media_stream();
});
}
@ -488,7 +497,7 @@ OwnedPeerConnection::~OwnedPeerConnection() {
static jlong JNI_PeerConnection_CreatePeerConnectionObserver(
JNIEnv* jni,
const JavaParamRef<jobject>& j_observer) {
const jni_zero::JavaParamRef<jobject>& j_observer) {
return jlongFromPointer(new PeerConnectionObserverJni(jni, j_observer));
}
@ -498,13 +507,14 @@ static void JNI_PeerConnection_FreeOwnedPeerConnection(JNIEnv*, jlong j_p) {
static jlong JNI_PeerConnection_GetNativePeerConnection(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return jlongFromPointer(ExtractNativePC(jni, j_pc));
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetLocalDescription(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnection_GetLocalDescription(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
PeerConnectionInterface* pc = ExtractNativePC(jni, j_pc);
// It's only safe to operate on SessionDescriptionInterface on the
// signaling thread, but `jni` may only be used on the current thread, so we
@ -521,9 +531,10 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetLocalDescription(
return sdp.empty() ? nullptr : NativeToJavaSessionDescription(jni, sdp, type);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetRemoteDescription(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnection_GetRemoteDescription(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
PeerConnectionInterface* pc = ExtractNativePC(jni, j_pc);
// It's only safe to operate on SessionDescriptionInterface on the
// signaling thread, but `jni` may only be used on the current thread, so we
@ -540,9 +551,9 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetRemoteDescription(
return sdp.empty() ? nullptr : NativeToJavaSessionDescription(jni, sdp, type);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetCertificate(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetCertificate(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
const PeerConnectionInterface::RTCConfiguration rtc_config =
ExtractNativePC(jni, j_pc)->GetConfiguration();
rtc::scoped_refptr<rtc::RTCCertificate> certificate =
@ -550,11 +561,12 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetCertificate(
return NativeToJavaRTCCertificatePEM(jni, certificate->ToPEM());
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_CreateDataChannel(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnection_CreateDataChannel(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jstring>& j_label,
const JavaParamRef<jobject>& j_init) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jstring>& j_label,
const jni_zero::JavaParamRef<jobject>& j_init) {
DataChannelInit init = JavaToNativeDataChannelInit(jni, j_init);
auto result = ExtractNativePC(jni, j_pc)->CreateDataChannelOrError(
JavaToNativeString(jni, j_label), &init);
@ -566,9 +578,9 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_CreateDataChannel(
static void JNI_PeerConnection_CreateOffer(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_observer,
const JavaParamRef<jobject>& j_constraints) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_observer,
const jni_zero::JavaParamRef<jobject>& j_constraints) {
std::unique_ptr<MediaConstraints> constraints =
JavaToNativeMediaConstraints(jni, j_constraints);
auto observer = rtc::make_ref_counted<CreateSdpObserverJni>(
@ -580,9 +592,9 @@ static void JNI_PeerConnection_CreateOffer(
static void JNI_PeerConnection_CreateAnswer(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_observer,
const JavaParamRef<jobject>& j_constraints) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_observer,
const jni_zero::JavaParamRef<jobject>& j_constraints) {
std::unique_ptr<MediaConstraints> constraints =
JavaToNativeMediaConstraints(jni, j_constraints);
auto observer = rtc::make_ref_counted<CreateSdpObserverJni>(
@ -594,8 +606,8 @@ static void JNI_PeerConnection_CreateAnswer(
static void JNI_PeerConnection_SetLocalDescriptionAutomatically(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_observer) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_observer) {
auto observer =
rtc::make_ref_counted<SetLocalSdpObserverJni>(jni, j_observer);
ExtractNativePC(jni, j_pc)->SetLocalDescription(observer);
@ -603,9 +615,9 @@ static void JNI_PeerConnection_SetLocalDescriptionAutomatically(
static void JNI_PeerConnection_SetLocalDescription(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_observer,
const JavaParamRef<jobject>& j_sdp) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_observer,
const jni_zero::JavaParamRef<jobject>& j_sdp) {
auto observer =
rtc::make_ref_counted<SetLocalSdpObserverJni>(jni, j_observer);
ExtractNativePC(jni, j_pc)->SetLocalDescription(
@ -614,38 +626,39 @@ static void JNI_PeerConnection_SetLocalDescription(
static void JNI_PeerConnection_SetRemoteDescription(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_observer,
const JavaParamRef<jobject>& j_sdp) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_observer,
const jni_zero::JavaParamRef<jobject>& j_sdp) {
auto observer =
rtc::make_ref_counted<SetRemoteSdpObserverJni>(jni, j_observer);
ExtractNativePC(jni, j_pc)->SetRemoteDescription(
JavaToNativeSessionDescription(jni, j_sdp), observer);
}
static void JNI_PeerConnection_RestartIce(JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
static void JNI_PeerConnection_RestartIce(
JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& j_pc) {
ExtractNativePC(jni, j_pc)->RestartIce();
}
static void JNI_PeerConnection_SetAudioPlayout(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jboolean playout) {
ExtractNativePC(jni, j_pc)->SetAudioPlayout(playout);
}
static void JNI_PeerConnection_SetAudioRecording(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jboolean recording) {
ExtractNativePC(jni, j_pc)->SetAudioRecording(recording);
}
static jboolean JNI_PeerConnection_SetConfiguration(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_rtc_config) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_rtc_config) {
// Need to merge constraints into RTCConfiguration again, which are stored
// in the OwnedPeerConnection object.
OwnedPeerConnection* owned_pc = reinterpret_cast<OwnedPeerConnection*>(
@ -661,10 +674,10 @@ static jboolean JNI_PeerConnection_SetConfiguration(
static jboolean JNI_PeerConnection_AddIceCandidate(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jstring>& j_sdp_mid,
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jstring>& j_sdp_mid,
jint j_sdp_mline_index,
const JavaParamRef<jstring>& j_candidate_sdp) {
const jni_zero::JavaParamRef<jstring>& j_candidate_sdp) {
std::string sdp_mid = JavaToNativeString(jni, j_sdp_mid);
std::string sdp = JavaToNativeString(jni, j_candidate_sdp);
std::unique_ptr<IceCandidateInterface> candidate(
@ -674,11 +687,11 @@ static jboolean JNI_PeerConnection_AddIceCandidate(
static void JNI_PeerConnection_AddIceCandidateWithObserver(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jstring>& j_sdp_mid,
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jstring>& j_sdp_mid,
jint j_sdp_mline_index,
const JavaParamRef<jstring>& j_candidate_sdp,
const JavaParamRef<jobject>& j_observer) {
const jni_zero::JavaParamRef<jstring>& j_candidate_sdp,
const jni_zero::JavaParamRef<jobject>& j_observer) {
std::string sdp_mid = JavaToNativeString(jni, j_sdp_mid);
std::string sdp = JavaToNativeString(jni, j_candidate_sdp);
std::unique_ptr<IceCandidateInterface> candidate(
@ -693,8 +706,8 @@ static void JNI_PeerConnection_AddIceCandidateWithObserver(
static jboolean JNI_PeerConnection_RemoveIceCandidates(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobjectArray>& j_candidates) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobjectArray>& j_candidates) {
std::vector<cricket::Candidate> candidates =
JavaToNativeVector<cricket::Candidate>(jni, j_candidates,
&JavaToNativeCandidate);
@ -703,7 +716,7 @@ static jboolean JNI_PeerConnection_RemoveIceCandidates(
static jboolean JNI_PeerConnection_AddLocalStream(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jlong native_stream) {
return ExtractNativePC(jni, j_pc)->AddStream(
reinterpret_cast<MediaStreamInterface*>(native_stream));
@ -711,17 +724,17 @@ static jboolean JNI_PeerConnection_AddLocalStream(
static void JNI_PeerConnection_RemoveLocalStream(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jlong native_stream) {
ExtractNativePC(jni, j_pc)->RemoveStream(
reinterpret_cast<MediaStreamInterface*>(native_stream));
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_CreateSender(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_CreateSender(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jstring>& j_kind,
const JavaParamRef<jstring>& j_stream_id) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jstring>& j_kind,
const jni_zero::JavaParamRef<jstring>& j_stream_id) {
std::string kind = JavaToNativeString(jni, j_kind);
std::string stream_id = JavaToNativeString(jni, j_stream_id);
rtc::scoped_refptr<RtpSenderInterface> sender =
@ -729,32 +742,32 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_CreateSender(
return NativeToJavaRtpSender(jni, sender);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetSenders(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetSenders(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return NativeToJavaList(jni, ExtractNativePC(jni, j_pc)->GetSenders(),
&NativeToJavaRtpSender);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetReceivers(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetReceivers(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return NativeToJavaList(jni, ExtractNativePC(jni, j_pc)->GetReceivers(),
&NativeToJavaRtpReceiver);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetTransceivers(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetTransceivers(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return NativeToJavaList(jni, ExtractNativePC(jni, j_pc)->GetTransceivers(),
&NativeToJavaRtpTransceiver);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTrack(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTrack(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
const jlong native_track,
const JavaParamRef<jobject>& j_stream_labels) {
const jni_zero::JavaParamRef<jobject>& j_stream_labels) {
RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> result =
ExtractNativePC(jni, j_pc)->AddTrack(
rtc::scoped_refptr<MediaStreamTrackInterface>(
@ -771,7 +784,7 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTrack(
static jboolean JNI_PeerConnection_RemoveTrack(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jlong native_sender) {
return ExtractNativePC(jni, j_pc)
->RemoveTrackOrError(rtc::scoped_refptr<RtpSenderInterface>(
@ -779,11 +792,12 @@ static jboolean JNI_PeerConnection_RemoveTrack(
.ok();
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTransceiverWithTrack(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnection_AddTransceiverWithTrack(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jlong native_track,
const JavaParamRef<jobject>& j_init) {
const jni_zero::JavaParamRef<jobject>& j_init) {
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
ExtractNativePC(jni, j_pc)->AddTransceiver(
rtc::scoped_refptr<MediaStreamTrackInterface>(
@ -798,11 +812,12 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTransceiverWithTrack(
}
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTransceiverOfType(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnection_AddTransceiverOfType(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_media_type,
const JavaParamRef<jobject>& j_init) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_media_type,
const jni_zero::JavaParamRef<jobject>& j_init) {
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
ExtractNativePC(jni, j_pc)->AddTransceiver(
JavaToNativeMediaType(jni, j_media_type),
@ -818,8 +833,8 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTransceiverOfType(
static jboolean JNI_PeerConnection_OldGetStats(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_observer,
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_observer,
jlong native_track) {
auto observer = rtc::make_ref_counted<StatsObserverJni>(jni, j_observer);
return ExtractNativePC(jni, j_pc)->GetStats(
@ -830,8 +845,8 @@ static jboolean JNI_PeerConnection_OldGetStats(
static void JNI_PeerConnection_NewGetStats(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_callback) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_callback) {
auto callback =
rtc::make_ref_counted<RTCStatsCollectorCallbackWrapper>(jni, j_callback);
ExtractNativePC(jni, j_pc)->GetStats(callback.get());
@ -839,9 +854,9 @@ static void JNI_PeerConnection_NewGetStats(
static void JNI_PeerConnection_NewGetStatsSender(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jlong native_sender,
const JavaParamRef<jobject>& j_callback) {
const jni_zero::JavaParamRef<jobject>& j_callback) {
auto callback =
rtc::make_ref_counted<RTCStatsCollectorCallbackWrapper>(jni, j_callback);
ExtractNativePC(jni, j_pc)->GetStats(
@ -852,9 +867,9 @@ static void JNI_PeerConnection_NewGetStatsSender(
static void JNI_PeerConnection_NewGetStatsReceiver(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
jlong native_receiver,
const JavaParamRef<jobject>& j_callback) {
const jni_zero::JavaParamRef<jobject>& j_callback) {
auto callback =
rtc::make_ref_counted<RTCStatsCollectorCallbackWrapper>(jni, j_callback);
ExtractNativePC(jni, j_pc)->GetStats(
@ -865,10 +880,10 @@ static void JNI_PeerConnection_NewGetStatsReceiver(
static jboolean JNI_PeerConnection_SetBitrate(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_min,
const JavaParamRef<jobject>& j_current,
const JavaParamRef<jobject>& j_max) {
const jni_zero::JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_min,
const jni_zero::JavaParamRef<jobject>& j_current,
const jni_zero::JavaParamRef<jobject>& j_max) {
BitrateSettings params;
params.min_bitrate_bps = JavaToNativeOptionalInt(jni, j_min);
params.start_bitrate_bps = JavaToNativeOptionalInt(jni, j_current);
@ -878,7 +893,7 @@ static jboolean JNI_PeerConnection_SetBitrate(
static jboolean JNI_PeerConnection_StartRtcEventLog(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jni_zero::JavaParamRef<jobject>& j_pc,
int file_descriptor,
int max_size_bytes) {
// TODO(eladalon): It would be better to not allow negative values into PC.
@ -896,41 +911,44 @@ static jboolean JNI_PeerConnection_StartRtcEventLog(
static void JNI_PeerConnection_StopRtcEventLog(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
ExtractNativePC(jni, j_pc)->StopRtcEventLog();
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_SignalingState(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_SignalingState(
JNIEnv* env,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return Java_SignalingState_fromNativeIndex(
env, ExtractNativePC(env, j_pc)->signaling_state());
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_IceConnectionState(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnection_IceConnectionState(
JNIEnv* env,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return Java_IceConnectionState_fromNativeIndex(
env, ExtractNativePC(env, j_pc)->ice_connection_state());
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_ConnectionState(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_PeerConnection_ConnectionState(
JNIEnv* env,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return Java_PeerConnectionState_fromNativeIndex(
env,
static_cast<int>(ExtractNativePC(env, j_pc)->peer_connection_state()));
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_IceGatheringState(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnection_IceGatheringState(
JNIEnv* env,
const JavaParamRef<jobject>& j_pc) {
const jni_zero::JavaParamRef<jobject>& j_pc) {
return Java_IceGatheringState_fromNativeIndex(
env, ExtractNativePC(env, j_pc)->ice_gathering_state());
}
static void JNI_PeerConnection_Close(JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
static void JNI_PeerConnection_Close(
JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& j_pc) {
ExtractNativePC(jni, j_pc)->Close();
}

63
sdk/android/src/jni/pc/peer_connection_factory.cc
View file

@ -40,6 +40,7 @@
#include "sdk/android/src/jni/pc/ssl_certificate_verifier_wrapper.h"
#include "sdk/android/src/jni/pc/video.h"
#include "system_wrappers/include/field_trial.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -61,23 +62,24 @@ std::unique_ptr<T> TakeOwnershipOfUniquePtr(jlong native_pointer) {
return std::unique_ptr<T>(reinterpret_cast<T*>(native_pointer));
}
typedef void (*JavaMethodPointer)(JNIEnv*, const JavaRef<jobject>&);
typedef void (*JavaMethodPointer)(JNIEnv*, const jni_zero::JavaRef<jobject>&);
// Post a message on the given thread that will call the Java method on the
// given Java object.
void PostJavaCallback(JNIEnv* env,
rtc::Thread* queue,
const JavaRef<jobject>& j_object,
const jni_zero::JavaRef<jobject>& j_object,
JavaMethodPointer java_method_pointer) {
ScopedJavaGlobalRef<jobject> object(env, j_object);
jni_zero::ScopedJavaGlobalRef<jobject> object(env, j_object);
queue->PostTask([object = std::move(object), java_method_pointer] {
java_method_pointer(AttachCurrentThreadIfNeeded(), object);
});
}
absl::optional<PeerConnectionFactoryInterface::Options>
JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni,
const JavaRef<jobject>& j_options) {
JavaToNativePeerConnectionFactoryOptions(
JNIEnv* jni,
const jni_zero::JavaRef<jobject>& j_options) {
if (j_options.is_null())
return absl::nullopt;
@ -120,8 +122,9 @@ ScopedJavaLocalRef<jobject> NativeToScopedJavaPeerConnectionFactory(
std::move(socket_factory), std::move(network_thread),
std::move(worker_thread), std::move(signaling_thread), pcf);
ScopedJavaLocalRef<jobject> j_pcf = Java_PeerConnectionFactory_Constructor(
env, NativeToJavaPointer(owned_factory));
jni_zero::ScopedJavaLocalRef<jobject> j_pcf =
Java_PeerConnectionFactory_Constructor(
env, NativeToJavaPointer(owned_factory));
PostJavaCallback(env, owned_factory->network_thread(), j_pcf,
&Java_PeerConnectionFactory_onNetworkThreadReady);
@ -170,7 +173,7 @@ static void JNI_PeerConnectionFactory_InitializeAndroidGlobals(JNIEnv* jni) {
static void JNI_PeerConnectionFactory_InitializeFieldTrials(
JNIEnv* jni,
const JavaParamRef<jstring>& j_trials_init_string) {
const jni_zero::JavaParamRef<jstring>& j_trials_init_string) {
std::unique_ptr<std::string>& field_trials_init_string =
GetStaticObjects().field_trials_init_string;
@ -189,17 +192,17 @@ static void JNI_PeerConnectionFactory_InitializeInternalTracer(JNIEnv* jni) {
rtc::tracing::SetupInternalTracer();
}
static ScopedJavaLocalRef<jstring>
static jni_zero::ScopedJavaLocalRef<jstring>
JNI_PeerConnectionFactory_FindFieldTrialsFullName(
JNIEnv* jni,
const JavaParamRef<jstring>& j_name) {
const jni_zero::JavaParamRef<jstring>& j_name) {
return NativeToJavaString(
jni, field_trial::FindFullName(JavaToStdString(jni, j_name)));
}
static jboolean JNI_PeerConnectionFactory_StartInternalTracingCapture(
JNIEnv* jni,
const JavaParamRef<jstring>& j_event_tracing_filename) {
const jni_zero::JavaParamRef<jstring>& j_event_tracing_filename) {
if (j_event_tracing_filename.is_null())
return false;
@ -225,13 +228,13 @@ static void JNI_PeerConnectionFactory_ShutdownInternalTracer(JNIEnv* jni) {
// `network_state_predictor_factory`, `neteq_factory`.
ScopedJavaLocalRef<jobject> CreatePeerConnectionFactoryForJava(
JNIEnv* jni,
const JavaParamRef<jobject>& jcontext,
const JavaParamRef<jobject>& joptions,
const jni_zero::JavaParamRef<jobject>& jcontext,
const jni_zero::JavaParamRef<jobject>& joptions,
rtc::scoped_refptr<AudioDeviceModule> audio_device_module,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
const JavaParamRef<jobject>& jencoder_factory,
const JavaParamRef<jobject>& jdecoder_factory,
const jni_zero::JavaParamRef<jobject>& jencoder_factory,
const jni_zero::JavaParamRef<jobject>& jdecoder_factory,
rtc::scoped_refptr<AudioProcessing> audio_processor,
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory,
std::unique_ptr<NetworkControllerFactoryInterface>
@ -306,16 +309,16 @@ ScopedJavaLocalRef<jobject> CreatePeerConnectionFactoryForJava(
std::move(worker_thread), std::move(signaling_thread));
}
static ScopedJavaLocalRef<jobject>
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_PeerConnectionFactory_CreatePeerConnectionFactory(
JNIEnv* jni,
const JavaParamRef<jobject>& jcontext,
const JavaParamRef<jobject>& joptions,
const jni_zero::JavaParamRef<jobject>& jcontext,
const jni_zero::JavaParamRef<jobject>& joptions,
jlong native_audio_device_module,
jlong native_audio_encoder_factory,
jlong native_audio_decoder_factory,
const JavaParamRef<jobject>& jencoder_factory,
const JavaParamRef<jobject>& jdecoder_factory,
const jni_zero::JavaParamRef<jobject>& jencoder_factory,
const jni_zero::JavaParamRef<jobject>& jdecoder_factory,
jlong native_audio_processor,
jlong native_fec_controller_factory,
jlong native_network_controller_factory,
@ -349,7 +352,7 @@ static void JNI_PeerConnectionFactory_FreeFactory(JNIEnv*, jlong j_p) {
static jlong JNI_PeerConnectionFactory_CreateLocalMediaStream(
JNIEnv* jni,
jlong native_factory,
const JavaParamRef<jstring>& label) {
const jni_zero::JavaParamRef<jstring>& label) {
rtc::scoped_refptr<MediaStreamInterface> stream(
PeerConnectionFactoryFromJava(native_factory)
->CreateLocalMediaStream(JavaToStdString(jni, label)));
@ -359,7 +362,7 @@ static jlong JNI_PeerConnectionFactory_CreateLocalMediaStream(
static jlong JNI_PeerConnectionFactory_CreateAudioSource(
JNIEnv* jni,
jlong native_factory,
const JavaParamRef<jobject>& j_constraints) {
const jni_zero::JavaParamRef<jobject>& j_constraints) {
std::unique_ptr<MediaConstraints> constraints =
JavaToNativeMediaConstraints(jni, j_constraints);
cricket::AudioOptions options;
@ -373,7 +376,7 @@ static jlong JNI_PeerConnectionFactory_CreateAudioSource(
jlong JNI_PeerConnectionFactory_CreateAudioTrack(
JNIEnv* jni,
jlong native_factory,
const JavaParamRef<jstring>& id,
const jni_zero::JavaParamRef<jstring>& id,
jlong native_source) {
rtc::scoped_refptr<AudioTrackInterface> track(
PeerConnectionFactoryFromJava(native_factory)
@ -386,7 +389,7 @@ jlong JNI_PeerConnectionFactory_CreateAudioTrack(
ScopedJavaLocalRef<jobject> JNI_PeerConnectionFactory_GetRtpSenderCapabilities(
JNIEnv* jni,
jlong native_factory,
const JavaParamRef<jobject>& media_type) {
const jni_zero::JavaParamRef<jobject>& media_type) {
auto factory = PeerConnectionFactoryFromJava(native_factory);
return NativeToJavaRtpCapabilities(
jni, factory->GetRtpSenderCapabilities(
@ -397,7 +400,7 @@ ScopedJavaLocalRef<jobject>
JNI_PeerConnectionFactory_GetRtpReceiverCapabilities(
JNIEnv* jni,
jlong native_factory,
const JavaParamRef<jobject>& media_type) {
const jni_zero::JavaParamRef<jobject>& media_type) {
auto factory = PeerConnectionFactoryFromJava(native_factory);
return NativeToJavaRtpCapabilities(
jni, factory->GetRtpReceiverCapabilities(
@ -427,10 +430,10 @@ static void JNI_PeerConnectionFactory_StopAecDump(JNIEnv* jni,
static jlong JNI_PeerConnectionFactory_CreatePeerConnection(
JNIEnv* jni,
jlong factory,
const JavaParamRef<jobject>& j_rtc_config,
const JavaParamRef<jobject>& j_constraints,
const jni_zero::JavaParamRef<jobject>& j_rtc_config,
const jni_zero::JavaParamRef<jobject>& j_constraints,
jlong observer_p,
const JavaParamRef<jobject>& j_sslCertificateVerifier) {
const jni_zero::JavaParamRef<jobject>& j_sslCertificateVerifier) {
std::unique_ptr<PeerConnectionObserver> observer(
reinterpret_cast<PeerConnectionObserver*>(observer_p));
@ -492,7 +495,7 @@ static jlong JNI_PeerConnectionFactory_CreateVideoSource(
static jlong JNI_PeerConnectionFactory_CreateVideoTrack(
JNIEnv* jni,
jlong native_factory,
const JavaParamRef<jstring>& id,
const jni_zero::JavaParamRef<jstring>& id,
jlong native_source) {
rtc::scoped_refptr<VideoTrackInterface> track =
PeerConnectionFactoryFromJava(native_factory)
@ -511,7 +514,7 @@ static jlong JNI_PeerConnectionFactory_GetNativePeerConnectionFactory(
static void JNI_PeerConnectionFactory_InjectLoggable(
JNIEnv* jni,
const JavaParamRef<jobject>& j_logging,
const jni_zero::JavaParamRef<jobject>& j_logging,
jint nativeSeverity) {
std::unique_ptr<JNILogSink>& jni_log_sink = GetStaticObjects().jni_log_sink;

12
sdk/android/src/jni/pc/rtc_certificate.cc
View file

@ -17,16 +17,17 @@
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/ice_candidate.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
rtc::RTCCertificatePEM JavaToNativeRTCCertificatePEM(
JNIEnv* jni,
const JavaRef<jobject>& j_rtc_certificate) {
ScopedJavaLocalRef<jstring> privatekey_field =
const jni_zero::JavaRef<jobject>& j_rtc_certificate) {
jni_zero::ScopedJavaLocalRef<jstring> privatekey_field =
Java_RtcCertificatePem_getPrivateKey(jni, j_rtc_certificate);
ScopedJavaLocalRef<jstring> certificate_field =
jni_zero::ScopedJavaLocalRef<jstring> certificate_field =
Java_RtcCertificatePem_getCertificate(jni, j_rtc_certificate);
return rtc::RTCCertificatePEM(JavaToNativeString(jni, privatekey_field),
JavaToNativeString(jni, certificate_field));
@ -40,9 +41,10 @@ ScopedJavaLocalRef<jobject> NativeToJavaRTCCertificatePEM(
NativeToJavaString(jni, certificate.certificate()));
}
static ScopedJavaLocalRef<jobject> JNI_RtcCertificatePem_GenerateCertificate(
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_RtcCertificatePem_GenerateCertificate(
JNIEnv* jni,
const JavaParamRef<jobject>& j_key_type,
const jni_zero::JavaParamRef<jobject>& j_key_type,
jlong j_expires) {
rtc::KeyType key_type = JavaToNativeKeyType(jni, j_key_type);
uint64_t expires = (uint64_t)j_expires;

14
sdk/android/src/jni/pc/rtp_receiver.cc
View file

@ -15,6 +15,7 @@
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/media_stream_track.h"
#include "sdk/android/src/jni/pc/rtp_parameters.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -26,7 +27,8 @@ namespace {
// dispatches C++ callbacks to Java.
class RtpReceiverObserverJni : public RtpReceiverObserverInterface {
public:
RtpReceiverObserverJni(JNIEnv* env, const JavaRef<jobject>& j_observer)
RtpReceiverObserverJni(JNIEnv* env,
const jni_zero::JavaRef<jobject>& j_observer)
: j_observer_global_(env, j_observer) {}
~RtpReceiverObserverJni() override = default;
@ -38,7 +40,7 @@ class RtpReceiverObserverJni : public RtpReceiverObserverInterface {
}
private:
const ScopedJavaGlobalRef<jobject> j_observer_global_;
const jni_zero::ScopedJavaGlobalRef<jobject> j_observer_global_;
};
} // namespace
@ -53,7 +55,7 @@ ScopedJavaLocalRef<jobject> NativeToJavaRtpReceiver(
JavaRtpReceiverGlobalOwner::JavaRtpReceiverGlobalOwner(
JNIEnv* env,
const JavaRef<jobject>& j_receiver)
const jni_zero::JavaRef<jobject>& j_receiver)
: j_receiver_(env, j_receiver) {}
JavaRtpReceiverGlobalOwner::JavaRtpReceiverGlobalOwner(
@ -74,7 +76,7 @@ static jlong JNI_RtpReceiver_GetTrack(JNIEnv* jni,
.release());
}
static ScopedJavaLocalRef<jobject> JNI_RtpReceiver_GetParameters(
static jni_zero::ScopedJavaLocalRef<jobject> JNI_RtpReceiver_GetParameters(
JNIEnv* jni,
jlong j_rtp_receiver_pointer) {
RtpParameters parameters =
@ -83,7 +85,7 @@ static ScopedJavaLocalRef<jobject> JNI_RtpReceiver_GetParameters(
return NativeToJavaRtpParameters(jni, parameters);
}
static ScopedJavaLocalRef<jstring> JNI_RtpReceiver_GetId(
static jni_zero::ScopedJavaLocalRef<jstring> JNI_RtpReceiver_GetId(
JNIEnv* jni,
jlong j_rtp_receiver_pointer) {
return NativeToJavaString(
@ -94,7 +96,7 @@ static ScopedJavaLocalRef<jstring> JNI_RtpReceiver_GetId(
static jlong JNI_RtpReceiver_SetObserver(
JNIEnv* jni,
jlong j_rtp_receiver_pointer,
const JavaParamRef<jobject>& j_observer) {
const jni_zero::JavaParamRef<jobject>& j_observer) {
RtpReceiverObserverJni* rtpReceiverObserver =
new RtpReceiverObserverJni(jni, j_observer);
reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)

11
sdk/android/src/jni/pc/rtp_sender.cc
View file

@ -14,6 +14,7 @@
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/rtp_parameters.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -47,7 +48,7 @@ jlong JNI_RtpSender_GetTrack(JNIEnv* jni, jlong j_rtp_sender_pointer) {
static void JNI_RtpSender_SetStreams(
JNIEnv* jni,
jlong j_rtp_sender_pointer,
const JavaParamRef<jobject>& j_stream_labels) {
const jni_zero::JavaParamRef<jobject>& j_stream_labels) {
reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->SetStreams(JavaListToNativeVector<std::string, jstring>(
jni, j_stream_labels, &JavaToNativeString));
@ -56,8 +57,8 @@ static void JNI_RtpSender_SetStreams(
ScopedJavaLocalRef<jobject> JNI_RtpSender_GetStreams(
JNIEnv* jni,
jlong j_rtp_sender_pointer) {
ScopedJavaLocalRef<jstring> (*convert_function)(JNIEnv*, const std::string&) =
&NativeToJavaString;
jni_zero::ScopedJavaLocalRef<jstring> (*convert_function)(
JNIEnv*, const std::string&) = &NativeToJavaString;
return NativeToJavaList(
jni,
reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)->stream_ids(),
@ -74,7 +75,7 @@ jlong JNI_RtpSender_GetDtmfSender(JNIEnv* jni, jlong j_rtp_sender_pointer) {
jboolean JNI_RtpSender_SetParameters(
JNIEnv* jni,
jlong j_rtp_sender_pointer,
const JavaParamRef<jobject>& j_parameters) {
const jni_zero::JavaParamRef<jobject>& j_parameters) {
if (IsNull(jni, j_parameters)) {
return false;
}
@ -108,7 +109,7 @@ static void JNI_RtpSender_SetFrameEncryptor(JNIEnv* jni,
j_frame_encryptor_pointer)));
}
static ScopedJavaLocalRef<jstring> JNI_RtpSender_GetMediaType(
static jni_zero::ScopedJavaLocalRef<jstring> JNI_RtpSender_GetMediaType(
JNIEnv* jni,
jlong j_rtp_sender_pointer) {
cricket::MediaType media_type =

13
sdk/android/src/jni/pc/rtp_transceiver.cc
View file

@ -21,6 +21,7 @@
#include "sdk/android/src/jni/pc/rtp_parameters.h"
#include "sdk/android/src/jni/pc/rtp_receiver.h"
#include "sdk/android/src/jni/pc/rtp_sender.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -38,7 +39,7 @@ ScopedJavaLocalRef<jobject> NativeToJavaRtpTransceiverDirection(
RtpTransceiverInit JavaToNativeRtpTransceiverInit(
JNIEnv* jni,
const JavaRef<jobject>& j_init) {
const jni_zero::JavaRef<jobject>& j_init) {
RtpTransceiverInit init;
// Convert the direction.
@ -46,13 +47,13 @@ RtpTransceiverInit JavaToNativeRtpTransceiverInit(
Java_RtpTransceiverInit_getDirectionNativeIndex(jni, j_init));
// Convert the stream ids.
ScopedJavaLocalRef<jobject> j_stream_ids =
jni_zero::ScopedJavaLocalRef<jobject> j_stream_ids =
Java_RtpTransceiverInit_getStreamIds(jni, j_init);
init.stream_ids = JavaListToNativeVector<std::string, jstring>(
jni, j_stream_ids, &JavaToNativeString);
// Convert the send encodings.
ScopedJavaLocalRef<jobject> j_send_encodings =
jni_zero::ScopedJavaLocalRef<jobject> j_send_encodings =
Java_RtpTransceiverInit_getSendEncodings(jni, j_init);
init.send_encodings = JavaListToNativeVector<RtpEncodingParameters, jobject>(
jni, j_send_encodings, &JavaToNativeRtpEncodingParameters);
@ -72,7 +73,7 @@ ScopedJavaLocalRef<jobject> NativeToJavaRtpTransceiver(
JavaRtpTransceiverGlobalOwner::JavaRtpTransceiverGlobalOwner(
JNIEnv* env,
const JavaRef<jobject>& j_transceiver)
const jni_zero::JavaRef<jobject>& j_transceiver)
: j_transceiver_(env, j_transceiver) {}
JavaRtpTransceiverGlobalOwner::JavaRtpTransceiverGlobalOwner(
@ -144,7 +145,7 @@ ScopedJavaLocalRef<jobject> JNI_RtpTransceiver_CurrentDirection(
ScopedJavaLocalRef<jobject> JNI_RtpTransceiver_SetCodecPreferences(
JNIEnv* jni,
jlong j_rtp_transceiver_pointer,
const JavaParamRef<jobject>& j_codecs) {
const jni_zero::JavaParamRef<jobject>& j_codecs) {
std::vector<RtpCodecCapability> codecs;
if (j_codecs) {
codecs = JavaListToNativeVector<RtpCodecCapability, jobject>(
@ -174,7 +175,7 @@ void JNI_RtpTransceiver_StopStandard(JNIEnv* jni,
jboolean JNI_RtpTransceiver_SetDirection(
JNIEnv* jni,
jlong j_rtp_transceiver_pointer,
const base::android::JavaParamRef<jobject>& j_rtp_transceiver_direction) {
const jni_zero::JavaParamRef<jobject>& j_rtp_transceiver_direction) {
if (IsNull(jni, j_rtp_transceiver_direction)) {
return false;
}

7
sdk/android/src/jni/software_video_decoder_factory.cc
View file

@ -18,6 +18,7 @@
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/video_codec_info.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -30,7 +31,7 @@ static jlong JNI_SoftwareVideoDecoderFactory_CreateFactory(JNIEnv* env) {
jboolean JNI_SoftwareVideoDecoderFactory_IsSupported(
JNIEnv* env,
jlong j_factory,
const JavaParamRef<jobject>& j_info) {
const jni_zero::JavaParamRef<jobject>& j_info) {
return VideoCodecInfoToSdpVideoFormat(env, j_info)
.IsCodecInList(reinterpret_cast<VideoDecoderFactory*>(j_factory)
->GetSupportedFormats());
@ -40,7 +41,7 @@ jlong JNI_SoftwareVideoDecoderFactory_Create(
JNIEnv* env,
jlong j_factory,
jlong j_webrtc_env_ref,
const JavaParamRef<jobject>& j_info) {
const jni_zero::JavaParamRef<jobject>& j_info) {
return NativeToJavaPointer(
reinterpret_cast<VideoDecoderFactory*>(j_factory)
->Create(*reinterpret_cast<const Environment*>(j_webrtc_env_ref),
@ -48,7 +49,7 @@ jlong JNI_SoftwareVideoDecoderFactory_Create(
.release());
}
static webrtc::ScopedJavaLocalRef<jobject>
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_SoftwareVideoDecoderFactory_GetSupportedCodecs(JNIEnv* env,
jlong j_factory) {
auto* const native_factory =

7
sdk/android/src/jni/software_video_encoder_factory.cc
View file

@ -15,6 +15,7 @@
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/video_codec_info.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -27,7 +28,7 @@ static jlong JNI_SoftwareVideoEncoderFactory_CreateFactory(JNIEnv* env) {
jboolean JNI_SoftwareVideoEncoderFactory_IsSupported(
JNIEnv* env,
jlong j_factory,
const JavaParamRef<jobject>& j_info) {
const jni_zero::JavaParamRef<jobject>& j_info) {
return VideoCodecInfoToSdpVideoFormat(env, j_info)
.IsCodecInList(reinterpret_cast<VideoEncoderFactory*>(j_factory)
->GetSupportedFormats());
@ -37,7 +38,7 @@ jlong JNI_SoftwareVideoEncoderFactory_Create(
JNIEnv* env,
jlong j_factory,
jlong j_webrtc_env_ref,
const JavaParamRef<jobject>& j_info) {
const jni_zero::JavaParamRef<jobject>& j_info) {
return NativeToJavaPointer(
reinterpret_cast<VideoEncoderFactory*>(j_factory)
->Create(*reinterpret_cast<const Environment*>(j_webrtc_env_ref),
@ -45,7 +46,7 @@ jlong JNI_SoftwareVideoEncoderFactory_Create(
.release());
}
static webrtc::ScopedJavaLocalRef<jobject>
static jni_zero::ScopedJavaLocalRef<jobject>
JNI_SoftwareVideoEncoderFactory_GetSupportedCodecs(JNIEnv* env,
jlong j_factory) {
auto* const native_factory =

5
sdk/android/src/jni/video_decoder_fallback.cc
View file

@ -15,6 +15,7 @@
#include "sdk/android/generated_video_jni/VideoDecoderFallback_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/video_decoder_wrapper.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -22,8 +23,8 @@ namespace jni {
static jlong JNI_VideoDecoderFallback_Create(
JNIEnv* jni,
jlong j_webrtc_env_ref,
const JavaParamRef<jobject>& j_fallback_decoder,
const JavaParamRef<jobject>& j_primary_decoder) {
const jni_zero::JavaParamRef<jobject>& j_fallback_decoder,
const jni_zero::JavaParamRef<jobject>& j_primary_decoder) {
std::unique_ptr<VideoDecoder> fallback_decoder =
JavaToNativeVideoDecoder(jni, j_fallback_decoder, j_webrtc_env_ref);
std::unique_ptr<VideoDecoder> primary_decoder =

5
sdk/android/src/jni/video_encoder_fallback.cc
View file

@ -15,6 +15,7 @@
#include "sdk/android/generated_video_jni/VideoEncoderFallback_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/video_encoder_wrapper.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -22,8 +23,8 @@ namespace jni {
jlong JNI_VideoEncoderFallback_Create(
JNIEnv* jni,
jlong j_webrtc_env_ref,
const JavaParamRef<jobject>& j_fallback_encoder,
const JavaParamRef<jobject>& j_primary_encoder) {
const jni_zero::JavaParamRef<jobject>& j_fallback_encoder,
const jni_zero::JavaParamRef<jobject>& j_primary_encoder) {
std::unique_ptr<VideoEncoder> fallback_encoder =
JavaToNativeVideoEncoder(jni, j_fallback_encoder, j_webrtc_env_ref);
std::unique_ptr<VideoEncoder> primary_encoder =

6
sdk/android/src/jni/video_track.cc
View file

@ -14,6 +14,7 @@
#include "sdk/android/generated_video_jni/VideoTrack_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/video_sink.h"
#include "third_party/jni_zero/jni_zero.h"
namespace webrtc {
namespace jni {
@ -35,8 +36,9 @@ static void JNI_VideoTrack_RemoveSink(JNIEnv* jni,
j_native_sink));
}
static jlong JNI_VideoTrack_WrapSink(JNIEnv* jni,
const JavaParamRef<jobject>& sink) {
static jlong JNI_VideoTrack_WrapSink(
JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& sink) {
return jlongFromPointer(new VideoSinkWrapper(jni, sink));
}

64
sdk/android/src/jni/yuv_helper.cc
View file

@ -12,6 +12,7 @@
#include "sdk/android/generated_video_jni/YuvHelper_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "third_party/jni_zero/jni_zero.h"
#include "third_party/libyuv/include/libyuv/convert.h"
#include "third_party/libyuv/include/libyuv/planar_functions.h"
@ -19,9 +20,9 @@ namespace webrtc {
namespace jni {
void JNI_YuvHelper_CopyPlane(JNIEnv* jni,
const JavaParamRef<jobject>& j_src,
const jni_zero::JavaParamRef<jobject>& j_src,
jint src_stride,
const JavaParamRef<jobject>& j_dst,
const jni_zero::JavaParamRef<jobject>& j_dst,
jint dst_stride,
jint width,
jint height) {
@ -34,17 +35,17 @@ void JNI_YuvHelper_CopyPlane(JNIEnv* jni,
}
void JNI_YuvHelper_I420Copy(JNIEnv* jni,
const JavaParamRef<jobject>& j_src_y,
const jni_zero::JavaParamRef<jobject>& j_src_y,
jint src_stride_y,
const JavaParamRef<jobject>& j_src_u,
const jni_zero::JavaParamRef<jobject>& j_src_u,
jint src_stride_u,
const JavaParamRef<jobject>& j_src_v,
const jni_zero::JavaParamRef<jobject>& j_src_v,
jint src_stride_v,
const JavaParamRef<jobject>& j_dst_y,
const jni_zero::JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const JavaParamRef<jobject>& j_dst_u,
const jni_zero::JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const JavaParamRef<jobject>& j_dst_v,
const jni_zero::JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v,
jint width,
jint height) {
@ -66,19 +67,20 @@ void JNI_YuvHelper_I420Copy(JNIEnv* jni,
dst_v, dst_stride_v, width, height);
}
static void JNI_YuvHelper_I420ToNV12(JNIEnv* jni,
const JavaParamRef<jobject>& j_src_y,
jint src_stride_y,
const JavaParamRef<jobject>& j_src_u,
jint src_stride_u,
const JavaParamRef<jobject>& j_src_v,
jint src_stride_v,
const JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const JavaParamRef<jobject>& j_dst_uv,
jint dst_stride_uv,
jint width,
jint height) {
static void JNI_YuvHelper_I420ToNV12(
JNIEnv* jni,
const jni_zero::JavaParamRef<jobject>& j_src_y,
jint src_stride_y,
const jni_zero::JavaParamRef<jobject>& j_src_u,
jint src_stride_u,
const jni_zero::JavaParamRef<jobject>& j_src_v,
jint src_stride_v,
const jni_zero::JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const jni_zero::JavaParamRef<jobject>& j_dst_uv,
jint dst_stride_uv,
jint width,
jint height) {
const uint8_t* src_y =
static_cast<const uint8_t*>(jni->GetDirectBufferAddress(j_src_y.obj()));
const uint8_t* src_u =
@ -96,17 +98,17 @@ static void JNI_YuvHelper_I420ToNV12(JNIEnv* jni,
}
void JNI_YuvHelper_I420Rotate(JNIEnv* jni,
const JavaParamRef<jobject>& j_src_y,
const jni_zero::JavaParamRef<jobject>& j_src_y,
jint src_stride_y,
const JavaParamRef<jobject>& j_src_u,
const jni_zero::JavaParamRef<jobject>& j_src_u,
jint src_stride_u,
const JavaParamRef<jobject>& j_src_v,
const jni_zero::JavaParamRef<jobject>& j_src_v,
jint src_stride_v,
const JavaParamRef<jobject>& j_dst_y,
const jni_zero::JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const JavaParamRef<jobject>& j_dst_u,
const jni_zero::JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const JavaParamRef<jobject>& j_dst_v,
const jni_zero::JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v,
jint src_width,
jint src_height,
@ -131,13 +133,13 @@ void JNI_YuvHelper_I420Rotate(JNIEnv* jni,
}
void JNI_YuvHelper_ABGRToI420(JNIEnv* jni,
const JavaParamRef<jobject>& j_src,
const jni_zero::JavaParamRef<jobject>& j_src,
jint src_stride,
const JavaParamRef<jobject>& j_dst_y,
const jni_zero::JavaParamRef<jobject>& j_dst_y,
jint dst_stride_y,
const JavaParamRef<jobject>& j_dst_u,
const jni_zero::JavaParamRef<jobject>& j_dst_u,
jint dst_stride_u,
const JavaParamRef<jobject>& j_dst_v,
const jni_zero::JavaParamRef<jobject>& j_dst_v,
jint dst_stride_v,
jint src_width,
jint src_height) {