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

Add new PeerConnection APIs to the Java SDK.

Browse Source 
This adds wrappers to the following native APIs:
- SdpSemantics enum added to the RTCConfiguration
- RtpTransceiver
- PeerConnection.addTrack
- PeerConnection.removeTrack
- PeerConnection.addTransceiver
- PeerConnection.getTransceivers
These APIs are used with the new Unified Plan semantics.

Bug: webrtc:8869
Change-Id: I19443f3ff7ffc91a139ad8276331f09e57cec554
Reviewed-on: https://webrtc-review.googlesource.com/57800
Commit-Queue: Seth Hampson <shampson@webrtc.org>
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22317}
This commit is contained in:
Seth Hampson
2018-03-06 15:47:10 -08:00
committed by Commit Bot
parent 513449eab9
commit c384e14707
12 changed files with 799 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
sdk/android/src/jni/pc/mediastream.cc
View File

@ -135,9 +135,9 @@ static jboolean JNI_MediaStream_RemoveVideoTrack(JNIEnv* jni,
}
static ScopedJavaLocalRef<jstring>
JNI_MediaStream_GetLabel(JNIEnv* jni, const JavaParamRef<jclass>&, jlong j_p) {
return NativeToJavaString(
jni, reinterpret_cast<MediaStreamInterface*>(j_p)->label());
JNI_MediaStream_GetId(JNIEnv* jni, const JavaParamRef<jclass>&, jlong j_p) {
return NativeToJavaString(jni,
reinterpret_cast<MediaStreamInterface*>(j_p)->id());
}
} // namespace jni

115
sdk/android/src/jni/pc/peerconnection.cc
View File

