zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Android: Generate JNI code for RtpReceiver and PeerConnection.Observer

Browse Source 
Bug: webrtc:8278
Change-Id: Ief62c37dd6820c2eb1ce94e37e0a61dd8726caae
Reviewed-on: https://webrtc-review.googlesource.com/28621
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21035}
This commit is contained in:
Magnus Jedvert
2017-12-04 13:43:27 +01:00
committed by Commit Bot
parent cb666f5e03
commit ba700f642b
14 changed files with 250 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
sdk/android/src/jni/jni_helpers.h
View File

@ -155,14 +155,22 @@ class ScopedGlobalRef {
public:
ScopedGlobalRef(JNIEnv* jni, T obj)
: obj_(static_cast<T>(jni->NewGlobalRef(obj))) {}
ScopedGlobalRef(ScopedGlobalRef&& other) : obj_(other.obj_) {
other.obj_ = nullptr;
}
~ScopedGlobalRef() {
DeleteGlobalRef(AttachCurrentThreadIfNeeded(), obj_);
if (obj_) {
DeleteGlobalRef(AttachCurrentThreadIfNeeded(), obj_);
}
}
T operator*() const {
return obj_;
}
private:
T obj_;
RTC_DISALLOW_COPY_AND_ASSIGN(ScopedGlobalRef);
};
// Provides a convenient way to iterate over a Java Iterable using the

11
sdk/android/src/jni/pc/java_native_conversion.cc
View File

