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

7
sdk/android/BUILD.gn
View File

@ -298,9 +298,11 @@ generate_jni("generated_peerconnection_jni") {
"api/org/webrtc/MediaStreamTrack.java", "api/org/webrtc/MediaStreamTrack.java",
"api/org/webrtc/NetworkMonitor.java", "api/org/webrtc/NetworkMonitor.java",
"api/org/webrtc/NetworkMonitorAutoDetect.java", "api/org/webrtc/NetworkMonitorAutoDetect.java",
"api/org/webrtc/PeerConnection.java",
"api/org/webrtc/RTCStats.java", "api/org/webrtc/RTCStats.java",
"api/org/webrtc/RTCStatsCollectorCallback.java", "api/org/webrtc/RTCStatsCollectorCallback.java",
"api/org/webrtc/RTCStatsReport.java", "api/org/webrtc/RTCStatsReport.java",
"api/org/webrtc/RtpReceiver.java",
"api/org/webrtc/StatsObserver.java", "api/org/webrtc/StatsObserver.java",
"api/org/webrtc/StatsReport.java", "api/org/webrtc/StatsReport.java",
] ]
@ -334,9 +336,8 @@ rtc_static_library("peerconnection_jni") {
"src/jni/pc/peerconnectionobserver_jni.h", "src/jni/pc/peerconnectionobserver_jni.h",
"src/jni/pc/rtcstatscollectorcallbackwrapper.cc", "src/jni/pc/rtcstatscollectorcallbackwrapper.cc",
"src/jni/pc/rtcstatscollectorcallbackwrapper.h", "src/jni/pc/rtcstatscollectorcallbackwrapper.h",
"src/jni/pc/rtpreceiver_jni.cc", "src/jni/pc/rtpreceiver.cc",
"src/jni/pc/rtpreceiverobserver_jni.cc", "src/jni/pc/rtpreceiver.h",
"src/jni/pc/rtpreceiverobserver_jni.h",
"src/jni/pc/rtpsender_jni.cc", "src/jni/pc/rtpsender_jni.cc",
"src/jni/pc/sdpobserver_jni.h", "src/jni/pc/sdpobserver_jni.h",
"src/jni/pc/statsobserver_jni.cc", "src/jni/pc/statsobserver_jni.cc",

97
sdk/android/api/org/webrtc/PeerConnection.java
View File

@ -22,7 +22,16 @@ import java.util.List;
*/ */
public class PeerConnection { public class PeerConnection {
/** Tracks PeerConnectionInterface::IceGatheringState */ /** Tracks PeerConnectionInterface::IceGatheringState */
public enum IceGatheringState { NEW, GATHERING, COMPLETE } public enum IceGatheringState {
NEW,
GATHERING,
COMPLETE;
@CalledByNative("IceGatheringState")
static IceGatheringState fromNativeIndex(int nativeIndex) {
return values()[nativeIndex];
}
}
/** Tracks PeerConnectionInterface::IceConnectionState */ /** Tracks PeerConnectionInterface::IceConnectionState */
public enum IceConnectionState { public enum IceConnectionState {
@ -32,7 +41,12 @@ public class PeerConnection {
COMPLETED, COMPLETED,
FAILED, FAILED,
DISCONNECTED, DISCONNECTED,
CLOSED CLOSED;
@CalledByNative("IceConnectionState")
static IceConnectionState fromNativeIndex(int nativeIndex) {
return values()[nativeIndex];
}
} }
/** Tracks PeerConnectionInterface::TlsCertPolicy */ /** Tracks PeerConnectionInterface::TlsCertPolicy */
@ -48,46 +62,51 @@ public class PeerConnection {
HAVE_LOCAL_PRANSWER, HAVE_LOCAL_PRANSWER,
HAVE_REMOTE_OFFER, HAVE_REMOTE_OFFER,
HAVE_REMOTE_PRANSWER, HAVE_REMOTE_PRANSWER,
CLOSED CLOSED;
@CalledByNative("SignalingState")
static SignalingState fromNativeIndex(int nativeIndex) {
return values()[nativeIndex];
}
} }
/** Java version of PeerConnectionObserver. */ /** Java version of PeerConnectionObserver. */
public static interface Observer { public static interface Observer {
/** Triggered when the SignalingState changes. */ /** Triggered when the SignalingState changes. */
public void onSignalingChange(SignalingState newState); @CalledByNative("Observer") void onSignalingChange(SignalingState newState);
/** Triggered when the IceConnectionState changes. */ /** Triggered when the IceConnectionState changes. */
public void onIceConnectionChange(IceConnectionState newState); @CalledByNative("Observer") void onIceConnectionChange(IceConnectionState newState);
/** Triggered when the ICE connection receiving status changes. */ /** Triggered when the ICE connection receiving status changes. */
public void onIceConnectionReceivingChange(boolean receiving); @CalledByNative("Observer") void onIceConnectionReceivingChange(boolean receiving);
/** Triggered when the IceGatheringState changes. */ /** Triggered when the IceGatheringState changes. */
public void onIceGatheringChange(IceGatheringState newState); @CalledByNative("Observer") void onIceGatheringChange(IceGatheringState newState);
/** Triggered when a new ICE candidate has been found. */ /** Triggered when a new ICE candidate has been found. */
public void onIceCandidate(IceCandidate candidate); @CalledByNative("Observer") void onIceCandidate(IceCandidate candidate);
/** Triggered when some ICE candidates have been removed. */ /** Triggered when some ICE candidates have been removed. */
public void onIceCandidatesRemoved(IceCandidate[] candidates); @CalledByNative("Observer") void onIceCandidatesRemoved(IceCandidate[] candidates);
/** Triggered when media is received on a new stream from remote peer. */ /** Triggered when media is received on a new stream from remote peer. */
public void onAddStream(MediaStream stream); @CalledByNative("Observer") void onAddStream(MediaStream stream);
/** Triggered when a remote peer close a stream. */ /** Triggered when a remote peer close a stream. */
public void onRemoveStream(MediaStream stream); @CalledByNative("Observer") void onRemoveStream(MediaStream stream);
/** Triggered when a remote peer opens a DataChannel. */ /** Triggered when a remote peer opens a DataChannel. */
public void onDataChannel(DataChannel dataChannel); @CalledByNative("Observer") void onDataChannel(DataChannel dataChannel);
/** Triggered when renegotiation is necessary. */ /** Triggered when renegotiation is necessary. */
public void onRenegotiationNeeded(); @CalledByNative("Observer") void onRenegotiationNeeded();
/** /**
* Triggered when a new track is signaled by the remote peer, as a result of * Triggered when a new track is signaled by the remote peer, as a result of
* setRemoteDescription. * setRemoteDescription.
*/ */
public void onAddTrack(RtpReceiver receiver, MediaStream[] mediaStreams); @CalledByNative("Observer") void onAddTrack(RtpReceiver receiver, MediaStream[] mediaStreams);
} }
/** Java version of PeerConnectionInterface.IceServer. */ /** Java version of PeerConnectionInterface.IceServer. */
@ -369,19 +388,19 @@ public class PeerConnection {
public native void setAudioRecording(boolean recording); public native void setAudioRecording(boolean recording);
public boolean setConfiguration(RTCConfiguration config) { public boolean setConfiguration(RTCConfiguration config) {
return nativeSetConfiguration(config, nativeObserver); return setNativeConfiguration(config, nativeObserver);
} }
public boolean addIceCandidate(IceCandidate candidate) { public boolean addIceCandidate(IceCandidate candidate) {
return nativeAddIceCandidate(candidate.sdpMid, candidate.sdpMLineIndex, candidate.sdp); return addNativeIceCandidate(candidate.sdpMid, candidate.sdpMLineIndex, candidate.sdp);
} }
public boolean removeIceCandidates(final IceCandidate[] candidates) { public boolean removeIceCandidates(final IceCandidate[] candidates) {
return nativeRemoveIceCandidates(candidates); return removeNativeIceCandidates(candidates);
} }
public boolean addStream(MediaStream stream) { public boolean addStream(MediaStream stream) {
boolean ret = nativeAddLocalStream(stream.nativeStream); boolean ret = addNativeLocalStream(stream.nativeStream);
if (!ret) { if (!ret) {
return false; return false;
} }
@ -390,7 +409,7 @@ public class PeerConnection {
} }
public void removeStream(MediaStream stream) { public void removeStream(MediaStream stream) {
nativeRemoveLocalStream(stream.nativeStream); removeNativeLocalStream(stream.nativeStream);
localStreams.remove(stream); localStreams.remove(stream);
} }
@ -432,7 +451,7 @@ public class PeerConnection {
* @return A new RtpSender object if successful, or null otherwise. * @return A new RtpSender object if successful, or null otherwise.
*/ */
public RtpSender createSender(String kind, String stream_id) { public RtpSender createSender(String kind, String stream_id) {
RtpSender new_sender = nativeCreateSender(kind, stream_id); RtpSender new_sender = createNativeSender(kind, stream_id);
if (new_sender != null) { if (new_sender != null) {
senders.add(new_sender); senders.add(new_sender);
} }
@ -445,7 +464,7 @@ public class PeerConnection {
for (RtpSender sender : senders) { for (RtpSender sender : senders) {
sender.dispose(); sender.dispose();
} }
senders = nativeGetSenders(); senders = getNativeSenders();
return Collections.unmodifiableList(senders); return Collections.unmodifiableList(senders);
} }
@ -453,20 +472,20 @@ public class PeerConnection {
for (RtpReceiver receiver : receivers) { for (RtpReceiver receiver : receivers) {
receiver.dispose(); receiver.dispose();
} }
receivers = nativeGetReceivers(); receivers = getNativeReceivers();
return Collections.unmodifiableList(receivers); return Collections.unmodifiableList(receivers);
} }
// Older, non-standard implementation of getStats. // Older, non-standard implementation of getStats.
@Deprecated @Deprecated
public boolean getStats(StatsObserver observer, MediaStreamTrack track) { public boolean getStats(StatsObserver observer, MediaStreamTrack track) {
return nativeOldGetStats(observer, (track == null) ? 0 : track.nativeTrack); return oldGetNativeStats(observer, (track == null) ? 0 : track.nativeTrack);
} }
// Gets stats using the new stats collection API, see webrtc/api/stats/. These // Gets stats using the new stats collection API, see webrtc/api/stats/. These
// will replace old stats collection API when the new API has matured enough. // will replace old stats collection API when the new API has matured enough.
public void getStats(RTCStatsCollectorCallback callback) { public void getStats(RTCStatsCollectorCallback callback) {
nativeNewGetStats(callback); newGetNativeStats(callback);
} }
// Limits the bandwidth allocated for all RTP streams sent by this // Limits the bandwidth allocated for all RTP streams sent by this
@ -479,13 +498,13 @@ public class PeerConnection {
// continue until the stopRtcEventLog function is called. The max_size_bytes // continue until the stopRtcEventLog function is called. The max_size_bytes
// argument is ignored, it is added for future use. // argument is ignored, it is added for future use.
public boolean startRtcEventLog(int file_descriptor, int max_size_bytes) { public boolean startRtcEventLog(int file_descriptor, int max_size_bytes) {
return nativeStartRtcEventLog(file_descriptor, max_size_bytes); return startNativeRtcEventLog(file_descriptor, max_size_bytes);
} }
// Stops recording an RTC event log. If no RTC event log is currently being // Stops recording an RTC event log. If no RTC event log is currently being
// recorded, this call will have no effect. // recorded, this call will have no effect.
public void stopRtcEventLog() { public void stopRtcEventLog() {
nativeStopRtcEventLog(); stopNativeRtcEventLog();
} }
// TODO(fischman): add support for DTMF-related methods once that API // TODO(fischman): add support for DTMF-related methods once that API
@ -517,7 +536,7 @@ public class PeerConnection {
public void dispose() { public void dispose() {
close(); close();
for (MediaStream stream : localStreams) { for (MediaStream stream : localStreams) {
nativeRemoveLocalStream(stream.nativeStream); removeNativeLocalStream(stream.nativeStream);
stream.dispose(); stream.dispose();
} }
localStreams.clear(); localStreams.clear();
@ -535,28 +554,28 @@ public class PeerConnection {
private static native void freeObserver(long nativeObserver); private static native void freeObserver(long nativeObserver);
public native boolean nativeSetConfiguration(RTCConfiguration config, long nativeObserver); private native boolean setNativeConfiguration(RTCConfiguration config, long nativeObserver);
private native boolean nativeAddIceCandidate( private native boolean addNativeIceCandidate(
String sdpMid, int sdpMLineIndex, String iceCandidateSdp); String sdpMid, int sdpMLineIndex, String iceCandidateSdp);
private native boolean nativeRemoveIceCandidates(final IceCandidate[] candidates); private native boolean removeNativeIceCandidates(final IceCandidate[] candidates);
private native boolean nativeAddLocalStream(long nativeStream); private native boolean addNativeLocalStream(long nativeStream);
private native void nativeRemoveLocalStream(long nativeStream); private native void removeNativeLocalStream(long nativeStream);
private native boolean nativeOldGetStats(StatsObserver observer, long nativeTrack); private native boolean oldGetNativeStats(StatsObserver observer, long nativeTrack);
private native void nativeNewGetStats(RTCStatsCollectorCallback callback); private native void newGetNativeStats(RTCStatsCollectorCallback callback);
private native RtpSender nativeCreateSender(String kind, String stream_id); private native RtpSender createNativeSender(String kind, String stream_id);
private native List<RtpSender> nativeGetSenders(); private native List<RtpSender> getNativeSenders();
private native List<RtpReceiver> nativeGetReceivers(); private native List<RtpReceiver> getNativeReceivers();
private native boolean nativeStartRtcEventLog(int file_descriptor, int max_size_bytes); private native boolean startNativeRtcEventLog(int file_descriptor, int max_size_bytes);
private native void nativeStopRtcEventLog(); private native void stopNativeRtcEventLog();
} }

31
sdk/android/api/org/webrtc/RtpReceiver.java
View File

@ -10,11 +10,14 @@
package org.webrtc; package org.webrtc;
import org.webrtc.MediaStreamTrack;
/** Java wrapper for a C++ RtpReceiverInterface. */ /** Java wrapper for a C++ RtpReceiverInterface. */
public class RtpReceiver { public class RtpReceiver {
/** Java wrapper for a C++ RtpReceiverObserverInterface*/ /** Java wrapper for a C++ RtpReceiverObserverInterface*/
public static interface Observer { public static interface Observer {
// Called when the first audio or video packet is received. // Called when the first audio or video packet is received.
@CalledByNative("Observer")
public void onFirstPacketReceived(MediaStreamTrack.MediaType media_type); public void onFirstPacketReceived(MediaStreamTrack.MediaType media_type);
} }
@ -23,9 +26,10 @@ public class RtpReceiver {
private MediaStreamTrack cachedTrack; private MediaStreamTrack cachedTrack;
@CalledByNative
public RtpReceiver(long nativeRtpReceiver) { public RtpReceiver(long nativeRtpReceiver) {
this.nativeRtpReceiver = nativeRtpReceiver; this.nativeRtpReceiver = nativeRtpReceiver;
long track = nativeGetTrack(nativeRtpReceiver); long track = getNativeTrack(nativeRtpReceiver);
// We can assume that an RtpReceiver always has an associated track. // We can assume that an RtpReceiver always has an associated track.
cachedTrack = new MediaStreamTrack(track); cachedTrack = new MediaStreamTrack(track);
} }
@ -35,21 +39,22 @@ public class RtpReceiver {
} }
public boolean setParameters(RtpParameters parameters) { public boolean setParameters(RtpParameters parameters) {
return nativeSetParameters(nativeRtpReceiver, parameters); return parameters == null ? false : setNativeParameters(nativeRtpReceiver, parameters);
} }
public RtpParameters getParameters() { public RtpParameters getParameters() {
return nativeGetParameters(nativeRtpReceiver); return getNativeParameters(nativeRtpReceiver);
} }
public String id() { public String id() {
return nativeId(nativeRtpReceiver); return getNativeId(nativeRtpReceiver);
} }
@CalledByNative
public void dispose() { public void dispose() {
cachedTrack.dispose(); cachedTrack.dispose();
if (nativeObserver != 0) { if (nativeObserver != 0) {
nativeUnsetObserver(nativeRtpReceiver, nativeObserver); unsetNativeObserver(nativeRtpReceiver, nativeObserver);
nativeObserver = 0; nativeObserver = 0;
} }
JniCommon.nativeReleaseRef(nativeRtpReceiver); JniCommon.nativeReleaseRef(nativeRtpReceiver);
@ -58,23 +63,23 @@ public class RtpReceiver {
public void SetObserver(Observer observer) { public void SetObserver(Observer observer) {
// Unset the existing one before setting a new one. // Unset the existing one before setting a new one.
if (nativeObserver != 0) { if (nativeObserver != 0) {
nativeUnsetObserver(nativeRtpReceiver, nativeObserver); unsetNativeObserver(nativeRtpReceiver, nativeObserver);
} }
nativeObserver = nativeSetObserver(nativeRtpReceiver, observer); nativeObserver = setNativeObserver(nativeRtpReceiver, observer);
} }
// This should increment the reference count of the track. // This should increment the reference count of the track.
// Will be released in dispose(). // Will be released in dispose().
private static native long nativeGetTrack(long nativeRtpReceiver); private static native long getNativeTrack(long nativeRtpReceiver);
private static native boolean nativeSetParameters( private static native boolean setNativeParameters(
long nativeRtpReceiver, RtpParameters parameters); long nativeRtpReceiver, RtpParameters parameters);
private static native RtpParameters nativeGetParameters(long nativeRtpReceiver); private static native RtpParameters getNativeParameters(long nativeRtpReceiver);
private static native String nativeId(long nativeRtpReceiver); private static native String getNativeId(long nativeRtpReceiver);
private static native long nativeSetObserver(long nativeRtpReceiver, Observer observer); private static native long setNativeObserver(long nativeRtpReceiver, Observer observer);
private static native long nativeUnsetObserver(long nativeRtpReceiver, long nativeObserver); private static native void unsetNativeObserver(long nativeRtpReceiver, long nativeObserver);
}; };

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

@ -155,14 +155,22 @@ class ScopedGlobalRef {
public: public:
ScopedGlobalRef(JNIEnv* jni, T obj) ScopedGlobalRef(JNIEnv* jni, T obj)
: obj_(static_cast<T>(jni->NewGlobalRef(obj))) {} : obj_(static_cast<T>(jni->NewGlobalRef(obj))) {}
ScopedGlobalRef(ScopedGlobalRef&& other) : obj_(other.obj_) {
other.obj_ = nullptr;
}
~ScopedGlobalRef() { ~ScopedGlobalRef() {
DeleteGlobalRef(AttachCurrentThreadIfNeeded(), obj_); if (obj_) {
DeleteGlobalRef(AttachCurrentThreadIfNeeded(), obj_);
}
} }
T operator*() const { T operator*() const {
return obj_; return obj_;
} }
private: private:
T obj_; T obj_;
RTC_DISALLOW_COPY_AND_ASSIGN(ScopedGlobalRef);
}; };
// Provides a convenient way to iterate over a Java Iterable using the // 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, RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters) {
jobject j_parameters, RtpParameters parameters;
RtpParameters* parameters) {
RTC_CHECK(parameters != nullptr);
jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters"); jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
jfieldID encodings_id = jfieldID encodings_id =
GetFieldID(jni, parameters_class, "encodings", "Ljava/util/List;"); GetFieldID(jni, parameters_class, "encodings", "Ljava/util/List;");
@ -507,7 +505,7 @@ void JavaToNativeRtpParameters(JNIEnv* jni,
CHECK_EXCEPTION(jni) << "error during CallLongMethod"; CHECK_EXCEPTION(jni) << "error during CallLongMethod";
encoding.ssrc = ssrc_value; encoding.ssrc = ssrc_value;
} }
parameters->encodings.push_back(encoding); parameters.encodings.push_back(encoding);
} }
// Convert codecs. // Convert codecs.
@ -533,8 +531,9 @@ void JavaToNativeRtpParameters(JNIEnv* jni,
jobject j_num_channels = jobject j_num_channels =
GetNullableObjectField(jni, j_codec, num_channels_id); GetNullableObjectField(jni, j_codec, num_channels_id);
codec.num_channels = JavaToNativeOptionalInt(jni, j_num_channels); codec.num_channels = JavaToNativeOptionalInt(jni, j_num_channels);
parameters->codecs.push_back(codec); parameters.codecs.push_back(codec);
} }
return parameters;
} }
jobject NativeToJavaRtpParameters(JNIEnv* jni, 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. * RtpParameters, used for RtpSender and RtpReceiver APIs.
*********************************************************/ *********************************************************/
void JavaToNativeRtpParameters(JNIEnv* jni, RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters);
jobject j_parameters,
RtpParameters* parameters);
jobject NativeToJavaRtpParameters(JNIEnv* jni, const RtpParameters& 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, JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeSetConfiguration, PeerConnection_setNativeConfiguration,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jobject j_rtc_config, jobject j_rtc_config,
@ -185,7 +185,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
} }
JNI_FUNCTION_DECLARATION(jboolean, JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeAddIceCandidate, PeerConnection_addNativeIceCandidate,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jstring j_sdp_mid, jstring j_sdp_mid,
@ -199,7 +199,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
} }
JNI_FUNCTION_DECLARATION(jboolean, JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeRemoveIceCandidates, PeerConnection_removeNativeIceCandidates,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jobjectArray j_candidates) { jobjectArray j_candidates) {
@ -213,7 +213,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
} }
JNI_FUNCTION_DECLARATION(jboolean, JNI_FUNCTION_DECLARATION(jboolean,
PeerConnection_nativeAddLocalStream, PeerConnection_addNativeLocalStream,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jlong native_stream) { jlong native_stream) {
@ -222,7 +222,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
} }
JNI_FUNCTION_DECLARATION(void, JNI_FUNCTION_DECLARATION(void,
PeerConnection_nativeRemoveLocalStream, PeerConnection_removeNativeLocalStream,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jlong native_stream) { jlong native_stream) {
@ -231,7 +231,7 @@ JNI_FUNCTION_DECLARATION(void,
} }
JNI_FUNCTION_DECLARATION(jobject, JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_nativeCreateSender, PeerConnection_createNativeSender,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jstring j_kind, jstring j_kind,
@ -258,7 +258,7 @@ JNI_FUNCTION_DECLARATION(jobject,
} }
JNI_FUNCTION_DECLARATION(jobject, JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_nativeGetSenders, PeerConnection_getNativeSenders,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc) { jobject j_pc) {
jclass j_array_list_class = FindClass(jni, "java/util/ArrayList"); jclass j_array_list_class = FindClass(jni, "java/util/ArrayList");
@ -289,7 +289,7 @@ JNI_FUNCTION_DECLARATION(jobject,
} }
JNI_FUNCTION_DECLARATION(jobject, JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_nativeGetReceivers, PeerConnection_getNativeReceivers,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc) { jobject j_pc) {
jclass j_array_list_class = FindClass(jni, "java/util/ArrayList"); 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); jobject j_receivers = jni->NewObject(j_array_list_class, j_array_list_ctor);
CHECK_EXCEPTION(jni) << "error during NewObject"; 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(); auto receivers = ExtractNativePC(jni, j_pc)->GetReceivers();
for (const auto& receiver : receivers) { for (const auto& receiver : receivers) {
jlong nativeReceiverPtr = jlongFromPointer(receiver.get()); jobject j_receiver = NativeToJavaRtpReceiver(jni, receiver);
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();
jni->CallBooleanMethod(j_receivers, j_array_list_add, j_receiver); jni->CallBooleanMethod(j_receivers, j_array_list_add, j_receiver);
CHECK_EXCEPTION(jni) << "error during CallBooleanMethod"; CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
} }
@ -319,7 +310,7 @@ JNI_FUNCTION_DECLARATION(jobject,
} }
JNI_FUNCTION_DECLARATION(bool, JNI_FUNCTION_DECLARATION(bool,
PeerConnection_nativeOldGetStats, PeerConnection_oldGetNativeStats,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jobject j_observer, jobject j_observer,
@ -332,7 +323,7 @@ JNI_FUNCTION_DECLARATION(bool,
} }
JNI_FUNCTION_DECLARATION(void, JNI_FUNCTION_DECLARATION(void,
PeerConnection_nativeNewGetStats, PeerConnection_newGetNativeStats,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
jobject j_callback) { jobject j_callback) {
@ -357,7 +348,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
} }
JNI_FUNCTION_DECLARATION(bool, JNI_FUNCTION_DECLARATION(bool,
PeerConnection_nativeStartRtcEventLog, PeerConnection_startNativeRtcEventLog,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc, jobject j_pc,
int file_descriptor, int file_descriptor,
@ -367,7 +358,7 @@ JNI_FUNCTION_DECLARATION(bool,
} }
JNI_FUNCTION_DECLARATION(void, JNI_FUNCTION_DECLARATION(void,
PeerConnection_nativeStopRtcEventLog, PeerConnection_stopNativeRtcEventLog,
JNIEnv* jni, JNIEnv* jni,
jobject j_pc) { jobject j_pc) {
ExtractNativePC(jni, j_pc)->StopRtcEventLog(); 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 "rtc_base/ptr_util.h"
#include "sdk/android/generated_peerconnection_jni/jni/MediaStream_jni.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/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h" #include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/datachannel.h" #include "sdk/android/src/jni/pc/datachannel.h"
@ -31,87 +32,68 @@ static JNIEnv* jni() {
PeerConnectionObserverJni::PeerConnectionObserverJni(JNIEnv* jni, PeerConnectionObserverJni::PeerConnectionObserverJni(JNIEnv* jni,
jobject j_observer) jobject j_observer)
: j_observer_global_(jni, 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")) {}
PeerConnectionObserverJni::~PeerConnectionObserverJni() { PeerConnectionObserverJni::~PeerConnectionObserverJni() {
ScopedLocalRefFrame local_ref_frame(jni()); ScopedLocalRefFrame local_ref_frame(jni());
while (!remote_streams_.empty()) while (!remote_streams_.empty())
DisposeRemoteStream(remote_streams_.begin()); DisposeRemoteStream(remote_streams_.begin());
while (!rtp_receivers_.empty())
DisposeRtpReceiver(rtp_receivers_.begin());
} }
void PeerConnectionObserverJni::OnIceCandidate( void PeerConnectionObserverJni::OnIceCandidate(
const IceCandidateInterface* candidate) { const IceCandidateInterface* candidate) {
JNIEnv* env = AttachCurrentThreadIfNeeded(); JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env); ScopedLocalRefFrame local_ref_frame(env);
jobject j_candidate = NativeToJavaIceCandidate(env, *candidate); Java_Observer_onIceCandidate(env, *j_observer_global_,
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";
} }
void PeerConnectionObserverJni::OnIceCandidatesRemoved( void PeerConnectionObserverJni::OnIceCandidatesRemoved(
const std::vector<cricket::Candidate>& candidates) { const std::vector<cricket::Candidate>& candidates) {
ScopedLocalRefFrame local_ref_frame(jni()); JNIEnv* env = AttachCurrentThreadIfNeeded();
jobjectArray candidates_array = NativeToJavaCandidateArray(jni(), candidates); ScopedLocalRefFrame local_ref_frame(env);
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onIceCandidatesRemoved", Java_Observer_onIceCandidatesRemoved(
"([Lorg/webrtc/IceCandidate;)V"); env, *j_observer_global_, NativeToJavaCandidateArray(env, candidates));
jni()->CallVoidMethod(*j_observer_global_, m, candidates_array);
CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod";
} }
void PeerConnectionObserverJni::OnSignalingChange( void PeerConnectionObserverJni::OnSignalingChange(
PeerConnectionInterface::SignalingState new_state) { PeerConnectionInterface::SignalingState new_state) {
ScopedLocalRefFrame local_ref_frame(jni()); JNIEnv* env = AttachCurrentThreadIfNeeded();
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSignalingChange", ScopedLocalRefFrame local_ref_frame(env);
"(Lorg/webrtc/PeerConnection$SignalingState;)V"); Java_Observer_onSignalingChange(
jobject new_state_enum = JavaEnumFromIndexAndClassName( env, *j_observer_global_,
jni(), "PeerConnection$SignalingState", new_state); Java_SignalingState_fromNativeIndex(env, new_state));
jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
} }
void PeerConnectionObserverJni::OnIceConnectionChange( void PeerConnectionObserverJni::OnIceConnectionChange(
PeerConnectionInterface::IceConnectionState new_state) { PeerConnectionInterface::IceConnectionState new_state) {
ScopedLocalRefFrame local_ref_frame(jni()); JNIEnv* env = AttachCurrentThreadIfNeeded();
jmethodID m = ScopedLocalRefFrame local_ref_frame(env);
GetMethodID(jni(), *j_observer_class_, "onIceConnectionChange", Java_Observer_onIceConnectionChange(
"(Lorg/webrtc/PeerConnection$IceConnectionState;)V"); env, *j_observer_global_,
jobject new_state_enum = JavaEnumFromIndexAndClassName( Java_IceConnectionState_fromNativeIndex(env, new_state));
jni(), "PeerConnection$IceConnectionState", new_state);
jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
} }
void PeerConnectionObserverJni::OnIceConnectionReceivingChange(bool receiving) { void PeerConnectionObserverJni::OnIceConnectionReceivingChange(bool receiving) {
ScopedLocalRefFrame local_ref_frame(jni()); JNIEnv* env = AttachCurrentThreadIfNeeded();
jmethodID m = GetMethodID(jni(), *j_observer_class_, ScopedLocalRefFrame local_ref_frame(env);
"onIceConnectionReceivingChange", "(Z)V"); Java_Observer_onIceConnectionReceivingChange(env, *j_observer_global_,
jni()->CallVoidMethod(*j_observer_global_, m, receiving); receiving);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
} }
void PeerConnectionObserverJni::OnIceGatheringChange( void PeerConnectionObserverJni::OnIceGatheringChange(
PeerConnectionInterface::IceGatheringState new_state) { PeerConnectionInterface::IceGatheringState new_state) {
ScopedLocalRefFrame local_ref_frame(jni()); JNIEnv* env = AttachCurrentThreadIfNeeded();
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onIceGatheringChange", ScopedLocalRefFrame local_ref_frame(env);
"(Lorg/webrtc/PeerConnection$IceGatheringState;)V"); Java_Observer_onIceGatheringChange(
jobject new_state_enum = JavaEnumFromIndexAndClassName( env, *j_observer_global_,
jni(), "PeerConnection$IceGatheringState", new_state); Java_IceGatheringState_fromNativeIndex(env, new_state));
jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
} }
void PeerConnectionObserverJni::OnAddStream( void PeerConnectionObserverJni::OnAddStream(
rtc::scoped_refptr<MediaStreamInterface> stream) { 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 // The stream could be added into the remote_streams_ map when calling
// OnAddTrack. // OnAddTrack.
jobject j_stream = GetOrCreateJavaStream(stream); jobject j_stream = GetOrCreateJavaStream(stream);
@ -123,10 +105,7 @@ void PeerConnectionObserverJni::OnAddStream(
AddNativeVideoTrackToJavaStream(track, j_stream); AddNativeVideoTrackToJavaStream(track, j_stream);
} }
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onAddStream", Java_Observer_onAddStream(env, *j_observer_global_, j_stream);
"(Lorg/webrtc/MediaStream;)V");
jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
// Create an observer to update the Java stream when the native stream's set // Create an observer to update the Java stream when the native stream's set
// of tracks changes. // of tracks changes.
@ -194,15 +173,12 @@ void PeerConnectionObserverJni::OnVideoTrackRemovedFromStream(
void PeerConnectionObserverJni::OnRemoveStream( void PeerConnectionObserverJni::OnRemoveStream(
rtc::scoped_refptr<MediaStreamInterface> stream) { 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); NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
RTC_CHECK(it != remote_streams_.end()) RTC_CHECK(it != remote_streams_.end())
<< "unexpected stream: " << std::hex << stream; << "unexpected stream: " << std::hex << stream;
jobject j_stream = it->second; Java_Observer_onRemoveStream(env, *j_observer_global_, 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";
// Release the refptr reference so that DisposeRemoteStream can assert // Release the refptr reference so that DisposeRemoteStream can assert
// it removes the final reference. // it removes the final reference.
@ -214,38 +190,26 @@ void PeerConnectionObserverJni::OnDataChannel(
rtc::scoped_refptr<DataChannelInterface> channel) { rtc::scoped_refptr<DataChannelInterface> channel) {
JNIEnv* env = AttachCurrentThreadIfNeeded(); JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env); ScopedLocalRefFrame local_ref_frame(env);
jobject j_channel = WrapNativeDataChannel(env, channel); Java_Observer_onDataChannel(env, *j_observer_global_,
jmethodID m = GetMethodID(env, *j_observer_class_, "onDataChannel", WrapNativeDataChannel(env, channel));
"(Lorg/webrtc/DataChannel;)V");
env->CallVoidMethod(*j_observer_global_, m, j_channel);
CHECK_EXCEPTION(env) << "error during CallVoidMethod";
} }
void PeerConnectionObserverJni::OnRenegotiationNeeded() { void PeerConnectionObserverJni::OnRenegotiationNeeded() {
ScopedLocalRefFrame local_ref_frame(jni()); JNIEnv* env = AttachCurrentThreadIfNeeded();
jmethodID m = ScopedLocalRefFrame local_ref_frame(env);
GetMethodID(jni(), *j_observer_class_, "onRenegotiationNeeded", "()V"); Java_Observer_onRenegotiationNeeded(env, *j_observer_global_);
jni()->CallVoidMethod(*j_observer_global_, m);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
} }
void PeerConnectionObserverJni::OnAddTrack( void PeerConnectionObserverJni::OnAddTrack(
rtc::scoped_refptr<RtpReceiverInterface> receiver, rtc::scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) { const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
ScopedLocalRefFrame local_ref_frame(jni()); JNIEnv* env = AttachCurrentThreadIfNeeded();
jobject j_rtp_receiver = ScopedLocalRefFrame local_ref_frame(env);
jni()->NewObject(*j_rtp_receiver_class_, j_rtp_receiver_ctor_, jobject j_rtp_receiver = NativeToJavaRtpReceiver(env, receiver);
jlongFromPointer(receiver.get())); rtp_receivers_.emplace_back(env, j_rtp_receiver);
CHECK_EXCEPTION(jni()) << "error during NewObject";
receiver->AddRef();
rtp_receivers_[receiver] = NewGlobalRef(jni(), j_rtp_receiver);
jobjectArray j_stream_array = NativeToJavaMediaStreamArray(jni(), streams); Java_Observer_onAddTrack(env, *j_observer_global_, j_rtp_receiver,
jmethodID m = NativeToJavaMediaStreamArray(env, streams));
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";
} }
void PeerConnectionObserverJni::SetConstraints( void PeerConnectionObserverJni::SetConstraints(
@ -274,17 +238,6 @@ void PeerConnectionObserverJni::DisposeRemoteStream(
DeleteGlobalRef(env, j_stream); 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. // If the NativeToJavaStreamsMap contains the stream, return it.
// Otherwise, create a new Java MediaStream. // Otherwise, create a new Java MediaStream.
jobject PeerConnectionObserverJni::GetOrCreateJavaStream( jobject PeerConnectionObserverJni::GetOrCreateJavaStream(

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

@ -19,6 +19,7 @@
#include "api/peerconnectioninterface.h" #include "api/peerconnectioninterface.h"
#include "sdk/android/src/jni/jni_helpers.h" #include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/mediaconstraints_jni.h" #include "sdk/android/src/jni/pc/mediaconstraints_jni.h"
#include "sdk/android/src/jni/pc/rtpreceiver.h"
namespace webrtc { namespace webrtc {
namespace jni { namespace jni {
@ -57,14 +58,12 @@ class PeerConnectionObserverJni : public PeerConnectionObserver,
private: private:
typedef std::map<MediaStreamInterface*, jobject> NativeToJavaStreamsMap; typedef std::map<MediaStreamInterface*, jobject> NativeToJavaStreamsMap;
typedef std::map<RtpReceiverInterface*, jobject> NativeToJavaRtpReceiverMap;
typedef std::map<MediaStreamTrackInterface*, jobject> typedef std::map<MediaStreamTrackInterface*, jobject>
NativeToJavaMediaTrackMap; NativeToJavaMediaTrackMap;
typedef std::map<MediaStreamTrackInterface*, RtpReceiverInterface*> typedef std::map<MediaStreamTrackInterface*, RtpReceiverInterface*>
NativeMediaStreamTrackToNativeRtpReceiver; NativeMediaStreamTrackToNativeRtpReceiver;
void DisposeRemoteStream(const NativeToJavaStreamsMap::iterator& it); void DisposeRemoteStream(const NativeToJavaStreamsMap::iterator& it);
void DisposeRtpReceiver(const NativeToJavaRtpReceiverMap::iterator& it);
// If the NativeToJavaStreamsMap contains the stream, return it. // If the NativeToJavaStreamsMap contains the stream, return it.
// Otherwise, create a new Java MediaStream. // Otherwise, create a new Java MediaStream.
@ -100,14 +99,11 @@ class PeerConnectionObserverJni : public PeerConnectionObserver,
MediaStreamInterface* stream); MediaStreamInterface* stream);
const ScopedGlobalRef<jobject> j_observer_global_; 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 // C++ -> Java remote streams. The stored jobects are global refs and must be
// manually deleted upon removal. Use DisposeRemoteStream(). // manually deleted upon removal. Use DisposeRemoteStream().
NativeToJavaStreamsMap remote_streams_; NativeToJavaStreamsMap remote_streams_;
NativeToJavaRtpReceiverMap rtp_receivers_; std::vector<JavaRtpReceiverGlobalOwner> rtp_receivers_;
std::unique_ptr<MediaConstraintsInterface> constraints_; std::unique_ptr<MediaConstraintsInterface> constraints_;
std::vector<std::unique_ptr<webrtc::MediaStreamObserver>> stream_observers_; 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. * 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/jni_helpers.h"
#include "sdk/android/src/jni/pc/java_native_conversion.h" #include "sdk/android/src/jni/pc/java_native_conversion.h"
#include "sdk/android/src/jni/pc/rtpreceiverobserver_jni.h"
namespace webrtc { namespace webrtc {
namespace jni { 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, JNI_FUNCTION_DECLARATION(jlong,
RtpReceiver_nativeGetTrack, RtpReceiver_getNativeTrack,
JNIEnv* jni, JNIEnv* jni,
jclass, jclass,
jlong j_rtp_receiver_pointer, jlong j_rtp_receiver_pointer,
@ -29,22 +74,18 @@ JNI_FUNCTION_DECLARATION(jlong,
} }
JNI_FUNCTION_DECLARATION(jboolean, JNI_FUNCTION_DECLARATION(jboolean,
RtpReceiver_nativeSetParameters, RtpReceiver_setNativeParameters,
JNIEnv* jni, JNIEnv* jni,
jclass, jclass,
jlong j_rtp_receiver_pointer, jlong j_rtp_receiver_pointer,
jobject j_parameters) { jobject j_parameters) {
if (IsNull(jni, j_parameters)) { RtpParameters parameters = JavaToNativeRtpParameters(jni, j_parameters);
return false;
}
RtpParameters parameters;
JavaToNativeRtpParameters(jni, j_parameters, &parameters);
return reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer) return reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
->SetParameters(parameters); ->SetParameters(parameters);
} }
JNI_FUNCTION_DECLARATION(jobject, JNI_FUNCTION_DECLARATION(jobject,
RtpReceiver_nativeGetParameters, RtpReceiver_getNativeParameters,
JNIEnv* jni, JNIEnv* jni,
jclass, jclass,
jlong j_rtp_receiver_pointer) { jlong j_rtp_receiver_pointer) {
@ -55,7 +96,7 @@ JNI_FUNCTION_DECLARATION(jobject,
} }
JNI_FUNCTION_DECLARATION(jstring, JNI_FUNCTION_DECLARATION(jstring,
RtpReceiver_nativeId, RtpReceiver_getNativeId,
JNIEnv* jni, JNIEnv* jni,
jclass, jclass,
jlong j_rtp_receiver_pointer) { jlong j_rtp_receiver_pointer) {
@ -65,7 +106,7 @@ JNI_FUNCTION_DECLARATION(jstring,
} }
JNI_FUNCTION_DECLARATION(jlong, JNI_FUNCTION_DECLARATION(jlong,
RtpReceiver_nativeSetObserver, RtpReceiver_setNativeObserver,
JNIEnv* jni, JNIEnv* jni,
jclass, jclass,
jlong j_rtp_receiver_pointer, jlong j_rtp_receiver_pointer,
@ -78,7 +119,7 @@ JNI_FUNCTION_DECLARATION(jlong,
} }
JNI_FUNCTION_DECLARATION(void, JNI_FUNCTION_DECLARATION(void,
RtpReceiver_nativeUnsetObserver, RtpReceiver_unsetNativeObserver,
JNIEnv* jni, JNIEnv* jni,
jclass, jclass,
jlong j_rtp_receiver_pointer, 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)) { if (IsNull(jni, j_parameters)) {
return false; return false;
} }
RtpParameters parameters; RtpParameters parameters = JavaToNativeRtpParameters(jni, j_parameters);
JavaToNativeRtpParameters(jni, j_parameters, &parameters);
return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer) return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->SetParameters(parameters); ->SetParameters(parameters);
} }