blob: 6c5ba976800aea1064b8cd782671da5b6a67a554 [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
kjellanderb24317b2016-02-10 07:54:43 -08002 * Copyright 2013 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003 *
kjellanderb24317b2016-02-10 07:54:43 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00009 */
10
11// Hints for future visitors:
12// This entire file is an implementation detail of the org.webrtc Java package,
13// the most interesting bits of which are org.webrtc.PeerConnection{,Factory}.
14// The layout of this file is roughly:
15// - various helper C++ functions & classes that wrap Java counterparts and
16// expose a C++ interface that can be passed to the C++ PeerConnection APIs
17// - implementations of methods declared "static" in the Java package (named
18// things like Java_org_webrtc_OMG_Can_This_Name_Be_Any_Longer, prescribed by
19// the JNI spec).
20//
21// Lifecycle notes: objects are owned where they will be called; in other words
22// FooObservers are owned by C++-land, and user-callable objects (e.g.
23// PeerConnection and VideoTrack) are owned by Java-land.
24// When this file allocates C++ RefCountInterfaces it AddRef()s an artificial
25// ref simulating the jlong held in Java-land, and then Release()s the ref in
26// the respective free call. Sometimes this AddRef is implicit in the
27// construction of a scoped_refptr<> which is then .release()d.
28// Any persistent (non-local) references from C++ to Java must be global or weak
29// (in which case they must be checked before use)!
30//
31// Exception notes: pretty much all JNI calls can throw Java exceptions, so each
32// call through a JNIEnv* pointer needs to be followed by an ExceptionCheck()
33// call. In this file this is done in CHECK_EXCEPTION, making for much easier
34// debugging in case of failure (the alternative is to wait for control to
35// return to the Java frame that called code in this file, at which point it's
36// impossible to tell which JNI call broke).
37
38#include <jni.h>
39#undef JNIEXPORT
40#define JNIEXPORT __attribute__((visibility("default")))
41
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000042#include <limits>
jbauch555604a2016-04-26 03:13:22 -070043#include <memory>
kwiberg0eb15ed2015-12-17 03:04:15 -080044#include <utility>
henrike@webrtc.org28e20752013-07-10 00:45:36 +000045
Henrik Kjellander15583c12016-02-10 10:53:12 +010046#include "webrtc/api/androidvideocapturer.h"
47#include "webrtc/api/dtlsidentitystore.h"
48#include "webrtc/api/java/jni/androidmediadecoder_jni.h"
49#include "webrtc/api/java/jni/androidmediaencoder_jni.h"
50#include "webrtc/api/java/jni/androidnetworkmonitor_jni.h"
51#include "webrtc/api/java/jni/androidvideocapturer_jni.h"
52#include "webrtc/api/java/jni/classreferenceholder.h"
53#include "webrtc/api/java/jni/jni_helpers.h"
54#include "webrtc/api/java/jni/native_handle_impl.h"
55#include "webrtc/api/mediaconstraintsinterface.h"
56#include "webrtc/api/peerconnectioninterface.h"
57#include "webrtc/api/rtpreceiverinterface.h"
58#include "webrtc/api/rtpsenderinterface.h"
Honghai Zhang7fb69db2016-03-14 11:59:18 -070059#include "webrtc/api/webrtcsdp.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000060#include "webrtc/base/bind.h"
andresp@webrtc.org4d19e052014-09-09 11:45:44 +000061#include "webrtc/base/checks.h"
Peter Boström6f28cf02015-12-07 23:17:15 +010062#include "webrtc/base/event_tracer.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000063#include "webrtc/base/logging.h"
Jiayang Liue63d2a12015-09-01 16:11:18 -070064#include "webrtc/base/logsinks.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000065#include "webrtc/base/messagequeue.h"
Peter Boström6f28cf02015-12-07 23:17:15 +010066#include "webrtc/base/networkmonitor.h"
Henrik Boströme06c2dd2016-05-13 13:50:38 +020067#include "webrtc/base/rtccertificategenerator.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000068#include "webrtc/base/ssladapter.h"
glaznev@webrtc.org44ae4c82015-02-09 23:25:58 +000069#include "webrtc/base/stringutils.h"
kjellandera96e2d72016-02-04 23:52:28 -080070#include "webrtc/media/base/videocapturer.h"
kjellandera96e2d72016-02-04 23:52:28 -080071#include "webrtc/media/devices/videorendererfactory.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010072#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
73#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010074#include "webrtc/system_wrappers/include/field_trial_default.h"
perkj47b62632016-02-08 01:07:19 -080075#include "webrtc/system_wrappers/include/logcat_trace_context.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010076#include "webrtc/system_wrappers/include/trace.h"
henrike@webrtc.org9de257d2013-07-17 14:42:53 +000077#include "webrtc/voice_engine/include/voe_base.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000078
Alex Glaznev4d2f4d12015-09-01 15:04:13 -070079using cricket::WebRtcVideoDecoderFactory;
80using cricket::WebRtcVideoEncoderFactory;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000081using rtc::Bind;
82using rtc::Thread;
83using rtc::ThreadManager;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000084using webrtc::AudioSourceInterface;
85using webrtc::AudioTrackInterface;
86using webrtc::AudioTrackVector;
87using webrtc::CreateSessionDescriptionObserver;
henrike@webrtc.org723d6832013-07-12 16:04:50 +000088using webrtc::DataBuffer;
89using webrtc::DataChannelInit;
90using webrtc::DataChannelInterface;
91using webrtc::DataChannelObserver;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000092using webrtc::IceCandidateInterface;
perkj47b62632016-02-08 01:07:19 -080093using webrtc::LogcatTraceContext;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000094using webrtc::MediaConstraintsInterface;
95using webrtc::MediaSourceInterface;
96using webrtc::MediaStreamInterface;
97using webrtc::MediaStreamTrackInterface;
98using webrtc::PeerConnectionFactoryInterface;
99using webrtc::PeerConnectionInterface;
100using webrtc::PeerConnectionObserver;
deadbeef4139c0f2015-10-06 12:29:25 -0700101using webrtc::RtpReceiverInterface;
102using webrtc::RtpSenderInterface;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000103using webrtc::SessionDescriptionInterface;
104using webrtc::SetSessionDescriptionObserver;
105using webrtc::StatsObserver;
106using webrtc::StatsReport;
tommi@webrtc.orge2e199b2014-12-15 13:22:54 +0000107using webrtc::StatsReports;
perkja3ede6c2016-03-08 01:27:48 +0100108using webrtc::VideoTrackSourceInterface;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000109using webrtc::VideoTrackInterface;
110using webrtc::VideoTrackVector;
fischman@webrtc.org540acde2014-02-13 03:56:14 +0000111using webrtc::kVideoCodecVP8;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000112
perkj@webrtc.org96e4db92015-02-13 12:46:51 +0000113namespace webrtc_jni {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000114
glaznev@webrtc.org44ae4c82015-02-09 23:25:58 +0000115// Field trials initialization string
116static char *field_trials_init_string = NULL;
117
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000118// Set in PeerConnectionFactory_initializeAndroidGlobals().
119static bool factory_static_initialized = false;
Alex Glaznev4d2f4d12015-09-01 15:04:13 -0700120static bool video_hw_acceleration_enabled = true;
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000121
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000122// Return the (singleton) Java Enum object corresponding to |index|;
123// |state_class_fragment| is something like "MediaSource$State".
glaznev@webrtc.orgb28474c2015-02-23 17:44:27 +0000124static jobject JavaEnumFromIndex(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000125 JNIEnv* jni, const std::string& state_class_fragment, int index) {
perkj@webrtc.org96e4db92015-02-13 12:46:51 +0000126 const std::string state_class = "org/webrtc/" + state_class_fragment;
127 return JavaEnumFromIndex(jni, FindClass(jni, state_class.c_str()),
128 state_class, index);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000129}
130
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000131static DataChannelInit JavaDataChannelInitToNative(
132 JNIEnv* jni, jobject j_init) {
133 DataChannelInit init;
134
135 jclass j_init_class = FindClass(jni, "org/webrtc/DataChannel$Init");
136 jfieldID ordered_id = GetFieldID(jni, j_init_class, "ordered", "Z");
137 jfieldID max_retransmit_time_id =
138 GetFieldID(jni, j_init_class, "maxRetransmitTimeMs", "I");
139 jfieldID max_retransmits_id =
140 GetFieldID(jni, j_init_class, "maxRetransmits", "I");
141 jfieldID protocol_id =
142 GetFieldID(jni, j_init_class, "protocol", "Ljava/lang/String;");
143 jfieldID negotiated_id = GetFieldID(jni, j_init_class, "negotiated", "Z");
144 jfieldID id_id = GetFieldID(jni, j_init_class, "id", "I");
145
146 init.ordered = GetBooleanField(jni, j_init, ordered_id);
147 init.maxRetransmitTime = GetIntField(jni, j_init, max_retransmit_time_id);
148 init.maxRetransmits = GetIntField(jni, j_init, max_retransmits_id);
149 init.protocol = JavaToStdString(
150 jni, GetStringField(jni, j_init, protocol_id));
151 init.negotiated = GetBooleanField(jni, j_init, negotiated_id);
152 init.id = GetIntField(jni, j_init, id_id);
153
154 return init;
155}
156
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000157class ConstraintsWrapper;
158
159// Adapter between the C++ PeerConnectionObserver interface and the Java
160// PeerConnection.Observer interface. Wraps an instance of the Java interface
161// and dispatches C++ callbacks to Java.
162class PCOJava : public PeerConnectionObserver {
163 public:
164 PCOJava(JNIEnv* jni, jobject j_observer)
165 : j_observer_global_(jni, j_observer),
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000166 j_observer_class_(jni, GetObjectClass(jni, *j_observer_global_)),
167 j_media_stream_class_(jni, FindClass(jni, "org/webrtc/MediaStream")),
168 j_media_stream_ctor_(GetMethodID(
169 jni, *j_media_stream_class_, "<init>", "(J)V")),
170 j_audio_track_class_(jni, FindClass(jni, "org/webrtc/AudioTrack")),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000171 j_audio_track_ctor_(GetMethodID(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000172 jni, *j_audio_track_class_, "<init>", "(J)V")),
173 j_video_track_class_(jni, FindClass(jni, "org/webrtc/VideoTrack")),
174 j_video_track_ctor_(GetMethodID(
175 jni, *j_video_track_class_, "<init>", "(J)V")),
176 j_data_channel_class_(jni, FindClass(jni, "org/webrtc/DataChannel")),
177 j_data_channel_ctor_(GetMethodID(
178 jni, *j_data_channel_class_, "<init>", "(J)V")) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000179 }
180
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200181 virtual ~PCOJava() {
182 ScopedLocalRefFrame local_ref_frame(jni());
183 while (!remote_streams_.empty())
184 DisposeRemoteStream(remote_streams_.begin());
185 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000186
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000187 void OnIceCandidate(const IceCandidateInterface* candidate) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000188 ScopedLocalRefFrame local_ref_frame(jni());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000189 std::string sdp;
henrikg91d6ede2015-09-17 00:24:34 -0700190 RTC_CHECK(candidate->ToString(&sdp)) << "got so far: " << sdp;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000191 jclass candidate_class = FindClass(jni(), "org/webrtc/IceCandidate");
192 jmethodID ctor = GetMethodID(jni(), candidate_class,
193 "<init>", "(Ljava/lang/String;ILjava/lang/String;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000194 jstring j_mid = JavaStringFromStdString(jni(), candidate->sdp_mid());
195 jstring j_sdp = JavaStringFromStdString(jni(), sdp);
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700196 jobject j_candidate = jni()->NewObject(candidate_class, ctor, j_mid,
197 candidate->sdp_mline_index(), j_sdp);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000198 CHECK_EXCEPTION(jni()) << "error during NewObject";
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000199 jmethodID m = GetMethodID(jni(), *j_observer_class_,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000200 "onIceCandidate", "(Lorg/webrtc/IceCandidate;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000201 jni()->CallVoidMethod(*j_observer_global_, m, j_candidate);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000202 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000203 }
204
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700205 void OnIceCandidatesRemoved(
nisseef8b61e2016-04-29 06:09:15 -0700206 const std::vector<cricket::Candidate>& candidates) override {
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700207 ScopedLocalRefFrame local_ref_frame(jni());
208 jobjectArray candidates_array = ToJavaCandidateArray(jni(), candidates);
209 jmethodID m =
210 GetMethodID(jni(), *j_observer_class_, "onIceCandidatesRemoved",
211 "([Lorg/webrtc/IceCandidate;)V");
212 jni()->CallVoidMethod(*j_observer_global_, m, candidates_array);
213 CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod";
214 }
215
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000216 void OnSignalingChange(
217 PeerConnectionInterface::SignalingState new_state) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000218 ScopedLocalRefFrame local_ref_frame(jni());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000219 jmethodID m = GetMethodID(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000220 jni(), *j_observer_class_, "onSignalingChange",
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000221 "(Lorg/webrtc/PeerConnection$SignalingState;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000222 jobject new_state_enum =
223 JavaEnumFromIndex(jni(), "PeerConnection$SignalingState", new_state);
224 jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000225 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000226 }
227
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000228 void OnIceConnectionChange(
229 PeerConnectionInterface::IceConnectionState new_state) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000230 ScopedLocalRefFrame local_ref_frame(jni());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000231 jmethodID m = GetMethodID(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000232 jni(), *j_observer_class_, "onIceConnectionChange",
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000233 "(Lorg/webrtc/PeerConnection$IceConnectionState;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000234 jobject new_state_enum = JavaEnumFromIndex(
235 jni(), "PeerConnection$IceConnectionState", new_state);
236 jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000237 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000238 }
239
Peter Thatcher54360512015-07-08 11:08:35 -0700240 void OnIceConnectionReceivingChange(bool receiving) override {
241 ScopedLocalRefFrame local_ref_frame(jni());
242 jmethodID m = GetMethodID(
243 jni(), *j_observer_class_, "onIceConnectionReceivingChange", "(Z)V");
244 jni()->CallVoidMethod(*j_observer_global_, m, receiving);
245 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
246 }
247
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000248 void OnIceGatheringChange(
249 PeerConnectionInterface::IceGatheringState new_state) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000250 ScopedLocalRefFrame local_ref_frame(jni());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000251 jmethodID m = GetMethodID(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000252 jni(), *j_observer_class_, "onIceGatheringChange",
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000253 "(Lorg/webrtc/PeerConnection$IceGatheringState;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000254 jobject new_state_enum = JavaEnumFromIndex(
255 jni(), "PeerConnection$IceGatheringState", new_state);
256 jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000257 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000258 }
259
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000260 void OnAddStream(MediaStreamInterface* stream) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000261 ScopedLocalRefFrame local_ref_frame(jni());
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200262 // Java MediaStream holds one reference. Corresponding Release() is in
263 // MediaStream_free, triggered by MediaStream.dispose().
264 stream->AddRef();
265 jobject j_stream =
266 jni()->NewObject(*j_media_stream_class_, j_media_stream_ctor_,
267 reinterpret_cast<jlong>(stream));
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000268 CHECK_EXCEPTION(jni()) << "error during NewObject";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000269
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200270 for (const auto& track : stream->GetAudioTracks()) {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000271 jstring id = JavaStringFromStdString(jni(), track->id());
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200272 // Java AudioTrack holds one reference. Corresponding Release() is in
273 // MediaStreamTrack_free, triggered by AudioTrack.dispose().
274 track->AddRef();
275 jobject j_track =
276 jni()->NewObject(*j_audio_track_class_, j_audio_track_ctor_,
277 reinterpret_cast<jlong>(track.get()), id);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000278 CHECK_EXCEPTION(jni()) << "error during NewObject";
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000279 jfieldID audio_tracks_id = GetFieldID(jni(),
280 *j_media_stream_class_,
281 "audioTracks",
282 "Ljava/util/LinkedList;");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000283 jobject audio_tracks = GetObjectField(jni(), j_stream, audio_tracks_id);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000284 jmethodID add = GetMethodID(jni(),
fischman@webrtc.org41776152014-01-09 00:31:17 +0000285 GetObjectClass(jni(), audio_tracks),
286 "add",
287 "(Ljava/lang/Object;)Z");
288 jboolean added = jni()->CallBooleanMethod(audio_tracks, add, j_track);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000289 CHECK_EXCEPTION(jni()) << "error during CallBooleanMethod";
henrikg91d6ede2015-09-17 00:24:34 -0700290 RTC_CHECK(added);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000291 }
292
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200293 for (const auto& track : stream->GetVideoTracks()) {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000294 jstring id = JavaStringFromStdString(jni(), track->id());
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200295 // Java VideoTrack holds one reference. Corresponding Release() is in
296 // MediaStreamTrack_free, triggered by VideoTrack.dispose().
297 track->AddRef();
298 jobject j_track =
299 jni()->NewObject(*j_video_track_class_, j_video_track_ctor_,
300 reinterpret_cast<jlong>(track.get()), id);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000301 CHECK_EXCEPTION(jni()) << "error during NewObject";
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000302 jfieldID video_tracks_id = GetFieldID(jni(),
303 *j_media_stream_class_,
304 "videoTracks",
305 "Ljava/util/LinkedList;");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000306 jobject video_tracks = GetObjectField(jni(), j_stream, video_tracks_id);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000307 jmethodID add = GetMethodID(jni(),
fischman@webrtc.org41776152014-01-09 00:31:17 +0000308 GetObjectClass(jni(), video_tracks),
309 "add",
310 "(Ljava/lang/Object;)Z");
311 jboolean added = jni()->CallBooleanMethod(video_tracks, add, j_track);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000312 CHECK_EXCEPTION(jni()) << "error during CallBooleanMethod";
henrikg91d6ede2015-09-17 00:24:34 -0700313 RTC_CHECK(added);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000314 }
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200315 remote_streams_[stream] = NewGlobalRef(jni(), j_stream);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000316
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000317 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onAddStream",
318 "(Lorg/webrtc/MediaStream;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000319 jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000320 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000321 }
322
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000323 void OnRemoveStream(MediaStreamInterface* stream) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000324 ScopedLocalRefFrame local_ref_frame(jni());
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200325 NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
henrikg91d6ede2015-09-17 00:24:34 -0700326 RTC_CHECK(it != remote_streams_.end()) << "unexpected stream: " << std::hex
327 << stream;
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200328 jobject j_stream = it->second;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000329 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onRemoveStream",
330 "(Lorg/webrtc/MediaStream;)V");
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200331 jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000332 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200333 DisposeRemoteStream(it);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000334 }
335
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000336 void OnDataChannel(DataChannelInterface* channel) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000337 ScopedLocalRefFrame local_ref_frame(jni());
338 jobject j_channel = jni()->NewObject(
339 *j_data_channel_class_, j_data_channel_ctor_, (jlong)channel);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000340 CHECK_EXCEPTION(jni()) << "error during NewObject";
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000341
342 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onDataChannel",
343 "(Lorg/webrtc/DataChannel;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000344 jni()->CallVoidMethod(*j_observer_global_, m, j_channel);
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000345
346 // Channel is now owned by Java object, and will be freed from
347 // DataChannel.dispose(). Important that this be done _after_ the
348 // CallVoidMethod above as Java code might call back into native code and be
349 // surprised to see a refcount of 2.
350 int bumped_count = channel->AddRef();
henrikg91d6ede2015-09-17 00:24:34 -0700351 RTC_CHECK(bumped_count == 2) << "Unexpected refcount OnDataChannel";
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000352
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000353 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000354 }
355
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000356 void OnRenegotiationNeeded() override {
fischman@webrtc.orgd7568a02014-01-13 22:04:12 +0000357 ScopedLocalRefFrame local_ref_frame(jni());
358 jmethodID m =
359 GetMethodID(jni(), *j_observer_class_, "onRenegotiationNeeded", "()V");
360 jni()->CallVoidMethod(*j_observer_global_, m);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000361 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
fischman@webrtc.orgd7568a02014-01-13 22:04:12 +0000362 }
363
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000364 void SetConstraints(ConstraintsWrapper* constraints) {
henrikg91d6ede2015-09-17 00:24:34 -0700365 RTC_CHECK(!constraints_.get()) << "constraints already set!";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000366 constraints_.reset(constraints);
367 }
368
369 const ConstraintsWrapper* constraints() { return constraints_.get(); }
370
371 private:
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200372 typedef std::map<MediaStreamInterface*, jobject> NativeToJavaStreamsMap;
373
374 void DisposeRemoteStream(const NativeToJavaStreamsMap::iterator& it) {
375 jobject j_stream = it->second;
376 remote_streams_.erase(it);
377 jni()->CallVoidMethod(
378 j_stream, GetMethodID(jni(), *j_media_stream_class_, "dispose", "()V"));
379 CHECK_EXCEPTION(jni()) << "error during MediaStream.dispose()";
380 DeleteGlobalRef(jni(), j_stream);
381 }
382
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700383 jobject ToJavaCandidate(JNIEnv* jni,
384 jclass* candidate_class,
385 const cricket::Candidate& candidate) {
386 std::string sdp = webrtc::SdpSerializeCandidate(candidate);
387 RTC_CHECK(!sdp.empty()) << "got an empty ICE candidate";
388 jmethodID ctor = GetMethodID(jni, *candidate_class, "<init>",
389 "(Ljava/lang/String;ILjava/lang/String;)V");
390 jstring j_mid = JavaStringFromStdString(jni, candidate.transport_name());
391 jstring j_sdp = JavaStringFromStdString(jni, sdp);
392 // sdp_mline_index is not used, pass an invalid value -1.
393 jobject j_candidate =
394 jni->NewObject(*candidate_class, ctor, j_mid, -1, j_sdp);
395 CHECK_EXCEPTION(jni) << "error during Java Candidate NewObject";
396 return j_candidate;
397 }
398
399 jobjectArray ToJavaCandidateArray(
400 JNIEnv* jni,
401 const std::vector<cricket::Candidate>& candidates) {
402 jclass candidate_class = FindClass(jni, "org/webrtc/IceCandidate");
403 jobjectArray java_candidates =
404 jni->NewObjectArray(candidates.size(), candidate_class, NULL);
405 int i = 0;
406 for (const cricket::Candidate& candidate : candidates) {
407 jobject j_candidate = ToJavaCandidate(jni, &candidate_class, candidate);
408 jni->SetObjectArrayElement(java_candidates, i++, j_candidate);
409 }
410 return java_candidates;
411 }
412
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000413 JNIEnv* jni() {
414 return AttachCurrentThreadIfNeeded();
415 }
416
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000417 const ScopedGlobalRef<jobject> j_observer_global_;
418 const ScopedGlobalRef<jclass> j_observer_class_;
419 const ScopedGlobalRef<jclass> j_media_stream_class_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000420 const jmethodID j_media_stream_ctor_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000421 const ScopedGlobalRef<jclass> j_audio_track_class_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000422 const jmethodID j_audio_track_ctor_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000423 const ScopedGlobalRef<jclass> j_video_track_class_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000424 const jmethodID j_video_track_ctor_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000425 const ScopedGlobalRef<jclass> j_data_channel_class_;
426 const jmethodID j_data_channel_ctor_;
Magnus Jedvert1c3dd382015-08-27 13:39:58 +0200427 // C++ -> Java remote streams. The stored jobects are global refs and must be
428 // manually deleted upon removal. Use DisposeRemoteStream().
429 NativeToJavaStreamsMap remote_streams_;
kwibergd1fe2812016-04-27 06:47:29 -0700430 std::unique_ptr<ConstraintsWrapper> constraints_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000431};
432
433// Wrapper for a Java MediaConstraints object. Copies all needed data so when
434// the constructor returns the Java object is no longer needed.
435class ConstraintsWrapper : public MediaConstraintsInterface {
436 public:
437 ConstraintsWrapper(JNIEnv* jni, jobject j_constraints) {
438 PopulateConstraintsFromJavaPairList(
439 jni, j_constraints, "mandatory", &mandatory_);
440 PopulateConstraintsFromJavaPairList(
441 jni, j_constraints, "optional", &optional_);
442 }
443
444 virtual ~ConstraintsWrapper() {}
445
446 // MediaConstraintsInterface.
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000447 const Constraints& GetMandatory() const override { return mandatory_; }
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000448
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000449 const Constraints& GetOptional() const override { return optional_; }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000450
451 private:
452 // Helper for translating a List<Pair<String, String>> to a Constraints.
453 static void PopulateConstraintsFromJavaPairList(
454 JNIEnv* jni, jobject j_constraints,
455 const char* field_name, Constraints* field) {
456 jfieldID j_id = GetFieldID(jni,
457 GetObjectClass(jni, j_constraints), field_name, "Ljava/util/List;");
458 jobject j_list = GetObjectField(jni, j_constraints, j_id);
skvlad303b3c22016-03-24 19:36:46 -0700459 for (jobject entry : Iterable(jni, j_list)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000460 jmethodID get_key = GetMethodID(jni,
461 GetObjectClass(jni, entry), "getKey", "()Ljava/lang/String;");
462 jstring j_key = reinterpret_cast<jstring>(
463 jni->CallObjectMethod(entry, get_key));
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000464 CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000465 jmethodID get_value = GetMethodID(jni,
466 GetObjectClass(jni, entry), "getValue", "()Ljava/lang/String;");
467 jstring j_value = reinterpret_cast<jstring>(
468 jni->CallObjectMethod(entry, get_value));
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000469 CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000470 field->push_back(Constraint(JavaToStdString(jni, j_key),
471 JavaToStdString(jni, j_value)));
472 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000473 }
474
475 Constraints mandatory_;
476 Constraints optional_;
477};
478
479static jobject JavaSdpFromNativeSdp(
480 JNIEnv* jni, const SessionDescriptionInterface* desc) {
481 std::string sdp;
henrikg91d6ede2015-09-17 00:24:34 -0700482 RTC_CHECK(desc->ToString(&sdp)) << "got so far: " << sdp;
fischman@webrtc.org41776152014-01-09 00:31:17 +0000483 jstring j_description = JavaStringFromStdString(jni, sdp);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000484
485 jclass j_type_class = FindClass(
486 jni, "org/webrtc/SessionDescription$Type");
487 jmethodID j_type_from_canonical = GetStaticMethodID(
488 jni, j_type_class, "fromCanonicalForm",
489 "(Ljava/lang/String;)Lorg/webrtc/SessionDescription$Type;");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000490 jstring j_type_string = JavaStringFromStdString(jni, desc->type());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000491 jobject j_type = jni->CallStaticObjectMethod(
fischman@webrtc.org41776152014-01-09 00:31:17 +0000492 j_type_class, j_type_from_canonical, j_type_string);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000493 CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000494
495 jclass j_sdp_class = FindClass(jni, "org/webrtc/SessionDescription");
496 jmethodID j_sdp_ctor = GetMethodID(
497 jni, j_sdp_class, "<init>",
498 "(Lorg/webrtc/SessionDescription$Type;Ljava/lang/String;)V");
499 jobject j_sdp = jni->NewObject(
fischman@webrtc.org41776152014-01-09 00:31:17 +0000500 j_sdp_class, j_sdp_ctor, j_type, j_description);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000501 CHECK_EXCEPTION(jni) << "error during NewObject";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000502 return j_sdp;
503}
504
505template <class T> // T is one of {Create,Set}SessionDescriptionObserver.
506class SdpObserverWrapper : public T {
507 public:
508 SdpObserverWrapper(JNIEnv* jni, jobject j_observer,
509 ConstraintsWrapper* constraints)
510 : constraints_(constraints),
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000511 j_observer_global_(jni, j_observer),
512 j_observer_class_(jni, GetObjectClass(jni, j_observer)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000513 }
514
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000515 virtual ~SdpObserverWrapper() {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000516
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000517 // Can't mark override because of templating.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000518 virtual void OnSuccess() {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000519 ScopedLocalRefFrame local_ref_frame(jni());
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000520 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSetSuccess", "()V");
521 jni()->CallVoidMethod(*j_observer_global_, m);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000522 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000523 }
524
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000525 // Can't mark override because of templating.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000526 virtual void OnSuccess(SessionDescriptionInterface* desc) {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000527 ScopedLocalRefFrame local_ref_frame(jni());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000528 jmethodID m = GetMethodID(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000529 jni(), *j_observer_class_, "onCreateSuccess",
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000530 "(Lorg/webrtc/SessionDescription;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000531 jobject j_sdp = JavaSdpFromNativeSdp(jni(), desc);
532 jni()->CallVoidMethod(*j_observer_global_, m, j_sdp);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000533 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000534 }
535
536 protected:
537 // Common implementation for failure of Set & Create types, distinguished by
538 // |op| being "Set" or "Create".
perkjfbeb97e2016-01-08 00:43:07 -0800539 void DoOnFailure(const std::string& op, const std::string& error) {
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000540 jmethodID m = GetMethodID(jni(), *j_observer_class_, "on" + op + "Failure",
541 "(Ljava/lang/String;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000542 jstring j_error_string = JavaStringFromStdString(jni(), error);
543 jni()->CallVoidMethod(*j_observer_global_, m, j_error_string);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000544 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000545 }
546
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000547 JNIEnv* jni() {
548 return AttachCurrentThreadIfNeeded();
549 }
550
fischman@webrtc.org41776152014-01-09 00:31:17 +0000551 private:
kwibergd1fe2812016-04-27 06:47:29 -0700552 std::unique_ptr<ConstraintsWrapper> constraints_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000553 const ScopedGlobalRef<jobject> j_observer_global_;
554 const ScopedGlobalRef<jclass> j_observer_class_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000555};
556
557class CreateSdpObserverWrapper
558 : public SdpObserverWrapper<CreateSessionDescriptionObserver> {
559 public:
560 CreateSdpObserverWrapper(JNIEnv* jni, jobject j_observer,
561 ConstraintsWrapper* constraints)
562 : SdpObserverWrapper(jni, j_observer, constraints) {}
563
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000564 void OnFailure(const std::string& error) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000565 ScopedLocalRefFrame local_ref_frame(jni());
perkjfbeb97e2016-01-08 00:43:07 -0800566 SdpObserverWrapper::DoOnFailure(std::string("Create"), error);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000567 }
568};
569
570class SetSdpObserverWrapper
571 : public SdpObserverWrapper<SetSessionDescriptionObserver> {
572 public:
573 SetSdpObserverWrapper(JNIEnv* jni, jobject j_observer,
574 ConstraintsWrapper* constraints)
575 : SdpObserverWrapper(jni, j_observer, constraints) {}
576
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000577 void OnFailure(const std::string& error) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000578 ScopedLocalRefFrame local_ref_frame(jni());
perkjfbeb97e2016-01-08 00:43:07 -0800579 SdpObserverWrapper::DoOnFailure(std::string("Set"), error);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000580 }
581};
582
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000583// Adapter for a Java DataChannel$Observer presenting a C++ DataChannelObserver
584// and dispatching the callback from C++ back to Java.
585class DataChannelObserverWrapper : public DataChannelObserver {
586 public:
587 DataChannelObserverWrapper(JNIEnv* jni, jobject j_observer)
588 : j_observer_global_(jni, j_observer),
589 j_observer_class_(jni, GetObjectClass(jni, j_observer)),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000590 j_buffer_class_(jni, FindClass(jni, "org/webrtc/DataChannel$Buffer")),
bemasc0edd50c2015-07-01 13:34:33 -0700591 j_on_buffered_amount_change_mid_(GetMethodID(
592 jni, *j_observer_class_, "onBufferedAmountChange", "(J)V")),
593 j_on_state_change_mid_(
594 GetMethodID(jni, *j_observer_class_, "onStateChange", "()V")),
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000595 j_on_message_mid_(GetMethodID(jni, *j_observer_class_, "onMessage",
596 "(Lorg/webrtc/DataChannel$Buffer;)V")),
bemasc0edd50c2015-07-01 13:34:33 -0700597 j_buffer_ctor_(GetMethodID(jni, *j_buffer_class_, "<init>",
598 "(Ljava/nio/ByteBuffer;Z)V")) {}
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000599
600 virtual ~DataChannelObserverWrapper() {}
601
Peter Boström0c4e06b2015-10-07 12:23:21 +0200602 void OnBufferedAmountChange(uint64_t previous_amount) override {
bemasc0edd50c2015-07-01 13:34:33 -0700603 ScopedLocalRefFrame local_ref_frame(jni());
604 jni()->CallVoidMethod(*j_observer_global_, j_on_buffered_amount_change_mid_,
605 previous_amount);
606 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
607 }
608
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000609 void OnStateChange() override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000610 ScopedLocalRefFrame local_ref_frame(jni());
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000611 jni()->CallVoidMethod(*j_observer_global_, j_on_state_change_mid_);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000612 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000613 }
614
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000615 void OnMessage(const DataBuffer& buffer) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000616 ScopedLocalRefFrame local_ref_frame(jni());
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000617 jobject byte_buffer = jni()->NewDirectByteBuffer(
Karl Wiberg94784372015-04-20 14:03:07 +0200618 const_cast<char*>(buffer.data.data<char>()), buffer.data.size());
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000619 jobject j_buffer = jni()->NewObject(*j_buffer_class_, j_buffer_ctor_,
620 byte_buffer, buffer.binary);
621 jni()->CallVoidMethod(*j_observer_global_, j_on_message_mid_, j_buffer);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000622 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000623 }
624
625 private:
626 JNIEnv* jni() {
627 return AttachCurrentThreadIfNeeded();
628 }
629
630 const ScopedGlobalRef<jobject> j_observer_global_;
631 const ScopedGlobalRef<jclass> j_observer_class_;
632 const ScopedGlobalRef<jclass> j_buffer_class_;
bemasc0edd50c2015-07-01 13:34:33 -0700633 const jmethodID j_on_buffered_amount_change_mid_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000634 const jmethodID j_on_state_change_mid_;
635 const jmethodID j_on_message_mid_;
636 const jmethodID j_buffer_ctor_;
637};
638
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000639// Adapter for a Java StatsObserver presenting a C++ StatsObserver and
640// dispatching the callback from C++ back to Java.
641class StatsObserverWrapper : public StatsObserver {
642 public:
643 StatsObserverWrapper(JNIEnv* jni, jobject j_observer)
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000644 : j_observer_global_(jni, j_observer),
645 j_observer_class_(jni, GetObjectClass(jni, j_observer)),
646 j_stats_report_class_(jni, FindClass(jni, "org/webrtc/StatsReport")),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000647 j_stats_report_ctor_(GetMethodID(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000648 jni, *j_stats_report_class_, "<init>",
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000649 "(Ljava/lang/String;Ljava/lang/String;D"
650 "[Lorg/webrtc/StatsReport$Value;)V")),
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000651 j_value_class_(jni, FindClass(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000652 jni, "org/webrtc/StatsReport$Value")),
653 j_value_ctor_(GetMethodID(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000654 jni, *j_value_class_, "<init>",
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000655 "(Ljava/lang/String;Ljava/lang/String;)V")) {
656 }
657
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000658 virtual ~StatsObserverWrapper() {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000659
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000660 void OnComplete(const StatsReports& reports) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000661 ScopedLocalRefFrame local_ref_frame(jni());
662 jobjectArray j_reports = ReportsToJava(jni(), reports);
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000663 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onComplete",
664 "([Lorg/webrtc/StatsReport;)V");
fischman@webrtc.org41776152014-01-09 00:31:17 +0000665 jni()->CallVoidMethod(*j_observer_global_, m, j_reports);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000666 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000667 }
668
669 private:
670 jobjectArray ReportsToJava(
tommi@webrtc.orge2e199b2014-12-15 13:22:54 +0000671 JNIEnv* jni, const StatsReports& reports) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000672 jobjectArray reports_array = jni->NewObjectArray(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000673 reports.size(), *j_stats_report_class_, NULL);
tommi@webrtc.orge2e199b2014-12-15 13:22:54 +0000674 int i = 0;
675 for (const auto* report : reports) {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000676 ScopedLocalRefFrame local_ref_frame(jni);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000677 jstring j_id = JavaStringFromStdString(jni, report->id()->ToString());
tommi@webrtc.org8e327c42015-01-19 20:41:26 +0000678 jstring j_type = JavaStringFromStdString(jni, report->TypeToString());
679 jobjectArray j_values = ValuesToJava(jni, report->values());
fischman@webrtc.org41776152014-01-09 00:31:17 +0000680 jobject j_report = jni->NewObject(*j_stats_report_class_,
681 j_stats_report_ctor_,
682 j_id,
683 j_type,
tommi@webrtc.org8e327c42015-01-19 20:41:26 +0000684 report->timestamp(),
fischman@webrtc.org41776152014-01-09 00:31:17 +0000685 j_values);
tommi@webrtc.orge2e199b2014-12-15 13:22:54 +0000686 jni->SetObjectArrayElement(reports_array, i++, j_report);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000687 }
688 return reports_array;
689 }
690
691 jobjectArray ValuesToJava(JNIEnv* jni, const StatsReport::Values& values) {
692 jobjectArray j_values = jni->NewObjectArray(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000693 values.size(), *j_value_class_, NULL);
tommi@webrtc.org92f40182015-03-04 15:25:19 +0000694 int i = 0;
695 for (const auto& it : values) {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000696 ScopedLocalRefFrame local_ref_frame(jni);
tommi@webrtc.orgc57310b2014-12-12 17:41:28 +0000697 // Should we use the '.name' enum value here instead of converting the
698 // name to a string?
tommi@webrtc.org92f40182015-03-04 15:25:19 +0000699 jstring j_name = JavaStringFromStdString(jni, it.second->display_name());
700 jstring j_value = JavaStringFromStdString(jni, it.second->ToString());
fischman@webrtc.org41776152014-01-09 00:31:17 +0000701 jobject j_element_value =
702 jni->NewObject(*j_value_class_, j_value_ctor_, j_name, j_value);
tommi@webrtc.org92f40182015-03-04 15:25:19 +0000703 jni->SetObjectArrayElement(j_values, i++, j_element_value);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000704 }
705 return j_values;
706 }
707
708 JNIEnv* jni() {
709 return AttachCurrentThreadIfNeeded();
710 }
711
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000712 const ScopedGlobalRef<jobject> j_observer_global_;
713 const ScopedGlobalRef<jclass> j_observer_class_;
714 const ScopedGlobalRef<jclass> j_stats_report_class_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000715 const jmethodID j_stats_report_ctor_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000716 const ScopedGlobalRef<jclass> j_value_class_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000717 const jmethodID j_value_ctor_;
718};
719
Niels Möller8f597622016-03-23 10:33:07 +0100720// Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000721// instance.
Niels Möller8f597622016-03-23 10:33:07 +0100722class JavaVideoRendererWrapper
723 : public rtc::VideoSinkInterface<cricket::VideoFrame> {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000724 public:
725 JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000726 : j_callbacks_(jni, j_callbacks),
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000727 j_render_frame_id_(GetMethodID(
728 jni, GetObjectClass(jni, j_callbacks), "renderFrame",
729 "(Lorg/webrtc/VideoRenderer$I420Frame;)V")),
730 j_frame_class_(jni,
731 FindClass(jni, "org/webrtc/VideoRenderer$I420Frame")),
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000732 j_i420_frame_ctor_id_(GetMethodID(
Magnus Jedverta6cba3a2015-08-29 15:57:43 +0200733 jni, *j_frame_class_, "<init>", "(III[I[Ljava/nio/ByteBuffer;J)V")),
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000734 j_texture_frame_ctor_id_(GetMethodID(
735 jni, *j_frame_class_, "<init>",
Per488e75f2015-11-19 10:43:36 +0100736 "(IIII[FJ)V")),
Magnus Jedvert7ef9d912015-08-25 09:32:06 +0200737 j_byte_buffer_class_(jni, FindClass(jni, "java/nio/ByteBuffer")) {
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000738 CHECK_EXCEPTION(jni);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000739 }
740
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000741 virtual ~JavaVideoRendererWrapper() {}
742
Niels Möller8f597622016-03-23 10:33:07 +0100743 void OnFrame(const cricket::VideoFrame& video_frame) override {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000744 ScopedLocalRefFrame local_ref_frame(jni());
Niels Möller8f597622016-03-23 10:33:07 +0100745 jobject j_frame = (video_frame.GetNativeHandle() != nullptr)
746 ? CricketToJavaTextureFrame(&video_frame)
747 : CricketToJavaI420Frame(&video_frame);
Magnus Jedvert1d640e52015-09-29 16:33:16 +0200748 // |j_callbacks_| is responsible for releasing |j_frame| with
749 // VideoRenderer.renderFrameDone().
Magnus Jedvert7ef9d912015-08-25 09:32:06 +0200750 jni()->CallVoidMethod(*j_callbacks_, j_render_frame_id_, j_frame);
751 CHECK_EXCEPTION(jni());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000752 }
753
754 private:
Magnus Jedvert1d640e52015-09-29 16:33:16 +0200755 // Make a shallow copy of |frame| to be used with Java. The callee has
756 // ownership of the frame, and the frame should be released with
757 // VideoRenderer.releaseNativeFrame().
758 static jlong javaShallowCopy(const cricket::VideoFrame* frame) {
759 return jlongFromPointer(frame->Copy());
760 }
761
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000762 // Return a VideoRenderer.I420Frame referring to the data in |frame|.
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000763 jobject CricketToJavaI420Frame(const cricket::VideoFrame* frame) {
fischman@webrtc.org41776152014-01-09 00:31:17 +0000764 jintArray strides = jni()->NewIntArray(3);
765 jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
nisse05654512016-04-29 02:56:00 -0700766 strides_array[0] = frame->video_frame_buffer()->StrideY();
767 strides_array[1] = frame->video_frame_buffer()->StrideU();
768 strides_array[2] = frame->video_frame_buffer()->StrideV();
fischman@webrtc.org41776152014-01-09 00:31:17 +0000769 jni()->ReleaseIntArrayElements(strides, strides_array, 0);
770 jobjectArray planes = jni()->NewObjectArray(3, *j_byte_buffer_class_, NULL);
nisse05654512016-04-29 02:56:00 -0700771 jobject y_buffer = jni()->NewDirectByteBuffer(
772 const_cast<uint8_t*>(frame->video_frame_buffer()->DataY()),
773 frame->video_frame_buffer()->StrideY() *
774 frame->video_frame_buffer()->height());
nissefc88ffe2016-05-03 00:32:08 -0700775 size_t chroma_height = (frame->height() + 1) / 2;
fischman@webrtc.org41776152014-01-09 00:31:17 +0000776 jobject u_buffer = jni()->NewDirectByteBuffer(
nisse05654512016-04-29 02:56:00 -0700777 const_cast<uint8_t*>(frame->video_frame_buffer()->DataU()),
nissefc88ffe2016-05-03 00:32:08 -0700778 frame->video_frame_buffer()->StrideU() * chroma_height);
fischman@webrtc.org41776152014-01-09 00:31:17 +0000779 jobject v_buffer = jni()->NewDirectByteBuffer(
nisse05654512016-04-29 02:56:00 -0700780 const_cast<uint8_t*>(frame->video_frame_buffer()->DataV()),
nissefc88ffe2016-05-03 00:32:08 -0700781 frame->video_frame_buffer()->StrideV() * chroma_height);
782
fischman@webrtc.org41776152014-01-09 00:31:17 +0000783 jni()->SetObjectArrayElement(planes, 0, y_buffer);
784 jni()->SetObjectArrayElement(planes, 1, u_buffer);
785 jni()->SetObjectArrayElement(planes, 2, v_buffer);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000786 return jni()->NewObject(
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000787 *j_frame_class_, j_i420_frame_ctor_id_,
nisse71a0c2f2016-04-04 00:57:29 -0700788 frame->width(), frame->height(),
nissef3868762016-04-13 03:29:16 -0700789 static_cast<int>(frame->rotation()),
Magnus Jedvert1d640e52015-09-29 16:33:16 +0200790 strides, planes, javaShallowCopy(frame));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000791 }
792
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000793 // Return a VideoRenderer.I420Frame referring texture object in |frame|.
794 jobject CricketToJavaTextureFrame(const cricket::VideoFrame* frame) {
795 NativeHandleImpl* handle =
796 reinterpret_cast<NativeHandleImpl*>(frame->GetNativeHandle());
Per488e75f2015-11-19 10:43:36 +0100797 jfloatArray sampling_matrix = jni()->NewFloatArray(16);
798 jni()->SetFloatArrayRegion(sampling_matrix, 0, 16, handle->sampling_matrix);
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000799 return jni()->NewObject(
800 *j_frame_class_, j_texture_frame_ctor_id_,
nisse71a0c2f2016-04-04 00:57:29 -0700801 frame->width(), frame->height(),
nissef3868762016-04-13 03:29:16 -0700802 static_cast<int>(frame->rotation()),
Per488e75f2015-11-19 10:43:36 +0100803 handle->oes_texture_id, sampling_matrix, javaShallowCopy(frame));
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000804 }
805
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000806 JNIEnv* jni() {
807 return AttachCurrentThreadIfNeeded();
808 }
809
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000810 ScopedGlobalRef<jobject> j_callbacks_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000811 jmethodID j_render_frame_id_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000812 ScopedGlobalRef<jclass> j_frame_class_;
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000813 jmethodID j_i420_frame_ctor_id_;
814 jmethodID j_texture_frame_ctor_id_;
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000815 ScopedGlobalRef<jclass> j_byte_buffer_class_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000816};
817
fischman@webrtc.org540acde2014-02-13 03:56:14 +0000818
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000819static DataChannelInterface* ExtractNativeDC(JNIEnv* jni, jobject j_dc) {
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000820 jfieldID native_dc_id = GetFieldID(jni,
821 GetObjectClass(jni, j_dc), "nativeDataChannel", "J");
822 jlong j_d = GetLongField(jni, j_dc, native_dc_id);
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000823 return reinterpret_cast<DataChannelInterface*>(j_d);
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000824}
825
826JOW(jlong, DataChannel_registerObserverNative)(
827 JNIEnv* jni, jobject j_dc, jobject j_observer) {
kwibergd1fe2812016-04-27 06:47:29 -0700828 std::unique_ptr<DataChannelObserverWrapper> observer(
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000829 new DataChannelObserverWrapper(jni, j_observer));
830 ExtractNativeDC(jni, j_dc)->RegisterObserver(observer.get());
fischman@webrtc.orgf41f06b2013-12-11 21:07:18 +0000831 return jlongFromPointer(observer.release());
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000832}
833
834JOW(void, DataChannel_unregisterObserverNative)(
835 JNIEnv* jni, jobject j_dc, jlong native_observer) {
836 ExtractNativeDC(jni, j_dc)->UnregisterObserver();
837 delete reinterpret_cast<DataChannelObserverWrapper*>(native_observer);
838}
839
840JOW(jstring, DataChannel_label)(JNIEnv* jni, jobject j_dc) {
841 return JavaStringFromStdString(jni, ExtractNativeDC(jni, j_dc)->label());
842}
843
844JOW(jobject, DataChannel_state)(JNIEnv* jni, jobject j_dc) {
845 return JavaEnumFromIndex(
846 jni, "DataChannel$State", ExtractNativeDC(jni, j_dc)->state());
847}
848
849JOW(jlong, DataChannel_bufferedAmount)(JNIEnv* jni, jobject j_dc) {
Peter Boström0c4e06b2015-10-07 12:23:21 +0200850 uint64_t buffered_amount = ExtractNativeDC(jni, j_dc)->buffered_amount();
851 RTC_CHECK_LE(buffered_amount, std::numeric_limits<int64_t>::max())
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000852 << "buffered_amount overflowed jlong!";
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000853 return static_cast<jlong>(buffered_amount);
854}
855
856JOW(void, DataChannel_close)(JNIEnv* jni, jobject j_dc) {
857 ExtractNativeDC(jni, j_dc)->Close();
858}
859
860JOW(jboolean, DataChannel_sendNative)(JNIEnv* jni, jobject j_dc,
861 jbyteArray data, jboolean binary) {
862 jbyte* bytes = jni->GetByteArrayElements(data, NULL);
863 bool ret = ExtractNativeDC(jni, j_dc)->Send(DataBuffer(
jbaucheec21bd2016-03-20 06:15:43 -0700864 rtc::CopyOnWriteBuffer(bytes, jni->GetArrayLength(data)),
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000865 binary));
866 jni->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
867 return ret;
868}
869
870JOW(void, DataChannel_dispose)(JNIEnv* jni, jobject j_dc) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000871 CHECK_RELEASE(ExtractNativeDC(jni, j_dc));
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000872}
873
fischman@webrtc.orgc883fdc2013-08-06 19:00:53 +0000874JOW(void, Logging_nativeEnableTracing)(
875 JNIEnv* jni, jclass, jstring j_path, jint nativeLevels,
876 jint nativeSeverity) {
877 std::string path = JavaToStdString(jni, j_path);
878 if (nativeLevels != webrtc::kTraceNone) {
andrew@webrtc.org90805182013-09-05 16:40:43 +0000879 webrtc::Trace::set_level_filter(nativeLevels);
fischman@webrtc.org7e4d0df2013-10-01 02:40:43 +0000880 if (path != "logcat:") {
henrikg91d6ede2015-09-17 00:24:34 -0700881 RTC_CHECK_EQ(0, webrtc::Trace::SetTraceFile(path.c_str(), false))
andresp@webrtc.org4d19e052014-09-09 11:45:44 +0000882 << "SetTraceFile failed";
fischman@webrtc.org7e4d0df2013-10-01 02:40:43 +0000883 } else {
884 // Intentionally leak this to avoid needing to reason about its lifecycle.
885 // It keeps no state and functions only as a dispatch point.
886 static LogcatTraceContext* g_trace_callback = new LogcatTraceContext();
887 }
fischman@webrtc.orgc883fdc2013-08-06 19:00:53 +0000888 }
Tommi0eefb4d2015-05-23 09:54:07 +0200889 if (nativeSeverity >= rtc::LS_SENSITIVE && nativeSeverity <= rtc::LS_ERROR) {
890 rtc::LogMessage::LogToDebug(
891 static_cast<rtc::LoggingSeverity>(nativeSeverity));
892 }
fischman@webrtc.orgc883fdc2013-08-06 19:00:53 +0000893}
894
Jiayang Liue63d2a12015-09-01 16:11:18 -0700895JOW(void, Logging_nativeEnableLogThreads)(JNIEnv* jni, jclass) {
896 rtc::LogMessage::LogThreads(true);
897}
898
899JOW(void, Logging_nativeEnableLogTimeStamps)(JNIEnv* jni, jclass) {
900 rtc::LogMessage::LogTimestamps(true);
901}
902
903JOW(void, Logging_nativeLog)(
jiayl66f0da22015-09-14 15:06:39 -0700904 JNIEnv* jni, jclass, jint j_severity, jstring j_tag, jstring j_message) {
Jiayang Liue63d2a12015-09-01 16:11:18 -0700905 std::string message = JavaToStdString(jni, j_message);
jiayl66f0da22015-09-14 15:06:39 -0700906 std::string tag = JavaToStdString(jni, j_tag);
907 LOG_TAG(static_cast<rtc::LoggingSeverity>(j_severity), tag) << message;
Jiayang Liue63d2a12015-09-01 16:11:18 -0700908}
909
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000910JOW(void, PeerConnection_freePeerConnection)(JNIEnv*, jclass, jlong j_p) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000911 CHECK_RELEASE(reinterpret_cast<PeerConnectionInterface*>(j_p));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000912}
913
914JOW(void, PeerConnection_freeObserver)(JNIEnv*, jclass, jlong j_p) {
915 PCOJava* p = reinterpret_cast<PCOJava*>(j_p);
916 delete p;
917}
918
919JOW(void, MediaSource_free)(JNIEnv*, jclass, jlong j_p) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000920 CHECK_RELEASE(reinterpret_cast<MediaSourceInterface*>(j_p));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000921}
922
glaznev@webrtc.orga59c5012014-09-17 03:26:59 +0000923JOW(void, VideoRenderer_freeWrappedVideoRenderer)(JNIEnv*, jclass, jlong j_p) {
924 delete reinterpret_cast<JavaVideoRendererWrapper*>(j_p);
925}
926
Magnus Jedverta6cba3a2015-08-29 15:57:43 +0200927JOW(void, VideoRenderer_releaseNativeFrame)(
928 JNIEnv* jni, jclass, jlong j_frame_ptr) {
929 delete reinterpret_cast<const cricket::VideoFrame*>(j_frame_ptr);
930}
931
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000932JOW(void, MediaStreamTrack_free)(JNIEnv*, jclass, jlong j_p) {
deadbeef4139c0f2015-10-06 12:29:25 -0700933 reinterpret_cast<MediaStreamTrackInterface*>(j_p)->Release();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000934}
935
936JOW(jboolean, MediaStream_nativeAddAudioTrack)(
937 JNIEnv* jni, jclass, jlong pointer, jlong j_audio_track_pointer) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000938 return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000939 reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000940}
941
942JOW(jboolean, MediaStream_nativeAddVideoTrack)(
943 JNIEnv* jni, jclass, jlong pointer, jlong j_video_track_pointer) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000944 return reinterpret_cast<MediaStreamInterface*>(pointer)
945 ->AddTrack(reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000946}
947
948JOW(jboolean, MediaStream_nativeRemoveAudioTrack)(
949 JNIEnv* jni, jclass, jlong pointer, jlong j_audio_track_pointer) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000950 return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000951 reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000952}
953
954JOW(jboolean, MediaStream_nativeRemoveVideoTrack)(
955 JNIEnv* jni, jclass, jlong pointer, jlong j_video_track_pointer) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000956 return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000957 reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000958}
959
960JOW(jstring, MediaStream_nativeLabel)(JNIEnv* jni, jclass, jlong j_p) {
961 return JavaStringFromStdString(
962 jni, reinterpret_cast<MediaStreamInterface*>(j_p)->label());
963}
964
965JOW(void, MediaStream_free)(JNIEnv*, jclass, jlong j_p) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +0000966 CHECK_RELEASE(reinterpret_cast<MediaStreamInterface*>(j_p));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000967}
968
969JOW(jlong, PeerConnectionFactory_nativeCreateObserver)(
970 JNIEnv * jni, jclass, jobject j_observer) {
971 return (jlong)new PCOJava(jni, j_observer);
972}
973
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000974JOW(jboolean, PeerConnectionFactory_initializeAndroidGlobals)(
fischman@webrtc.orga150bc92014-05-14 22:00:50 +0000975 JNIEnv* jni, jclass, jobject context,
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000976 jboolean initialize_audio, jboolean initialize_video,
Alex Glaznev4d2f4d12015-09-01 15:04:13 -0700977 jboolean video_hw_acceleration) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000978 bool failure = false;
Alex Glaznev4d2f4d12015-09-01 15:04:13 -0700979 video_hw_acceleration_enabled = video_hw_acceleration;
honghaiz023f3ef2015-10-19 09:39:32 -0700980 AndroidNetworkMonitor::SetAndroidContext(jni, context);
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000981 if (!factory_static_initialized) {
andresp@webrtc.org85ef7702014-09-17 11:44:51 +0000982 if (initialize_video) {
perkj@webrtc.org83bc7212015-02-11 11:26:56 +0000983 failure |= AndroidVideoCapturerJni::SetAndroidObjects(jni, context);
andresp@webrtc.org85ef7702014-09-17 11:44:51 +0000984 }
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000985 if (initialize_audio)
henrika@webrtc.org474d1eb2015-03-09 12:39:53 +0000986 failure |= webrtc::VoiceEngine::SetAndroidObjects(GetJVM(), context);
glaznev@webrtc.org99678452014-09-15 17:52:42 +0000987 factory_static_initialized = true;
988 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000989 return !failure;
990}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000991
glaznev@webrtc.org44ae4c82015-02-09 23:25:58 +0000992JOW(void, PeerConnectionFactory_initializeFieldTrials)(
993 JNIEnv* jni, jclass, jstring j_trials_init_string) {
994 field_trials_init_string = NULL;
995 if (j_trials_init_string != NULL) {
996 const char* init_string =
997 jni->GetStringUTFChars(j_trials_init_string, NULL);
998 int init_string_length = jni->GetStringUTFLength(j_trials_init_string);
999 field_trials_init_string = new char[init_string_length + 1];
1000 rtc::strcpyn(field_trials_init_string, init_string_length + 1, init_string);
1001 jni->ReleaseStringUTFChars(j_trials_init_string, init_string);
perkj@webrtc.org96e4db92015-02-13 12:46:51 +00001002 LOG(LS_INFO) << "initializeFieldTrials: " << field_trials_init_string;
glaznev@webrtc.org44ae4c82015-02-09 23:25:58 +00001003 }
1004 webrtc::field_trial::InitFieldTrialsFromString(field_trials_init_string);
1005}
1006
Peter Boström6f28cf02015-12-07 23:17:15 +01001007JOW(void, PeerConnectionFactory_initializeInternalTracer)(JNIEnv* jni, jclass) {
1008 rtc::tracing::SetupInternalTracer();
1009}
1010
1011JOW(jboolean, PeerConnectionFactory_startInternalTracingCapture)(
1012 JNIEnv* jni, jclass, jstring j_event_tracing_filename) {
1013 if (!j_event_tracing_filename)
1014 return false;
1015
1016 const char* init_string =
1017 jni->GetStringUTFChars(j_event_tracing_filename, NULL);
1018 LOG(LS_INFO) << "Starting internal tracing to: " << init_string;
1019 bool ret = rtc::tracing::StartInternalCapture(init_string);
1020 jni->ReleaseStringUTFChars(j_event_tracing_filename, init_string);
1021 return ret;
1022}
1023
1024JOW(void, PeerConnectionFactory_stopInternalTracingCapture)(
1025 JNIEnv* jni, jclass) {
1026 rtc::tracing::StopInternalCapture();
1027}
1028
1029JOW(void, PeerConnectionFactory_shutdownInternalTracer)(JNIEnv* jni, jclass) {
1030 rtc::tracing::ShutdownInternalTracer();
1031}
1032
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001033// Helper struct for working around the fact that CreatePeerConnectionFactory()
1034// comes in two flavors: either entirely automagical (constructing its own
1035// threads and deleting them on teardown, but no external codec factory support)
1036// or entirely manual (requires caller to delete threads after factory
1037// teardown). This struct takes ownership of its ctor's arguments to present a
1038// single thing for Java to hold and eventually free.
1039class OwnedFactoryAndThreads {
1040 public:
1041 OwnedFactoryAndThreads(Thread* worker_thread,
1042 Thread* signaling_thread,
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001043 WebRtcVideoEncoderFactory* encoder_factory,
1044 WebRtcVideoDecoderFactory* decoder_factory,
honghaiz023f3ef2015-10-19 09:39:32 -07001045 rtc::NetworkMonitorFactory* network_monitor_factory,
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001046 PeerConnectionFactoryInterface* factory)
1047 : worker_thread_(worker_thread),
1048 signaling_thread_(signaling_thread),
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001049 encoder_factory_(encoder_factory),
1050 decoder_factory_(decoder_factory),
honghaiz023f3ef2015-10-19 09:39:32 -07001051 network_monitor_factory_(network_monitor_factory),
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001052 factory_(factory) {}
1053
honghaiz023f3ef2015-10-19 09:39:32 -07001054 ~OwnedFactoryAndThreads() {
1055 CHECK_RELEASE(factory_);
1056 if (network_monitor_factory_ != nullptr) {
1057 rtc::NetworkMonitorFactory::ReleaseFactory(network_monitor_factory_);
1058 }
1059 }
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001060
1061 PeerConnectionFactoryInterface* factory() { return factory_; }
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001062 WebRtcVideoEncoderFactory* encoder_factory() { return encoder_factory_; }
1063 WebRtcVideoDecoderFactory* decoder_factory() { return decoder_factory_; }
honghaiz023f3ef2015-10-19 09:39:32 -07001064 rtc::NetworkMonitorFactory* network_monitor_factory() {
1065 return network_monitor_factory_;
1066 }
1067 void clear_network_monitor_factory() { network_monitor_factory_ = nullptr; }
Alex Glaznev21622a12015-10-07 14:50:13 -07001068 void InvokeJavaCallbacksOnFactoryThreads();
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001069
1070 private:
Alex Glaznev21622a12015-10-07 14:50:13 -07001071 void JavaCallbackOnFactoryThreads();
1072
kwibergd1fe2812016-04-27 06:47:29 -07001073 const std::unique_ptr<Thread> worker_thread_;
1074 const std::unique_ptr<Thread> signaling_thread_;
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001075 WebRtcVideoEncoderFactory* encoder_factory_;
1076 WebRtcVideoDecoderFactory* decoder_factory_;
honghaiz023f3ef2015-10-19 09:39:32 -07001077 rtc::NetworkMonitorFactory* network_monitor_factory_;
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001078 PeerConnectionFactoryInterface* factory_; // Const after ctor except dtor.
1079};
1080
Alex Glaznev21622a12015-10-07 14:50:13 -07001081void OwnedFactoryAndThreads::JavaCallbackOnFactoryThreads() {
1082 JNIEnv* jni = AttachCurrentThreadIfNeeded();
1083 ScopedLocalRefFrame local_ref_frame(jni);
1084 jclass j_factory_class = FindClass(jni, "org/webrtc/PeerConnectionFactory");
1085 jmethodID m = nullptr;
kwiberg9708e9c2016-03-29 10:17:42 -07001086 if (Thread::Current() == worker_thread_.get()) {
Alex Glaznev21622a12015-10-07 14:50:13 -07001087 LOG(LS_INFO) << "Worker thread JavaCallback";
1088 m = GetStaticMethodID(jni, j_factory_class, "onWorkerThreadReady", "()V");
1089 }
kwiberg9708e9c2016-03-29 10:17:42 -07001090 if (Thread::Current() == signaling_thread_.get()) {
Alex Glaznev21622a12015-10-07 14:50:13 -07001091 LOG(LS_INFO) << "Signaling thread JavaCallback";
1092 m = GetStaticMethodID(
1093 jni, j_factory_class, "onSignalingThreadReady", "()V");
1094 }
1095 if (m != nullptr) {
1096 jni->CallStaticVoidMethod(j_factory_class, m);
1097 CHECK_EXCEPTION(jni) << "error during JavaCallback::CallStaticVoidMethod";
1098 }
1099}
1100
1101void OwnedFactoryAndThreads::InvokeJavaCallbacksOnFactoryThreads() {
1102 LOG(LS_INFO) << "InvokeJavaCallbacksOnFactoryThreads.";
1103 worker_thread_->Invoke<void>(
1104 Bind(&OwnedFactoryAndThreads::JavaCallbackOnFactoryThreads, this));
1105 signaling_thread_->Invoke<void>(
1106 Bind(&OwnedFactoryAndThreads::JavaCallbackOnFactoryThreads, this));
1107}
1108
honghaiz67b1e1a2016-01-14 14:45:38 -08001109PeerConnectionFactoryInterface::Options ParseOptionsFromJava(JNIEnv* jni,
1110 jobject options) {
1111 jclass options_class = jni->GetObjectClass(options);
1112 jfieldID network_ignore_mask_field =
1113 jni->GetFieldID(options_class, "networkIgnoreMask", "I");
1114 int network_ignore_mask =
1115 jni->GetIntField(options, network_ignore_mask_field);
1116
1117 jfieldID disable_encryption_field =
1118 jni->GetFieldID(options_class, "disableEncryption", "Z");
1119 bool disable_encryption =
1120 jni->GetBooleanField(options, disable_encryption_field);
1121
1122 jfieldID disable_network_monitor_field =
1123 jni->GetFieldID(options_class, "disableNetworkMonitor", "Z");
1124 bool disable_network_monitor =
1125 jni->GetBooleanField(options, disable_network_monitor_field);
1126
1127 PeerConnectionFactoryInterface::Options native_options;
1128
1129 // This doesn't necessarily match the c++ version of this struct; feel free
1130 // to add more parameters as necessary.
1131 native_options.network_ignore_mask = network_ignore_mask;
1132 native_options.disable_encryption = disable_encryption;
1133 native_options.disable_network_monitor = disable_network_monitor;
1134 return native_options;
1135}
1136
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001137JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnectionFactory)(
honghaiz67b1e1a2016-01-14 14:45:38 -08001138 JNIEnv* jni, jclass, jobject joptions) {
fischman@webrtc.org2c98af72014-05-14 17:33:32 +00001139 // talk/ assumes pretty widely that the current Thread is ThreadManager'd, but
1140 // ThreadManager only WrapCurrentThread()s the thread where it is first
1141 // created. Since the semantics around when auto-wrapping happens in
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001142 // webrtc/base/ are convoluted, we simply wrap here to avoid having to think
fischman@webrtc.org2c98af72014-05-14 17:33:32 +00001143 // about ramifications of auto-wrapping there.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001144 rtc::ThreadManager::Instance()->WrapCurrentThread();
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001145 webrtc::Trace::CreateTrace();
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001146 Thread* worker_thread = new Thread();
1147 worker_thread->SetName("worker_thread", NULL);
1148 Thread* signaling_thread = new Thread();
1149 signaling_thread->SetName("signaling_thread", NULL);
henrikg91d6ede2015-09-17 00:24:34 -07001150 RTC_CHECK(worker_thread->Start() && signaling_thread->Start())
andresp@webrtc.org4d19e052014-09-09 11:45:44 +00001151 << "Failed to start threads";
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001152 WebRtcVideoEncoderFactory* encoder_factory = nullptr;
1153 WebRtcVideoDecoderFactory* decoder_factory = nullptr;
honghaiz023f3ef2015-10-19 09:39:32 -07001154 rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;
1155
honghaiz67b1e1a2016-01-14 14:45:38 -08001156 PeerConnectionFactoryInterface::Options options;
1157 bool has_options = joptions != NULL;
1158 if (has_options) {
1159 options = ParseOptionsFromJava(jni, joptions);
1160 }
perkj47b62632016-02-08 01:07:19 -08001161
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001162 if (video_hw_acceleration_enabled) {
1163 encoder_factory = new MediaCodecVideoEncoderFactory();
1164 decoder_factory = new MediaCodecVideoDecoderFactory();
glaznev@webrtc.orgdea51732014-12-01 20:02:13 +00001165 }
honghaiz67b1e1a2016-01-14 14:45:38 -08001166 // Do not create network_monitor_factory only if the options are
1167 // provided and disable_network_monitor therein is set to true.
1168 if (!(has_options && options.disable_network_monitor)) {
1169 network_monitor_factory = new AndroidNetworkMonitorFactory();
1170 rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);
1171 }
perkj47b62632016-02-08 01:07:19 -08001172
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001173 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001174 webrtc::CreatePeerConnectionFactory(worker_thread,
1175 signaling_thread,
1176 NULL,
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001177 encoder_factory,
1178 decoder_factory));
Patrik Höglunde1c5ec72015-09-17 17:20:38 +02001179 RTC_CHECK(factory) << "Failed to create the peer connection factory; "
1180 << "WebRTC/libjingle init likely failed on this device";
honghaiz67b1e1a2016-01-14 14:45:38 -08001181 // TODO(honghaiz): Maybe put the options as the argument of
1182 // CreatePeerConnectionFactory.
1183 if (has_options) {
1184 factory->SetOptions(options);
1185 }
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001186 OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads(
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001187 worker_thread, signaling_thread,
1188 encoder_factory, decoder_factory,
honghaiz023f3ef2015-10-19 09:39:32 -07001189 network_monitor_factory, factory.release());
Alex Glaznev21622a12015-10-07 14:50:13 -07001190 owned_factory->InvokeJavaCallbacksOnFactoryThreads();
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001191 return jlongFromPointer(owned_factory);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001192}
1193
Alex Glaznev21622a12015-10-07 14:50:13 -07001194JOW(void, PeerConnectionFactory_nativeFreeFactory)(JNIEnv*, jclass, jlong j_p) {
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001195 delete reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
glaznev@webrtc.org44ae4c82015-02-09 23:25:58 +00001196 if (field_trials_init_string) {
1197 webrtc::field_trial::InitFieldTrialsFromString(NULL);
1198 delete field_trials_init_string;
1199 field_trials_init_string = NULL;
1200 }
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001201 webrtc::Trace::ReturnTrace();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001202}
1203
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001204static PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
1205 return reinterpret_cast<OwnedFactoryAndThreads*>(j_p)->factory();
1206}
1207
Alex Glaznev21622a12015-10-07 14:50:13 -07001208JOW(void, PeerConnectionFactory_nativeThreadsCallbacks)(
1209 JNIEnv*, jclass, jlong j_p) {
1210 OwnedFactoryAndThreads *factory =
1211 reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
1212 factory->InvokeJavaCallbacksOnFactoryThreads();
1213}
1214
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001215JOW(jlong, PeerConnectionFactory_nativeCreateLocalMediaStream)(
1216 JNIEnv* jni, jclass, jlong native_factory, jstring label) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001217 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001218 factoryFromJava(native_factory));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001219 rtc::scoped_refptr<MediaStreamInterface> stream(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001220 factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
1221 return (jlong)stream.release();
1222}
1223
1224JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource)(
magjed0dc23162016-03-14 03:59:38 -07001225 JNIEnv* jni, jclass, jlong native_factory, jobject j_egl_context,
1226 jobject j_video_capturer, jobject j_constraints) {
Magnus Jedvert5e7834e2016-02-12 17:05:29 +01001227 // Create a cricket::VideoCapturer from |j_video_capturer|.
Magnus Jedvert5e7834e2016-02-12 17:05:29 +01001228 rtc::scoped_refptr<webrtc::AndroidVideoCapturerDelegate> delegate =
1229 new rtc::RefCountedObject<AndroidVideoCapturerJni>(
magjed0dc23162016-03-14 03:59:38 -07001230 jni, j_video_capturer, j_egl_context);
kwibergd1fe2812016-04-27 06:47:29 -07001231 std::unique_ptr<cricket::VideoCapturer> capturer(
Magnus Jedvert5e7834e2016-02-12 17:05:29 +01001232 new webrtc::AndroidVideoCapturer(delegate));
perkja3ede6c2016-03-08 01:27:48 +01001233 // Create a webrtc::VideoTrackSourceInterface from the cricket::VideoCapturer,
Magnus Jedvert5e7834e2016-02-12 17:05:29 +01001234 // native factory and constraints.
kwibergd1fe2812016-04-27 06:47:29 -07001235 std::unique_ptr<ConstraintsWrapper> constraints(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001236 new ConstraintsWrapper(jni, j_constraints));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001237 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001238 factoryFromJava(native_factory));
perkja3ede6c2016-03-08 01:27:48 +01001239 rtc::scoped_refptr<VideoTrackSourceInterface> source(
Magnus Jedvert5e7834e2016-02-12 17:05:29 +01001240 factory->CreateVideoSource(capturer.release(), constraints.get()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001241 return (jlong)source.release();
1242}
1243
1244JOW(jlong, PeerConnectionFactory_nativeCreateVideoTrack)(
1245 JNIEnv* jni, jclass, jlong native_factory, jstring id,
1246 jlong native_source) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001247 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001248 factoryFromJava(native_factory));
perkja3ede6c2016-03-08 01:27:48 +01001249 rtc::scoped_refptr<VideoTrackInterface> track(factory->CreateVideoTrack(
1250 JavaToStdString(jni, id),
1251 reinterpret_cast<VideoTrackSourceInterface*>(native_source)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001252 return (jlong)track.release();
1253}
1254
fischman@webrtc.org3eda6432014-02-13 04:01:04 +00001255JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)(
1256 JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) {
kwibergd1fe2812016-04-27 06:47:29 -07001257 std::unique_ptr<ConstraintsWrapper> constraints(
fischman@webrtc.org3eda6432014-02-13 04:01:04 +00001258 new ConstraintsWrapper(jni, j_constraints));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001259 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
fischman@webrtc.org540acde2014-02-13 03:56:14 +00001260 factoryFromJava(native_factory));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001261 rtc::scoped_refptr<AudioSourceInterface> source(
fischman@webrtc.org3eda6432014-02-13 04:01:04 +00001262 factory->CreateAudioSource(constraints.get()));
1263 return (jlong)source.release();
1264}
1265
1266JOW(jlong, PeerConnectionFactory_nativeCreateAudioTrack)(
1267 JNIEnv* jni, jclass, jlong native_factory, jstring id,
1268 jlong native_source) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001269 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
fischman@webrtc.org3eda6432014-02-13 04:01:04 +00001270 factoryFromJava(native_factory));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001271 rtc::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack(
fischman@webrtc.org3eda6432014-02-13 04:01:04 +00001272 JavaToStdString(jni, id),
1273 reinterpret_cast<AudioSourceInterface*>(native_source)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001274 return (jlong)track.release();
1275}
1276
ivocb2514722015-11-24 09:00:36 -08001277JOW(jboolean, PeerConnectionFactory_nativeStartAecDump)(
ivocd66b44d2016-01-15 03:06:36 -08001278 JNIEnv* jni, jclass, jlong native_factory, jint file,
1279 jint filesize_limit_bytes) {
ivocb2514722015-11-24 09:00:36 -08001280 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
1281 factoryFromJava(native_factory));
ivocd66b44d2016-01-15 03:06:36 -08001282 return factory->StartAecDump(file, filesize_limit_bytes);
ivocb2514722015-11-24 09:00:36 -08001283}
1284
1285JOW(void, PeerConnectionFactory_nativeStopAecDump)(
1286 JNIEnv* jni, jclass, jlong native_factory) {
ivocb2514722015-11-24 09:00:36 -08001287 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
1288 factoryFromJava(native_factory));
1289 factory->StopAecDump();
ivocb2514722015-11-24 09:00:36 -08001290}
1291
ivocc1513ee2016-05-13 08:30:39 -07001292JOW(jboolean, PeerConnectionFactory_nativeStartRtcEventLog)
1293(JNIEnv* jni,
1294 jclass,
1295 jlong native_factory,
1296 jint file,
1297 jint filesize_limit_bytes) {
ivocb2514722015-11-24 09:00:36 -08001298 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
1299 factoryFromJava(native_factory));
ivocc1513ee2016-05-13 08:30:39 -07001300 return factory->StartRtcEventLog(file, filesize_limit_bytes);
ivocb2514722015-11-24 09:00:36 -08001301}
1302
1303JOW(void, PeerConnectionFactory_nativeStopRtcEventLog)(
1304 JNIEnv* jni, jclass, jlong native_factory) {
ivocb2514722015-11-24 09:00:36 -08001305 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
1306 factoryFromJava(native_factory));
1307 factory->StopRtcEventLog();
ivocb2514722015-11-24 09:00:36 -08001308}
1309
phoglund@webrtc.org006521d2015-02-12 09:23:59 +00001310JOW(void, PeerConnectionFactory_nativeSetOptions)(
1311 JNIEnv* jni, jclass, jlong native_factory, jobject options) {
1312 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
1313 factoryFromJava(native_factory));
honghaiz67b1e1a2016-01-14 14:45:38 -08001314 PeerConnectionFactoryInterface::Options options_to_set =
1315 ParseOptionsFromJava(jni, options);
phoglund@webrtc.org006521d2015-02-12 09:23:59 +00001316 factory->SetOptions(options_to_set);
Honghai Zhang20ac4342016-01-14 15:56:26 -08001317
1318 if (options_to_set.disable_network_monitor) {
1319 OwnedFactoryAndThreads* owner =
1320 reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
1321 if (owner->network_monitor_factory()) {
1322 rtc::NetworkMonitorFactory::ReleaseFactory(
1323 owner->network_monitor_factory());
1324 owner->clear_network_monitor_factory();
1325 }
1326 }
phoglund@webrtc.org006521d2015-02-12 09:23:59 +00001327}
1328
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001329JOW(void, PeerConnectionFactory_nativeSetVideoHwAccelerationOptions)(
perkj30e91822015-11-20 01:31:25 -08001330 JNIEnv* jni, jclass, jlong native_factory, jobject local_egl_context,
1331 jobject remote_egl_context) {
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001332 OwnedFactoryAndThreads* owned_factory =
1333 reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
perkj30e91822015-11-20 01:31:25 -08001334
perkj48477c12015-12-18 00:34:37 -08001335 jclass j_eglbase14_context_class =
1336 FindClass(jni, "org/webrtc/EglBase14$Context");
1337
perkj30e91822015-11-20 01:31:25 -08001338 MediaCodecVideoEncoderFactory* encoder_factory =
1339 static_cast<MediaCodecVideoEncoderFactory*>
1340 (owned_factory->encoder_factory());
perkj48477c12015-12-18 00:34:37 -08001341 if (encoder_factory &&
1342 jni->IsInstanceOf(local_egl_context, j_eglbase14_context_class)) {
perkj30e91822015-11-20 01:31:25 -08001343 LOG(LS_INFO) << "Set EGL context for HW encoding.";
perkj96381432015-12-15 02:48:07 -08001344 encoder_factory->SetEGLContext(jni, local_egl_context);
perkj30e91822015-11-20 01:31:25 -08001345 }
1346
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001347 MediaCodecVideoDecoderFactory* decoder_factory =
1348 static_cast<MediaCodecVideoDecoderFactory*>
1349 (owned_factory->decoder_factory());
magjed23782122016-03-29 05:13:21 -07001350 if (decoder_factory) {
perkj30e91822015-11-20 01:31:25 -08001351 LOG(LS_INFO) << "Set EGL context for HW decoding.";
perkj96381432015-12-15 02:48:07 -08001352 decoder_factory->SetEGLContext(jni, remote_egl_context);
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001353 }
Alex Glaznev4d2f4d12015-09-01 15:04:13 -07001354}
1355
Jiayang Liucac1b382015-04-30 12:35:24 -07001356static PeerConnectionInterface::IceTransportsType
1357JavaIceTransportsTypeToNativeType(JNIEnv* jni, jobject j_ice_transports_type) {
1358 std::string enum_name = GetJavaEnumName(
1359 jni, "org/webrtc/PeerConnection$IceTransportsType",
1360 j_ice_transports_type);
1361
1362 if (enum_name == "ALL")
1363 return PeerConnectionInterface::kAll;
1364
1365 if (enum_name == "RELAY")
1366 return PeerConnectionInterface::kRelay;
1367
1368 if (enum_name == "NOHOST")
1369 return PeerConnectionInterface::kNoHost;
1370
1371 if (enum_name == "NONE")
1372 return PeerConnectionInterface::kNone;
1373
henrikg91d6ede2015-09-17 00:24:34 -07001374 RTC_CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name;
Jiayang Liucac1b382015-04-30 12:35:24 -07001375 return PeerConnectionInterface::kAll;
1376}
1377
1378static PeerConnectionInterface::BundlePolicy
1379JavaBundlePolicyToNativeType(JNIEnv* jni, jobject j_bundle_policy) {
1380 std::string enum_name = GetJavaEnumName(
1381 jni, "org/webrtc/PeerConnection$BundlePolicy",
1382 j_bundle_policy);
1383
1384 if (enum_name == "BALANCED")
1385 return PeerConnectionInterface::kBundlePolicyBalanced;
1386
1387 if (enum_name == "MAXBUNDLE")
1388 return PeerConnectionInterface::kBundlePolicyMaxBundle;
1389
1390 if (enum_name == "MAXCOMPAT")
1391 return PeerConnectionInterface::kBundlePolicyMaxCompat;
1392
henrikg91d6ede2015-09-17 00:24:34 -07001393 RTC_CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name;
Jiayang Liucac1b382015-04-30 12:35:24 -07001394 return PeerConnectionInterface::kBundlePolicyBalanced;
1395}
1396
Peter Thatcheraf55ccc2015-05-21 07:48:41 -07001397static PeerConnectionInterface::RtcpMuxPolicy
1398JavaRtcpMuxPolicyToNativeType(JNIEnv* jni, jobject j_rtcp_mux_policy) {
1399 std::string enum_name = GetJavaEnumName(
1400 jni, "org/webrtc/PeerConnection$RtcpMuxPolicy",
1401 j_rtcp_mux_policy);
1402
1403 if (enum_name == "NEGOTIATE")
1404 return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
1405
1406 if (enum_name == "REQUIRE")
1407 return PeerConnectionInterface::kRtcpMuxPolicyRequire;
1408
henrikg91d6ede2015-09-17 00:24:34 -07001409 RTC_CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name;
Peter Thatcheraf55ccc2015-05-21 07:48:41 -07001410 return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
1411}
1412
Jiayang Liucac1b382015-04-30 12:35:24 -07001413static PeerConnectionInterface::TcpCandidatePolicy
1414JavaTcpCandidatePolicyToNativeType(
1415 JNIEnv* jni, jobject j_tcp_candidate_policy) {
1416 std::string enum_name = GetJavaEnumName(
1417 jni, "org/webrtc/PeerConnection$TcpCandidatePolicy",
1418 j_tcp_candidate_policy);
1419
1420 if (enum_name == "ENABLED")
1421 return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
1422
1423 if (enum_name == "DISABLED")
1424 return PeerConnectionInterface::kTcpCandidatePolicyDisabled;
1425
henrikg91d6ede2015-09-17 00:24:34 -07001426 RTC_CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
Jiayang Liucac1b382015-04-30 12:35:24 -07001427 return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
1428}
1429
glaznev97579a42015-09-01 11:31:27 -07001430static rtc::KeyType JavaKeyTypeToNativeType(JNIEnv* jni, jobject j_key_type) {
1431 std::string enum_name = GetJavaEnumName(
1432 jni, "org/webrtc/PeerConnection$KeyType", j_key_type);
1433
1434 if (enum_name == "RSA")
1435 return rtc::KT_RSA;
1436 if (enum_name == "ECDSA")
1437 return rtc::KT_ECDSA;
1438
henrikg91d6ede2015-09-17 00:24:34 -07001439 RTC_CHECK(false) << "Unexpected KeyType enum_name " << enum_name;
glaznev97579a42015-09-01 11:31:27 -07001440 return rtc::KT_ECDSA;
1441}
1442
honghaiz1f429e32015-09-28 07:57:34 -07001443static PeerConnectionInterface::ContinualGatheringPolicy
1444 JavaContinualGatheringPolicyToNativeType(
1445 JNIEnv* jni, jobject j_gathering_policy) {
1446 std::string enum_name = GetJavaEnumName(
1447 jni, "org/webrtc/PeerConnection$ContinualGatheringPolicy",
1448 j_gathering_policy);
1449 if (enum_name == "GATHER_ONCE")
1450 return PeerConnectionInterface::GATHER_ONCE;
1451
1452 if (enum_name == "GATHER_CONTINUALLY")
1453 return PeerConnectionInterface::GATHER_CONTINUALLY;
1454
1455 RTC_CHECK(false) << "Unexpected ContinualGatheringPolicy enum name "
1456 << enum_name;
1457 return PeerConnectionInterface::GATHER_ONCE;
1458}
1459
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001460static void JavaIceServersToJsepIceServers(
1461 JNIEnv* jni, jobject j_ice_servers,
1462 PeerConnectionInterface::IceServers* ice_servers) {
skvlad303b3c22016-03-24 19:36:46 -07001463 for (jobject j_ice_server : Iterable(jni, j_ice_servers)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001464 jclass j_ice_server_class = GetObjectClass(jni, j_ice_server);
1465 jfieldID j_ice_server_uri_id =
1466 GetFieldID(jni, j_ice_server_class, "uri", "Ljava/lang/String;");
1467 jfieldID j_ice_server_username_id =
1468 GetFieldID(jni, j_ice_server_class, "username", "Ljava/lang/String;");
1469 jfieldID j_ice_server_password_id =
1470 GetFieldID(jni, j_ice_server_class, "password", "Ljava/lang/String;");
1471 jstring uri = reinterpret_cast<jstring>(
1472 GetObjectField(jni, j_ice_server, j_ice_server_uri_id));
1473 jstring username = reinterpret_cast<jstring>(
1474 GetObjectField(jni, j_ice_server, j_ice_server_username_id));
1475 jstring password = reinterpret_cast<jstring>(
1476 GetObjectField(jni, j_ice_server, j_ice_server_password_id));
1477 PeerConnectionInterface::IceServer server;
1478 server.uri = JavaToStdString(jni, uri);
1479 server.username = JavaToStdString(jni, username);
1480 server.password = JavaToStdString(jni, password);
1481 ice_servers->push_back(server);
1482 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001483}
1484
deadbeefa67696b2015-09-29 11:56:26 -07001485static void JavaRTCConfigurationToJsepRTCConfiguration(
1486 JNIEnv* jni,
1487 jobject j_rtc_config,
1488 PeerConnectionInterface::RTCConfiguration* rtc_config) {
Jiayang Liucac1b382015-04-30 12:35:24 -07001489 jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
1490
1491 jfieldID j_ice_transports_type_id = GetFieldID(
1492 jni, j_rtc_config_class, "iceTransportsType",
1493 "Lorg/webrtc/PeerConnection$IceTransportsType;");
1494 jobject j_ice_transports_type = GetObjectField(
1495 jni, j_rtc_config, j_ice_transports_type_id);
1496
1497 jfieldID j_bundle_policy_id = GetFieldID(
1498 jni, j_rtc_config_class, "bundlePolicy",
1499 "Lorg/webrtc/PeerConnection$BundlePolicy;");
1500 jobject j_bundle_policy = GetObjectField(
1501 jni, j_rtc_config, j_bundle_policy_id);
1502
Peter Thatcheraf55ccc2015-05-21 07:48:41 -07001503 jfieldID j_rtcp_mux_policy_id = GetFieldID(
1504 jni, j_rtc_config_class, "rtcpMuxPolicy",
1505 "Lorg/webrtc/PeerConnection$RtcpMuxPolicy;");
1506 jobject j_rtcp_mux_policy = GetObjectField(
1507 jni, j_rtc_config, j_rtcp_mux_policy_id);
1508
Jiayang Liucac1b382015-04-30 12:35:24 -07001509 jfieldID j_tcp_candidate_policy_id = GetFieldID(
1510 jni, j_rtc_config_class, "tcpCandidatePolicy",
1511 "Lorg/webrtc/PeerConnection$TcpCandidatePolicy;");
1512 jobject j_tcp_candidate_policy = GetObjectField(
1513 jni, j_rtc_config, j_tcp_candidate_policy_id);
1514
1515 jfieldID j_ice_servers_id = GetFieldID(
glaznev97579a42015-09-01 11:31:27 -07001516 jni, j_rtc_config_class, "iceServers", "Ljava/util/List;");
Jiayang Liucac1b382015-04-30 12:35:24 -07001517 jobject j_ice_servers = GetObjectField(jni, j_rtc_config, j_ice_servers_id);
1518
honghaiz4edc39c2015-09-01 09:53:56 -07001519 jfieldID j_audio_jitter_buffer_max_packets_id =
1520 GetFieldID(jni, j_rtc_config_class, "audioJitterBufferMaxPackets", "I");
Henrik Lundin5263b3c2015-06-01 10:29:41 +02001521 jfieldID j_audio_jitter_buffer_fast_accelerate_id = GetFieldID(
1522 jni, j_rtc_config_class, "audioJitterBufferFastAccelerate", "Z");
Jiayang Liucac1b382015-04-30 12:35:24 -07001523
honghaiz4edc39c2015-09-01 09:53:56 -07001524 jfieldID j_ice_connection_receiving_timeout_id =
1525 GetFieldID(jni, j_rtc_config_class, "iceConnectionReceivingTimeout", "I");
1526
Honghai Zhang381b4212015-12-04 12:24:03 -08001527 jfieldID j_ice_backup_candidate_pair_ping_interval_id = GetFieldID(
1528 jni, j_rtc_config_class, "iceBackupCandidatePairPingInterval", "I");
1529
honghaiz1f429e32015-09-28 07:57:34 -07001530 jfieldID j_continual_gathering_policy_id =
1531 GetFieldID(jni, j_rtc_config_class, "continualGatheringPolicy",
1532 "Lorg/webrtc/PeerConnection$ContinualGatheringPolicy;");
1533 jobject j_continual_gathering_policy =
1534 GetObjectField(jni, j_rtc_config, j_continual_gathering_policy_id);
1535
deadbeefa67696b2015-09-29 11:56:26 -07001536 rtc_config->type =
deadbeef7603c762015-09-23 17:37:11 -07001537 JavaIceTransportsTypeToNativeType(jni, j_ice_transports_type);
deadbeefa67696b2015-09-29 11:56:26 -07001538 rtc_config->bundle_policy =
1539 JavaBundlePolicyToNativeType(jni, j_bundle_policy);
1540 rtc_config->rtcp_mux_policy =
deadbeef7603c762015-09-23 17:37:11 -07001541 JavaRtcpMuxPolicyToNativeType(jni, j_rtcp_mux_policy);
deadbeefa67696b2015-09-29 11:56:26 -07001542 rtc_config->tcp_candidate_policy =
deadbeef7603c762015-09-23 17:37:11 -07001543 JavaTcpCandidatePolicyToNativeType(jni, j_tcp_candidate_policy);
deadbeefa67696b2015-09-29 11:56:26 -07001544 JavaIceServersToJsepIceServers(jni, j_ice_servers, &rtc_config->servers);
1545 rtc_config->audio_jitter_buffer_max_packets =
deadbeef7603c762015-09-23 17:37:11 -07001546 GetIntField(jni, j_rtc_config, j_audio_jitter_buffer_max_packets_id);
deadbeefa67696b2015-09-29 11:56:26 -07001547 rtc_config->audio_jitter_buffer_fast_accelerate = GetBooleanField(
deadbeef7603c762015-09-23 17:37:11 -07001548 jni, j_rtc_config, j_audio_jitter_buffer_fast_accelerate_id);
deadbeefa67696b2015-09-29 11:56:26 -07001549 rtc_config->ice_connection_receiving_timeout =
deadbeef7603c762015-09-23 17:37:11 -07001550 GetIntField(jni, j_rtc_config, j_ice_connection_receiving_timeout_id);
Honghai Zhang381b4212015-12-04 12:24:03 -08001551 rtc_config->ice_backup_candidate_pair_ping_interval = GetIntField(
1552 jni, j_rtc_config, j_ice_backup_candidate_pair_ping_interval_id);
deadbeefa67696b2015-09-29 11:56:26 -07001553 rtc_config->continual_gathering_policy =
honghaiz1f429e32015-09-28 07:57:34 -07001554 JavaContinualGatheringPolicyToNativeType(
1555 jni, j_continual_gathering_policy);
deadbeefa67696b2015-09-29 11:56:26 -07001556}
1557
1558JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnection)(
1559 JNIEnv *jni, jclass, jlong factory, jobject j_rtc_config,
1560 jobject j_constraints, jlong observer_p) {
1561 rtc::scoped_refptr<PeerConnectionFactoryInterface> f(
1562 reinterpret_cast<PeerConnectionFactoryInterface*>(
1563 factoryFromJava(factory)));
1564
1565 PeerConnectionInterface::RTCConfiguration rtc_config;
1566 JavaRTCConfigurationToJsepRTCConfiguration(jni, j_rtc_config, &rtc_config);
1567
1568 jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
1569 jfieldID j_key_type_id = GetFieldID(jni, j_rtc_config_class, "keyType",
1570 "Lorg/webrtc/PeerConnection$KeyType;");
1571 jobject j_key_type = GetObjectField(jni, j_rtc_config, j_key_type_id);
Jiayang Liucac1b382015-04-30 12:35:24 -07001572
Henrik Boströme06c2dd2016-05-13 13:50:38 +02001573 // Generate non-default certificate.
1574 rtc::KeyType key_type = JavaKeyTypeToNativeType(jni, j_key_type);
1575 if (key_type != rtc::KT_DEFAULT) {
1576 rtc::scoped_refptr<rtc::RTCCertificate> certificate =
1577 rtc::RTCCertificateGenerator::GenerateCertificate(
1578 rtc::KeyParams(key_type), rtc::Optional<uint64_t>());
1579 if (!certificate) {
1580 LOG(LS_ERROR) << "Failed to generate certificate. KeyType: " << key_type;
1581 return 0;
glaznev97579a42015-09-01 11:31:27 -07001582 }
Henrik Boströme06c2dd2016-05-13 13:50:38 +02001583 rtc_config.certificates.push_back(certificate);
glaznev97579a42015-09-01 11:31:27 -07001584 }
1585
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001586 PCOJava* observer = reinterpret_cast<PCOJava*>(observer_p);
1587 observer->SetConstraints(new ConstraintsWrapper(jni, j_constraints));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001588 rtc::scoped_refptr<PeerConnectionInterface> pc(f->CreatePeerConnection(
Jiayang Liucac1b382015-04-30 12:35:24 -07001589 rtc_config, observer->constraints(), NULL, NULL, observer));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001590 return (jlong)pc.release();
1591}
1592
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001593static rtc::scoped_refptr<PeerConnectionInterface> ExtractNativePC(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001594 JNIEnv* jni, jobject j_pc) {
1595 jfieldID native_pc_id = GetFieldID(jni,
1596 GetObjectClass(jni, j_pc), "nativePeerConnection", "J");
1597 jlong j_p = GetLongField(jni, j_pc, native_pc_id);
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001598 return rtc::scoped_refptr<PeerConnectionInterface>(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001599 reinterpret_cast<PeerConnectionInterface*>(j_p));
1600}
1601
1602JOW(jobject, PeerConnection_getLocalDescription)(JNIEnv* jni, jobject j_pc) {
1603 const SessionDescriptionInterface* sdp =
1604 ExtractNativePC(jni, j_pc)->local_description();
1605 return sdp ? JavaSdpFromNativeSdp(jni, sdp) : NULL;
1606}
1607
1608JOW(jobject, PeerConnection_getRemoteDescription)(JNIEnv* jni, jobject j_pc) {
1609 const SessionDescriptionInterface* sdp =
1610 ExtractNativePC(jni, j_pc)->remote_description();
1611 return sdp ? JavaSdpFromNativeSdp(jni, sdp) : NULL;
1612}
1613
henrike@webrtc.org723d6832013-07-12 16:04:50 +00001614JOW(jobject, PeerConnection_createDataChannel)(
1615 JNIEnv* jni, jobject j_pc, jstring j_label, jobject j_init) {
1616 DataChannelInit init = JavaDataChannelInitToNative(jni, j_init);
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001617 rtc::scoped_refptr<DataChannelInterface> channel(
henrike@webrtc.org723d6832013-07-12 16:04:50 +00001618 ExtractNativePC(jni, j_pc)->CreateDataChannel(
1619 JavaToStdString(jni, j_label), &init));
fischman@webrtc.org87881672013-09-03 18:58:12 +00001620 // Mustn't pass channel.get() directly through NewObject to avoid reading its
1621 // vararg parameter as 64-bit and reading memory that doesn't belong to the
1622 // 32-bit parameter.
1623 jlong nativeChannelPtr = jlongFromPointer(channel.get());
henrikg91d6ede2015-09-17 00:24:34 -07001624 RTC_CHECK(nativeChannelPtr) << "Failed to create DataChannel";
henrike@webrtc.org723d6832013-07-12 16:04:50 +00001625 jclass j_data_channel_class = FindClass(jni, "org/webrtc/DataChannel");
1626 jmethodID j_data_channel_ctor = GetMethodID(
1627 jni, j_data_channel_class, "<init>", "(J)V");
1628 jobject j_channel = jni->NewObject(
fischman@webrtc.org87881672013-09-03 18:58:12 +00001629 j_data_channel_class, j_data_channel_ctor, nativeChannelPtr);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +00001630 CHECK_EXCEPTION(jni) << "error during NewObject";
henrike@webrtc.org723d6832013-07-12 16:04:50 +00001631 // Channel is now owned by Java object, and will be freed from there.
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001632 int bumped_count = channel->AddRef();
henrikg91d6ede2015-09-17 00:24:34 -07001633 RTC_CHECK(bumped_count == 2) << "Unexpected refcount";
henrike@webrtc.org723d6832013-07-12 16:04:50 +00001634 return j_channel;
1635}
1636
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001637JOW(void, PeerConnection_createOffer)(
1638 JNIEnv* jni, jobject j_pc, jobject j_observer, jobject j_constraints) {
1639 ConstraintsWrapper* constraints =
1640 new ConstraintsWrapper(jni, j_constraints);
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001641 rtc::scoped_refptr<CreateSdpObserverWrapper> observer(
1642 new rtc::RefCountedObject<CreateSdpObserverWrapper>(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001643 jni, j_observer, constraints));
1644 ExtractNativePC(jni, j_pc)->CreateOffer(observer, constraints);
1645}
1646
1647JOW(void, PeerConnection_createAnswer)(
1648 JNIEnv* jni, jobject j_pc, jobject j_observer, jobject j_constraints) {
1649 ConstraintsWrapper* constraints =
1650 new ConstraintsWrapper(jni, j_constraints);
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001651 rtc::scoped_refptr<CreateSdpObserverWrapper> observer(
1652 new rtc::RefCountedObject<CreateSdpObserverWrapper>(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001653 jni, j_observer, constraints));
1654 ExtractNativePC(jni, j_pc)->CreateAnswer(observer, constraints);
1655}
1656
1657// Helper to create a SessionDescriptionInterface from a SessionDescription.
1658static SessionDescriptionInterface* JavaSdpToNativeSdp(
1659 JNIEnv* jni, jobject j_sdp) {
1660 jfieldID j_type_id = GetFieldID(
1661 jni, GetObjectClass(jni, j_sdp), "type",
1662 "Lorg/webrtc/SessionDescription$Type;");
1663 jobject j_type = GetObjectField(jni, j_sdp, j_type_id);
1664 jmethodID j_canonical_form_id = GetMethodID(
1665 jni, GetObjectClass(jni, j_type), "canonicalForm",
1666 "()Ljava/lang/String;");
1667 jstring j_type_string = (jstring)jni->CallObjectMethod(
1668 j_type, j_canonical_form_id);
andresp@webrtc.org4d19e052014-09-09 11:45:44 +00001669 CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001670 std::string std_type = JavaToStdString(jni, j_type_string);
1671
1672 jfieldID j_description_id = GetFieldID(
1673 jni, GetObjectClass(jni, j_sdp), "description", "Ljava/lang/String;");
1674 jstring j_description = (jstring)GetObjectField(jni, j_sdp, j_description_id);
1675 std::string std_description = JavaToStdString(jni, j_description);
1676
1677 return webrtc::CreateSessionDescription(
1678 std_type, std_description, NULL);
1679}
1680
1681JOW(void, PeerConnection_setLocalDescription)(
1682 JNIEnv* jni, jobject j_pc,
1683 jobject j_observer, jobject j_sdp) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001684 rtc::scoped_refptr<SetSdpObserverWrapper> observer(
1685 new rtc::RefCountedObject<SetSdpObserverWrapper>(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001686 jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL)));
1687 ExtractNativePC(jni, j_pc)->SetLocalDescription(
1688 observer, JavaSdpToNativeSdp(jni, j_sdp));
1689}
1690
1691JOW(void, PeerConnection_setRemoteDescription)(
1692 JNIEnv* jni, jobject j_pc,
1693 jobject j_observer, jobject j_sdp) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001694 rtc::scoped_refptr<SetSdpObserverWrapper> observer(
1695 new rtc::RefCountedObject<SetSdpObserverWrapper>(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001696 jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL)));
1697 ExtractNativePC(jni, j_pc)->SetRemoteDescription(
1698 observer, JavaSdpToNativeSdp(jni, j_sdp));
1699}
1700
deadbeefa67696b2015-09-29 11:56:26 -07001701JOW(jboolean, PeerConnection_setConfiguration)(
1702 JNIEnv* jni, jobject j_pc, jobject j_rtc_config) {
1703 PeerConnectionInterface::RTCConfiguration rtc_config;
1704 JavaRTCConfigurationToJsepRTCConfiguration(jni, j_rtc_config, &rtc_config);
1705 return ExtractNativePC(jni, j_pc)->SetConfiguration(rtc_config);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001706}
1707
1708JOW(jboolean, PeerConnection_nativeAddIceCandidate)(
1709 JNIEnv* jni, jobject j_pc, jstring j_sdp_mid,
1710 jint j_sdp_mline_index, jstring j_candidate_sdp) {
1711 std::string sdp_mid = JavaToStdString(jni, j_sdp_mid);
1712 std::string sdp = JavaToStdString(jni, j_candidate_sdp);
kwibergd1fe2812016-04-27 06:47:29 -07001713 std::unique_ptr<IceCandidateInterface> candidate(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001714 webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, NULL));
1715 return ExtractNativePC(jni, j_pc)->AddIceCandidate(candidate.get());
1716}
1717
Honghai Zhang7fb69db2016-03-14 11:59:18 -07001718static cricket::Candidate GetCandidateFromJava(JNIEnv* jni,
1719 jobject j_candidate) {
1720 jclass j_candidate_class = GetObjectClass(jni, j_candidate);
1721 jfieldID j_sdp_mid_id =
1722 GetFieldID(jni, j_candidate_class, "sdpMid", "Ljava/lang/String;");
1723 std::string sdp_mid =
1724 JavaToStdString(jni, GetStringField(jni, j_candidate, j_sdp_mid_id));
1725 jfieldID j_sdp_id =
1726 GetFieldID(jni, j_candidate_class, "sdp", "Ljava/lang/String;");
1727 std::string sdp =
1728 JavaToStdString(jni, GetStringField(jni, j_candidate, j_sdp_id));
1729 cricket::Candidate candidate;
1730 if (!webrtc::SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) {
1731 LOG(LS_ERROR) << "SdpDescrializeCandidate failed with sdp " << sdp;
1732 }
1733 return candidate;
1734}
1735
1736JOW(jboolean, PeerConnection_nativeRemoveIceCandidates)
1737(JNIEnv* jni, jobject j_pc, jobjectArray j_candidates) {
1738 std::vector<cricket::Candidate> candidates;
1739 size_t num_candidates = jni->GetArrayLength(j_candidates);
1740 for (size_t i = 0; i < num_candidates; ++i) {
1741 jobject j_candidate = jni->GetObjectArrayElement(j_candidates, i);
1742 candidates.push_back(GetCandidateFromJava(jni, j_candidate));
1743 }
1744 return ExtractNativePC(jni, j_pc)->RemoveIceCandidates(candidates);
1745}
1746
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001747JOW(jboolean, PeerConnection_nativeAddLocalStream)(
perkj@webrtc.orgc2dd5ee2014-11-04 11:31:29 +00001748 JNIEnv* jni, jobject j_pc, jlong native_stream) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001749 return ExtractNativePC(jni, j_pc)->AddStream(
perkj@webrtc.orgc2dd5ee2014-11-04 11:31:29 +00001750 reinterpret_cast<MediaStreamInterface*>(native_stream));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001751}
1752
1753JOW(void, PeerConnection_nativeRemoveLocalStream)(
1754 JNIEnv* jni, jobject j_pc, jlong native_stream) {
1755 ExtractNativePC(jni, j_pc)->RemoveStream(
1756 reinterpret_cast<MediaStreamInterface*>(native_stream));
1757}
1758
deadbeefee524f72015-12-02 11:27:40 -08001759JOW(jobject, PeerConnection_nativeCreateSender)(
deadbeefbd7d8f72015-12-18 16:58:44 -08001760 JNIEnv* jni, jobject j_pc, jstring j_kind, jstring j_stream_id) {
deadbeefee524f72015-12-02 11:27:40 -08001761 jclass j_rtp_sender_class = FindClass(jni, "org/webrtc/RtpSender");
1762 jmethodID j_rtp_sender_ctor =
1763 GetMethodID(jni, j_rtp_sender_class, "<init>", "(J)V");
1764
1765 std::string kind = JavaToStdString(jni, j_kind);
deadbeefbd7d8f72015-12-18 16:58:44 -08001766 std::string stream_id = JavaToStdString(jni, j_stream_id);
deadbeefee524f72015-12-02 11:27:40 -08001767 rtc::scoped_refptr<RtpSenderInterface> sender =
deadbeefbd7d8f72015-12-18 16:58:44 -08001768 ExtractNativePC(jni, j_pc)->CreateSender(kind, stream_id);
deadbeefee524f72015-12-02 11:27:40 -08001769 if (!sender.get()) {
1770 return nullptr;
1771 }
1772 jlong nativeSenderPtr = jlongFromPointer(sender.get());
1773 jobject j_sender =
1774 jni->NewObject(j_rtp_sender_class, j_rtp_sender_ctor, nativeSenderPtr);
1775 CHECK_EXCEPTION(jni) << "error during NewObject";
1776 // Sender is now owned by the Java object, and will be freed from
1777 // RtpSender.dispose(), called by PeerConnection.dispose() or getSenders().
1778 sender->AddRef();
1779 return j_sender;
1780}
1781
deadbeef4139c0f2015-10-06 12:29:25 -07001782JOW(jobject, PeerConnection_nativeGetSenders)(JNIEnv* jni, jobject j_pc) {
1783 jclass j_array_list_class = FindClass(jni, "java/util/ArrayList");
1784 jmethodID j_array_list_ctor =
1785 GetMethodID(jni, j_array_list_class, "<init>", "()V");
1786 jmethodID j_array_list_add =
1787 GetMethodID(jni, j_array_list_class, "add", "(Ljava/lang/Object;)Z");
1788 jobject j_senders = jni->NewObject(j_array_list_class, j_array_list_ctor);
1789 CHECK_EXCEPTION(jni) << "error during NewObject";
1790
1791 jclass j_rtp_sender_class = FindClass(jni, "org/webrtc/RtpSender");
1792 jmethodID j_rtp_sender_ctor =
1793 GetMethodID(jni, j_rtp_sender_class, "<init>", "(J)V");
1794
1795 auto senders = ExtractNativePC(jni, j_pc)->GetSenders();
1796 for (const auto& sender : senders) {
1797 jlong nativeSenderPtr = jlongFromPointer(sender.get());
1798 jobject j_sender =
1799 jni->NewObject(j_rtp_sender_class, j_rtp_sender_ctor, nativeSenderPtr);
1800 CHECK_EXCEPTION(jni) << "error during NewObject";
deadbeefee524f72015-12-02 11:27:40 -08001801 // Sender is now owned by the Java object, and will be freed from
1802 // RtpSender.dispose(), called by PeerConnection.dispose() or getSenders().
deadbeef4139c0f2015-10-06 12:29:25 -07001803 sender->AddRef();
1804 jni->CallBooleanMethod(j_senders, j_array_list_add, j_sender);
1805 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
1806 }
1807 return j_senders;
1808}
1809
1810JOW(jobject, PeerConnection_nativeGetReceivers)(JNIEnv* jni, jobject j_pc) {
1811 jclass j_array_list_class = FindClass(jni, "java/util/ArrayList");
1812 jmethodID j_array_list_ctor =
1813 GetMethodID(jni, j_array_list_class, "<init>", "()V");
1814 jmethodID j_array_list_add =
1815 GetMethodID(jni, j_array_list_class, "add", "(Ljava/lang/Object;)Z");
1816 jobject j_receivers = jni->NewObject(j_array_list_class, j_array_list_ctor);
1817 CHECK_EXCEPTION(jni) << "error during NewObject";
1818
1819 jclass j_rtp_receiver_class = FindClass(jni, "org/webrtc/RtpReceiver");
1820 jmethodID j_rtp_receiver_ctor =
1821 GetMethodID(jni, j_rtp_receiver_class, "<init>", "(J)V");
1822
1823 auto receivers = ExtractNativePC(jni, j_pc)->GetReceivers();
1824 for (const auto& receiver : receivers) {
1825 jlong nativeReceiverPtr = jlongFromPointer(receiver.get());
1826 jobject j_receiver = jni->NewObject(j_rtp_receiver_class,
1827 j_rtp_receiver_ctor, nativeReceiverPtr);
1828 CHECK_EXCEPTION(jni) << "error during NewObject";
1829 // Receiver is now owned by Java object, and will be freed from there.
1830 receiver->AddRef();
1831 jni->CallBooleanMethod(j_receivers, j_array_list_add, j_receiver);
1832 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
1833 }
1834 return j_receivers;
1835}
1836
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001837JOW(bool, PeerConnection_nativeGetStats)(
1838 JNIEnv* jni, jobject j_pc, jobject j_observer, jlong native_track) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001839 rtc::scoped_refptr<StatsObserverWrapper> observer(
1840 new rtc::RefCountedObject<StatsObserverWrapper>(jni, j_observer));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001841 return ExtractNativePC(jni, j_pc)->GetStats(
jiayl@webrtc.orgdb41b4d2014-03-03 21:30:06 +00001842 observer,
1843 reinterpret_cast<MediaStreamTrackInterface*>(native_track),
1844 PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001845}
1846
1847JOW(jobject, PeerConnection_signalingState)(JNIEnv* jni, jobject j_pc) {
1848 PeerConnectionInterface::SignalingState state =
1849 ExtractNativePC(jni, j_pc)->signaling_state();
1850 return JavaEnumFromIndex(jni, "PeerConnection$SignalingState", state);
1851}
1852
1853JOW(jobject, PeerConnection_iceConnectionState)(JNIEnv* jni, jobject j_pc) {
1854 PeerConnectionInterface::IceConnectionState state =
1855 ExtractNativePC(jni, j_pc)->ice_connection_state();
1856 return JavaEnumFromIndex(jni, "PeerConnection$IceConnectionState", state);
1857}
1858
braveyao@webrtc.orgfedb9ea2015-01-21 07:57:06 +00001859JOW(jobject, PeerConnection_iceGatheringState)(JNIEnv* jni, jobject j_pc) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001860 PeerConnectionInterface::IceGatheringState state =
1861 ExtractNativePC(jni, j_pc)->ice_gathering_state();
braveyao@webrtc.orgfedb9ea2015-01-21 07:57:06 +00001862 return JavaEnumFromIndex(jni, "PeerConnection$IceGatheringState", state);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001863}
1864
1865JOW(void, PeerConnection_close)(JNIEnv* jni, jobject j_pc) {
1866 ExtractNativePC(jni, j_pc)->Close();
1867 return;
1868}
1869
1870JOW(jobject, MediaSource_nativeState)(JNIEnv* jni, jclass, jlong j_p) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001871 rtc::scoped_refptr<MediaSourceInterface> p(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001872 reinterpret_cast<MediaSourceInterface*>(j_p));
1873 return JavaEnumFromIndex(jni, "MediaSource$State", p->state());
1874}
1875
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001876JOW(jlong, VideoRenderer_nativeWrapVideoRenderer)(
1877 JNIEnv* jni, jclass, jobject j_callbacks) {
kwibergd1fe2812016-04-27 06:47:29 -07001878 std::unique_ptr<JavaVideoRendererWrapper> renderer(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001879 new JavaVideoRendererWrapper(jni, j_callbacks));
1880 return (jlong)renderer.release();
1881}
1882
glaznev@webrtc.orgf6932292015-02-05 17:29:59 +00001883JOW(void, VideoRenderer_nativeCopyPlane)(
1884 JNIEnv *jni, jclass, jobject j_src_buffer, jint width, jint height,
1885 jint src_stride, jobject j_dst_buffer, jint dst_stride) {
1886 size_t src_size = jni->GetDirectBufferCapacity(j_src_buffer);
1887 size_t dst_size = jni->GetDirectBufferCapacity(j_dst_buffer);
henrikg91d6ede2015-09-17 00:24:34 -07001888 RTC_CHECK(src_stride >= width) << "Wrong source stride " << src_stride;
1889 RTC_CHECK(dst_stride >= width) << "Wrong destination stride " << dst_stride;
1890 RTC_CHECK(src_size >= src_stride * height)
glaznev@webrtc.orgf6932292015-02-05 17:29:59 +00001891 << "Insufficient source buffer capacity " << src_size;
henrikg91d6ede2015-09-17 00:24:34 -07001892 RTC_CHECK(dst_size >= dst_stride * height)
nissefc88ffe2016-05-03 00:32:08 -07001893 << "Insufficient destination buffer capacity " << dst_size;
glaznev@webrtc.orgf6932292015-02-05 17:29:59 +00001894 uint8_t *src =
1895 reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_src_buffer));
1896 uint8_t *dst =
1897 reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_dst_buffer));
1898 if (src_stride == dst_stride) {
1899 memcpy(dst, src, src_stride * height);
1900 } else {
1901 for (int i = 0; i < height; i++) {
1902 memcpy(dst, src, width);
1903 src += src_stride;
1904 dst += dst_stride;
1905 }
1906 }
1907}
1908
perkj@webrtc.org8f605e82015-02-17 13:53:56 +00001909JOW(void, VideoSource_stop)(JNIEnv* jni, jclass, jlong j_p) {
perkja3ede6c2016-03-08 01:27:48 +01001910 reinterpret_cast<VideoTrackSourceInterface*>(j_p)->Stop();
fischman@webrtc.org4e65e072013-10-03 18:23:13 +00001911}
1912
1913JOW(void, VideoSource_restart)(
1914 JNIEnv* jni, jclass, jlong j_p_source, jlong j_p_format) {
perkja3ede6c2016-03-08 01:27:48 +01001915 reinterpret_cast<VideoTrackSourceInterface*>(j_p_source)->Restart();
fischman@webrtc.org4e65e072013-10-03 18:23:13 +00001916}
1917
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001918JOW(jstring, MediaStreamTrack_nativeId)(JNIEnv* jni, jclass, jlong j_p) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001919 return JavaStringFromStdString(
1920 jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->id());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001921}
1922
1923JOW(jstring, MediaStreamTrack_nativeKind)(JNIEnv* jni, jclass, jlong j_p) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001924 return JavaStringFromStdString(
1925 jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->kind());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001926}
1927
1928JOW(jboolean, MediaStreamTrack_nativeEnabled)(JNIEnv* jni, jclass, jlong j_p) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001929 return reinterpret_cast<MediaStreamTrackInterface*>(j_p)->enabled();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001930}
1931
1932JOW(jobject, MediaStreamTrack_nativeState)(JNIEnv* jni, jclass, jlong j_p) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001933 return JavaEnumFromIndex(
1934 jni,
1935 "MediaStreamTrack$State",
1936 reinterpret_cast<MediaStreamTrackInterface*>(j_p)->state());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001937}
1938
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001939JOW(jboolean, MediaStreamTrack_nativeSetEnabled)(
1940 JNIEnv* jni, jclass, jlong j_p, jboolean enabled) {
fischman@webrtc.org32001ef2013-08-12 23:26:21 +00001941 return reinterpret_cast<MediaStreamTrackInterface*>(j_p)
1942 ->set_enabled(enabled);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001943}
1944
1945JOW(void, VideoTrack_nativeAddRenderer)(
1946 JNIEnv* jni, jclass,
1947 jlong j_video_track_pointer, jlong j_renderer_pointer) {
Niels Möller8f597622016-03-23 10:33:07 +01001948 reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
1949 ->AddOrUpdateSink(
1950 reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
1951 j_renderer_pointer),
1952 rtc::VideoSinkWants());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001953}
1954
1955JOW(void, VideoTrack_nativeRemoveRenderer)(
1956 JNIEnv* jni, jclass,
1957 jlong j_video_track_pointer, jlong j_renderer_pointer) {
Niels Möller8f597622016-03-23 10:33:07 +01001958 reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
1959 ->RemoveSink(
1960 reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
1961 j_renderer_pointer));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001962}
perkj@webrtc.org96e4db92015-02-13 12:46:51 +00001963
Jiayang Liue63d2a12015-09-01 16:11:18 -07001964JOW(jlong, CallSessionFileRotatingLogSink_nativeAddSink)(
1965 JNIEnv* jni, jclass,
1966 jstring j_dirPath, jint j_maxFileSize, jint j_severity) {
1967 std::string dir_path = JavaToStdString(jni, j_dirPath);
1968 rtc::CallSessionFileRotatingLogSink* sink =
1969 new rtc::CallSessionFileRotatingLogSink(dir_path, j_maxFileSize);
1970 if (!sink->Init()) {
1971 LOG_V(rtc::LoggingSeverity::LS_WARNING) <<
1972 "Failed to init CallSessionFileRotatingLogSink for path " << dir_path;
1973 delete sink;
1974 return 0;
1975 }
1976 rtc::LogMessage::AddLogToStream(
1977 sink, static_cast<rtc::LoggingSeverity>(j_severity));
1978 return (jlong) sink;
1979}
1980
1981JOW(void, CallSessionFileRotatingLogSink_nativeDeleteSink)(
1982 JNIEnv* jni, jclass, jlong j_sink) {
1983 rtc::CallSessionFileRotatingLogSink* sink =
1984 reinterpret_cast<rtc::CallSessionFileRotatingLogSink*>(j_sink);
1985 rtc::LogMessage::RemoveLogToStream(sink);
1986 delete sink;
1987}
1988
1989JOW(jbyteArray, CallSessionFileRotatingLogSink_nativeGetLogData)(
1990 JNIEnv* jni, jclass, jstring j_dirPath) {
1991 std::string dir_path = JavaToStdString(jni, j_dirPath);
kwibergd1fe2812016-04-27 06:47:29 -07001992 std::unique_ptr<rtc::CallSessionFileRotatingStream> stream(
Jiayang Liue63d2a12015-09-01 16:11:18 -07001993 new rtc::CallSessionFileRotatingStream(dir_path));
1994 if (!stream->Open()) {
1995 LOG_V(rtc::LoggingSeverity::LS_WARNING) <<
1996 "Failed to open CallSessionFileRotatingStream for path " << dir_path;
1997 return jni->NewByteArray(0);
1998 }
1999 size_t log_size = 0;
2000 if (!stream->GetSize(&log_size) || log_size == 0) {
2001 LOG_V(rtc::LoggingSeverity::LS_WARNING) <<
2002 "CallSessionFileRotatingStream returns 0 size for path " << dir_path;
2003 return jni->NewByteArray(0);
2004 }
2005
2006 size_t read = 0;
kwibergd1fe2812016-04-27 06:47:29 -07002007 std::unique_ptr<jbyte> buffer(static_cast<jbyte*>(malloc(log_size)));
Jiayang Liue63d2a12015-09-01 16:11:18 -07002008 stream->ReadAll(buffer.get(), log_size, &read, nullptr);
2009
2010 jbyteArray result = jni->NewByteArray(read);
2011 jni->SetByteArrayRegion(result, 0, read, buffer.get());
2012
2013 return result;
2014}
2015
Taylor Brandstettere5ba13b2016-01-07 15:11:25 -08002016JOW(jboolean, RtpSender_nativeSetTrack)(JNIEnv* jni,
deadbeef4139c0f2015-10-06 12:29:25 -07002017 jclass,
2018 jlong j_rtp_sender_pointer,
2019 jlong j_track_pointer) {
Taylor Brandstettere5ba13b2016-01-07 15:11:25 -08002020 return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
deadbeef4139c0f2015-10-06 12:29:25 -07002021 ->SetTrack(reinterpret_cast<MediaStreamTrackInterface*>(j_track_pointer));
2022}
2023
2024JOW(jlong, RtpSender_nativeGetTrack)(JNIEnv* jni,
2025 jclass,
2026 jlong j_rtp_sender_pointer,
2027 jlong j_track_pointer) {
2028 return jlongFromPointer(
2029 reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
2030 ->track()
2031 .release());
2032}
2033
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002034static void JavaRtpParametersToJsepRtpParameters(
skvlad303b3c22016-03-24 19:36:46 -07002035 JNIEnv* jni,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002036 jobject j_parameters,
2037 webrtc::RtpParameters* parameters) {
2038 RTC_CHECK(parameters != nullptr);
2039 jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
2040 jfieldID encodings_id =
2041 GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;");
2042 jfieldID codecs_id =
2043 GetFieldID(jni, parameters_class, "codecs", "Ljava/util/LinkedList;");
2044
2045 // Convert encodings.
2046 jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
skvlad303b3c22016-03-24 19:36:46 -07002047 const int kBitrateUnlimited = -1;
2048 jclass j_encoding_parameters_class =
2049 jni->FindClass("org/webrtc/RtpParameters$Encoding");
Taylor Brandstetterf8711c02016-03-29 17:21:29 -07002050 jfieldID active_id =
2051 GetFieldID(jni, j_encoding_parameters_class, "active", "Z");
skvlad303b3c22016-03-24 19:36:46 -07002052 jfieldID bitrate_id = GetFieldID(jni, j_encoding_parameters_class,
2053 "maxBitrateBps", "Ljava/lang/Integer;");
2054 jclass j_integer_class = jni->FindClass("java/lang/Integer");
2055 jmethodID int_value_id = GetMethodID(jni, j_integer_class, "intValue", "()I");
2056
2057 for (jobject j_encoding_parameters : Iterable(jni, j_encodings)) {
2058 webrtc::RtpEncodingParameters encoding;
Taylor Brandstetterf8711c02016-03-29 17:21:29 -07002059 encoding.active = GetBooleanField(jni, j_encoding_parameters, active_id);
deadbeef60631772016-04-04 10:21:02 -07002060 jobject j_bitrate =
2061 GetNullableObjectField(jni, j_encoding_parameters, bitrate_id);
skvlad303b3c22016-03-24 19:36:46 -07002062 if (!IsNull(jni, j_bitrate)) {
2063 int bitrate_value = jni->CallIntMethod(j_bitrate, int_value_id);
2064 CHECK_EXCEPTION(jni) << "error during CallIntMethod";
2065 encoding.max_bitrate_bps = bitrate_value;
2066 } else {
2067 encoding.max_bitrate_bps = kBitrateUnlimited;
2068 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002069 parameters->encodings.push_back(encoding);
skvlad303b3c22016-03-24 19:36:46 -07002070 }
skvlad303b3c22016-03-24 19:36:46 -07002071
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002072 // Convert codecs.
2073 jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002074 jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec");
2075 jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I");
2076 jfieldID mime_type_id =
2077 GetFieldID(jni, codec_class, "mimeType", "Ljava/lang/String;");
2078 jfieldID clock_rate_id = GetFieldID(jni, codec_class, "clockRate", "I");
2079 jfieldID channels_id = GetFieldID(jni, codec_class, "channels", "I");
2080
2081 for (jobject j_codec : Iterable(jni, j_codecs)) {
2082 webrtc::RtpCodecParameters codec;
2083 codec.payload_type = GetIntField(jni, j_codec, payload_type_id);
2084 codec.mime_type =
2085 JavaToStdString(jni, GetStringField(jni, j_codec, mime_type_id));
2086 codec.clock_rate = GetIntField(jni, j_codec, clock_rate_id);
2087 codec.channels = GetIntField(jni, j_codec, channels_id);
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002088 parameters->codecs.push_back(codec);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002089 }
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002090}
2091
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002092static jobject JsepRtpParametersToJavaRtpParameters(
2093 JNIEnv* jni,
2094 const webrtc::RtpParameters& parameters) {
skvlad303b3c22016-03-24 19:36:46 -07002095 jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
2096 jmethodID parameters_ctor =
2097 GetMethodID(jni, parameters_class, "<init>", "()V");
2098 jobject j_parameters = jni->NewObject(parameters_class, parameters_ctor);
2099 CHECK_EXCEPTION(jni) << "error during NewObject";
2100
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002101 // Add encodings.
skvlad303b3c22016-03-24 19:36:46 -07002102 jclass encoding_class = jni->FindClass("org/webrtc/RtpParameters$Encoding");
2103 jmethodID encoding_ctor = GetMethodID(jni, encoding_class, "<init>", "()V");
2104 jfieldID encodings_id =
2105 GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;");
2106 jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002107 jmethodID encodings_add = GetMethodID(jni, GetObjectClass(jni, j_encodings),
2108 "add", "(Ljava/lang/Object;)Z");
Taylor Brandstetterf8711c02016-03-29 17:21:29 -07002109 jfieldID active_id =
2110 GetFieldID(jni, encoding_class, "active", "Z");
skvlad303b3c22016-03-24 19:36:46 -07002111 jfieldID bitrate_id =
2112 GetFieldID(jni, encoding_class, "maxBitrateBps", "Ljava/lang/Integer;");
2113
2114 jclass integer_class = jni->FindClass("java/lang/Integer");
2115 jmethodID integer_ctor = GetMethodID(jni, integer_class, "<init>", "(I)V");
2116
Taylor Brandstetterf8711c02016-03-29 17:21:29 -07002117 for (const webrtc::RtpEncodingParameters& encoding : parameters.encodings) {
skvlad303b3c22016-03-24 19:36:46 -07002118 jobject j_encoding_parameters =
2119 jni->NewObject(encoding_class, encoding_ctor);
2120 CHECK_EXCEPTION(jni) << "error during NewObject";
Taylor Brandstetterf8711c02016-03-29 17:21:29 -07002121 jni->SetBooleanField(j_encoding_parameters, active_id, encoding.active);
2122 CHECK_EXCEPTION(jni) << "error during SetBooleanField";
skvlad303b3c22016-03-24 19:36:46 -07002123 if (encoding.max_bitrate_bps > 0) {
2124 jobject j_bitrate_value =
2125 jni->NewObject(integer_class, integer_ctor, encoding.max_bitrate_bps);
2126 CHECK_EXCEPTION(jni) << "error during NewObject";
2127 jni->SetObjectField(j_encoding_parameters, bitrate_id, j_bitrate_value);
2128 CHECK_EXCEPTION(jni) << "error during SetObjectField";
2129 }
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002130 jboolean added = jni->CallBooleanMethod(j_encodings, encodings_add,
2131 j_encoding_parameters);
skvlad303b3c22016-03-24 19:36:46 -07002132 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002133 RTC_CHECK(added);
skvlad303b3c22016-03-24 19:36:46 -07002134 }
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002135
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002136 // Add codecs.
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07002137 jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec");
2138 jmethodID codec_ctor = GetMethodID(jni, codec_class, "<init>", "()V");
2139 jfieldID codecs_id =
2140 GetFieldID(jni, parameters_class, "codecs", "Ljava/util/LinkedList;");
2141 jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id);
2142 jmethodID codecs_add = GetMethodID(jni, GetObjectClass(jni, j_codecs),
2143 "add", "(Ljava/lang/Object;)Z");
2144 jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I");
2145 jfieldID mime_type_id =
2146 GetFieldID(jni, codec_class, "mimeType", "Ljava/lang/String;");
2147 jfieldID clock_rate_id = GetFieldID(jni, codec_class, "clockRate", "I");
2148 jfieldID channels_id = GetFieldID(jni, codec_class, "channels", "I");
2149
2150 for (const webrtc::RtpCodecParameters& codec : parameters.codecs) {
2151 jobject j_codec = jni->NewObject(codec_class, codec_ctor);
2152 CHECK_EXCEPTION(jni) << "error during NewObject";
2153 jni->SetIntField(j_codec, payload_type_id, codec.payload_type);
2154 CHECK_EXCEPTION(jni) << "error during SetIntField";
2155 jni->SetObjectField(j_codec, mime_type_id,
2156 JavaStringFromStdString(jni, codec.mime_type));
2157 CHECK_EXCEPTION(jni) << "error during SetObjectField";
2158 jni->SetIntField(j_codec, clock_rate_id, codec.clock_rate);
2159 CHECK_EXCEPTION(jni) << "error during SetIntField";
2160 jni->SetIntField(j_codec, channels_id, codec.channels);
2161 CHECK_EXCEPTION(jni) << "error during SetIntField";
2162 jboolean added = jni->CallBooleanMethod(j_codecs, codecs_add, j_codec);
2163 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
2164 RTC_CHECK(added);
2165 }
2166
skvlad303b3c22016-03-24 19:36:46 -07002167 return j_parameters;
2168}
2169
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002170JOW(jboolean, RtpSender_nativeSetParameters)
2171(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer, jobject j_parameters) {
2172 if (IsNull(jni, j_parameters)) {
2173 return false;
2174 }
2175 webrtc::RtpParameters parameters;
2176 JavaRtpParametersToJsepRtpParameters(jni, j_parameters, &parameters);
2177 return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
2178 ->SetParameters(parameters);
2179}
2180
2181JOW(jobject, RtpSender_nativeGetParameters)
2182(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
2183 webrtc::RtpParameters parameters =
2184 reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
2185 ->GetParameters();
2186 return JsepRtpParametersToJavaRtpParameters(jni, parameters);
2187}
2188
deadbeef4139c0f2015-10-06 12:29:25 -07002189JOW(jstring, RtpSender_nativeId)(
2190 JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
2191 return JavaStringFromStdString(
2192 jni, reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)->id());
2193}
2194
2195JOW(void, RtpSender_free)(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
2196 reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)->Release();
2197}
2198
2199JOW(jlong, RtpReceiver_nativeGetTrack)(JNIEnv* jni,
2200 jclass,
2201 jlong j_rtp_receiver_pointer,
2202 jlong j_track_pointer) {
2203 return jlongFromPointer(
2204 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
2205 ->track()
2206 .release());
2207}
2208
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002209JOW(jboolean, RtpReceiver_nativeSetParameters)
2210(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer, jobject j_parameters) {
2211 if (IsNull(jni, j_parameters)) {
2212 return false;
2213 }
2214 webrtc::RtpParameters parameters;
2215 JavaRtpParametersToJsepRtpParameters(jni, j_parameters, &parameters);
2216 return reinterpret_cast<RtpReceiverInterface*>(j_rtp_sender_pointer)
2217 ->SetParameters(parameters);
2218}
2219
2220JOW(jobject, RtpReceiver_nativeGetParameters)
2221(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) {
2222 webrtc::RtpParameters parameters =
2223 reinterpret_cast<RtpReceiverInterface*>(j_rtp_sender_pointer)
2224 ->GetParameters();
2225 return JsepRtpParametersToJavaRtpParameters(jni, parameters);
2226}
2227
deadbeef4139c0f2015-10-06 12:29:25 -07002228JOW(jstring, RtpReceiver_nativeId)(
2229 JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
2230 return JavaStringFromStdString(
2231 jni,
2232 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id());
2233}
2234
2235JOW(void, RtpReceiver_free)(JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
2236 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->Release();
2237}
2238
perkj@webrtc.org96e4db92015-02-13 12:46:51 +00002239} // namespace webrtc_jni