@ -471,10 +471,8 @@ void JavaToNativeRTCConfiguration(
}
}
void JavaToNativeRtpParameters(JNIEnv* jni,
jobject j_parameters,
RtpParameters* parameters) {
RTC_CHECK(parameters != nullptr);
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters) {
RtpParameters parameters;
jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
jfieldID encodings_id =
GetFieldID(jni, parameters_class, "encodings", "Ljava/util/List;");
@ -507,7 +505,7 @@ void JavaToNativeRtpParameters(JNIEnv* jni,
CHECK_EXCEPTION(jni) << "error during CallLongMethod";
encoding.ssrc = ssrc_value;
}
parameters->encodings.push_back(encoding);
parameters.encodings.push_back(encoding);
}
// Convert codecs.
@ -533,8 +531,9 @@ void JavaToNativeRtpParameters(JNIEnv* jni,
jobject j_num_channels =
GetNullableObjectField(jni, j_codec, num_channels_id);
codec.num_channels = JavaToNativeOptionalInt(jni, j_num_channels);
parameters->codecs.push_back(codec);
parameters.codecs.push_back(codec);
}
return parameters;
}
jobject NativeToJavaRtpParameters(JNIEnv* jni,

4
sdk/android/src/jni/pc/java_native_conversion.h
View File

@ -98,9 +98,7 @@ void JavaToNativeRTCConfiguration(
/*********************************************************
* RtpParameters, used for RtpSender and RtpReceiver APIs.
*********************************************************/
void JavaToNativeRtpParameters(JNIEnv* jni,
jobject j_parameters,
RtpParameters* parameters);
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters);
jobject NativeToJavaRtpParameters(JNIEnv* jni, const RtpParameters& parameters);

35
sdk/android/src/jni/pc/peerconnection_jni.cc
View File

@ -168,7 +168,7 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeSetConfiguration,
PeerConnection_setNativeConfiguration,
JNIEnv* jni,
jobject j_pc,
jobject j_rtc_config,
@ -185,7 +185,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
}
JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeAddIceCandidate,
PeerConnection_addNativeIceCandidate,
JNIEnv* jni,
jobject j_pc,
jstring j_sdp_mid,
@ -199,7 +199,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
}
JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeRemoveIceCandidates,
PeerConnection_removeNativeIceCandidates,
JNIEnv* jni,
jobject j_pc,
jobjectArray j_candidates) {
@ -213,7 +213,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
}
JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeAddLocalStream,
PeerConnection_addNativeLocalStream,
JNIEnv* jni,
jobject j_pc,
jlong native_stream) {
@ -222,7 +222,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnection_nativeRemoveLocalStream,
PeerConnection_removeNativeLocalStream,
JNIEnv* jni,
jobject j_pc,
jlong native_stream) {
@ -231,7 +231,7 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_nativeCreateSender,
PeerConnection_createNativeSender,
JNIEnv* jni,
jobject j_pc,
jstring j_kind,
@ -258,7 +258,7 @@ JNI_FUNCTION_DECLARATION(jobject,
}
JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_nativeGetSenders,
PeerConnection_getNativeSenders,
JNIEnv* jni,
jobject j_pc) {
jclass j_array_list_class = FindClass(jni, "java/util/ArrayList");
@ -289,7 +289,7 @@ JNI_FUNCTION_DECLARATION(jobject,
}
JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_nativeGetReceivers,
PeerConnection_getNativeReceivers,
JNIEnv* jni,
jobject j_pc) {
jclass j_array_list_class = FindClass(jni, "java/util/ArrayList");
@ -300,18 +300,9 @@ JNI_FUNCTION_DECLARATION(jobject,
jobject j_receivers = jni->NewObject(j_array_list_class, j_array_list_ctor);
CHECK_EXCEPTION(jni) << "error during NewObject";
jclass j_rtp_receiver_class = FindClass(jni, "org/webrtc/RtpReceiver");
jmethodID j_rtp_receiver_ctor =
GetMethodID(jni, j_rtp_receiver_class, "<init>", "(J)V");
auto receivers = ExtractNativePC(jni, j_pc)->GetReceivers();
for (const auto& receiver : receivers) {
jlong nativeReceiverPtr = jlongFromPointer(receiver.get());
jobject j_receiver = jni->NewObject(j_rtp_receiver_class,
j_rtp_receiver_ctor, nativeReceiverPtr);
CHECK_EXCEPTION(jni) << "error during NewObject";
// Receiver is now owned by Java object, and will be freed from there.
receiver->AddRef();
jobject j_receiver = NativeToJavaRtpReceiver(jni, receiver);
jni->CallBooleanMethod(j_receivers, j_array_list_add, j_receiver);
CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
}
@ -319,7 +310,7 @@ JNI_FUNCTION_DECLARATION(jobject,
}
JNI_FUNCTION_DECLARATION(bool,
PeerConnection_nativeOldGetStats,
PeerConnection_oldGetNativeStats,
JNIEnv* jni,
jobject j_pc,
jobject j_observer,
@ -332,7 +323,7 @@ JNI_FUNCTION_DECLARATION(bool,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnection_nativeNewGetStats,
PeerConnection_newGetNativeStats,
JNIEnv* jni,
jobject j_pc,
jobject j_callback) {
@ -357,7 +348,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
}
JNI_FUNCTION_DECLARATION(bool,
PeerConnection_nativeStartRtcEventLog,
PeerConnection_startNativeRtcEventLog,
JNIEnv* jni,
jobject j_pc,
int file_descriptor,
@ -367,7 +358,7 @@ JNI_FUNCTION_DECLARATION(bool,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnection_nativeStopRtcEventLog,
PeerConnection_stopNativeRtcEventLog,
JNIEnv* jni,
jobject j_pc) {
ExtractNativePC(jni, j_pc)->StopRtcEventLog();

135
sdk/android/src/jni/pc/peerconnectionobserver_jni.cc
View File

@ -15,6 +15,7 @@
#include "rtc_base/ptr_util.h"
#include "sdk/android/generated_peerconnection_jni/jni/MediaStream_jni.h"
#include "sdk/android/generated_peerconnection_jni/jni/PeerConnection_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/datachannel.h"
@ -31,87 +32,68 @@ static JNIEnv* jni() {
PeerConnectionObserverJni::PeerConnectionObserverJni(JNIEnv* jni,
jobject j_observer)
: j_observer_global_(jni, j_observer),
j_observer_class_(jni, GetObjectClass(jni, *j_observer_global_)),
j_rtp_receiver_class_(jni, FindClass(jni, "org/webrtc/RtpReceiver")),
j_rtp_receiver_ctor_(
GetMethodID(jni, *j_rtp_receiver_class_, "<init>", "(J)V")) {}
: j_observer_global_(jni, j_observer) {}
PeerConnectionObserverJni::~PeerConnectionObserverJni() {
ScopedLocalRefFrame local_ref_frame(jni());
while (!remote_streams_.empty())
DisposeRemoteStream(remote_streams_.begin());
while (!rtp_receivers_.empty())
DisposeRtpReceiver(rtp_receivers_.begin());
}
void PeerConnectionObserverJni::OnIceCandidate(
const IceCandidateInterface* candidate) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
jobject j_candidate = NativeToJavaIceCandidate(env, *candidate);
jmethodID m = GetMethodID(env, *j_observer_class_, "onIceCandidate",
"(Lorg/webrtc/IceCandidate;)V");
env->CallVoidMethod(*j_observer_global_, m, j_candidate);
CHECK_EXCEPTION(env) << "error during CallVoidMethod";
Java_Observer_onIceCandidate(env, *j_observer_global_,
NativeToJavaIceCandidate(env, *candidate));
}
void PeerConnectionObserverJni::OnIceCandidatesRemoved(
const std::vector<cricket::Candidate>& candidates) {
ScopedLocalRefFrame local_ref_frame(jni());
jobjectArray candidates_array = NativeToJavaCandidateArray(jni(), candidates);
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onIceCandidatesRemoved",
"([Lorg/webrtc/IceCandidate;)V");
jni()->CallVoidMethod(*j_observer_global_, m, candidates_array);
CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod";
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
Java_Observer_onIceCandidatesRemoved(
env, *j_observer_global_, NativeToJavaCandidateArray(env, candidates));
}
void PeerConnectionObserverJni::OnSignalingChange(
PeerConnectionInterface::SignalingState new_state) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSignalingChange",
"(Lorg/webrtc/PeerConnection$SignalingState;)V");
jobject new_state_enum = JavaEnumFromIndexAndClassName(
jni(), "PeerConnection$SignalingState", new_state);
jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
Java_Observer_onSignalingChange(
env, *j_observer_global_,
Java_SignalingState_fromNativeIndex(env, new_state));
}
void PeerConnectionObserverJni::OnIceConnectionChange(
PeerConnectionInterface::IceConnectionState new_state) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m =
GetMethodID(jni(), *j_observer_class_, "onIceConnectionChange",
"(Lorg/webrtc/PeerConnection$IceConnectionState;)V");
jobject new_state_enum = JavaEnumFromIndexAndClassName(
jni(), "PeerConnection$IceConnectionState", new_state);
jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
Java_Observer_onIceConnectionChange(
env, *j_observer_global_,
Java_IceConnectionState_fromNativeIndex(env, new_state));
}
void PeerConnectionObserverJni::OnIceConnectionReceivingChange(bool receiving) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_,
"onIceConnectionReceivingChange", "(Z)V");
jni()->CallVoidMethod(*j_observer_global_, m, receiving);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
Java_Observer_onIceConnectionReceivingChange(env, *j_observer_global_,
receiving);
}
void PeerConnectionObserverJni::OnIceGatheringChange(
PeerConnectionInterface::IceGatheringState new_state) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onIceGatheringChange",
"(Lorg/webrtc/PeerConnection$IceGatheringState;)V");
jobject new_state_enum = JavaEnumFromIndexAndClassName(
jni(), "PeerConnection$IceGatheringState", new_state);
jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
Java_Observer_onIceGatheringChange(
env, *j_observer_global_,
Java_IceGatheringState_fromNativeIndex(env, new_state));
}
void PeerConnectionObserverJni::OnAddStream(
rtc::scoped_refptr<MediaStreamInterface> stream) {
ScopedLocalRefFrame local_ref_frame(jni());
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
// The stream could be added into the remote_streams_ map when calling
// OnAddTrack.
jobject j_stream = GetOrCreateJavaStream(stream);
@ -123,10 +105,7 @@ void PeerConnectionObserverJni::OnAddStream(
AddNativeVideoTrackToJavaStream(track, j_stream);
}
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onAddStream",
"(Lorg/webrtc/MediaStream;)V");
jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
Java_Observer_onAddStream(env, *j_observer_global_, j_stream);
// Create an observer to update the Java stream when the native stream's set
// of tracks changes.
@ -194,15 +173,12 @@ void PeerConnectionObserverJni::OnVideoTrackRemovedFromStream(
void PeerConnectionObserverJni::OnRemoveStream(
rtc::scoped_refptr<MediaStreamInterface> stream) {
ScopedLocalRefFrame local_ref_frame(jni());
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
RTC_CHECK(it != remote_streams_.end())
<< "unexpected stream: " << std::hex << stream;
jobject j_stream = it->second;
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onRemoveStream",
"(Lorg/webrtc/MediaStream;)V");
jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
Java_Observer_onRemoveStream(env, *j_observer_global_, it->second);
// Release the refptr reference so that DisposeRemoteStream can assert
// it removes the final reference.
@ -214,38 +190,26 @@ void PeerConnectionObserverJni::OnDataChannel(
rtc::scoped_refptr<DataChannelInterface> channel) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
jobject j_channel = WrapNativeDataChannel(env, channel);
jmethodID m = GetMethodID(env, *j_observer_class_, "onDataChannel",
"(Lorg/webrtc/DataChannel;)V");
env->CallVoidMethod(*j_observer_global_, m, j_channel);
CHECK_EXCEPTION(env) << "error during CallVoidMethod";
Java_Observer_onDataChannel(env, *j_observer_global_,
WrapNativeDataChannel(env, channel));
}
void PeerConnectionObserverJni::OnRenegotiationNeeded() {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m =
GetMethodID(jni(), *j_observer_class_, "onRenegotiationNeeded", "()V");
jni()->CallVoidMethod(*j_observer_global_, m);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
Java_Observer_onRenegotiationNeeded(env, *j_observer_global_);
}
void PeerConnectionObserverJni::OnAddTrack(
rtc::scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
ScopedLocalRefFrame local_ref_frame(jni());
jobject j_rtp_receiver =
jni()->NewObject(*j_rtp_receiver_class_, j_rtp_receiver_ctor_,
jlongFromPointer(receiver.get()));
CHECK_EXCEPTION(jni()) << "error during NewObject";
receiver->AddRef();
rtp_receivers_[receiver] = NewGlobalRef(jni(), j_rtp_receiver);
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
jobject j_rtp_receiver = NativeToJavaRtpReceiver(env, receiver);
rtp_receivers_.emplace_back(env, j_rtp_receiver);
jobjectArray j_stream_array = NativeToJavaMediaStreamArray(jni(), streams);
jmethodID m =
GetMethodID(jni(), *j_observer_class_, "onAddTrack",
"(Lorg/webrtc/RtpReceiver;[Lorg/webrtc/MediaStream;)V");
jni()->CallVoidMethod(*j_observer_global_, m, j_rtp_receiver, j_stream_array);
CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod";
Java_Observer_onAddTrack(env, *j_observer_global_, j_rtp_receiver,
NativeToJavaMediaStreamArray(env, streams));
}
void PeerConnectionObserverJni::SetConstraints(
@ -274,17 +238,6 @@ void PeerConnectionObserverJni::DisposeRemoteStream(
DeleteGlobalRef(env, j_stream);
}
void PeerConnectionObserverJni::DisposeRtpReceiver(
const NativeToJavaRtpReceiverMap::iterator& it) {
jobject j_rtp_receiver = it->second;
rtp_receivers_.erase(it);
jni()->CallVoidMethod(
j_rtp_receiver,
GetMethodID(jni(), *j_rtp_receiver_class_, "dispose", "()V"));
CHECK_EXCEPTION(jni()) << "error during RtpReceiver.dispose()";
DeleteGlobalRef(jni(), j_rtp_receiver);
}
// If the NativeToJavaStreamsMap contains the stream, return it.
// Otherwise, create a new Java MediaStream.
jobject PeerConnectionObserverJni::GetOrCreateJavaStream(

8
sdk/android/src/jni/pc/peerconnectionobserver_jni.h
View File

@ -19,6 +19,7 @@
#include "api/peerconnectioninterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/mediaconstraints_jni.h"
#include "sdk/android/src/jni/pc/rtpreceiver.h"
namespace webrtc {
namespace jni {
@ -57,14 +58,12 @@ class PeerConnectionObserverJni : public PeerConnectionObserver,
private:
typedef std::map<MediaStreamInterface*, jobject> NativeToJavaStreamsMap;
typedef std::map<RtpReceiverInterface*, jobject> NativeToJavaRtpReceiverMap;
typedef std::map<MediaStreamTrackInterface*, jobject>
NativeToJavaMediaTrackMap;
typedef std::map<MediaStreamTrackInterface*, RtpReceiverInterface*>
NativeMediaStreamTrackToNativeRtpReceiver;
void DisposeRemoteStream(const NativeToJavaStreamsMap::iterator& it);
void DisposeRtpReceiver(const NativeToJavaRtpReceiverMap::iterator& it);
// If the NativeToJavaStreamsMap contains the stream, return it.
// Otherwise, create a new Java MediaStream.
@ -100,14 +99,11 @@ class PeerConnectionObserverJni : public PeerConnectionObserver,
MediaStreamInterface* stream);
const ScopedGlobalRef<jobject> j_observer_global_;
const ScopedGlobalRef<jclass> j_observer_class_;
const ScopedGlobalRef<jclass> j_rtp_receiver_class_;
const jmethodID j_rtp_receiver_ctor_;
// C++ -> Java remote streams. The stored jobects are global refs and must be
// manually deleted upon removal. Use DisposeRemoteStream().
NativeToJavaStreamsMap remote_streams_;
NativeToJavaRtpReceiverMap rtp_receivers_;
std::vector<JavaRtpReceiverGlobalOwner> rtp_receivers_;
std::unique_ptr<MediaConstraintsInterface> constraints_;
std::vector<std::unique_ptr<webrtc::MediaStreamObserver>> stream_observers_;
};

67
sdk/android/src/jni/pc/rtpreceiver_jni.cc → sdk/android/src/jni/pc/rtpreceiver.cc
View File

@ -8,16 +8,61 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "api/rtpreceiverinterface.h"
#include "sdk/android/src/jni/pc/rtpreceiver.h"
#include "sdk/android/generated_peerconnection_jni/jni/RtpReceiver_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/java_native_conversion.h"
#include "sdk/android/src/jni/pc/rtpreceiverobserver_jni.h"
namespace webrtc {
namespace jni {
namespace {
// Adapter between the C++ RtpReceiverObserverInterface and the Java
// RtpReceiver.Observer interface. Wraps an instance of the Java interface and
// dispatches C++ callbacks to Java.
class RtpReceiverObserverJni : public RtpReceiverObserverInterface {
public:
RtpReceiverObserverJni(JNIEnv* env, jobject j_observer)
: j_observer_global_(env, j_observer) {}
~RtpReceiverObserverJni() override = default;
void OnFirstPacketReceived(cricket::MediaType media_type) override {
JNIEnv* const env = AttachCurrentThreadIfNeeded();
Java_Observer_onFirstPacketReceived(env, *j_observer_global_,
NativeToJavaMediaType(env, media_type));
}
private:
const ScopedGlobalRef<jobject> j_observer_global_;
};
} // namespace
jobject NativeToJavaRtpReceiver(
JNIEnv* env,
rtc::scoped_refptr<RtpReceiverInterface> receiver) {
// Receiver is now owned by Java object, and will be freed from there.
return Java_RtpReceiver_Constructor(env,
jlongFromPointer(receiver.release()));
}
JavaRtpReceiverGlobalOwner::JavaRtpReceiverGlobalOwner(JNIEnv* env,
jobject j_receiver)
: j_receiver_(env, j_receiver) {}
JavaRtpReceiverGlobalOwner::JavaRtpReceiverGlobalOwner(
JavaRtpReceiverGlobalOwner&& other) = default;
JavaRtpReceiverGlobalOwner::~JavaRtpReceiverGlobalOwner() {
if (*j_receiver_)
Java_RtpReceiver_dispose(AttachCurrentThreadIfNeeded(), *j_receiver_);
}
JNI_FUNCTION_DECLARATION(jlong,
RtpReceiver_nativeGetTrack,
RtpReceiver_getNativeTrack,
JNIEnv* jni,
jclass,
jlong j_rtp_receiver_pointer,
@ -29,22 +74,18 @@ JNI_FUNCTION_DECLARATION(jlong,
}
JNI_FUNCTION_DECLARATION(jboolean,
RtpReceiver_nativeSetParameters,
RtpReceiver_setNativeParameters,
JNIEnv* jni,
jclass,
jlong j_rtp_receiver_pointer,
jobject j_parameters) {
if (IsNull(jni, j_parameters)) {
return false;
}
RtpParameters parameters;
JavaToNativeRtpParameters(jni, j_parameters, &parameters);
RtpParameters parameters = JavaToNativeRtpParameters(jni, j_parameters);
return reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
->SetParameters(parameters);
}
JNI_FUNCTION_DECLARATION(jobject,
RtpReceiver_nativeGetParameters,
RtpReceiver_getNativeParameters,
JNIEnv* jni,
jclass,
jlong j_rtp_receiver_pointer) {
@ -55,7 +96,7 @@ JNI_FUNCTION_DECLARATION(jobject,
}
JNI_FUNCTION_DECLARATION(jstring,
RtpReceiver_nativeId,
RtpReceiver_getNativeId,
JNIEnv* jni,
jclass,
jlong j_rtp_receiver_pointer) {
@ -65,7 +106,7 @@ JNI_FUNCTION_DECLARATION(jstring,
}
JNI_FUNCTION_DECLARATION(jlong,
RtpReceiver_nativeSetObserver,
RtpReceiver_setNativeObserver,
JNIEnv* jni,
jclass,
jlong j_rtp_receiver_pointer,
@ -78,7 +119,7 @@ JNI_FUNCTION_DECLARATION(jlong,
}
JNI_FUNCTION_DECLARATION(void,
RtpReceiver_nativeUnsetObserver,
RtpReceiver_unsetNativeObserver,
JNIEnv* jni,
jclass,
jlong j_rtp_receiver_pointer,

41
sdk/android/src/jni/pc/rtpreceiver.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_RTPRECEIVER_H_
#define SDK_ANDROID_SRC_JNI_PC_RTPRECEIVER_H_
#include <jni.h>
#include "api/rtpreceiverinterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
jobject NativeToJavaRtpReceiver(
JNIEnv* env,
rtc::scoped_refptr<RtpReceiverInterface> receiver);
// Takes ownership of the passed |j_receiver| and stores it as a global
// reference. Will call dispose() in the dtor.
class JavaRtpReceiverGlobalOwner {
public:
JavaRtpReceiverGlobalOwner(JNIEnv* env, jobject j_receiver);
JavaRtpReceiverGlobalOwner(JavaRtpReceiverGlobalOwner&& other);
~JavaRtpReceiverGlobalOwner();
private:
ScopedGlobalRef<jobject> j_receiver_;
};
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_RTPRECEIVER_H_

34
sdk/android/src/jni/pc/rtpreceiverobserver_jni.cc
View File

@ -1,34 +0,0 @@
/*
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/rtpreceiverobserver_jni.h"
#include "sdk/android/src/jni/pc/java_native_conversion.h"
namespace webrtc {
namespace jni {
void RtpReceiverObserverJni::OnFirstPacketReceived(
cricket::MediaType media_type) {
JNIEnv* const jni = AttachCurrentThreadIfNeeded();
jmethodID j_on_first_packet_received_mid = GetMethodID(
jni, GetObjectClass(jni, *j_observer_global_), "onFirstPacketReceived",
"(Lorg/webrtc/MediaStreamTrack$MediaType;)V");
// Get the Java version of media type.
jobject JavaMediaType = NativeToJavaMediaType(jni, media_type);
// Trigger the callback function.
jni->CallVoidMethod(*j_observer_global_, j_on_first_packet_received_mid,
JavaMediaType);
CHECK_EXCEPTION(jni) << "error during CallVoidMethod";
}
} // namespace jni
} // namespace webrtc

39
sdk/android/src/jni/pc/rtpreceiverobserver_jni.h
View File

@ -1,39 +0,0 @@
/*
* Copyright 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_RTPRECEIVEROBSERVER_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_RTPRECEIVEROBSERVER_JNI_H_
#include "api/rtpreceiverinterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
// Adapter between the C++ RtpReceiverObserverInterface and the Java
// RtpReceiver.Observer interface. Wraps an instance of the Java interface and
// dispatches C++ callbacks to Java.
class RtpReceiverObserverJni : public RtpReceiverObserverInterface {
public:
RtpReceiverObserverJni(JNIEnv* jni, jobject j_observer)
: j_observer_global_(jni, j_observer) {}
~RtpReceiverObserverJni() override {}
void OnFirstPacketReceived(cricket::MediaType media_type) override;
private:
const ScopedGlobalRef<jobject> j_observer_global_;
};
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_RTPRECEIVEROBSERVER_JNI_H_

3
sdk/android/src/jni/pc/rtpsender_jni.cc
View File

@ -56,8 +56,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
if (IsNull(jni, j_parameters)) {
return false;
}
RtpParameters parameters;
JavaToNativeRtpParameters(jni, j_parameters, &parameters);
RtpParameters parameters = JavaToNativeRtpParameters(jni, j_parameters);
return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->SetParameters(parameters);
}