@ -36,6 +36,7 @@
#include "api/peerconnectioninterface.h"
#include "api/rtpreceiverinterface.h"
#include "api/rtpsenderinterface.h"
#include "api/rtptransceiverinterface.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/ptr_util.h"
@ -45,8 +46,10 @@
#include "sdk/android/src/jni/pc/datachannel.h"
#include "sdk/android/src/jni/pc/icecandidate.h"
#include "sdk/android/src/jni/pc/mediaconstraints.h"
#include "sdk/android/src/jni/pc/mediastreamtrack.h"
#include "sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h"
#include "sdk/android/src/jni/pc/rtpsender.h"
#include "sdk/android/src/jni/pc/rtptransceiver.h"
#include "sdk/android/src/jni/pc/sdpobserver.h"
#include "sdk/android/src/jni/pc/sessiondescription.h"
#include "sdk/android/src/jni/pc/statsobserver.h"
@ -86,19 +89,35 @@ PeerConnectionInterface::IceServers JavaToNativeIceServers(
ScopedJavaLocalRef<jobject> tls_elliptic_curves =
Java_IceServer_getTlsEllipticCurves(jni, j_ice_server);
PeerConnectionInterface::IceServer server;
server.urls = JavaToStdVectorStrings(jni, urls);
server.username = JavaToStdString(jni, username);
server.password = JavaToStdString(jni, password);
server.urls = JavaListToNativeVector<std::string, jstring>(
jni, urls, &JavaToNativeString);
server.username = JavaToNativeString(jni, username);
server.password = JavaToNativeString(jni, password);
server.tls_cert_policy = tls_cert_policy;
server.hostname = JavaToStdString(jni, hostname);
server.tls_alpn_protocols = JavaToStdVectorStrings(jni, tls_alpn_protocols);
server.tls_elliptic_curves =
JavaToStdVectorStrings(jni, tls_elliptic_curves);
server.hostname = JavaToNativeString(jni, hostname);
server.tls_alpn_protocols = JavaListToNativeVector<std::string, jstring>(
jni, tls_alpn_protocols, &JavaToNativeString);
server.tls_elliptic_curves = JavaListToNativeVector<std::string, jstring>(
jni, tls_elliptic_curves, &JavaToNativeString);
ice_servers.push_back(server);
}
return ice_servers;
}
SdpSemantics JavaToNativeSdpSemantics(JNIEnv* jni,
const JavaRef<jobject>& j_sdp_semantics) {
std::string enum_name = GetJavaEnumName(jni, j_sdp_semantics);
if (enum_name == "PLAN_B")
return SdpSemantics::kPlanB;
if (enum_name == "UNIFIED_PLAN")
return SdpSemantics::kUnifiedPlan;
RTC_NOTREACHED();
return SdpSemantics::kPlanB;
}
} // namespace
void JavaToNativeRTCConfiguration(
@ -123,6 +142,8 @@ void JavaToNativeRTCConfiguration(
Java_RTCConfiguration_getTurnCustomizer(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_network_preference =
Java_RTCConfiguration_getNetworkPreference(jni, j_rtc_config);
ScopedJavaLocalRef<jobject> j_sdp_semantics =
Java_RTCConfiguration_getSdpSemantics(jni, j_rtc_config);
rtc_config->type = JavaToNativeIceTransportsType(jni, j_ice_transports_type);
rtc_config->bundle_policy = JavaToNativeBundlePolicy(jni, j_bundle_policy);
@ -193,6 +214,7 @@ void JavaToNativeRTCConfiguration(
jni, Java_RTCConfiguration_getEnableDtlsSrtp(jni, j_rtc_config));
rtc_config->network_preference =
JavaToNativeNetworkPreference(jni, j_network_preference);
rtc_config->sdp_semantics = JavaToNativeSdpSemantics(jni, j_sdp_semantics);
}
rtc::KeyType GetRtcConfigKeyType(JNIEnv* env,
@ -380,7 +402,7 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_CreateDataChannel(
DataChannelInit init = JavaToNativeDataChannelInit(jni, j_init);
rtc::scoped_refptr<DataChannelInterface> channel(
ExtractNativePC(jni, j_pc)->CreateDataChannel(
JavaToStdString(jni, j_label), &init));
JavaToNativeString(jni, j_label), &init));
return WrapNativeDataChannel(jni, channel);
}
@ -469,8 +491,8 @@ static jboolean JNI_PeerConnection_AddIceCandidate(
const JavaParamRef<jstring>& j_sdp_mid,
jint j_sdp_mline_index,
const JavaParamRef<jstring>& j_candidate_sdp) {
std::string sdp_mid = JavaToStdString(jni, j_sdp_mid);
std::string sdp = JavaToStdString(jni, 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(
CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, nullptr));
return ExtractNativePC(jni, j_pc)->AddIceCandidate(candidate.get());
@ -507,8 +529,8 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_CreateSender(
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jstring>& j_kind,
const JavaParamRef<jstring>& j_stream_id) {
std::string kind = JavaToStdString(jni, j_kind);
std::string stream_id = JavaToStdString(jni, j_stream_id);
std::string kind = JavaToNativeString(jni, j_kind);
std::string stream_id = JavaToNativeString(jni, j_stream_id);
rtc::scoped_refptr<RtpSenderInterface> sender =
ExtractNativePC(jni, j_pc)->CreateSender(kind, stream_id);
return NativeToJavaRtpSender(jni, sender);
@ -528,6 +550,75 @@ static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetReceivers(
&NativeToJavaRtpReceiver);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_GetTransceivers(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc) {
return NativeToJavaList(jni, ExtractNativePC(jni, j_pc)->GetTransceivers(),
&NativeToJavaRtpTransceiver);
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTrack(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const jlong native_track,
const JavaParamRef<jobject>& j_stream_labels) {
RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> result =
ExtractNativePC(jni, j_pc)->AddTrack(
reinterpret_cast<MediaStreamTrackInterface*>(native_track),
JavaListToNativeVector<std::string, jstring>(jni, j_stream_labels,
&JavaToNativeString));
if (!result.ok()) {
RTC_LOG(LS_ERROR) << "Failed to add track: " << result.error().message();
return nullptr;
} else {
return NativeToJavaRtpSender(jni, result.MoveValue());
}
}
static jboolean JNI_PeerConnection_RemoveTrack(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
jlong native_sender) {
return ExtractNativePC(jni, j_pc)->RemoveTrack(
reinterpret_cast<RtpSenderInterface*>(native_sender));
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTransceiverWithTrack(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
jlong native_track,
const JavaParamRef<jobject>& j_init) {
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
ExtractNativePC(jni, j_pc)->AddTransceiver(
reinterpret_cast<MediaStreamTrackInterface*>(native_track),
JavaToNativeRtpTransceiverInit(jni, j_init));
if (!result.ok()) {
RTC_LOG(LS_ERROR) << "Failed to add transceiver: "
<< result.error().message();
return nullptr;
} else {
return NativeToJavaRtpTransceiver(jni, result.MoveValue());
}
}
static ScopedJavaLocalRef<jobject> JNI_PeerConnection_AddTransceiverOfType(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,
const JavaParamRef<jobject>& j_media_type,
const JavaParamRef<jobject>& j_init) {
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> result =
ExtractNativePC(jni, j_pc)->AddTransceiver(
JavaToNativeMediaType(jni, j_media_type),
JavaToNativeRtpTransceiverInit(jni, j_init));
if (!result.ok()) {
RTC_LOG(LS_ERROR) << "Failed to add transceiver: "
<< result.error().message();
return nullptr;
} else {
return NativeToJavaRtpTransceiver(jni, result.MoveValue());
}
}
static jboolean JNI_PeerConnection_OldGetStats(
JNIEnv* jni,
const JavaParamRef<jobject>& j_pc,

26
sdk/android/src/jni/pc/rtpparameters.cc
View File

@ -40,6 +40,21 @@ ScopedJavaLocalRef<jobject> NativeToJavaRtpCodecParameter(
} // namespace
RtpEncodingParameters JavaToNativeRtpEncodingParameters(
JNIEnv* jni,
const JavaRef<jobject>& j_encoding_parameters) {
RtpEncodingParameters encoding;
encoding.active = Java_Encoding_getActive(jni, j_encoding_parameters);
ScopedJavaLocalRef<jobject> j_bitrate =
Java_Encoding_getMaxBitrateBps(jni, j_encoding_parameters);
encoding.max_bitrate_bps = JavaToNativeOptionalInt(jni, j_bitrate);
ScopedJavaLocalRef<jobject> j_ssrc =
Java_Encoding_getSsrc(jni, j_encoding_parameters);
if (!IsNull(jni, j_ssrc))
encoding.ssrc = JavaToNativeLong(jni, j_ssrc);
return encoding;
}
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni,
const JavaRef<jobject>& j_parameters) {
RtpParameters parameters;
@ -49,15 +64,8 @@ RtpParameters JavaToNativeRtpParameters(JNIEnv* jni,
Java_RtpParameters_getEncodings(jni, j_parameters);
for (const JavaRef<jobject>& j_encoding_parameters :
Iterable(jni, j_encodings)) {
RtpEncodingParameters encoding;
encoding.active = Java_Encoding_getActive(jni, j_encoding_parameters);
ScopedJavaLocalRef<jobject> j_bitrate =
Java_Encoding_getMaxBitrateBps(jni, j_encoding_parameters);
encoding.max_bitrate_bps = JavaToNativeOptionalInt(jni, j_bitrate);
ScopedJavaLocalRef<jobject> j_ssrc =
Java_Encoding_getSsrc(jni, j_encoding_parameters);
if (!IsNull(jni, j_ssrc))
encoding.ssrc = JavaToNativeLong(jni, j_ssrc);
RtpEncodingParameters encoding =
JavaToNativeRtpEncodingParameters(jni, j_encoding_parameters);
parameters.encodings.push_back(encoding);
}

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

@ -19,6 +19,10 @@
namespace webrtc {
namespace jni {
RtpEncodingParameters JavaToNativeRtpEncodingParameters(
JNIEnv* env,
const JavaRef<jobject>& j_encoding_parameters);
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni,
const JavaRef<jobject>& j_parameters);
ScopedJavaLocalRef<jobject> NativeToJavaRtpParameters(

151
sdk/android/src/jni/pc/rtptransceiver.cc Normal file
View File

@ -0,0 +1,151 @@
/*
* Copyright 2018 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/rtptransceiver.h"
#include <string>
#include "sdk/android/generated_peerconnection_jni/jni/RtpTransceiver_jni.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/mediastreamtrack.h"
#include "sdk/android/src/jni/pc/rtpparameters.h"
#include "sdk/android/src/jni/pc/rtpreceiver.h"
#include "sdk/android/src/jni/pc/rtpsender.h"
namespace webrtc {
namespace jni {
namespace {
ScopedJavaLocalRef<jobject> NativeToJavaRtpTransceiverDirection(
JNIEnv* jni,
RtpTransceiverDirection rtp_transceiver_direction) {
return Java_RtpTransceiverDirection_fromNativeIndex(
jni, static_cast<int>(rtp_transceiver_direction));
}
} // namespace
RtpTransceiverInit JavaToNativeRtpTransceiverInit(
JNIEnv* jni,
const JavaRef<jobject>& j_init) {
RtpTransceiverInit init;
// Convert the direction.
init.direction = static_cast<RtpTransceiverDirection>(
Java_RtpTransceiverInit_getDirectionNativeIndex(jni, j_init));
// Convert the stream ids.
ScopedJavaLocalRef<jobject> j_stream_ids =
Java_RtpTransceiverInit_getStreamIds(jni, j_init);
init.stream_ids = JavaListToNativeVector<std::string, jstring>(
jni, j_stream_ids, &JavaToNativeString);
return init;
}
ScopedJavaLocalRef<jobject> NativeToJavaRtpTransceiver(
JNIEnv* env,
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
if (!transceiver) {
return nullptr;
}
// Transceiver will now have shared ownership by the Java object.
return Java_RtpTransceiver_Constructor(
env, jlongFromPointer(transceiver.release()));
}
ScopedJavaLocalRef<jobject> JNI_RtpTransceiver_GetMediaType(
JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
return NativeToJavaMediaType(
jni, reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->media_type());
}
ScopedJavaLocalRef<jstring> JNI_RtpTransceiver_GetMid(
JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
rtc::Optional<std::string> mid =
reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->mid();
return NativeToJavaString(jni, mid);
}
ScopedJavaLocalRef<jobject> JNI_RtpTransceiver_GetSender(
JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
return NativeToJavaRtpSender(
jni, reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->sender());
}
ScopedJavaLocalRef<jobject> JNI_RtpTransceiver_GetReceiver(
JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
return NativeToJavaRtpReceiver(
jni, reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->receiver());
}
jboolean JNI_RtpTransceiver_Stopped(JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
return reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->stopped();
}
ScopedJavaLocalRef<jobject> JNI_RtpTransceiver_Direction(
JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
return NativeToJavaRtpTransceiverDirection(
jni, reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->direction());
}
ScopedJavaLocalRef<jobject> JNI_RtpTransceiver_CurrentDirection(
JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
rtc::Optional<RtpTransceiverDirection> direction =
reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->current_direction();
return direction ? NativeToJavaRtpTransceiverDirection(jni, *direction)
: nullptr;
}
void JNI_RtpTransceiver_Stop(JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer) {
reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)->Stop();
}
void JNI_RtpTransceiver_SetDirection(
JNIEnv* jni,
const base::android::JavaParamRef<jclass>&,
jlong j_rtp_transceiver_pointer,
const base::android::JavaParamRef<jobject>& j_rtp_transceiver_direction) {
if (IsNull(jni, j_rtp_transceiver_direction)) {
return;
}
RtpTransceiverDirection direction = static_cast<RtpTransceiverDirection>(
Java_RtpTransceiverDirection_getNativeIndex(jni,
j_rtp_transceiver_direction));
reinterpret_cast<RtpTransceiverInterface*>(j_rtp_transceiver_pointer)
->SetDirection(direction);
}
} // namespace jni
} // namespace webrtc

33
sdk/android/src/jni/pc/rtptransceiver.h Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright 2018 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_RTPTRANSCEIVER_H_
#define SDK_ANDROID_SRC_JNI_PC_RTPTRANSCEIVER_H_
#include <jni.h>
#include "api/rtptransceiverinterface.h"
#include "sdk/android/native_api/jni/scoped_java_ref.h"
namespace webrtc {
namespace jni {
RtpTransceiverInit JavaToNativeRtpTransceiverInit(
JNIEnv* jni,
const JavaRef<jobject>& j_init);
ScopedJavaLocalRef<jobject> NativeToJavaRtpTransceiver(
JNIEnv* env,
rtc::scoped_refptr<RtpTransceiverInterface> transceiver);
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_RTPTRANSCEIVER_H_