| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2013 The WebRTC project authors. All Rights Reserved. | |
| 3 * | |
| 4 * 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. | |
| 9 */ | |
| 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 | |
| 42 #include <limits> | |
| 43 #include <memory> | |
| 44 #include <utility> | |
| 45 | |
| 46 #include "webrtc/api/mediaconstraintsinterface.h" | |
| 47 #include "webrtc/api/peerconnectioninterface.h" | |
| 48 #include "webrtc/api/rtpreceiverinterface.h" | |
| 49 #include "webrtc/api/rtpsenderinterface.h" | |
| 50 #include "webrtc/api/videosourceproxy.h" | |
| 51 #include "webrtc/media/base/mediaengine.h" | |
| 52 #include "webrtc/media/base/videocapturer.h" | |
| 53 #include "webrtc/modules/utility/include/jvm_android.h" | |
| 54 #include "webrtc/pc/webrtcsdp.h" | |
| 55 #include "webrtc/rtc_base/bind.h" | |
| 56 #include "webrtc/rtc_base/checks.h" | |
| 57 #include "webrtc/rtc_base/event_tracer.h" | |
| 58 #include "webrtc/rtc_base/logging.h" | |
| 59 #include "webrtc/rtc_base/logsinks.h" | |
| 60 #include "webrtc/rtc_base/messagequeue.h" | |
| 61 #include "webrtc/rtc_base/networkmonitor.h" | |
| 62 #include "webrtc/rtc_base/rtccertificategenerator.h" | |
| 63 #include "webrtc/rtc_base/ssladapter.h" | |
| 64 #include "webrtc/rtc_base/stringutils.h" | |
| 65 #include "webrtc/sdk/android/src/jni/androidnetworkmonitor_jni.h" | |
| 66 // Adding 'nogncheck' to disable the gn include headers check. | |
| 67 // We don't want to always depend on audio and video related targets. | |
| 68 #include "webrtc/sdk/android/src/jni/androidvideotracksource.h" // nogncheck | |
| 69 #include "webrtc/sdk/android/src/jni/audio_jni.h" | |
| 70 #include "webrtc/sdk/android/src/jni/classreferenceholder.h" | |
| 71 #include "webrtc/sdk/android/src/jni/jni_helpers.h" | |
| 72 #include "webrtc/sdk/android/src/jni/media_jni.h" | |
| 73 #include "webrtc/sdk/android/src/jni/ownedfactoryandthreads.h" | |
| 74 #include "webrtc/sdk/android/src/jni/rtcstatscollectorcallbackwrapper.h" | |
| 75 #include "webrtc/sdk/android/src/jni/video_jni.h" | |
| 76 #include "webrtc/system_wrappers/include/field_trial.h" | |
| 77 // Adding 'nogncheck' to disable the gn include headers check. | |
| 78 // We don't want to depend on 'system_wrappers:field_trial_default' because | |
| 79 // clients should be able to provide their own implementation. | |
| 80 #include "webrtc/system_wrappers/include/field_trial_default.h" // nogncheck | |
| 81 #include "webrtc/system_wrappers/include/logcat_trace_context.h" | |
| 82 #include "webrtc/system_wrappers/include/trace.h" | |
| 83 #include "webrtc/voice_engine/include/voe_base.h" // nogncheck | |
| 84 | |
| 85 using cricket::WebRtcVideoDecoderFactory; | |
| 86 using cricket::WebRtcVideoEncoderFactory; | |
| 87 using rtc::Bind; | |
| 88 using rtc::Thread; | |
| 89 using rtc::ThreadManager; | |
| 90 using webrtc::AudioSourceInterface; | |
| 91 using webrtc::AudioTrackInterface; | |
| 92 using webrtc::AudioTrackVector; | |
| 93 using webrtc::CreateSessionDescriptionObserver; | |
| 94 using webrtc::DataBuffer; | |
| 95 using webrtc::DataChannelInit; | |
| 96 using webrtc::DataChannelInterface; | |
| 97 using webrtc::DataChannelObserver; | |
| 98 using webrtc::DtmfSenderInterface; | |
| 99 using webrtc::IceCandidateInterface; | |
| 100 using webrtc::LogcatTraceContext; | |
| 101 using webrtc::MediaConstraintsInterface; | |
| 102 using webrtc::MediaSourceInterface; | |
| 103 using webrtc::MediaStreamInterface; | |
| 104 using webrtc::MediaStreamTrackInterface; | |
| 105 using webrtc::PeerConnectionFactoryInterface; | |
| 106 using webrtc::PeerConnectionInterface; | |
| 107 using webrtc::PeerConnectionObserver; | |
| 108 using webrtc::RtpReceiverInterface; | |
| 109 using webrtc::RtpReceiverObserverInterface; | |
| 110 using webrtc::RtpSenderInterface; | |
| 111 using webrtc::SessionDescriptionInterface; | |
| 112 using webrtc::SetSessionDescriptionObserver; | |
| 113 using webrtc::StatsObserver; | |
| 114 using webrtc::StatsReport; | |
| 115 using webrtc::StatsReports; | |
| 116 using webrtc::VideoTrackInterface; | |
| 117 | |
| 118 namespace webrtc_jni { | |
| 119 | |
| 120 // Field trials initialization string | |
| 121 static char *field_trials_init_string = NULL; | |
| 122 | |
| 123 // Set in PeerConnectionFactory_initializeAndroidGlobals(). | |
| 124 static bool factory_static_initialized = false; | |
| 125 static bool video_hw_acceleration_enabled = true; | |
| 126 | |
| 127 // Return the (singleton) Java Enum object corresponding to |index|; | |
| 128 // |state_class_fragment| is something like "MediaSource$State". | |
| 129 static jobject JavaEnumFromIndex( | |
| 130 JNIEnv* jni, const std::string& state_class_fragment, int index) { | |
| 131 const std::string state_class = "org/webrtc/" + state_class_fragment; | |
| 132 return JavaEnumFromIndex(jni, FindClass(jni, state_class.c_str()), | |
| 133 state_class, index); | |
| 134 } | |
| 135 | |
| 136 static DataChannelInit JavaDataChannelInitToNative( | |
| 137 JNIEnv* jni, jobject j_init) { | |
| 138 DataChannelInit init; | |
| 139 | |
| 140 jclass j_init_class = FindClass(jni, "org/webrtc/DataChannel$Init"); | |
| 141 jfieldID ordered_id = GetFieldID(jni, j_init_class, "ordered", "Z"); | |
| 142 jfieldID max_retransmit_time_id = | |
| 143 GetFieldID(jni, j_init_class, "maxRetransmitTimeMs", "I"); | |
| 144 jfieldID max_retransmits_id = | |
| 145 GetFieldID(jni, j_init_class, "maxRetransmits", "I"); | |
| 146 jfieldID protocol_id = | |
| 147 GetFieldID(jni, j_init_class, "protocol", "Ljava/lang/String;"); | |
| 148 jfieldID negotiated_id = GetFieldID(jni, j_init_class, "negotiated", "Z"); | |
| 149 jfieldID id_id = GetFieldID(jni, j_init_class, "id", "I"); | |
| 150 | |
| 151 init.ordered = GetBooleanField(jni, j_init, ordered_id); | |
| 152 init.maxRetransmitTime = GetIntField(jni, j_init, max_retransmit_time_id); | |
| 153 init.maxRetransmits = GetIntField(jni, j_init, max_retransmits_id); | |
| 154 init.protocol = JavaToStdString( | |
| 155 jni, GetStringField(jni, j_init, protocol_id)); | |
| 156 init.negotiated = GetBooleanField(jni, j_init, negotiated_id); | |
| 157 init.id = GetIntField(jni, j_init, id_id); | |
| 158 | |
| 159 return init; | |
| 160 } | |
| 161 | |
| 162 static cricket::MediaType JavaMediaTypeToJsepMediaType(JNIEnv* jni, | |
| 163 jobject j_media_type) { | |
| 164 jclass j_media_type_class = | |
| 165 FindClass(jni, "org/webrtc/MediaStreamTrack$MediaType"); | |
| 166 jmethodID j_name_id = | |
| 167 GetMethodID(jni, j_media_type_class, "name", "()Ljava/lang/String;"); | |
| 168 jstring j_type_string = | |
| 169 (jstring)jni->CallObjectMethod(j_media_type, j_name_id); | |
| 170 CHECK_EXCEPTION(jni) << "error during CallObjectMethod"; | |
| 171 std::string type_string = JavaToStdString(jni, j_type_string); | |
| 172 | |
| 173 RTC_DCHECK(type_string == "MEDIA_TYPE_AUDIO" || | |
| 174 type_string == "MEDIA_TYPE_VIDEO") | |
| 175 << "Media type: " << type_string; | |
| 176 return type_string == "MEDIA_TYPE_AUDIO" ? cricket::MEDIA_TYPE_AUDIO | |
| 177 : cricket::MEDIA_TYPE_VIDEO; | |
| 178 } | |
| 179 | |
| 180 static jobject JsepMediaTypeToJavaMediaType(JNIEnv* jni, | |
| 181 cricket::MediaType media_type) { | |
| 182 jclass j_media_type_class = | |
| 183 FindClass(jni, "org/webrtc/MediaStreamTrack$MediaType"); | |
| 184 | |
| 185 const char* media_type_str = nullptr; | |
| 186 switch (media_type) { | |
| 187 case cricket::MEDIA_TYPE_AUDIO: | |
| 188 media_type_str = "MEDIA_TYPE_AUDIO"; | |
| 189 break; | |
| 190 case cricket::MEDIA_TYPE_VIDEO: | |
| 191 media_type_str = "MEDIA_TYPE_VIDEO"; | |
| 192 break; | |
| 193 case cricket::MEDIA_TYPE_DATA: | |
| 194 RTC_NOTREACHED(); | |
| 195 break; | |
| 196 } | |
| 197 jfieldID j_media_type_fid = | |
| 198 GetStaticFieldID(jni, j_media_type_class, media_type_str, | |
| 199 "Lorg/webrtc/MediaStreamTrack$MediaType;"); | |
| 200 return GetStaticObjectField(jni, j_media_type_class, j_media_type_fid); | |
| 201 } | |
| 202 | |
| 203 class ConstraintsWrapper; | |
| 204 | |
| 205 // Adapter between the C++ PeerConnectionObserver interface and the Java | |
| 206 // PeerConnection.Observer interface. Wraps an instance of the Java interface | |
| 207 // and dispatches C++ callbacks to Java. | |
| 208 class PCOJava : public PeerConnectionObserver { | |
| 209 public: | |
| 210 PCOJava(JNIEnv* jni, jobject j_observer) | |
| 211 : j_observer_global_(jni, j_observer), | |
| 212 j_observer_class_(jni, GetObjectClass(jni, *j_observer_global_)), | |
| 213 j_media_stream_class_(jni, FindClass(jni, "org/webrtc/MediaStream")), | |
| 214 j_media_stream_ctor_( | |
| 215 GetMethodID(jni, *j_media_stream_class_, "<init>", "(J)V")), | |
| 216 j_audio_track_class_(jni, FindClass(jni, "org/webrtc/AudioTrack")), | |
| 217 j_audio_track_ctor_( | |
| 218 GetMethodID(jni, *j_audio_track_class_, "<init>", "(J)V")), | |
| 219 j_video_track_class_(jni, FindClass(jni, "org/webrtc/VideoTrack")), | |
| 220 j_video_track_ctor_( | |
| 221 GetMethodID(jni, *j_video_track_class_, "<init>", "(J)V")), | |
| 222 j_data_channel_class_(jni, FindClass(jni, "org/webrtc/DataChannel")), | |
| 223 j_data_channel_ctor_( | |
| 224 GetMethodID(jni, *j_data_channel_class_, "<init>", "(J)V")), | |
| 225 j_rtp_receiver_class_(jni, FindClass(jni, "org/webrtc/RtpReceiver")), | |
| 226 j_rtp_receiver_ctor_( | |
| 227 GetMethodID(jni, *j_rtp_receiver_class_, "<init>", "(J)V")) {} | |
| 228 | |
| 229 virtual ~PCOJava() { | |
| 230 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 231 while (!remote_streams_.empty()) | |
| 232 DisposeRemoteStream(remote_streams_.begin()); | |
| 233 while (!rtp_receivers_.empty()) | |
| 234 DisposeRtpReceiver(rtp_receivers_.begin()); | |
| 235 } | |
| 236 | |
| 237 void OnIceCandidate(const IceCandidateInterface* candidate) override { | |
| 238 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 239 std::string sdp; | |
| 240 RTC_CHECK(candidate->ToString(&sdp)) << "got so far: " << sdp; | |
| 241 jclass candidate_class = FindClass(jni(), "org/webrtc/IceCandidate"); | |
| 242 jmethodID ctor = GetMethodID( | |
| 243 jni(), candidate_class, "<init>", | |
| 244 "(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V"); | |
| 245 jstring j_mid = JavaStringFromStdString(jni(), candidate->sdp_mid()); | |
| 246 jstring j_sdp = JavaStringFromStdString(jni(), sdp); | |
| 247 jstring j_url = | |
| 248 JavaStringFromStdString(jni(), candidate->candidate().url()); | |
| 249 jobject j_candidate = | |
| 250 jni()->NewObject(candidate_class, ctor, j_mid, | |
| 251 candidate->sdp_mline_index(), j_sdp, j_url); | |
| 252 CHECK_EXCEPTION(jni()) << "error during NewObject"; | |
| 253 jmethodID m = GetMethodID(jni(), *j_observer_class_, | |
| 254 "onIceCandidate", "(Lorg/webrtc/IceCandidate;)V"); | |
| 255 jni()->CallVoidMethod(*j_observer_global_, m, j_candidate); | |
| 256 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 257 } | |
| 258 | |
| 259 void OnIceCandidatesRemoved( | |
| 260 const std::vector<cricket::Candidate>& candidates) override { | |
| 261 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 262 jobjectArray candidates_array = ToJavaCandidateArray(jni(), candidates); | |
| 263 jmethodID m = | |
| 264 GetMethodID(jni(), *j_observer_class_, "onIceCandidatesRemoved", | |
| 265 "([Lorg/webrtc/IceCandidate;)V"); | |
| 266 jni()->CallVoidMethod(*j_observer_global_, m, candidates_array); | |
| 267 CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod"; | |
| 268 } | |
| 269 | |
| 270 void OnSignalingChange( | |
| 271 PeerConnectionInterface::SignalingState new_state) override { | |
| 272 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 273 jmethodID m = GetMethodID( | |
| 274 jni(), *j_observer_class_, "onSignalingChange", | |
| 275 "(Lorg/webrtc/PeerConnection$SignalingState;)V"); | |
| 276 jobject new_state_enum = | |
| 277 JavaEnumFromIndex(jni(), "PeerConnection$SignalingState", new_state); | |
| 278 jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum); | |
| 279 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 280 } | |
| 281 | |
| 282 void OnIceConnectionChange( | |
| 283 PeerConnectionInterface::IceConnectionState new_state) override { | |
| 284 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 285 jmethodID m = GetMethodID( | |
| 286 jni(), *j_observer_class_, "onIceConnectionChange", | |
| 287 "(Lorg/webrtc/PeerConnection$IceConnectionState;)V"); | |
| 288 jobject new_state_enum = JavaEnumFromIndex( | |
| 289 jni(), "PeerConnection$IceConnectionState", new_state); | |
| 290 jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum); | |
| 291 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 292 } | |
| 293 | |
| 294 void OnIceConnectionReceivingChange(bool receiving) override { | |
| 295 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 296 jmethodID m = GetMethodID( | |
| 297 jni(), *j_observer_class_, "onIceConnectionReceivingChange", "(Z)V"); | |
| 298 jni()->CallVoidMethod(*j_observer_global_, m, receiving); | |
| 299 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 300 } | |
| 301 | |
| 302 void OnIceGatheringChange( | |
| 303 PeerConnectionInterface::IceGatheringState new_state) override { | |
| 304 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 305 jmethodID m = GetMethodID( | |
| 306 jni(), *j_observer_class_, "onIceGatheringChange", | |
| 307 "(Lorg/webrtc/PeerConnection$IceGatheringState;)V"); | |
| 308 jobject new_state_enum = JavaEnumFromIndex( | |
| 309 jni(), "PeerConnection$IceGatheringState", new_state); | |
| 310 jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum); | |
| 311 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 312 } | |
| 313 | |
| 314 void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override { | |
| 315 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 316 // The stream could be added into the remote_streams_ map when calling | |
| 317 // OnAddTrack. | |
| 318 jobject j_stream = GetOrCreateJavaStream(stream); | |
| 319 | |
| 320 for (const auto& track : stream->GetAudioTracks()) { | |
| 321 jstring id = JavaStringFromStdString(jni(), track->id()); | |
| 322 // Java AudioTrack holds one reference. Corresponding Release() is in | |
| 323 // MediaStreamTrack_free, triggered by AudioTrack.dispose(). | |
| 324 track->AddRef(); | |
| 325 jobject j_track = | |
| 326 jni()->NewObject(*j_audio_track_class_, j_audio_track_ctor_, | |
| 327 reinterpret_cast<jlong>(track.get()), id); | |
| 328 CHECK_EXCEPTION(jni()) << "error during NewObject"; | |
| 329 jfieldID audio_tracks_id = GetFieldID(jni(), | |
| 330 *j_media_stream_class_, | |
| 331 "audioTracks", | |
| 332 "Ljava/util/LinkedList;"); | |
| 333 jobject audio_tracks = GetObjectField(jni(), j_stream, audio_tracks_id); | |
| 334 jmethodID add = GetMethodID(jni(), | |
| 335 GetObjectClass(jni(), audio_tracks), | |
| 336 "add", | |
| 337 "(Ljava/lang/Object;)Z"); | |
| 338 jboolean added = jni()->CallBooleanMethod(audio_tracks, add, j_track); | |
| 339 CHECK_EXCEPTION(jni()) << "error during CallBooleanMethod"; | |
| 340 RTC_CHECK(added); | |
| 341 } | |
| 342 | |
| 343 for (const auto& track : stream->GetVideoTracks()) { | |
| 344 jstring id = JavaStringFromStdString(jni(), track->id()); | |
| 345 // Java VideoTrack holds one reference. Corresponding Release() is in | |
| 346 // MediaStreamTrack_free, triggered by VideoTrack.dispose(). | |
| 347 track->AddRef(); | |
| 348 jobject j_track = | |
| 349 jni()->NewObject(*j_video_track_class_, j_video_track_ctor_, | |
| 350 reinterpret_cast<jlong>(track.get()), id); | |
| 351 CHECK_EXCEPTION(jni()) << "error during NewObject"; | |
| 352 jfieldID video_tracks_id = GetFieldID(jni(), | |
| 353 *j_media_stream_class_, | |
| 354 "videoTracks", | |
| 355 "Ljava/util/LinkedList;"); | |
| 356 jobject video_tracks = GetObjectField(jni(), j_stream, video_tracks_id); | |
| 357 jmethodID add = GetMethodID(jni(), | |
| 358 GetObjectClass(jni(), video_tracks), | |
| 359 "add", | |
| 360 "(Ljava/lang/Object;)Z"); | |
| 361 jboolean added = jni()->CallBooleanMethod(video_tracks, add, j_track); | |
| 362 CHECK_EXCEPTION(jni()) << "error during CallBooleanMethod"; | |
| 363 RTC_CHECK(added); | |
| 364 } | |
| 365 | |
| 366 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onAddStream", | |
| 367 "(Lorg/webrtc/MediaStream;)V"); | |
| 368 jni()->CallVoidMethod(*j_observer_global_, m, j_stream); | |
| 369 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 370 } | |
| 371 | |
| 372 void OnRemoveStream( | |
| 373 rtc::scoped_refptr<MediaStreamInterface> stream) override { | |
| 374 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 375 NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream); | |
| 376 RTC_CHECK(it != remote_streams_.end()) << "unexpected stream: " << std::hex | |
| 377 << stream; | |
| 378 jobject j_stream = it->second; | |
| 379 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onRemoveStream", | |
| 380 "(Lorg/webrtc/MediaStream;)V"); | |
| 381 jni()->CallVoidMethod(*j_observer_global_, m, j_stream); | |
| 382 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 383 // Release the refptr reference so that DisposeRemoteStream can assert | |
| 384 // it removes the final reference. | |
| 385 stream = nullptr; | |
| 386 DisposeRemoteStream(it); | |
| 387 } | |
| 388 | |
| 389 void OnDataChannel( | |
| 390 rtc::scoped_refptr<DataChannelInterface> channel) override { | |
| 391 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 392 jobject j_channel = | |
| 393 jni()->NewObject(*j_data_channel_class_, j_data_channel_ctor_, | |
| 394 jlongFromPointer(channel.get())); | |
| 395 CHECK_EXCEPTION(jni()) << "error during NewObject"; | |
| 396 | |
| 397 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onDataChannel", | |
| 398 "(Lorg/webrtc/DataChannel;)V"); | |
| 399 jni()->CallVoidMethod(*j_observer_global_, m, j_channel); | |
| 400 | |
| 401 // Channel is now owned by Java object, and will be freed from | |
| 402 // DataChannel.dispose(). Important that this be done _after_ the | |
| 403 // CallVoidMethod above as Java code might call back into native code and be | |
| 404 // surprised to see a refcount of 2. | |
| 405 int bumped_count = channel->AddRef(); | |
| 406 RTC_CHECK(bumped_count == 2) << "Unexpected refcount OnDataChannel"; | |
| 407 | |
| 408 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 409 } | |
| 410 | |
| 411 void OnRenegotiationNeeded() override { | |
| 412 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 413 jmethodID m = | |
| 414 GetMethodID(jni(), *j_observer_class_, "onRenegotiationNeeded", "()V"); | |
| 415 jni()->CallVoidMethod(*j_observer_global_, m); | |
| 416 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 417 } | |
| 418 | |
| 419 void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver, | |
| 420 const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& | |
| 421 streams) override { | |
| 422 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 423 jobject j_rtp_receiver = | |
| 424 jni()->NewObject(*j_rtp_receiver_class_, j_rtp_receiver_ctor_, | |
| 425 jlongFromPointer(receiver.get())); | |
| 426 CHECK_EXCEPTION(jni()) << "error during NewObject"; | |
| 427 receiver->AddRef(); | |
| 428 rtp_receivers_[receiver] = NewGlobalRef(jni(), j_rtp_receiver); | |
| 429 | |
| 430 jobjectArray j_stream_array = ToJavaMediaStreamArray(jni(), streams); | |
| 431 jmethodID m = | |
| 432 GetMethodID(jni(), *j_observer_class_, "onAddTrack", | |
| 433 "(Lorg/webrtc/RtpReceiver;[Lorg/webrtc/MediaStream;)V"); | |
| 434 jni()->CallVoidMethod(*j_observer_global_, m, j_rtp_receiver, | |
| 435 j_stream_array); | |
| 436 CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod"; | |
| 437 } | |
| 438 | |
| 439 void SetConstraints(ConstraintsWrapper* constraints) { | |
| 440 RTC_CHECK(!constraints_.get()) << "constraints already set!"; | |
| 441 constraints_.reset(constraints); | |
| 442 } | |
| 443 | |
| 444 const ConstraintsWrapper* constraints() { return constraints_.get(); } | |
| 445 | |
| 446 private: | |
| 447 typedef std::map<MediaStreamInterface*, jobject> NativeToJavaStreamsMap; | |
| 448 typedef std::map<RtpReceiverInterface*, jobject> NativeToJavaRtpReceiverMap; | |
| 449 | |
| 450 void DisposeRemoteStream(const NativeToJavaStreamsMap::iterator& it) { | |
| 451 jobject j_stream = it->second; | |
| 452 remote_streams_.erase(it); | |
| 453 jni()->CallVoidMethod( | |
| 454 j_stream, GetMethodID(jni(), *j_media_stream_class_, "dispose", "()V")); | |
| 455 CHECK_EXCEPTION(jni()) << "error during MediaStream.dispose()"; | |
| 456 DeleteGlobalRef(jni(), j_stream); | |
| 457 } | |
| 458 | |
| 459 void DisposeRtpReceiver(const NativeToJavaRtpReceiverMap::iterator& it) { | |
| 460 jobject j_rtp_receiver = it->second; | |
| 461 rtp_receivers_.erase(it); | |
| 462 jni()->CallVoidMethod( | |
| 463 j_rtp_receiver, | |
| 464 GetMethodID(jni(), *j_rtp_receiver_class_, "dispose", "()V")); | |
| 465 CHECK_EXCEPTION(jni()) << "error during RtpReceiver.dispose()"; | |
| 466 DeleteGlobalRef(jni(), j_rtp_receiver); | |
| 467 } | |
| 468 | |
| 469 jobject ToJavaCandidate(JNIEnv* jni, | |
| 470 jclass* candidate_class, | |
| 471 const cricket::Candidate& candidate) { | |
| 472 std::string sdp = webrtc::SdpSerializeCandidate(candidate); | |
| 473 RTC_CHECK(!sdp.empty()) << "got an empty ICE candidate"; | |
| 474 jmethodID ctor = GetMethodID(jni, *candidate_class, "<init>", | |
| 475 "(Ljava/lang/String;ILjava/lang/String;)V"); | |
| 476 jstring j_mid = JavaStringFromStdString(jni, candidate.transport_name()); | |
| 477 jstring j_sdp = JavaStringFromStdString(jni, sdp); | |
| 478 // sdp_mline_index is not used, pass an invalid value -1. | |
| 479 jobject j_candidate = | |
| 480 jni->NewObject(*candidate_class, ctor, j_mid, -1, j_sdp); | |
| 481 CHECK_EXCEPTION(jni) << "error during Java Candidate NewObject"; | |
| 482 return j_candidate; | |
| 483 } | |
| 484 | |
| 485 jobjectArray ToJavaCandidateArray( | |
| 486 JNIEnv* jni, | |
| 487 const std::vector<cricket::Candidate>& candidates) { | |
| 488 jclass candidate_class = FindClass(jni, "org/webrtc/IceCandidate"); | |
| 489 jobjectArray java_candidates = | |
| 490 jni->NewObjectArray(candidates.size(), candidate_class, NULL); | |
| 491 int i = 0; | |
| 492 for (const cricket::Candidate& candidate : candidates) { | |
| 493 jobject j_candidate = ToJavaCandidate(jni, &candidate_class, candidate); | |
| 494 jni->SetObjectArrayElement(java_candidates, i++, j_candidate); | |
| 495 } | |
| 496 return java_candidates; | |
| 497 } | |
| 498 | |
| 499 jobjectArray ToJavaMediaStreamArray( | |
| 500 JNIEnv* jni, | |
| 501 const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) { | |
| 502 jobjectArray java_streams = | |
| 503 jni->NewObjectArray(streams.size(), *j_media_stream_class_, nullptr); | |
| 504 CHECK_EXCEPTION(jni) << "error during NewObjectArray"; | |
| 505 for (size_t i = 0; i < streams.size(); ++i) { | |
| 506 jobject j_stream = GetOrCreateJavaStream(streams[i]); | |
| 507 jni->SetObjectArrayElement(java_streams, i, j_stream); | |
| 508 } | |
| 509 return java_streams; | |
| 510 } | |
| 511 | |
| 512 // If the NativeToJavaStreamsMap contains the stream, return it. | |
| 513 // Otherwise, create a new Java MediaStream. | |
| 514 jobject GetOrCreateJavaStream( | |
| 515 const rtc::scoped_refptr<MediaStreamInterface>& stream) { | |
| 516 NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream); | |
| 517 if (it != remote_streams_.end()) { | |
| 518 return it->second; | |
| 519 } | |
| 520 | |
| 521 // Java MediaStream holds one reference. Corresponding Release() is in | |
| 522 // MediaStream_free, triggered by MediaStream.dispose(). | |
| 523 stream->AddRef(); | |
| 524 jobject j_stream = | |
| 525 jni()->NewObject(*j_media_stream_class_, j_media_stream_ctor_, | |
| 526 reinterpret_cast<jlong>(stream.get())); | |
| 527 CHECK_EXCEPTION(jni()) << "error during NewObject"; | |
| 528 | |
| 529 remote_streams_[stream] = NewGlobalRef(jni(), j_stream); | |
| 530 return j_stream; | |
| 531 } | |
| 532 | |
| 533 JNIEnv* jni() { | |
| 534 return AttachCurrentThreadIfNeeded(); | |
| 535 } | |
| 536 | |
| 537 const ScopedGlobalRef<jobject> j_observer_global_; | |
| 538 const ScopedGlobalRef<jclass> j_observer_class_; | |
| 539 const ScopedGlobalRef<jclass> j_media_stream_class_; | |
| 540 const jmethodID j_media_stream_ctor_; | |
| 541 const ScopedGlobalRef<jclass> j_audio_track_class_; | |
| 542 const jmethodID j_audio_track_ctor_; | |
| 543 const ScopedGlobalRef<jclass> j_video_track_class_; | |
| 544 const jmethodID j_video_track_ctor_; | |
| 545 const ScopedGlobalRef<jclass> j_data_channel_class_; | |
| 546 const jmethodID j_data_channel_ctor_; | |
| 547 const ScopedGlobalRef<jclass> j_rtp_receiver_class_; | |
| 548 const jmethodID j_rtp_receiver_ctor_; | |
| 549 // C++ -> Java remote streams. The stored jobects are global refs and must be | |
| 550 // manually deleted upon removal. Use DisposeRemoteStream(). | |
| 551 NativeToJavaStreamsMap remote_streams_; | |
| 552 NativeToJavaRtpReceiverMap rtp_receivers_; | |
| 553 std::unique_ptr<ConstraintsWrapper> constraints_; | |
| 554 }; | |
| 555 | |
| 556 // Wrapper for a Java MediaConstraints object. Copies all needed data so when | |
| 557 // the constructor returns the Java object is no longer needed. | |
| 558 class ConstraintsWrapper : public MediaConstraintsInterface { | |
| 559 public: | |
| 560 ConstraintsWrapper(JNIEnv* jni, jobject j_constraints) { | |
| 561 PopulateConstraintsFromJavaPairList( | |
| 562 jni, j_constraints, "mandatory", &mandatory_); | |
| 563 PopulateConstraintsFromJavaPairList( | |
| 564 jni, j_constraints, "optional", &optional_); | |
| 565 } | |
| 566 | |
| 567 virtual ~ConstraintsWrapper() {} | |
| 568 | |
| 569 // MediaConstraintsInterface. | |
| 570 const Constraints& GetMandatory() const override { return mandatory_; } | |
| 571 | |
| 572 const Constraints& GetOptional() const override { return optional_; } | |
| 573 | |
| 574 private: | |
| 575 // Helper for translating a List<Pair<String, String>> to a Constraints. | |
| 576 static void PopulateConstraintsFromJavaPairList( | |
| 577 JNIEnv* jni, jobject j_constraints, | |
| 578 const char* field_name, Constraints* field) { | |
| 579 jfieldID j_id = GetFieldID(jni, | |
| 580 GetObjectClass(jni, j_constraints), field_name, "Ljava/util/List;"); | |
| 581 jobject j_list = GetObjectField(jni, j_constraints, j_id); | |
| 582 for (jobject entry : Iterable(jni, j_list)) { | |
| 583 jmethodID get_key = GetMethodID(jni, | |
| 584 GetObjectClass(jni, entry), "getKey", "()Ljava/lang/String;"); | |
| 585 jstring j_key = reinterpret_cast<jstring>( | |
| 586 jni->CallObjectMethod(entry, get_key)); | |
| 587 CHECK_EXCEPTION(jni) << "error during CallObjectMethod"; | |
| 588 jmethodID get_value = GetMethodID(jni, | |
| 589 GetObjectClass(jni, entry), "getValue", "()Ljava/lang/String;"); | |
| 590 jstring j_value = reinterpret_cast<jstring>( | |
| 591 jni->CallObjectMethod(entry, get_value)); | |
| 592 CHECK_EXCEPTION(jni) << "error during CallObjectMethod"; | |
| 593 field->push_back(Constraint(JavaToStdString(jni, j_key), | |
| 594 JavaToStdString(jni, j_value))); | |
| 595 } | |
| 596 } | |
| 597 | |
| 598 Constraints mandatory_; | |
| 599 Constraints optional_; | |
| 600 }; | |
| 601 | |
| 602 static jobject JavaSdpFromNativeSdp( | |
| 603 JNIEnv* jni, const SessionDescriptionInterface* desc) { | |
| 604 std::string sdp; | |
| 605 RTC_CHECK(desc->ToString(&sdp)) << "got so far: " << sdp; | |
| 606 jstring j_description = JavaStringFromStdString(jni, sdp); | |
| 607 | |
| 608 jclass j_type_class = FindClass( | |
| 609 jni, "org/webrtc/SessionDescription$Type"); | |
| 610 jmethodID j_type_from_canonical = GetStaticMethodID( | |
| 611 jni, j_type_class, "fromCanonicalForm", | |
| 612 "(Ljava/lang/String;)Lorg/webrtc/SessionDescription$Type;"); | |
| 613 jstring j_type_string = JavaStringFromStdString(jni, desc->type()); | |
| 614 jobject j_type = jni->CallStaticObjectMethod( | |
| 615 j_type_class, j_type_from_canonical, j_type_string); | |
| 616 CHECK_EXCEPTION(jni) << "error during CallObjectMethod"; | |
| 617 | |
| 618 jclass j_sdp_class = FindClass(jni, "org/webrtc/SessionDescription"); | |
| 619 jmethodID j_sdp_ctor = GetMethodID( | |
| 620 jni, j_sdp_class, "<init>", | |
| 621 "(Lorg/webrtc/SessionDescription$Type;Ljava/lang/String;)V"); | |
| 622 jobject j_sdp = jni->NewObject( | |
| 623 j_sdp_class, j_sdp_ctor, j_type, j_description); | |
| 624 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 625 return j_sdp; | |
| 626 } | |
| 627 | |
| 628 template <class T> // T is one of {Create,Set}SessionDescriptionObserver. | |
| 629 class SdpObserverWrapper : public T { | |
| 630 public: | |
| 631 SdpObserverWrapper(JNIEnv* jni, jobject j_observer, | |
| 632 ConstraintsWrapper* constraints) | |
| 633 : constraints_(constraints), | |
| 634 j_observer_global_(jni, j_observer), | |
| 635 j_observer_class_(jni, GetObjectClass(jni, j_observer)) { | |
| 636 } | |
| 637 | |
| 638 virtual ~SdpObserverWrapper() {} | |
| 639 | |
| 640 // Can't mark override because of templating. | |
| 641 virtual void OnSuccess() { | |
| 642 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 643 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSetSuccess", "()V"); | |
| 644 jni()->CallVoidMethod(*j_observer_global_, m); | |
| 645 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 646 } | |
| 647 | |
| 648 // Can't mark override because of templating. | |
| 649 virtual void OnSuccess(SessionDescriptionInterface* desc) { | |
| 650 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 651 jmethodID m = GetMethodID( | |
| 652 jni(), *j_observer_class_, "onCreateSuccess", | |
| 653 "(Lorg/webrtc/SessionDescription;)V"); | |
| 654 jobject j_sdp = JavaSdpFromNativeSdp(jni(), desc); | |
| 655 jni()->CallVoidMethod(*j_observer_global_, m, j_sdp); | |
| 656 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 657 // OnSuccess transfers ownership of the description (there's a TODO to make | |
| 658 // it use unique_ptr...). | |
| 659 delete desc; | |
| 660 } | |
| 661 | |
| 662 protected: | |
| 663 // Common implementation for failure of Set & Create types, distinguished by | |
| 664 // |op| being "Set" or "Create". | |
| 665 void DoOnFailure(const std::string& op, const std::string& error) { | |
| 666 jmethodID m = GetMethodID(jni(), *j_observer_class_, "on" + op + "Failure", | |
| 667 "(Ljava/lang/String;)V"); | |
| 668 jstring j_error_string = JavaStringFromStdString(jni(), error); | |
| 669 jni()->CallVoidMethod(*j_observer_global_, m, j_error_string); | |
| 670 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 671 } | |
| 672 | |
| 673 JNIEnv* jni() { | |
| 674 return AttachCurrentThreadIfNeeded(); | |
| 675 } | |
| 676 | |
| 677 private: | |
| 678 std::unique_ptr<ConstraintsWrapper> constraints_; | |
| 679 const ScopedGlobalRef<jobject> j_observer_global_; | |
| 680 const ScopedGlobalRef<jclass> j_observer_class_; | |
| 681 }; | |
| 682 | |
| 683 class CreateSdpObserverWrapper | |
| 684 : public SdpObserverWrapper<CreateSessionDescriptionObserver> { | |
| 685 public: | |
| 686 CreateSdpObserverWrapper(JNIEnv* jni, jobject j_observer, | |
| 687 ConstraintsWrapper* constraints) | |
| 688 : SdpObserverWrapper(jni, j_observer, constraints) {} | |
| 689 | |
| 690 void OnFailure(const std::string& error) override { | |
| 691 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 692 SdpObserverWrapper::DoOnFailure(std::string("Create"), error); | |
| 693 } | |
| 694 }; | |
| 695 | |
| 696 class SetSdpObserverWrapper | |
| 697 : public SdpObserverWrapper<SetSessionDescriptionObserver> { | |
| 698 public: | |
| 699 SetSdpObserverWrapper(JNIEnv* jni, jobject j_observer, | |
| 700 ConstraintsWrapper* constraints) | |
| 701 : SdpObserverWrapper(jni, j_observer, constraints) {} | |
| 702 | |
| 703 void OnFailure(const std::string& error) override { | |
| 704 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 705 SdpObserverWrapper::DoOnFailure(std::string("Set"), error); | |
| 706 } | |
| 707 }; | |
| 708 | |
| 709 // Adapter for a Java DataChannel$Observer presenting a C++ DataChannelObserver | |
| 710 // and dispatching the callback from C++ back to Java. | |
| 711 class DataChannelObserverWrapper : public DataChannelObserver { | |
| 712 public: | |
| 713 DataChannelObserverWrapper(JNIEnv* jni, jobject j_observer) | |
| 714 : j_observer_global_(jni, j_observer), | |
| 715 j_observer_class_(jni, GetObjectClass(jni, j_observer)), | |
| 716 j_buffer_class_(jni, FindClass(jni, "org/webrtc/DataChannel$Buffer")), | |
| 717 j_on_buffered_amount_change_mid_(GetMethodID( | |
| 718 jni, *j_observer_class_, "onBufferedAmountChange", "(J)V")), | |
| 719 j_on_state_change_mid_( | |
| 720 GetMethodID(jni, *j_observer_class_, "onStateChange", "()V")), | |
| 721 j_on_message_mid_(GetMethodID(jni, *j_observer_class_, "onMessage", | |
| 722 "(Lorg/webrtc/DataChannel$Buffer;)V")), | |
| 723 j_buffer_ctor_(GetMethodID(jni, *j_buffer_class_, "<init>", | |
| 724 "(Ljava/nio/ByteBuffer;Z)V")) {} | |
| 725 | |
| 726 virtual ~DataChannelObserverWrapper() {} | |
| 727 | |
| 728 void OnBufferedAmountChange(uint64_t previous_amount) override { | |
| 729 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 730 jni()->CallVoidMethod(*j_observer_global_, j_on_buffered_amount_change_mid_, | |
| 731 previous_amount); | |
| 732 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 733 } | |
| 734 | |
| 735 void OnStateChange() override { | |
| 736 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 737 jni()->CallVoidMethod(*j_observer_global_, j_on_state_change_mid_); | |
| 738 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 739 } | |
| 740 | |
| 741 void OnMessage(const DataBuffer& buffer) override { | |
| 742 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 743 jobject byte_buffer = jni()->NewDirectByteBuffer( | |
| 744 const_cast<char*>(buffer.data.data<char>()), buffer.data.size()); | |
| 745 jobject j_buffer = jni()->NewObject(*j_buffer_class_, j_buffer_ctor_, | |
| 746 byte_buffer, buffer.binary); | |
| 747 jni()->CallVoidMethod(*j_observer_global_, j_on_message_mid_, j_buffer); | |
| 748 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 749 } | |
| 750 | |
| 751 private: | |
| 752 JNIEnv* jni() { | |
| 753 return AttachCurrentThreadIfNeeded(); | |
| 754 } | |
| 755 | |
| 756 const ScopedGlobalRef<jobject> j_observer_global_; | |
| 757 const ScopedGlobalRef<jclass> j_observer_class_; | |
| 758 const ScopedGlobalRef<jclass> j_buffer_class_; | |
| 759 const jmethodID j_on_buffered_amount_change_mid_; | |
| 760 const jmethodID j_on_state_change_mid_; | |
| 761 const jmethodID j_on_message_mid_; | |
| 762 const jmethodID j_buffer_ctor_; | |
| 763 }; | |
| 764 | |
| 765 // Adapter for a Java StatsObserver presenting a C++ StatsObserver and | |
| 766 // dispatching the callback from C++ back to Java. | |
| 767 class StatsObserverWrapper : public StatsObserver { | |
| 768 public: | |
| 769 StatsObserverWrapper(JNIEnv* jni, jobject j_observer) | |
| 770 : j_observer_global_(jni, j_observer), | |
| 771 j_observer_class_(jni, GetObjectClass(jni, j_observer)), | |
| 772 j_stats_report_class_(jni, FindClass(jni, "org/webrtc/StatsReport")), | |
| 773 j_stats_report_ctor_(GetMethodID( | |
| 774 jni, *j_stats_report_class_, "<init>", | |
| 775 "(Ljava/lang/String;Ljava/lang/String;D" | |
| 776 "[Lorg/webrtc/StatsReport$Value;)V")), | |
| 777 j_value_class_(jni, FindClass( | |
| 778 jni, "org/webrtc/StatsReport$Value")), | |
| 779 j_value_ctor_(GetMethodID( | |
| 780 jni, *j_value_class_, "<init>", | |
| 781 "(Ljava/lang/String;Ljava/lang/String;)V")) { | |
| 782 } | |
| 783 | |
| 784 virtual ~StatsObserverWrapper() {} | |
| 785 | |
| 786 void OnComplete(const StatsReports& reports) override { | |
| 787 ScopedLocalRefFrame local_ref_frame(jni()); | |
| 788 jobjectArray j_reports = ReportsToJava(jni(), reports); | |
| 789 jmethodID m = GetMethodID(jni(), *j_observer_class_, "onComplete", | |
| 790 "([Lorg/webrtc/StatsReport;)V"); | |
| 791 jni()->CallVoidMethod(*j_observer_global_, m, j_reports); | |
| 792 CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; | |
| 793 } | |
| 794 | |
| 795 private: | |
| 796 jobjectArray ReportsToJava( | |
| 797 JNIEnv* jni, const StatsReports& reports) { | |
| 798 jobjectArray reports_array = jni->NewObjectArray( | |
| 799 reports.size(), *j_stats_report_class_, NULL); | |
| 800 int i = 0; | |
| 801 for (const auto* report : reports) { | |
| 802 ScopedLocalRefFrame local_ref_frame(jni); | |
| 803 jstring j_id = JavaStringFromStdString(jni, report->id()->ToString()); | |
| 804 jstring j_type = JavaStringFromStdString(jni, report->TypeToString()); | |
| 805 jobjectArray j_values = ValuesToJava(jni, report->values()); | |
| 806 jobject j_report = jni->NewObject(*j_stats_report_class_, | |
| 807 j_stats_report_ctor_, | |
| 808 j_id, | |
| 809 j_type, | |
| 810 report->timestamp(), | |
| 811 j_values); | |
| 812 jni->SetObjectArrayElement(reports_array, i++, j_report); | |
| 813 } | |
| 814 return reports_array; | |
| 815 } | |
| 816 | |
| 817 jobjectArray ValuesToJava(JNIEnv* jni, const StatsReport::Values& values) { | |
| 818 jobjectArray j_values = jni->NewObjectArray( | |
| 819 values.size(), *j_value_class_, NULL); | |
| 820 int i = 0; | |
| 821 for (const auto& it : values) { | |
| 822 ScopedLocalRefFrame local_ref_frame(jni); | |
| 823 // Should we use the '.name' enum value here instead of converting the | |
| 824 // name to a string? | |
| 825 jstring j_name = JavaStringFromStdString(jni, it.second->display_name()); | |
| 826 jstring j_value = JavaStringFromStdString(jni, it.second->ToString()); | |
| 827 jobject j_element_value = | |
| 828 jni->NewObject(*j_value_class_, j_value_ctor_, j_name, j_value); | |
| 829 jni->SetObjectArrayElement(j_values, i++, j_element_value); | |
| 830 } | |
| 831 return j_values; | |
| 832 } | |
| 833 | |
| 834 JNIEnv* jni() { | |
| 835 return AttachCurrentThreadIfNeeded(); | |
| 836 } | |
| 837 | |
| 838 const ScopedGlobalRef<jobject> j_observer_global_; | |
| 839 const ScopedGlobalRef<jclass> j_observer_class_; | |
| 840 const ScopedGlobalRef<jclass> j_stats_report_class_; | |
| 841 const jmethodID j_stats_report_ctor_; | |
| 842 const ScopedGlobalRef<jclass> j_value_class_; | |
| 843 const jmethodID j_value_ctor_; | |
| 844 }; | |
| 845 | |
| 846 // Adapter between the C++ RtpReceiverObserverInterface and the Java | |
| 847 // RtpReceiver.Observer interface. Wraps an instance of the Java interface and | |
| 848 // dispatches C++ callbacks to Java. | |
| 849 class RtpReceiverObserver : public RtpReceiverObserverInterface { | |
| 850 public: | |
| 851 RtpReceiverObserver(JNIEnv* jni, jobject j_observer) | |
| 852 : j_observer_global_(jni, j_observer) {} | |
| 853 | |
| 854 ~RtpReceiverObserver() override {} | |
| 855 | |
| 856 void OnFirstPacketReceived(cricket::MediaType media_type) override { | |
| 857 JNIEnv* const jni = AttachCurrentThreadIfNeeded(); | |
| 858 | |
| 859 jmethodID j_on_first_packet_received_mid = GetMethodID( | |
| 860 jni, GetObjectClass(jni, *j_observer_global_), "onFirstPacketReceived", | |
| 861 "(Lorg/webrtc/MediaStreamTrack$MediaType;)V"); | |
| 862 // Get the Java version of media type. | |
| 863 jobject JavaMediaType = JsepMediaTypeToJavaMediaType(jni, media_type); | |
| 864 // Trigger the callback function. | |
| 865 jni->CallVoidMethod(*j_observer_global_, j_on_first_packet_received_mid, | |
| 866 JavaMediaType); | |
| 867 CHECK_EXCEPTION(jni) << "error during CallVoidMethod"; | |
| 868 } | |
| 869 | |
| 870 private: | |
| 871 const ScopedGlobalRef<jobject> j_observer_global_; | |
| 872 }; | |
| 873 | |
| 874 static DataChannelInterface* ExtractNativeDC(JNIEnv* jni, jobject j_dc) { | |
| 875 jfieldID native_dc_id = GetFieldID(jni, | |
| 876 GetObjectClass(jni, j_dc), "nativeDataChannel", "J"); | |
| 877 jlong j_d = GetLongField(jni, j_dc, native_dc_id); | |
| 878 return reinterpret_cast<DataChannelInterface*>(j_d); | |
| 879 } | |
| 880 | |
| 881 JOW(jlong, DataChannel_registerObserverNative)( | |
| 882 JNIEnv* jni, jobject j_dc, jobject j_observer) { | |
| 883 std::unique_ptr<DataChannelObserverWrapper> observer( | |
| 884 new DataChannelObserverWrapper(jni, j_observer)); | |
| 885 ExtractNativeDC(jni, j_dc)->RegisterObserver(observer.get()); | |
| 886 return jlongFromPointer(observer.release()); | |
| 887 } | |
| 888 | |
| 889 JOW(void, DataChannel_unregisterObserverNative)( | |
| 890 JNIEnv* jni, jobject j_dc, jlong native_observer) { | |
| 891 ExtractNativeDC(jni, j_dc)->UnregisterObserver(); | |
| 892 delete reinterpret_cast<DataChannelObserverWrapper*>(native_observer); | |
| 893 } | |
| 894 | |
| 895 JOW(jstring, DataChannel_label)(JNIEnv* jni, jobject j_dc) { | |
| 896 return JavaStringFromStdString(jni, ExtractNativeDC(jni, j_dc)->label()); | |
| 897 } | |
| 898 | |
| 899 JOW(jint, DataChannel_id)(JNIEnv* jni, jobject j_dc) { | |
| 900 int id = ExtractNativeDC(jni, j_dc)->id(); | |
| 901 RTC_CHECK_LE(id, std::numeric_limits<int32_t>::max()) | |
| 902 << "id overflowed jint!"; | |
| 903 return static_cast<jint>(id); | |
| 904 } | |
| 905 | |
| 906 JOW(jobject, DataChannel_state)(JNIEnv* jni, jobject j_dc) { | |
| 907 return JavaEnumFromIndex( | |
| 908 jni, "DataChannel$State", ExtractNativeDC(jni, j_dc)->state()); | |
| 909 } | |
| 910 | |
| 911 JOW(jlong, DataChannel_bufferedAmount)(JNIEnv* jni, jobject j_dc) { | |
| 912 uint64_t buffered_amount = ExtractNativeDC(jni, j_dc)->buffered_amount(); | |
| 913 RTC_CHECK_LE(buffered_amount, std::numeric_limits<int64_t>::max()) | |
| 914 << "buffered_amount overflowed jlong!"; | |
| 915 return static_cast<jlong>(buffered_amount); | |
| 916 } | |
| 917 | |
| 918 JOW(void, DataChannel_close)(JNIEnv* jni, jobject j_dc) { | |
| 919 ExtractNativeDC(jni, j_dc)->Close(); | |
| 920 } | |
| 921 | |
| 922 JOW(jboolean, DataChannel_sendNative)(JNIEnv* jni, jobject j_dc, | |
| 923 jbyteArray data, jboolean binary) { | |
| 924 jbyte* bytes = jni->GetByteArrayElements(data, NULL); | |
| 925 bool ret = ExtractNativeDC(jni, j_dc)->Send(DataBuffer( | |
| 926 rtc::CopyOnWriteBuffer(bytes, jni->GetArrayLength(data)), | |
| 927 binary)); | |
| 928 jni->ReleaseByteArrayElements(data, bytes, JNI_ABORT); | |
| 929 return ret; | |
| 930 } | |
| 931 | |
| 932 JOW(void, DataChannel_dispose)(JNIEnv* jni, jobject j_dc) { | |
| 933 CHECK_RELEASE(ExtractNativeDC(jni, j_dc)); | |
| 934 } | |
| 935 | |
| 936 JOW(void, Logging_nativeEnableTracing)( | |
| 937 JNIEnv* jni, jclass, jstring j_path, jint nativeLevels) { | |
| 938 std::string path = JavaToStdString(jni, j_path); | |
| 939 if (nativeLevels != webrtc::kTraceNone) { | |
| 940 webrtc::Trace::set_level_filter(nativeLevels); | |
| 941 if (path != "logcat:") { | |
| 942 RTC_CHECK_EQ(0, webrtc::Trace::SetTraceFile(path.c_str(), false)) | |
| 943 << "SetTraceFile failed"; | |
| 944 } else { | |
| 945 // Intentionally leak this to avoid needing to reason about its lifecycle. | |
| 946 // It keeps no state and functions only as a dispatch point. | |
| 947 static LogcatTraceContext* g_trace_callback = new LogcatTraceContext(); | |
| 948 } | |
| 949 } | |
| 950 } | |
| 951 | |
| 952 JOW(void, Logging_nativeEnableLogToDebugOutput) | |
| 953 (JNIEnv *jni, jclass, jint nativeSeverity) { | |
| 954 if (nativeSeverity >= rtc::LS_SENSITIVE && nativeSeverity <= rtc::LS_NONE) { | |
| 955 rtc::LogMessage::LogToDebug( | |
| 956 static_cast<rtc::LoggingSeverity>(nativeSeverity)); | |
| 957 } | |
| 958 } | |
| 959 | |
| 960 JOW(void, Logging_nativeEnableLogThreads)(JNIEnv* jni, jclass) { | |
| 961 rtc::LogMessage::LogThreads(true); | |
| 962 } | |
| 963 | |
| 964 JOW(void, Logging_nativeEnableLogTimeStamps)(JNIEnv* jni, jclass) { | |
| 965 rtc::LogMessage::LogTimestamps(true); | |
| 966 } | |
| 967 | |
| 968 JOW(void, Logging_nativeLog)( | |
| 969 JNIEnv* jni, jclass, jint j_severity, jstring j_tag, jstring j_message) { | |
| 970 std::string message = JavaToStdString(jni, j_message); | |
| 971 std::string tag = JavaToStdString(jni, j_tag); | |
| 972 LOG_TAG(static_cast<rtc::LoggingSeverity>(j_severity), tag) << message; | |
| 973 } | |
| 974 | |
| 975 JOW(void, PeerConnection_freePeerConnection)(JNIEnv*, jclass, jlong j_p) { | |
| 976 CHECK_RELEASE(reinterpret_cast<PeerConnectionInterface*>(j_p)); | |
| 977 } | |
| 978 | |
| 979 JOW(void, PeerConnection_freeObserver)(JNIEnv*, jclass, jlong j_p) { | |
| 980 PCOJava* p = reinterpret_cast<PCOJava*>(j_p); | |
| 981 delete p; | |
| 982 } | |
| 983 | |
| 984 JOW(void, MediaSource_free)(JNIEnv*, jclass, jlong j_p) { | |
| 985 reinterpret_cast<rtc::RefCountInterface*>(j_p)->Release(); | |
| 986 } | |
| 987 | |
| 988 JOW(void, MediaStreamTrack_free)(JNIEnv*, jclass, jlong j_p) { | |
| 989 reinterpret_cast<MediaStreamTrackInterface*>(j_p)->Release(); | |
| 990 } | |
| 991 | |
| 992 JOW(jboolean, MediaStream_nativeAddAudioTrack)( | |
| 993 JNIEnv* jni, jclass, jlong pointer, jlong j_audio_track_pointer) { | |
| 994 return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack( | |
| 995 reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer)); | |
| 996 } | |
| 997 | |
| 998 JOW(jboolean, MediaStream_nativeAddVideoTrack)( | |
| 999 JNIEnv* jni, jclass, jlong pointer, jlong j_video_track_pointer) { | |
| 1000 return reinterpret_cast<MediaStreamInterface*>(pointer) | |
| 1001 ->AddTrack(reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)); | |
| 1002 } | |
| 1003 | |
| 1004 JOW(jboolean, MediaStream_nativeRemoveAudioTrack)( | |
| 1005 JNIEnv* jni, jclass, jlong pointer, jlong j_audio_track_pointer) { | |
| 1006 return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack( | |
| 1007 reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer)); | |
| 1008 } | |
| 1009 | |
| 1010 JOW(jboolean, MediaStream_nativeRemoveVideoTrack)( | |
| 1011 JNIEnv* jni, jclass, jlong pointer, jlong j_video_track_pointer) { | |
| 1012 return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack( | |
| 1013 reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)); | |
| 1014 } | |
| 1015 | |
| 1016 JOW(jstring, MediaStream_nativeLabel)(JNIEnv* jni, jclass, jlong j_p) { | |
| 1017 return JavaStringFromStdString( | |
| 1018 jni, reinterpret_cast<MediaStreamInterface*>(j_p)->label()); | |
| 1019 } | |
| 1020 | |
| 1021 JOW(void, MediaStream_free)(JNIEnv*, jclass, jlong j_p) { | |
| 1022 CHECK_RELEASE(reinterpret_cast<MediaStreamInterface*>(j_p)); | |
| 1023 } | |
| 1024 | |
| 1025 JOW(jlong, PeerConnectionFactory_nativeCreateObserver)( | |
| 1026 JNIEnv * jni, jclass, jobject j_observer) { | |
| 1027 return (jlong)new PCOJava(jni, j_observer); | |
| 1028 } | |
| 1029 | |
| 1030 JOW(void, PeerConnectionFactory_nativeInitializeAndroidGlobals) | |
| 1031 (JNIEnv* jni, | |
| 1032 jclass, | |
| 1033 jobject context, | |
| 1034 jboolean video_hw_acceleration) { | |
| 1035 video_hw_acceleration_enabled = video_hw_acceleration; | |
| 1036 if (!factory_static_initialized) { | |
| 1037 webrtc::JVM::Initialize(GetJVM()); | |
| 1038 factory_static_initialized = true; | |
| 1039 } | |
| 1040 } | |
| 1041 | |
| 1042 JOW(void, PeerConnectionFactory_initializeFieldTrials)( | |
| 1043 JNIEnv* jni, jclass, jstring j_trials_init_string) { | |
| 1044 field_trials_init_string = NULL; | |
| 1045 if (j_trials_init_string != NULL) { | |
| 1046 const char* init_string = | |
| 1047 jni->GetStringUTFChars(j_trials_init_string, NULL); | |
| 1048 int init_string_length = jni->GetStringUTFLength(j_trials_init_string); | |
| 1049 field_trials_init_string = new char[init_string_length + 1]; | |
| 1050 rtc::strcpyn(field_trials_init_string, init_string_length + 1, init_string); | |
| 1051 jni->ReleaseStringUTFChars(j_trials_init_string, init_string); | |
| 1052 LOG(LS_INFO) << "initializeFieldTrials: " << field_trials_init_string; | |
| 1053 } | |
| 1054 webrtc::field_trial::InitFieldTrialsFromString(field_trials_init_string); | |
| 1055 } | |
| 1056 | |
| 1057 JOW(void, PeerConnectionFactory_initializeInternalTracer)(JNIEnv* jni, jclass) { | |
| 1058 rtc::tracing::SetupInternalTracer(); | |
| 1059 } | |
| 1060 | |
| 1061 JOW(jstring, PeerConnectionFactory_nativeFieldTrialsFindFullName) | |
| 1062 (JNIEnv* jni, jclass, jstring j_name) { | |
| 1063 return JavaStringFromStdString( | |
| 1064 jni, webrtc::field_trial::FindFullName(JavaToStdString(jni, j_name))); | |
| 1065 } | |
| 1066 | |
| 1067 JOW(jboolean, PeerConnectionFactory_startInternalTracingCapture)( | |
| 1068 JNIEnv* jni, jclass, jstring j_event_tracing_filename) { | |
| 1069 if (!j_event_tracing_filename) | |
| 1070 return false; | |
| 1071 | |
| 1072 const char* init_string = | |
| 1073 jni->GetStringUTFChars(j_event_tracing_filename, NULL); | |
| 1074 LOG(LS_INFO) << "Starting internal tracing to: " << init_string; | |
| 1075 bool ret = rtc::tracing::StartInternalCapture(init_string); | |
| 1076 jni->ReleaseStringUTFChars(j_event_tracing_filename, init_string); | |
| 1077 return ret; | |
| 1078 } | |
| 1079 | |
| 1080 JOW(void, PeerConnectionFactory_stopInternalTracingCapture)( | |
| 1081 JNIEnv* jni, jclass) { | |
| 1082 rtc::tracing::StopInternalCapture(); | |
| 1083 } | |
| 1084 | |
| 1085 JOW(void, PeerConnectionFactory_shutdownInternalTracer)(JNIEnv* jni, jclass) { | |
| 1086 rtc::tracing::ShutdownInternalTracer(); | |
| 1087 } | |
| 1088 | |
| 1089 JOW(void, AudioTrack_nativeSetVolume) | |
| 1090 (JNIEnv*, jclass, jlong j_p, jdouble volume) { | |
| 1091 rtc::scoped_refptr<AudioSourceInterface> source( | |
| 1092 reinterpret_cast<AudioTrackInterface*>(j_p)->GetSource()); | |
| 1093 source->SetVolume(volume); | |
| 1094 } | |
| 1095 | |
| 1096 PeerConnectionFactoryInterface::Options ParseOptionsFromJava(JNIEnv* jni, | |
| 1097 jobject options) { | |
| 1098 jclass options_class = jni->GetObjectClass(options); | |
| 1099 jfieldID network_ignore_mask_field = | |
| 1100 jni->GetFieldID(options_class, "networkIgnoreMask", "I"); | |
| 1101 int network_ignore_mask = | |
| 1102 jni->GetIntField(options, network_ignore_mask_field); | |
| 1103 | |
| 1104 jfieldID disable_encryption_field = | |
| 1105 jni->GetFieldID(options_class, "disableEncryption", "Z"); | |
| 1106 bool disable_encryption = | |
| 1107 jni->GetBooleanField(options, disable_encryption_field); | |
| 1108 | |
| 1109 jfieldID disable_network_monitor_field = | |
| 1110 jni->GetFieldID(options_class, "disableNetworkMonitor", "Z"); | |
| 1111 bool disable_network_monitor = | |
| 1112 jni->GetBooleanField(options, disable_network_monitor_field); | |
| 1113 | |
| 1114 PeerConnectionFactoryInterface::Options native_options; | |
| 1115 | |
| 1116 // This doesn't necessarily match the c++ version of this struct; feel free | |
| 1117 // to add more parameters as necessary. | |
| 1118 native_options.network_ignore_mask = network_ignore_mask; | |
| 1119 native_options.disable_encryption = disable_encryption; | |
| 1120 native_options.disable_network_monitor = disable_network_monitor; | |
| 1121 return native_options; | |
| 1122 } | |
| 1123 | |
| 1124 JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnectionFactory) | |
| 1125 (JNIEnv* jni, | |
| 1126 jclass, | |
| 1127 jobject joptions, | |
| 1128 jobject jencoder_factory, | |
| 1129 jobject jdecoder_factory) { | |
| 1130 // talk/ assumes pretty widely that the current Thread is ThreadManager'd, but | |
| 1131 // ThreadManager only WrapCurrentThread()s the thread where it is first | |
| 1132 // created. Since the semantics around when auto-wrapping happens in | |
| 1133 // webrtc/rtc_base/ are convoluted, we simply wrap here to avoid having to | |
| 1134 // think about ramifications of auto-wrapping there. | |
| 1135 rtc::ThreadManager::Instance()->WrapCurrentThread(); | |
| 1136 webrtc::Trace::CreateTrace(); | |
| 1137 | |
| 1138 std::unique_ptr<Thread> network_thread = | |
| 1139 rtc::Thread::CreateWithSocketServer(); | |
| 1140 network_thread->SetName("network_thread", nullptr); | |
| 1141 RTC_CHECK(network_thread->Start()) << "Failed to start thread"; | |
| 1142 | |
| 1143 std::unique_ptr<Thread> worker_thread = rtc::Thread::Create(); | |
| 1144 worker_thread->SetName("worker_thread", nullptr); | |
| 1145 RTC_CHECK(worker_thread->Start()) << "Failed to start thread"; | |
| 1146 | |
| 1147 std::unique_ptr<Thread> signaling_thread = rtc::Thread::Create(); | |
| 1148 signaling_thread->SetName("signaling_thread", NULL); | |
| 1149 RTC_CHECK(signaling_thread->Start()) << "Failed to start thread"; | |
| 1150 | |
| 1151 WebRtcVideoEncoderFactory* video_encoder_factory = nullptr; | |
| 1152 WebRtcVideoDecoderFactory* video_decoder_factory = nullptr; | |
| 1153 rtc::NetworkMonitorFactory* network_monitor_factory = nullptr; | |
| 1154 auto audio_encoder_factory = CreateAudioEncoderFactory(); | |
| 1155 auto audio_decoder_factory = CreateAudioDecoderFactory(); | |
| 1156 | |
| 1157 PeerConnectionFactoryInterface::Options options; | |
| 1158 bool has_options = joptions != NULL; | |
| 1159 if (has_options) { | |
| 1160 options = ParseOptionsFromJava(jni, joptions); | |
| 1161 } | |
| 1162 | |
| 1163 if (video_hw_acceleration_enabled) { | |
| 1164 video_encoder_factory = CreateVideoEncoderFactory(jni, jencoder_factory); | |
| 1165 video_decoder_factory = CreateVideoDecoderFactory(jni, jdecoder_factory); | |
| 1166 } | |
| 1167 // Do not create network_monitor_factory only if the options are | |
| 1168 // provided and disable_network_monitor therein is set to true. | |
| 1169 if (!(has_options && options.disable_network_monitor)) { | |
| 1170 network_monitor_factory = new AndroidNetworkMonitorFactory(); | |
| 1171 rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory); | |
| 1172 } | |
| 1173 | |
| 1174 webrtc::AudioDeviceModule* adm = nullptr; | |
| 1175 rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer = nullptr; | |
| 1176 std::unique_ptr<webrtc::CallFactoryInterface> call_factory( | |
| 1177 CreateCallFactory()); | |
| 1178 std::unique_ptr<webrtc::RtcEventLogFactoryInterface> rtc_event_log_factory( | |
| 1179 CreateRtcEventLogFactory()); | |
| 1180 std::unique_ptr<cricket::MediaEngineInterface> media_engine(CreateMediaEngine( | |
| 1181 adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory, | |
| 1182 video_decoder_factory, audio_mixer)); | |
| 1183 | |
| 1184 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | |
| 1185 CreateModularPeerConnectionFactory( | |
| 1186 network_thread.get(), worker_thread.get(), signaling_thread.get(), | |
| 1187 adm, audio_encoder_factory, audio_decoder_factory, | |
| 1188 video_encoder_factory, video_decoder_factory, audio_mixer, | |
| 1189 std::move(media_engine), std::move(call_factory), | |
| 1190 std::move(rtc_event_log_factory))); | |
| 1191 RTC_CHECK(factory) << "Failed to create the peer connection factory; " | |
| 1192 << "WebRTC/libjingle init likely failed on this device"; | |
| 1193 // TODO(honghaiz): Maybe put the options as the argument of | |
| 1194 // CreatePeerConnectionFactory. | |
| 1195 if (has_options) { | |
| 1196 factory->SetOptions(options); | |
| 1197 } | |
| 1198 OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads( | |
| 1199 std::move(network_thread), std::move(worker_thread), | |
| 1200 std::move(signaling_thread), video_encoder_factory, video_decoder_factory, | |
| 1201 network_monitor_factory, factory.release()); | |
| 1202 owned_factory->InvokeJavaCallbacksOnFactoryThreads(); | |
| 1203 return jlongFromPointer(owned_factory); | |
| 1204 } | |
| 1205 | |
| 1206 JOW(void, PeerConnectionFactory_nativeFreeFactory)(JNIEnv*, jclass, jlong j_p) { | |
| 1207 delete reinterpret_cast<OwnedFactoryAndThreads*>(j_p); | |
| 1208 if (field_trials_init_string) { | |
| 1209 webrtc::field_trial::InitFieldTrialsFromString(NULL); | |
| 1210 delete field_trials_init_string; | |
| 1211 field_trials_init_string = NULL; | |
| 1212 } | |
| 1213 webrtc::Trace::ReturnTrace(); | |
| 1214 } | |
| 1215 | |
| 1216 JOW(void, PeerConnectionFactory_nativeThreadsCallbacks)( | |
| 1217 JNIEnv*, jclass, jlong j_p) { | |
| 1218 OwnedFactoryAndThreads *factory = | |
| 1219 reinterpret_cast<OwnedFactoryAndThreads*>(j_p); | |
| 1220 factory->InvokeJavaCallbacksOnFactoryThreads(); | |
| 1221 } | |
| 1222 | |
| 1223 JOW(jlong, PeerConnectionFactory_nativeCreateLocalMediaStream)( | |
| 1224 JNIEnv* jni, jclass, jlong native_factory, jstring label) { | |
| 1225 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | |
| 1226 factoryFromJava(native_factory)); | |
| 1227 rtc::scoped_refptr<MediaStreamInterface> stream( | |
| 1228 factory->CreateLocalMediaStream(JavaToStdString(jni, label))); | |
| 1229 return (jlong)stream.release(); | |
| 1230 } | |
| 1231 | |
| 1232 JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)( | |
| 1233 JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) { | |
| 1234 std::unique_ptr<ConstraintsWrapper> constraints( | |
| 1235 new ConstraintsWrapper(jni, j_constraints)); | |
| 1236 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | |
| 1237 factoryFromJava(native_factory)); | |
| 1238 cricket::AudioOptions options; | |
| 1239 CopyConstraintsIntoAudioOptions(constraints.get(), &options); | |
| 1240 rtc::scoped_refptr<AudioSourceInterface> source( | |
| 1241 factory->CreateAudioSource(options)); | |
| 1242 return (jlong)source.release(); | |
| 1243 } | |
| 1244 | |
| 1245 JOW(jlong, PeerConnectionFactory_nativeCreateAudioTrack)( | |
| 1246 JNIEnv* jni, jclass, jlong native_factory, jstring id, | |
| 1247 jlong native_source) { | |
| 1248 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | |
| 1249 factoryFromJava(native_factory)); | |
| 1250 rtc::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack( | |
| 1251 JavaToStdString(jni, id), | |
| 1252 reinterpret_cast<AudioSourceInterface*>(native_source))); | |
| 1253 return (jlong)track.release(); | |
| 1254 } | |
| 1255 | |
| 1256 JOW(jboolean, PeerConnectionFactory_nativeStartAecDump)( | |
| 1257 JNIEnv* jni, jclass, jlong native_factory, jint file, | |
| 1258 jint filesize_limit_bytes) { | |
| 1259 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | |
| 1260 factoryFromJava(native_factory)); | |
| 1261 return factory->StartAecDump(file, filesize_limit_bytes); | |
| 1262 } | |
| 1263 | |
| 1264 JOW(void, PeerConnectionFactory_nativeStopAecDump)( | |
| 1265 JNIEnv* jni, jclass, jlong native_factory) { | |
| 1266 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | |
| 1267 factoryFromJava(native_factory)); | |
| 1268 factory->StopAecDump(); | |
| 1269 } | |
| 1270 | |
| 1271 JOW(void, PeerConnectionFactory_nativeSetOptions)( | |
| 1272 JNIEnv* jni, jclass, jlong native_factory, jobject options) { | |
| 1273 rtc::scoped_refptr<PeerConnectionFactoryInterface> factory( | |
| 1274 factoryFromJava(native_factory)); | |
| 1275 PeerConnectionFactoryInterface::Options options_to_set = | |
| 1276 ParseOptionsFromJava(jni, options); | |
| 1277 factory->SetOptions(options_to_set); | |
| 1278 | |
| 1279 if (options_to_set.disable_network_monitor) { | |
| 1280 OwnedFactoryAndThreads* owner = | |
| 1281 reinterpret_cast<OwnedFactoryAndThreads*>(native_factory); | |
| 1282 if (owner->network_monitor_factory()) { | |
| 1283 rtc::NetworkMonitorFactory::ReleaseFactory( | |
| 1284 owner->network_monitor_factory()); | |
| 1285 owner->clear_network_monitor_factory(); | |
| 1286 } | |
| 1287 } | |
| 1288 } | |
| 1289 | |
| 1290 static PeerConnectionInterface::IceTransportsType | |
| 1291 JavaIceTransportsTypeToNativeType(JNIEnv* jni, jobject j_ice_transports_type) { | |
| 1292 std::string enum_name = GetJavaEnumName( | |
| 1293 jni, "org/webrtc/PeerConnection$IceTransportsType", | |
| 1294 j_ice_transports_type); | |
| 1295 | |
| 1296 if (enum_name == "ALL") | |
| 1297 return PeerConnectionInterface::kAll; | |
| 1298 | |
| 1299 if (enum_name == "RELAY") | |
| 1300 return PeerConnectionInterface::kRelay; | |
| 1301 | |
| 1302 if (enum_name == "NOHOST") | |
| 1303 return PeerConnectionInterface::kNoHost; | |
| 1304 | |
| 1305 if (enum_name == "NONE") | |
| 1306 return PeerConnectionInterface::kNone; | |
| 1307 | |
| 1308 RTC_CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name; | |
| 1309 return PeerConnectionInterface::kAll; | |
| 1310 } | |
| 1311 | |
| 1312 static PeerConnectionInterface::BundlePolicy | |
| 1313 JavaBundlePolicyToNativeType(JNIEnv* jni, jobject j_bundle_policy) { | |
| 1314 std::string enum_name = GetJavaEnumName( | |
| 1315 jni, "org/webrtc/PeerConnection$BundlePolicy", | |
| 1316 j_bundle_policy); | |
| 1317 | |
| 1318 if (enum_name == "BALANCED") | |
| 1319 return PeerConnectionInterface::kBundlePolicyBalanced; | |
| 1320 | |
| 1321 if (enum_name == "MAXBUNDLE") | |
| 1322 return PeerConnectionInterface::kBundlePolicyMaxBundle; | |
| 1323 | |
| 1324 if (enum_name == "MAXCOMPAT") | |
| 1325 return PeerConnectionInterface::kBundlePolicyMaxCompat; | |
| 1326 | |
| 1327 RTC_CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name; | |
| 1328 return PeerConnectionInterface::kBundlePolicyBalanced; | |
| 1329 } | |
| 1330 | |
| 1331 static PeerConnectionInterface::RtcpMuxPolicy | |
| 1332 JavaRtcpMuxPolicyToNativeType(JNIEnv* jni, jobject j_rtcp_mux_policy) { | |
| 1333 std::string enum_name = GetJavaEnumName( | |
| 1334 jni, "org/webrtc/PeerConnection$RtcpMuxPolicy", | |
| 1335 j_rtcp_mux_policy); | |
| 1336 | |
| 1337 if (enum_name == "NEGOTIATE") | |
| 1338 return PeerConnectionInterface::kRtcpMuxPolicyNegotiate; | |
| 1339 | |
| 1340 if (enum_name == "REQUIRE") | |
| 1341 return PeerConnectionInterface::kRtcpMuxPolicyRequire; | |
| 1342 | |
| 1343 RTC_CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name; | |
| 1344 return PeerConnectionInterface::kRtcpMuxPolicyNegotiate; | |
| 1345 } | |
| 1346 | |
| 1347 static PeerConnectionInterface::TcpCandidatePolicy | |
| 1348 JavaTcpCandidatePolicyToNativeType( | |
| 1349 JNIEnv* jni, jobject j_tcp_candidate_policy) { | |
| 1350 std::string enum_name = GetJavaEnumName( | |
| 1351 jni, "org/webrtc/PeerConnection$TcpCandidatePolicy", | |
| 1352 j_tcp_candidate_policy); | |
| 1353 | |
| 1354 if (enum_name == "ENABLED") | |
| 1355 return PeerConnectionInterface::kTcpCandidatePolicyEnabled; | |
| 1356 | |
| 1357 if (enum_name == "DISABLED") | |
| 1358 return PeerConnectionInterface::kTcpCandidatePolicyDisabled; | |
| 1359 | |
| 1360 RTC_CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name; | |
| 1361 return PeerConnectionInterface::kTcpCandidatePolicyEnabled; | |
| 1362 } | |
| 1363 | |
| 1364 static PeerConnectionInterface::CandidateNetworkPolicy | |
| 1365 JavaCandidateNetworkPolicyToNativeType(JNIEnv* jni, | |
| 1366 jobject j_candidate_network_policy) { | |
| 1367 std::string enum_name = | |
| 1368 GetJavaEnumName(jni, "org/webrtc/PeerConnection$CandidateNetworkPolicy", | |
| 1369 j_candidate_network_policy); | |
| 1370 | |
| 1371 if (enum_name == "ALL") | |
| 1372 return PeerConnectionInterface::kCandidateNetworkPolicyAll; | |
| 1373 | |
| 1374 if (enum_name == "LOW_COST") | |
| 1375 return PeerConnectionInterface::kCandidateNetworkPolicyLowCost; | |
| 1376 | |
| 1377 RTC_CHECK(false) << "Unexpected CandidateNetworkPolicy enum_name " | |
| 1378 << enum_name; | |
| 1379 return PeerConnectionInterface::kCandidateNetworkPolicyAll; | |
| 1380 } | |
| 1381 | |
| 1382 static rtc::KeyType JavaKeyTypeToNativeType(JNIEnv* jni, jobject j_key_type) { | |
| 1383 std::string enum_name = GetJavaEnumName( | |
| 1384 jni, "org/webrtc/PeerConnection$KeyType", j_key_type); | |
| 1385 | |
| 1386 if (enum_name == "RSA") | |
| 1387 return rtc::KT_RSA; | |
| 1388 if (enum_name == "ECDSA") | |
| 1389 return rtc::KT_ECDSA; | |
| 1390 | |
| 1391 RTC_CHECK(false) << "Unexpected KeyType enum_name " << enum_name; | |
| 1392 return rtc::KT_ECDSA; | |
| 1393 } | |
| 1394 | |
| 1395 static PeerConnectionInterface::ContinualGatheringPolicy | |
| 1396 JavaContinualGatheringPolicyToNativeType( | |
| 1397 JNIEnv* jni, jobject j_gathering_policy) { | |
| 1398 std::string enum_name = GetJavaEnumName( | |
| 1399 jni, "org/webrtc/PeerConnection$ContinualGatheringPolicy", | |
| 1400 j_gathering_policy); | |
| 1401 if (enum_name == "GATHER_ONCE") | |
| 1402 return PeerConnectionInterface::GATHER_ONCE; | |
| 1403 | |
| 1404 if (enum_name == "GATHER_CONTINUALLY") | |
| 1405 return PeerConnectionInterface::GATHER_CONTINUALLY; | |
| 1406 | |
| 1407 RTC_CHECK(false) << "Unexpected ContinualGatheringPolicy enum name " | |
| 1408 << enum_name; | |
| 1409 return PeerConnectionInterface::GATHER_ONCE; | |
| 1410 } | |
| 1411 | |
| 1412 static PeerConnectionInterface::TlsCertPolicy JavaTlsCertPolicyTypeToNativeType( | |
| 1413 JNIEnv* jni, | |
| 1414 jobject j_ice_server_tls_cert_policy) { | |
| 1415 std::string enum_name = | |
| 1416 GetJavaEnumName(jni, "org/webrtc/PeerConnection$TlsCertPolicy", | |
| 1417 j_ice_server_tls_cert_policy); | |
| 1418 | |
| 1419 if (enum_name == "TLS_CERT_POLICY_SECURE") | |
| 1420 return PeerConnectionInterface::kTlsCertPolicySecure; | |
| 1421 | |
| 1422 if (enum_name == "TLS_CERT_POLICY_INSECURE_NO_CHECK") | |
| 1423 return PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck; | |
| 1424 | |
| 1425 RTC_CHECK(false) << "Unexpected TlsCertPolicy enum_name " << enum_name; | |
| 1426 return PeerConnectionInterface::kTlsCertPolicySecure; | |
| 1427 } | |
| 1428 | |
| 1429 static void JavaIceServersToJsepIceServers( | |
| 1430 JNIEnv* jni, jobject j_ice_servers, | |
| 1431 PeerConnectionInterface::IceServers* ice_servers) { | |
| 1432 for (jobject j_ice_server : Iterable(jni, j_ice_servers)) { | |
| 1433 jclass j_ice_server_class = GetObjectClass(jni, j_ice_server); | |
| 1434 jfieldID j_ice_server_uri_id = | |
| 1435 GetFieldID(jni, j_ice_server_class, "uri", "Ljava/lang/String;"); | |
| 1436 jfieldID j_ice_server_username_id = | |
| 1437 GetFieldID(jni, j_ice_server_class, "username", "Ljava/lang/String;"); | |
| 1438 jfieldID j_ice_server_password_id = | |
| 1439 GetFieldID(jni, j_ice_server_class, "password", "Ljava/lang/String;"); | |
| 1440 jfieldID j_ice_server_tls_cert_policy_id = | |
| 1441 GetFieldID(jni, j_ice_server_class, "tlsCertPolicy", | |
| 1442 "Lorg/webrtc/PeerConnection$TlsCertPolicy;"); | |
| 1443 jobject j_ice_server_tls_cert_policy = | |
| 1444 GetObjectField(jni, j_ice_server, j_ice_server_tls_cert_policy_id); | |
| 1445 jfieldID j_ice_server_hostname_id = | |
| 1446 GetFieldID(jni, j_ice_server_class, "hostname", "Ljava/lang/String;"); | |
| 1447 jstring uri = reinterpret_cast<jstring>( | |
| 1448 GetObjectField(jni, j_ice_server, j_ice_server_uri_id)); | |
| 1449 jstring username = reinterpret_cast<jstring>( | |
| 1450 GetObjectField(jni, j_ice_server, j_ice_server_username_id)); | |
| 1451 jstring password = reinterpret_cast<jstring>( | |
| 1452 GetObjectField(jni, j_ice_server, j_ice_server_password_id)); | |
| 1453 PeerConnectionInterface::TlsCertPolicy tls_cert_policy = | |
| 1454 JavaTlsCertPolicyTypeToNativeType(jni, j_ice_server_tls_cert_policy); | |
| 1455 jstring hostname = reinterpret_cast<jstring>( | |
| 1456 GetObjectField(jni, j_ice_server, j_ice_server_hostname_id)); | |
| 1457 PeerConnectionInterface::IceServer server; | |
| 1458 server.uri = JavaToStdString(jni, uri); | |
| 1459 server.username = JavaToStdString(jni, username); | |
| 1460 server.password = JavaToStdString(jni, password); | |
| 1461 server.tls_cert_policy = tls_cert_policy; | |
| 1462 server.hostname = JavaToStdString(jni, hostname); | |
| 1463 ice_servers->push_back(server); | |
| 1464 } | |
| 1465 } | |
| 1466 | |
| 1467 static void JavaRTCConfigurationToJsepRTCConfiguration( | |
| 1468 JNIEnv* jni, | |
| 1469 jobject j_rtc_config, | |
| 1470 PeerConnectionInterface::RTCConfiguration* rtc_config) { | |
| 1471 jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config); | |
| 1472 | |
| 1473 jfieldID j_ice_transports_type_id = GetFieldID( | |
| 1474 jni, j_rtc_config_class, "iceTransportsType", | |
| 1475 "Lorg/webrtc/PeerConnection$IceTransportsType;"); | |
| 1476 jobject j_ice_transports_type = GetObjectField( | |
| 1477 jni, j_rtc_config, j_ice_transports_type_id); | |
| 1478 | |
| 1479 jfieldID j_bundle_policy_id = GetFieldID( | |
| 1480 jni, j_rtc_config_class, "bundlePolicy", | |
| 1481 "Lorg/webrtc/PeerConnection$BundlePolicy;"); | |
| 1482 jobject j_bundle_policy = GetObjectField( | |
| 1483 jni, j_rtc_config, j_bundle_policy_id); | |
| 1484 | |
| 1485 jfieldID j_rtcp_mux_policy_id = GetFieldID( | |
| 1486 jni, j_rtc_config_class, "rtcpMuxPolicy", | |
| 1487 "Lorg/webrtc/PeerConnection$RtcpMuxPolicy;"); | |
| 1488 jobject j_rtcp_mux_policy = GetObjectField( | |
| 1489 jni, j_rtc_config, j_rtcp_mux_policy_id); | |
| 1490 | |
| 1491 jfieldID j_tcp_candidate_policy_id = GetFieldID( | |
| 1492 jni, j_rtc_config_class, "tcpCandidatePolicy", | |
| 1493 "Lorg/webrtc/PeerConnection$TcpCandidatePolicy;"); | |
| 1494 jobject j_tcp_candidate_policy = GetObjectField( | |
| 1495 jni, j_rtc_config, j_tcp_candidate_policy_id); | |
| 1496 | |
| 1497 jfieldID j_candidate_network_policy_id = GetFieldID( | |
| 1498 jni, j_rtc_config_class, "candidateNetworkPolicy", | |
| 1499 "Lorg/webrtc/PeerConnection$CandidateNetworkPolicy;"); | |
| 1500 jobject j_candidate_network_policy = GetObjectField( | |
| 1501 jni, j_rtc_config, j_candidate_network_policy_id); | |
| 1502 | |
| 1503 jfieldID j_ice_servers_id = GetFieldID( | |
| 1504 jni, j_rtc_config_class, "iceServers", "Ljava/util/List;"); | |
| 1505 jobject j_ice_servers = GetObjectField(jni, j_rtc_config, j_ice_servers_id); | |
| 1506 | |
| 1507 jfieldID j_audio_jitter_buffer_max_packets_id = | |
| 1508 GetFieldID(jni, j_rtc_config_class, "audioJitterBufferMaxPackets", "I"); | |
| 1509 jfieldID j_audio_jitter_buffer_fast_accelerate_id = GetFieldID( | |
| 1510 jni, j_rtc_config_class, "audioJitterBufferFastAccelerate", "Z"); | |
| 1511 | |
| 1512 jfieldID j_ice_connection_receiving_timeout_id = | |
| 1513 GetFieldID(jni, j_rtc_config_class, "iceConnectionReceivingTimeout", "I"); | |
| 1514 | |
| 1515 jfieldID j_ice_backup_candidate_pair_ping_interval_id = GetFieldID( | |
| 1516 jni, j_rtc_config_class, "iceBackupCandidatePairPingInterval", "I"); | |
| 1517 | |
| 1518 jfieldID j_continual_gathering_policy_id = | |
| 1519 GetFieldID(jni, j_rtc_config_class, "continualGatheringPolicy", | |
| 1520 "Lorg/webrtc/PeerConnection$ContinualGatheringPolicy;"); | |
| 1521 jobject j_continual_gathering_policy = | |
| 1522 GetObjectField(jni, j_rtc_config, j_continual_gathering_policy_id); | |
| 1523 | |
| 1524 jfieldID j_ice_candidate_pool_size_id = | |
| 1525 GetFieldID(jni, j_rtc_config_class, "iceCandidatePoolSize", "I"); | |
| 1526 jfieldID j_presume_writable_when_fully_relayed_id = GetFieldID( | |
| 1527 jni, j_rtc_config_class, "presumeWritableWhenFullyRelayed", "Z"); | |
| 1528 | |
| 1529 jfieldID j_prune_turn_ports_id = | |
| 1530 GetFieldID(jni, j_rtc_config_class, "pruneTurnPorts", "Z"); | |
| 1531 | |
| 1532 jfieldID j_ice_check_min_interval_id = GetFieldID( | |
| 1533 jni, j_rtc_config_class, "iceCheckMinInterval", "Ljava/lang/Integer;"); | |
| 1534 jclass j_integer_class = jni->FindClass("java/lang/Integer"); | |
| 1535 jmethodID int_value_id = GetMethodID(jni, j_integer_class, "intValue", "()I"); | |
| 1536 | |
| 1537 jfieldID j_disable_ipv6_on_wifi_id = | |
| 1538 GetFieldID(jni, j_rtc_config_class, "disableIPv6OnWifi", "Z"); | |
| 1539 | |
| 1540 jfieldID j_max_ipv6_networks_id = | |
| 1541 GetFieldID(jni, j_rtc_config_class, "maxIPv6Networks", "I"); | |
| 1542 | |
| 1543 jfieldID j_ice_regather_interval_range_id = | |
| 1544 GetFieldID(jni, j_rtc_config_class, "iceRegatherIntervalRange", | |
| 1545 "Lorg/webrtc/PeerConnection$IntervalRange;"); | |
| 1546 jclass j_interval_range_class = | |
| 1547 jni->FindClass("org/webrtc/PeerConnection$IntervalRange"); | |
| 1548 jmethodID get_min_id = | |
| 1549 GetMethodID(jni, j_interval_range_class, "getMin", "()I"); | |
| 1550 jmethodID get_max_id = | |
| 1551 GetMethodID(jni, j_interval_range_class, "getMax", "()I"); | |
| 1552 | |
| 1553 rtc_config->type = | |
| 1554 JavaIceTransportsTypeToNativeType(jni, j_ice_transports_type); | |
| 1555 rtc_config->bundle_policy = | |
| 1556 JavaBundlePolicyToNativeType(jni, j_bundle_policy); | |
| 1557 rtc_config->rtcp_mux_policy = | |
| 1558 JavaRtcpMuxPolicyToNativeType(jni, j_rtcp_mux_policy); | |
| 1559 rtc_config->tcp_candidate_policy = | |
| 1560 JavaTcpCandidatePolicyToNativeType(jni, j_tcp_candidate_policy); | |
| 1561 rtc_config->candidate_network_policy = | |
| 1562 JavaCandidateNetworkPolicyToNativeType(jni, j_candidate_network_policy); | |
| 1563 JavaIceServersToJsepIceServers(jni, j_ice_servers, &rtc_config->servers); | |
| 1564 rtc_config->audio_jitter_buffer_max_packets = | |
| 1565 GetIntField(jni, j_rtc_config, j_audio_jitter_buffer_max_packets_id); | |
| 1566 rtc_config->audio_jitter_buffer_fast_accelerate = GetBooleanField( | |
| 1567 jni, j_rtc_config, j_audio_jitter_buffer_fast_accelerate_id); | |
| 1568 rtc_config->ice_connection_receiving_timeout = | |
| 1569 GetIntField(jni, j_rtc_config, j_ice_connection_receiving_timeout_id); | |
| 1570 rtc_config->ice_backup_candidate_pair_ping_interval = GetIntField( | |
| 1571 jni, j_rtc_config, j_ice_backup_candidate_pair_ping_interval_id); | |
| 1572 rtc_config->continual_gathering_policy = | |
| 1573 JavaContinualGatheringPolicyToNativeType( | |
| 1574 jni, j_continual_gathering_policy); | |
| 1575 rtc_config->ice_candidate_pool_size = | |
| 1576 GetIntField(jni, j_rtc_config, j_ice_candidate_pool_size_id); | |
| 1577 rtc_config->prune_turn_ports = | |
| 1578 GetBooleanField(jni, j_rtc_config, j_prune_turn_ports_id); | |
| 1579 rtc_config->presume_writable_when_fully_relayed = GetBooleanField( | |
| 1580 jni, j_rtc_config, j_presume_writable_when_fully_relayed_id); | |
| 1581 jobject j_ice_check_min_interval = | |
| 1582 GetNullableObjectField(jni, j_rtc_config, j_ice_check_min_interval_id); | |
| 1583 if (!IsNull(jni, j_ice_check_min_interval)) { | |
| 1584 int ice_check_min_interval_value = | |
| 1585 jni->CallIntMethod(j_ice_check_min_interval, int_value_id); | |
| 1586 rtc_config->ice_check_min_interval = | |
| 1587 rtc::Optional<int>(ice_check_min_interval_value); | |
| 1588 } | |
| 1589 rtc_config->disable_ipv6_on_wifi = | |
| 1590 GetBooleanField(jni, j_rtc_config, j_disable_ipv6_on_wifi_id); | |
| 1591 rtc_config->max_ipv6_networks = | |
| 1592 GetIntField(jni, j_rtc_config, j_max_ipv6_networks_id); | |
| 1593 jobject j_ice_regather_interval_range = GetNullableObjectField( | |
| 1594 jni, j_rtc_config, j_ice_regather_interval_range_id); | |
| 1595 if (!IsNull(jni, j_ice_regather_interval_range)) { | |
| 1596 int min = jni->CallIntMethod(j_ice_regather_interval_range, get_min_id); | |
| 1597 int max = jni->CallIntMethod(j_ice_regather_interval_range, get_max_id); | |
| 1598 rtc_config->ice_regather_interval_range.emplace(min, max); | |
| 1599 } | |
| 1600 } | |
| 1601 | |
| 1602 JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnection)( | |
| 1603 JNIEnv *jni, jclass, jlong factory, jobject j_rtc_config, | |
| 1604 jobject j_constraints, jlong observer_p) { | |
| 1605 rtc::scoped_refptr<PeerConnectionFactoryInterface> f( | |
| 1606 reinterpret_cast<PeerConnectionFactoryInterface*>( | |
| 1607 factoryFromJava(factory))); | |
| 1608 | |
| 1609 PeerConnectionInterface::RTCConfiguration rtc_config( | |
| 1610 PeerConnectionInterface::RTCConfigurationType::kAggressive); | |
| 1611 JavaRTCConfigurationToJsepRTCConfiguration(jni, j_rtc_config, &rtc_config); | |
| 1612 | |
| 1613 jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config); | |
| 1614 jfieldID j_key_type_id = GetFieldID(jni, j_rtc_config_class, "keyType", | |
| 1615 "Lorg/webrtc/PeerConnection$KeyType;"); | |
| 1616 jobject j_key_type = GetObjectField(jni, j_rtc_config, j_key_type_id); | |
| 1617 | |
| 1618 // Generate non-default certificate. | |
| 1619 rtc::KeyType key_type = JavaKeyTypeToNativeType(jni, j_key_type); | |
| 1620 if (key_type != rtc::KT_DEFAULT) { | |
| 1621 rtc::scoped_refptr<rtc::RTCCertificate> certificate = | |
| 1622 rtc::RTCCertificateGenerator::GenerateCertificate( | |
| 1623 rtc::KeyParams(key_type), rtc::Optional<uint64_t>()); | |
| 1624 if (!certificate) { | |
| 1625 LOG(LS_ERROR) << "Failed to generate certificate. KeyType: " << key_type; | |
| 1626 return 0; | |
| 1627 } | |
| 1628 rtc_config.certificates.push_back(certificate); | |
| 1629 } | |
| 1630 | |
| 1631 PCOJava* observer = reinterpret_cast<PCOJava*>(observer_p); | |
| 1632 observer->SetConstraints(new ConstraintsWrapper(jni, j_constraints)); | |
| 1633 CopyConstraintsIntoRtcConfiguration(observer->constraints(), &rtc_config); | |
| 1634 rtc::scoped_refptr<PeerConnectionInterface> pc( | |
| 1635 f->CreatePeerConnection(rtc_config, nullptr, nullptr, observer)); | |
| 1636 return (jlong)pc.release(); | |
| 1637 } | |
| 1638 | |
| 1639 static rtc::scoped_refptr<PeerConnectionInterface> ExtractNativePC( | |
| 1640 JNIEnv* jni, jobject j_pc) { | |
| 1641 jfieldID native_pc_id = GetFieldID(jni, | |
| 1642 GetObjectClass(jni, j_pc), "nativePeerConnection", "J"); | |
| 1643 jlong j_p = GetLongField(jni, j_pc, native_pc_id); | |
| 1644 return rtc::scoped_refptr<PeerConnectionInterface>( | |
| 1645 reinterpret_cast<PeerConnectionInterface*>(j_p)); | |
| 1646 } | |
| 1647 | |
| 1648 JOW(jobject, PeerConnection_getLocalDescription)(JNIEnv* jni, jobject j_pc) { | |
| 1649 const SessionDescriptionInterface* sdp = | |
| 1650 ExtractNativePC(jni, j_pc)->local_description(); | |
| 1651 return sdp ? JavaSdpFromNativeSdp(jni, sdp) : NULL; | |
| 1652 } | |
| 1653 | |
| 1654 JOW(jobject, PeerConnection_getRemoteDescription)(JNIEnv* jni, jobject j_pc) { | |
| 1655 const SessionDescriptionInterface* sdp = | |
| 1656 ExtractNativePC(jni, j_pc)->remote_description(); | |
| 1657 return sdp ? JavaSdpFromNativeSdp(jni, sdp) : NULL; | |
| 1658 } | |
| 1659 | |
| 1660 JOW(jobject, PeerConnection_createDataChannel)( | |
| 1661 JNIEnv* jni, jobject j_pc, jstring j_label, jobject j_init) { | |
| 1662 DataChannelInit init = JavaDataChannelInitToNative(jni, j_init); | |
| 1663 rtc::scoped_refptr<DataChannelInterface> channel( | |
| 1664 ExtractNativePC(jni, j_pc)->CreateDataChannel( | |
| 1665 JavaToStdString(jni, j_label), &init)); | |
| 1666 // Mustn't pass channel.get() directly through NewObject to avoid reading its | |
| 1667 // vararg parameter as 64-bit and reading memory that doesn't belong to the | |
| 1668 // 32-bit parameter. | |
| 1669 jlong nativeChannelPtr = jlongFromPointer(channel.get()); | |
| 1670 if (!nativeChannelPtr) { | |
| 1671 LOG(LS_ERROR) << "Failed to create DataChannel"; | |
| 1672 return nullptr; | |
| 1673 } | |
| 1674 jclass j_data_channel_class = FindClass(jni, "org/webrtc/DataChannel"); | |
| 1675 jmethodID j_data_channel_ctor = GetMethodID( | |
| 1676 jni, j_data_channel_class, "<init>", "(J)V"); | |
| 1677 jobject j_channel = jni->NewObject( | |
| 1678 j_data_channel_class, j_data_channel_ctor, nativeChannelPtr); | |
| 1679 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 1680 // Channel is now owned by Java object, and will be freed from there. | |
| 1681 int bumped_count = channel->AddRef(); | |
| 1682 RTC_CHECK(bumped_count == 2) << "Unexpected refcount"; | |
| 1683 return j_channel; | |
| 1684 } | |
| 1685 | |
| 1686 JOW(void, PeerConnection_createOffer)( | |
| 1687 JNIEnv* jni, jobject j_pc, jobject j_observer, jobject j_constraints) { | |
| 1688 ConstraintsWrapper* constraints = | |
| 1689 new ConstraintsWrapper(jni, j_constraints); | |
| 1690 rtc::scoped_refptr<CreateSdpObserverWrapper> observer( | |
| 1691 new rtc::RefCountedObject<CreateSdpObserverWrapper>( | |
| 1692 jni, j_observer, constraints)); | |
| 1693 ExtractNativePC(jni, j_pc)->CreateOffer(observer, constraints); | |
| 1694 } | |
| 1695 | |
| 1696 JOW(void, PeerConnection_createAnswer)( | |
| 1697 JNIEnv* jni, jobject j_pc, jobject j_observer, jobject j_constraints) { | |
| 1698 ConstraintsWrapper* constraints = | |
| 1699 new ConstraintsWrapper(jni, j_constraints); | |
| 1700 rtc::scoped_refptr<CreateSdpObserverWrapper> observer( | |
| 1701 new rtc::RefCountedObject<CreateSdpObserverWrapper>( | |
| 1702 jni, j_observer, constraints)); | |
| 1703 ExtractNativePC(jni, j_pc)->CreateAnswer(observer, constraints); | |
| 1704 } | |
| 1705 | |
| 1706 // Helper to create a SessionDescriptionInterface from a SessionDescription. | |
| 1707 static SessionDescriptionInterface* JavaSdpToNativeSdp( | |
| 1708 JNIEnv* jni, jobject j_sdp) { | |
| 1709 jfieldID j_type_id = GetFieldID( | |
| 1710 jni, GetObjectClass(jni, j_sdp), "type", | |
| 1711 "Lorg/webrtc/SessionDescription$Type;"); | |
| 1712 jobject j_type = GetObjectField(jni, j_sdp, j_type_id); | |
| 1713 jmethodID j_canonical_form_id = GetMethodID( | |
| 1714 jni, GetObjectClass(jni, j_type), "canonicalForm", | |
| 1715 "()Ljava/lang/String;"); | |
| 1716 jstring j_type_string = (jstring)jni->CallObjectMethod( | |
| 1717 j_type, j_canonical_form_id); | |
| 1718 CHECK_EXCEPTION(jni) << "error during CallObjectMethod"; | |
| 1719 std::string std_type = JavaToStdString(jni, j_type_string); | |
| 1720 | |
| 1721 jfieldID j_description_id = GetFieldID( | |
| 1722 jni, GetObjectClass(jni, j_sdp), "description", "Ljava/lang/String;"); | |
| 1723 jstring j_description = (jstring)GetObjectField(jni, j_sdp, j_description_id); | |
| 1724 std::string std_description = JavaToStdString(jni, j_description); | |
| 1725 | |
| 1726 return webrtc::CreateSessionDescription( | |
| 1727 std_type, std_description, NULL); | |
| 1728 } | |
| 1729 | |
| 1730 JOW(void, PeerConnection_setLocalDescription)( | |
| 1731 JNIEnv* jni, jobject j_pc, | |
| 1732 jobject j_observer, jobject j_sdp) { | |
| 1733 rtc::scoped_refptr<SetSdpObserverWrapper> observer( | |
| 1734 new rtc::RefCountedObject<SetSdpObserverWrapper>( | |
| 1735 jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL))); | |
| 1736 ExtractNativePC(jni, j_pc)->SetLocalDescription( | |
| 1737 observer, JavaSdpToNativeSdp(jni, j_sdp)); | |
| 1738 } | |
| 1739 | |
| 1740 JOW(void, PeerConnection_setRemoteDescription)( | |
| 1741 JNIEnv* jni, jobject j_pc, | |
| 1742 jobject j_observer, jobject j_sdp) { | |
| 1743 rtc::scoped_refptr<SetSdpObserverWrapper> observer( | |
| 1744 new rtc::RefCountedObject<SetSdpObserverWrapper>( | |
| 1745 jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL))); | |
| 1746 ExtractNativePC(jni, j_pc)->SetRemoteDescription( | |
| 1747 observer, JavaSdpToNativeSdp(jni, j_sdp)); | |
| 1748 } | |
| 1749 | |
| 1750 JOW(jboolean, PeerConnection_nativeSetConfiguration)( | |
| 1751 JNIEnv* jni, jobject j_pc, jobject j_rtc_config, jlong native_observer) { | |
| 1752 // Need to merge constraints into RTCConfiguration again, which are stored | |
| 1753 // in the observer object. | |
| 1754 PCOJava* observer = reinterpret_cast<PCOJava*>(native_observer); | |
| 1755 PeerConnectionInterface::RTCConfiguration rtc_config( | |
| 1756 PeerConnectionInterface::RTCConfigurationType::kAggressive); | |
| 1757 JavaRTCConfigurationToJsepRTCConfiguration(jni, j_rtc_config, &rtc_config); | |
| 1758 CopyConstraintsIntoRtcConfiguration(observer->constraints(), &rtc_config); | |
| 1759 return ExtractNativePC(jni, j_pc)->SetConfiguration(rtc_config); | |
| 1760 } | |
| 1761 | |
| 1762 JOW(jboolean, PeerConnection_nativeAddIceCandidate)( | |
| 1763 JNIEnv* jni, jobject j_pc, jstring j_sdp_mid, | |
| 1764 jint j_sdp_mline_index, jstring j_candidate_sdp) { | |
| 1765 std::string sdp_mid = JavaToStdString(jni, j_sdp_mid); | |
| 1766 std::string sdp = JavaToStdString(jni, j_candidate_sdp); | |
| 1767 std::unique_ptr<IceCandidateInterface> candidate( | |
| 1768 webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, NULL)); | |
| 1769 return ExtractNativePC(jni, j_pc)->AddIceCandidate(candidate.get()); | |
| 1770 } | |
| 1771 | |
| 1772 static cricket::Candidate GetCandidateFromJava(JNIEnv* jni, | |
| 1773 jobject j_candidate) { | |
| 1774 jclass j_candidate_class = GetObjectClass(jni, j_candidate); | |
| 1775 jfieldID j_sdp_mid_id = | |
| 1776 GetFieldID(jni, j_candidate_class, "sdpMid", "Ljava/lang/String;"); | |
| 1777 std::string sdp_mid = | |
| 1778 JavaToStdString(jni, GetStringField(jni, j_candidate, j_sdp_mid_id)); | |
| 1779 jfieldID j_sdp_id = | |
| 1780 GetFieldID(jni, j_candidate_class, "sdp", "Ljava/lang/String;"); | |
| 1781 std::string sdp = | |
| 1782 JavaToStdString(jni, GetStringField(jni, j_candidate, j_sdp_id)); | |
| 1783 cricket::Candidate candidate; | |
| 1784 if (!webrtc::SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) { | |
| 1785 LOG(LS_ERROR) << "SdpDescrializeCandidate failed with sdp " << sdp; | |
| 1786 } | |
| 1787 return candidate; | |
| 1788 } | |
| 1789 | |
| 1790 JOW(jboolean, PeerConnection_nativeRemoveIceCandidates) | |
| 1791 (JNIEnv* jni, jobject j_pc, jobjectArray j_candidates) { | |
| 1792 std::vector<cricket::Candidate> candidates; | |
| 1793 size_t num_candidates = jni->GetArrayLength(j_candidates); | |
| 1794 for (size_t i = 0; i < num_candidates; ++i) { | |
| 1795 jobject j_candidate = jni->GetObjectArrayElement(j_candidates, i); | |
| 1796 candidates.push_back(GetCandidateFromJava(jni, j_candidate)); | |
| 1797 } | |
| 1798 return ExtractNativePC(jni, j_pc)->RemoveIceCandidates(candidates); | |
| 1799 } | |
| 1800 | |
| 1801 JOW(jboolean, PeerConnection_nativeAddLocalStream)( | |
| 1802 JNIEnv* jni, jobject j_pc, jlong native_stream) { | |
| 1803 return ExtractNativePC(jni, j_pc)->AddStream( | |
| 1804 reinterpret_cast<MediaStreamInterface*>(native_stream)); | |
| 1805 } | |
| 1806 | |
| 1807 JOW(void, PeerConnection_nativeRemoveLocalStream)( | |
| 1808 JNIEnv* jni, jobject j_pc, jlong native_stream) { | |
| 1809 ExtractNativePC(jni, j_pc)->RemoveStream( | |
| 1810 reinterpret_cast<MediaStreamInterface*>(native_stream)); | |
| 1811 } | |
| 1812 | |
| 1813 JOW(jobject, PeerConnection_nativeCreateSender)( | |
| 1814 JNIEnv* jni, jobject j_pc, jstring j_kind, jstring j_stream_id) { | |
| 1815 jclass j_rtp_sender_class = FindClass(jni, "org/webrtc/RtpSender"); | |
| 1816 jmethodID j_rtp_sender_ctor = | |
| 1817 GetMethodID(jni, j_rtp_sender_class, "<init>", "(J)V"); | |
| 1818 | |
| 1819 std::string kind = JavaToStdString(jni, j_kind); | |
| 1820 std::string stream_id = JavaToStdString(jni, j_stream_id); | |
| 1821 rtc::scoped_refptr<RtpSenderInterface> sender = | |
| 1822 ExtractNativePC(jni, j_pc)->CreateSender(kind, stream_id); | |
| 1823 if (!sender.get()) { | |
| 1824 return nullptr; | |
| 1825 } | |
| 1826 jlong nativeSenderPtr = jlongFromPointer(sender.get()); | |
| 1827 jobject j_sender = | |
| 1828 jni->NewObject(j_rtp_sender_class, j_rtp_sender_ctor, nativeSenderPtr); | |
| 1829 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 1830 // Sender is now owned by the Java object, and will be freed from | |
| 1831 // RtpSender.dispose(), called by PeerConnection.dispose() or getSenders(). | |
| 1832 sender->AddRef(); | |
| 1833 return j_sender; | |
| 1834 } | |
| 1835 | |
| 1836 JOW(jobject, PeerConnection_nativeGetSenders)(JNIEnv* jni, jobject j_pc) { | |
| 1837 jclass j_array_list_class = FindClass(jni, "java/util/ArrayList"); | |
| 1838 jmethodID j_array_list_ctor = | |
| 1839 GetMethodID(jni, j_array_list_class, "<init>", "()V"); | |
| 1840 jmethodID j_array_list_add = | |
| 1841 GetMethodID(jni, j_array_list_class, "add", "(Ljava/lang/Object;)Z"); | |
| 1842 jobject j_senders = jni->NewObject(j_array_list_class, j_array_list_ctor); | |
| 1843 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 1844 | |
| 1845 jclass j_rtp_sender_class = FindClass(jni, "org/webrtc/RtpSender"); | |
| 1846 jmethodID j_rtp_sender_ctor = | |
| 1847 GetMethodID(jni, j_rtp_sender_class, "<init>", "(J)V"); | |
| 1848 | |
| 1849 auto senders = ExtractNativePC(jni, j_pc)->GetSenders(); | |
| 1850 for (const auto& sender : senders) { | |
| 1851 jlong nativeSenderPtr = jlongFromPointer(sender.get()); | |
| 1852 jobject j_sender = | |
| 1853 jni->NewObject(j_rtp_sender_class, j_rtp_sender_ctor, nativeSenderPtr); | |
| 1854 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 1855 // Sender is now owned by the Java object, and will be freed from | |
| 1856 // RtpSender.dispose(), called by PeerConnection.dispose() or getSenders(). | |
| 1857 sender->AddRef(); | |
| 1858 jni->CallBooleanMethod(j_senders, j_array_list_add, j_sender); | |
| 1859 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod"; | |
| 1860 } | |
| 1861 return j_senders; | |
| 1862 } | |
| 1863 | |
| 1864 JOW(jobject, PeerConnection_nativeGetReceivers)(JNIEnv* jni, jobject j_pc) { | |
| 1865 jclass j_array_list_class = FindClass(jni, "java/util/ArrayList"); | |
| 1866 jmethodID j_array_list_ctor = | |
| 1867 GetMethodID(jni, j_array_list_class, "<init>", "()V"); | |
| 1868 jmethodID j_array_list_add = | |
| 1869 GetMethodID(jni, j_array_list_class, "add", "(Ljava/lang/Object;)Z"); | |
| 1870 jobject j_receivers = jni->NewObject(j_array_list_class, j_array_list_ctor); | |
| 1871 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 1872 | |
| 1873 jclass j_rtp_receiver_class = FindClass(jni, "org/webrtc/RtpReceiver"); | |
| 1874 jmethodID j_rtp_receiver_ctor = | |
| 1875 GetMethodID(jni, j_rtp_receiver_class, "<init>", "(J)V"); | |
| 1876 | |
| 1877 auto receivers = ExtractNativePC(jni, j_pc)->GetReceivers(); | |
| 1878 for (const auto& receiver : receivers) { | |
| 1879 jlong nativeReceiverPtr = jlongFromPointer(receiver.get()); | |
| 1880 jobject j_receiver = jni->NewObject(j_rtp_receiver_class, | |
| 1881 j_rtp_receiver_ctor, nativeReceiverPtr); | |
| 1882 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 1883 // Receiver is now owned by Java object, and will be freed from there. | |
| 1884 receiver->AddRef(); | |
| 1885 jni->CallBooleanMethod(j_receivers, j_array_list_add, j_receiver); | |
| 1886 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod"; | |
| 1887 } | |
| 1888 return j_receivers; | |
| 1889 } | |
| 1890 | |
| 1891 JOW(bool, PeerConnection_nativeOldGetStats) | |
| 1892 (JNIEnv* jni, jobject j_pc, jobject j_observer, jlong native_track) { | |
| 1893 rtc::scoped_refptr<StatsObserverWrapper> observer( | |
| 1894 new rtc::RefCountedObject<StatsObserverWrapper>(jni, j_observer)); | |
| 1895 return ExtractNativePC(jni, j_pc)->GetStats( | |
| 1896 observer, | |
| 1897 reinterpret_cast<MediaStreamTrackInterface*>(native_track), | |
| 1898 PeerConnectionInterface::kStatsOutputLevelStandard); | |
| 1899 } | |
| 1900 | |
| 1901 JOW(void, PeerConnection_nativeNewGetStats) | |
| 1902 (JNIEnv* jni, jobject j_pc, jobject j_callback) { | |
| 1903 rtc::scoped_refptr<RTCStatsCollectorCallbackWrapper> callback( | |
| 1904 new rtc::RefCountedObject<RTCStatsCollectorCallbackWrapper>(jni, | |
| 1905 j_callback)); | |
| 1906 ExtractNativePC(jni, j_pc)->GetStats(callback); | |
| 1907 } | |
| 1908 | |
| 1909 JOW(bool, PeerConnection_nativeStartRtcEventLog)( | |
| 1910 JNIEnv* jni, jobject j_pc, int file_descriptor, int max_size_bytes) { | |
| 1911 return ExtractNativePC(jni, j_pc)->StartRtcEventLog(file_descriptor, | |
| 1912 max_size_bytes); | |
| 1913 } | |
| 1914 | |
| 1915 JOW(void, PeerConnection_nativeStopRtcEventLog)(JNIEnv* jni, jobject j_pc) { | |
| 1916 ExtractNativePC(jni, j_pc)->StopRtcEventLog(); | |
| 1917 } | |
| 1918 | |
| 1919 JOW(jobject, PeerConnection_signalingState)(JNIEnv* jni, jobject j_pc) { | |
| 1920 PeerConnectionInterface::SignalingState state = | |
| 1921 ExtractNativePC(jni, j_pc)->signaling_state(); | |
| 1922 return JavaEnumFromIndex(jni, "PeerConnection$SignalingState", state); | |
| 1923 } | |
| 1924 | |
| 1925 JOW(jobject, PeerConnection_iceConnectionState)(JNIEnv* jni, jobject j_pc) { | |
| 1926 PeerConnectionInterface::IceConnectionState state = | |
| 1927 ExtractNativePC(jni, j_pc)->ice_connection_state(); | |
| 1928 return JavaEnumFromIndex(jni, "PeerConnection$IceConnectionState", state); | |
| 1929 } | |
| 1930 | |
| 1931 JOW(jobject, PeerConnection_iceGatheringState)(JNIEnv* jni, jobject j_pc) { | |
| 1932 PeerConnectionInterface::IceGatheringState state = | |
| 1933 ExtractNativePC(jni, j_pc)->ice_gathering_state(); | |
| 1934 return JavaEnumFromIndex(jni, "PeerConnection$IceGatheringState", state); | |
| 1935 } | |
| 1936 | |
| 1937 JOW(void, PeerConnection_close)(JNIEnv* jni, jobject j_pc) { | |
| 1938 ExtractNativePC(jni, j_pc)->Close(); | |
| 1939 return; | |
| 1940 } | |
| 1941 | |
| 1942 JOW(jobject, MediaSource_nativeState)(JNIEnv* jni, jclass, jlong j_p) { | |
| 1943 rtc::scoped_refptr<MediaSourceInterface> p( | |
| 1944 reinterpret_cast<MediaSourceInterface*>(j_p)); | |
| 1945 return JavaEnumFromIndex(jni, "MediaSource$State", p->state()); | |
| 1946 } | |
| 1947 | |
| 1948 JOW(jstring, MediaStreamTrack_nativeId)(JNIEnv* jni, jclass, jlong j_p) { | |
| 1949 return JavaStringFromStdString( | |
| 1950 jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->id()); | |
| 1951 } | |
| 1952 | |
| 1953 JOW(jstring, MediaStreamTrack_nativeKind)(JNIEnv* jni, jclass, jlong j_p) { | |
| 1954 return JavaStringFromStdString( | |
| 1955 jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->kind()); | |
| 1956 } | |
| 1957 | |
| 1958 JOW(jboolean, MediaStreamTrack_nativeEnabled)(JNIEnv* jni, jclass, jlong j_p) { | |
| 1959 return reinterpret_cast<MediaStreamTrackInterface*>(j_p)->enabled(); | |
| 1960 } | |
| 1961 | |
| 1962 JOW(jobject, MediaStreamTrack_nativeState)(JNIEnv* jni, jclass, jlong j_p) { | |
| 1963 return JavaEnumFromIndex( | |
| 1964 jni, | |
| 1965 "MediaStreamTrack$State", | |
| 1966 reinterpret_cast<MediaStreamTrackInterface*>(j_p)->state()); | |
| 1967 } | |
| 1968 | |
| 1969 JOW(jboolean, MediaStreamTrack_nativeSetEnabled)( | |
| 1970 JNIEnv* jni, jclass, jlong j_p, jboolean enabled) { | |
| 1971 return reinterpret_cast<MediaStreamTrackInterface*>(j_p) | |
| 1972 ->set_enabled(enabled); | |
| 1973 } | |
| 1974 | |
| 1975 JOW(jlong, CallSessionFileRotatingLogSink_nativeAddSink)( | |
| 1976 JNIEnv* jni, jclass, | |
| 1977 jstring j_dirPath, jint j_maxFileSize, jint j_severity) { | |
| 1978 std::string dir_path = JavaToStdString(jni, j_dirPath); | |
| 1979 rtc::CallSessionFileRotatingLogSink* sink = | |
| 1980 new rtc::CallSessionFileRotatingLogSink(dir_path, j_maxFileSize); | |
| 1981 if (!sink->Init()) { | |
| 1982 LOG_V(rtc::LoggingSeverity::LS_WARNING) << | |
| 1983 "Failed to init CallSessionFileRotatingLogSink for path " << dir_path; | |
| 1984 delete sink; | |
| 1985 return 0; | |
| 1986 } | |
| 1987 rtc::LogMessage::AddLogToStream( | |
| 1988 sink, static_cast<rtc::LoggingSeverity>(j_severity)); | |
| 1989 return (jlong) sink; | |
| 1990 } | |
| 1991 | |
| 1992 JOW(void, CallSessionFileRotatingLogSink_nativeDeleteSink)( | |
| 1993 JNIEnv* jni, jclass, jlong j_sink) { | |
| 1994 rtc::CallSessionFileRotatingLogSink* sink = | |
| 1995 reinterpret_cast<rtc::CallSessionFileRotatingLogSink*>(j_sink); | |
| 1996 rtc::LogMessage::RemoveLogToStream(sink); | |
| 1997 delete sink; | |
| 1998 } | |
| 1999 | |
| 2000 JOW(jbyteArray, CallSessionFileRotatingLogSink_nativeGetLogData)( | |
| 2001 JNIEnv* jni, jclass, jstring j_dirPath) { | |
| 2002 std::string dir_path = JavaToStdString(jni, j_dirPath); | |
| 2003 std::unique_ptr<rtc::CallSessionFileRotatingStream> stream( | |
| 2004 new rtc::CallSessionFileRotatingStream(dir_path)); | |
| 2005 if (!stream->Open()) { | |
| 2006 LOG_V(rtc::LoggingSeverity::LS_WARNING) << | |
| 2007 "Failed to open CallSessionFileRotatingStream for path " << dir_path; | |
| 2008 return jni->NewByteArray(0); | |
| 2009 } | |
| 2010 size_t log_size = 0; | |
| 2011 if (!stream->GetSize(&log_size) || log_size == 0) { | |
| 2012 LOG_V(rtc::LoggingSeverity::LS_WARNING) << | |
| 2013 "CallSessionFileRotatingStream returns 0 size for path " << dir_path; | |
| 2014 return jni->NewByteArray(0); | |
| 2015 } | |
| 2016 | |
| 2017 size_t read = 0; | |
| 2018 std::unique_ptr<jbyte> buffer(static_cast<jbyte*>(malloc(log_size))); | |
| 2019 stream->ReadAll(buffer.get(), log_size, &read, nullptr); | |
| 2020 | |
| 2021 jbyteArray result = jni->NewByteArray(read); | |
| 2022 jni->SetByteArrayRegion(result, 0, read, buffer.get()); | |
| 2023 | |
| 2024 return result; | |
| 2025 } | |
| 2026 | |
| 2027 JOW(jboolean, RtpSender_nativeSetTrack)(JNIEnv* jni, | |
| 2028 jclass, | |
| 2029 jlong j_rtp_sender_pointer, | |
| 2030 jlong j_track_pointer) { | |
| 2031 return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer) | |
| 2032 ->SetTrack(reinterpret_cast<MediaStreamTrackInterface*>(j_track_pointer)); | |
| 2033 } | |
| 2034 | |
| 2035 JOW(jlong, RtpSender_nativeGetTrack) | |
| 2036 (JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) { | |
| 2037 return jlongFromPointer( | |
| 2038 reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer) | |
| 2039 ->track() | |
| 2040 .release()); | |
| 2041 } | |
| 2042 | |
| 2043 JOW(jlong, RtpSender_nativeGetDtmfSender) | |
| 2044 (JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) { | |
| 2045 return jlongFromPointer( | |
| 2046 reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer) | |
| 2047 ->GetDtmfSender() | |
| 2048 .release()); | |
| 2049 } | |
| 2050 | |
| 2051 static void JavaRtpParametersToJsepRtpParameters( | |
| 2052 JNIEnv* jni, | |
| 2053 jobject j_parameters, | |
| 2054 webrtc::RtpParameters* parameters) { | |
| 2055 RTC_CHECK(parameters != nullptr); | |
| 2056 jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters"); | |
| 2057 jfieldID encodings_id = | |
| 2058 GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;"); | |
| 2059 jfieldID codecs_id = | |
| 2060 GetFieldID(jni, parameters_class, "codecs", "Ljava/util/LinkedList;"); | |
| 2061 | |
| 2062 // Convert encodings. | |
| 2063 jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id); | |
| 2064 jclass j_encoding_parameters_class = | |
| 2065 jni->FindClass("org/webrtc/RtpParameters$Encoding"); | |
| 2066 jfieldID active_id = | |
| 2067 GetFieldID(jni, j_encoding_parameters_class, "active", "Z"); | |
| 2068 jfieldID bitrate_id = GetFieldID(jni, j_encoding_parameters_class, | |
| 2069 "maxBitrateBps", "Ljava/lang/Integer;"); | |
| 2070 jfieldID ssrc_id = | |
| 2071 GetFieldID(jni, j_encoding_parameters_class, "ssrc", "Ljava/lang/Long;"); | |
| 2072 jclass j_integer_class = jni->FindClass("java/lang/Integer"); | |
| 2073 jclass j_long_class = jni->FindClass("java/lang/Long"); | |
| 2074 jmethodID int_value_id = GetMethodID(jni, j_integer_class, "intValue", "()I"); | |
| 2075 jmethodID long_value_id = GetMethodID(jni, j_long_class, "longValue", "()J"); | |
| 2076 | |
| 2077 for (jobject j_encoding_parameters : Iterable(jni, j_encodings)) { | |
| 2078 webrtc::RtpEncodingParameters encoding; | |
| 2079 encoding.active = GetBooleanField(jni, j_encoding_parameters, active_id); | |
| 2080 jobject j_bitrate = | |
| 2081 GetNullableObjectField(jni, j_encoding_parameters, bitrate_id); | |
| 2082 if (!IsNull(jni, j_bitrate)) { | |
| 2083 int bitrate_value = jni->CallIntMethod(j_bitrate, int_value_id); | |
| 2084 CHECK_EXCEPTION(jni) << "error during CallIntMethod"; | |
| 2085 encoding.max_bitrate_bps = rtc::Optional<int>(bitrate_value); | |
| 2086 } | |
| 2087 jobject j_ssrc = | |
| 2088 GetNullableObjectField(jni, j_encoding_parameters, ssrc_id); | |
| 2089 if (!IsNull(jni, j_ssrc)) { | |
| 2090 jlong ssrc_value = jni->CallLongMethod(j_ssrc, long_value_id); | |
| 2091 CHECK_EXCEPTION(jni) << "error during CallLongMethod"; | |
| 2092 encoding.ssrc = rtc::Optional<uint32_t>(ssrc_value); | |
| 2093 } | |
| 2094 parameters->encodings.push_back(encoding); | |
| 2095 } | |
| 2096 | |
| 2097 // Convert codecs. | |
| 2098 jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id); | |
| 2099 jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec"); | |
| 2100 jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I"); | |
| 2101 jfieldID name_id = GetFieldID(jni, codec_class, "name", "Ljava/lang/String;"); | |
| 2102 jfieldID kind_id = GetFieldID(jni, codec_class, "kind", | |
| 2103 "Lorg/webrtc/MediaStreamTrack$MediaType;"); | |
| 2104 jfieldID clock_rate_id = | |
| 2105 GetFieldID(jni, codec_class, "clockRate", "Ljava/lang/Integer;"); | |
| 2106 jfieldID num_channels_id = | |
| 2107 GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;"); | |
| 2108 | |
| 2109 for (jobject j_codec : Iterable(jni, j_codecs)) { | |
| 2110 webrtc::RtpCodecParameters codec; | |
| 2111 codec.payload_type = GetIntField(jni, j_codec, payload_type_id); | |
| 2112 codec.name = JavaToStdString(jni, GetStringField(jni, j_codec, name_id)); | |
| 2113 codec.kind = JavaMediaTypeToJsepMediaType( | |
| 2114 jni, GetObjectField(jni, j_codec, kind_id)); | |
| 2115 jobject j_clock_rate = GetNullableObjectField(jni, j_codec, clock_rate_id); | |
| 2116 if (!IsNull(jni, j_clock_rate)) { | |
| 2117 int clock_rate_value = jni->CallIntMethod(j_clock_rate, int_value_id); | |
| 2118 CHECK_EXCEPTION(jni) << "error during CallIntMethod"; | |
| 2119 codec.clock_rate = rtc::Optional<int>(clock_rate_value); | |
| 2120 } | |
| 2121 jobject j_num_channels = | |
| 2122 GetNullableObjectField(jni, j_codec, num_channels_id); | |
| 2123 if (!IsNull(jni, j_num_channels)) { | |
| 2124 int num_channels_value = jni->CallIntMethod(j_num_channels, int_value_id); | |
| 2125 CHECK_EXCEPTION(jni) << "error during CallIntMethod"; | |
| 2126 codec.num_channels = rtc::Optional<int>(num_channels_value); | |
| 2127 } | |
| 2128 parameters->codecs.push_back(codec); | |
| 2129 } | |
| 2130 } | |
| 2131 | |
| 2132 static jobject JsepRtpParametersToJavaRtpParameters( | |
| 2133 JNIEnv* jni, | |
| 2134 const webrtc::RtpParameters& parameters) { | |
| 2135 jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters"); | |
| 2136 jmethodID parameters_ctor = | |
| 2137 GetMethodID(jni, parameters_class, "<init>", "()V"); | |
| 2138 jobject j_parameters = jni->NewObject(parameters_class, parameters_ctor); | |
| 2139 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 2140 | |
| 2141 // Add encodings. | |
| 2142 jclass encoding_class = jni->FindClass("org/webrtc/RtpParameters$Encoding"); | |
| 2143 jmethodID encoding_ctor = GetMethodID(jni, encoding_class, "<init>", "()V"); | |
| 2144 jfieldID encodings_id = | |
| 2145 GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;"); | |
| 2146 jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id); | |
| 2147 jmethodID encodings_add = GetMethodID(jni, GetObjectClass(jni, j_encodings), | |
| 2148 "add", "(Ljava/lang/Object;)Z"); | |
| 2149 jfieldID active_id = GetFieldID(jni, encoding_class, "active", "Z"); | |
| 2150 jfieldID bitrate_id = | |
| 2151 GetFieldID(jni, encoding_class, "maxBitrateBps", "Ljava/lang/Integer;"); | |
| 2152 jfieldID ssrc_id = | |
| 2153 GetFieldID(jni, encoding_class, "ssrc", "Ljava/lang/Long;"); | |
| 2154 | |
| 2155 jclass integer_class = jni->FindClass("java/lang/Integer"); | |
| 2156 jclass long_class = jni->FindClass("java/lang/Long"); | |
| 2157 jmethodID integer_ctor = GetMethodID(jni, integer_class, "<init>", "(I)V"); | |
| 2158 jmethodID long_ctor = GetMethodID(jni, long_class, "<init>", "(J)V"); | |
| 2159 | |
| 2160 for (const webrtc::RtpEncodingParameters& encoding : parameters.encodings) { | |
| 2161 jobject j_encoding_parameters = | |
| 2162 jni->NewObject(encoding_class, encoding_ctor); | |
| 2163 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 2164 jni->SetBooleanField(j_encoding_parameters, active_id, encoding.active); | |
| 2165 CHECK_EXCEPTION(jni) << "error during SetBooleanField"; | |
| 2166 if (encoding.max_bitrate_bps) { | |
| 2167 jobject j_bitrate_value = jni->NewObject(integer_class, integer_ctor, | |
| 2168 *(encoding.max_bitrate_bps)); | |
| 2169 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 2170 jni->SetObjectField(j_encoding_parameters, bitrate_id, j_bitrate_value); | |
| 2171 CHECK_EXCEPTION(jni) << "error during SetObjectField"; | |
| 2172 } | |
| 2173 if (encoding.ssrc) { | |
| 2174 jobject j_ssrc_value = jni->NewObject(long_class, long_ctor, | |
| 2175 static_cast<jlong>(*encoding.ssrc)); | |
| 2176 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 2177 jni->SetObjectField(j_encoding_parameters, ssrc_id, j_ssrc_value); | |
| 2178 CHECK_EXCEPTION(jni) << "error during SetObjectField"; | |
| 2179 } | |
| 2180 jboolean added = jni->CallBooleanMethod(j_encodings, encodings_add, | |
| 2181 j_encoding_parameters); | |
| 2182 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod"; | |
| 2183 RTC_CHECK(added); | |
| 2184 } | |
| 2185 | |
| 2186 // Add codecs. | |
| 2187 jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec"); | |
| 2188 jmethodID codec_ctor = GetMethodID(jni, codec_class, "<init>", "()V"); | |
| 2189 jfieldID codecs_id = | |
| 2190 GetFieldID(jni, parameters_class, "codecs", "Ljava/util/LinkedList;"); | |
| 2191 jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id); | |
| 2192 jmethodID codecs_add = GetMethodID(jni, GetObjectClass(jni, j_codecs), "add", | |
| 2193 "(Ljava/lang/Object;)Z"); | |
| 2194 jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I"); | |
| 2195 jfieldID name_id = GetFieldID(jni, codec_class, "name", "Ljava/lang/String;"); | |
| 2196 jfieldID kind_id = GetFieldID(jni, codec_class, "kind", | |
| 2197 "Lorg/webrtc/MediaStreamTrack$MediaType;"); | |
| 2198 jfieldID clock_rate_id = | |
| 2199 GetFieldID(jni, codec_class, "clockRate", "Ljava/lang/Integer;"); | |
| 2200 jfieldID num_channels_id = | |
| 2201 GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;"); | |
| 2202 | |
| 2203 for (const webrtc::RtpCodecParameters& codec : parameters.codecs) { | |
| 2204 jobject j_codec = jni->NewObject(codec_class, codec_ctor); | |
| 2205 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 2206 jni->SetIntField(j_codec, payload_type_id, codec.payload_type); | |
| 2207 CHECK_EXCEPTION(jni) << "error during SetIntField"; | |
| 2208 jni->SetObjectField(j_codec, name_id, | |
| 2209 JavaStringFromStdString(jni, codec.name)); | |
| 2210 CHECK_EXCEPTION(jni) << "error during SetObjectField"; | |
| 2211 jni->SetObjectField(j_codec, kind_id, | |
| 2212 JsepMediaTypeToJavaMediaType(jni, codec.kind)); | |
| 2213 CHECK_EXCEPTION(jni) << "error during SetObjectField"; | |
| 2214 if (codec.clock_rate) { | |
| 2215 jobject j_clock_rate_value = | |
| 2216 jni->NewObject(integer_class, integer_ctor, *(codec.clock_rate)); | |
| 2217 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 2218 jni->SetObjectField(j_codec, clock_rate_id, j_clock_rate_value); | |
| 2219 CHECK_EXCEPTION(jni) << "error during SetObjectField"; | |
| 2220 } | |
| 2221 if (codec.num_channels) { | |
| 2222 jobject j_num_channels_value = | |
| 2223 jni->NewObject(integer_class, integer_ctor, *(codec.num_channels)); | |
| 2224 CHECK_EXCEPTION(jni) << "error during NewObject"; | |
| 2225 jni->SetObjectField(j_codec, num_channels_id, j_num_channels_value); | |
| 2226 CHECK_EXCEPTION(jni) << "error during SetObjectField"; | |
| 2227 } | |
| 2228 jboolean added = jni->CallBooleanMethod(j_codecs, codecs_add, j_codec); | |
| 2229 CHECK_EXCEPTION(jni) << "error during CallBooleanMethod"; | |
| 2230 RTC_CHECK(added); | |
| 2231 } | |
| 2232 | |
| 2233 return j_parameters; | |
| 2234 } | |
| 2235 | |
| 2236 JOW(jboolean, RtpSender_nativeSetParameters) | |
| 2237 (JNIEnv* jni, jclass, jlong j_rtp_sender_pointer, jobject j_parameters) { | |
| 2238 if (IsNull(jni, j_parameters)) { | |
| 2239 return false; | |
| 2240 } | |
| 2241 webrtc::RtpParameters parameters; | |
| 2242 JavaRtpParametersToJsepRtpParameters(jni, j_parameters, ¶meters); | |
| 2243 return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer) | |
| 2244 ->SetParameters(parameters); | |
| 2245 } | |
| 2246 | |
| 2247 JOW(jobject, RtpSender_nativeGetParameters) | |
| 2248 (JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) { | |
| 2249 webrtc::RtpParameters parameters = | |
| 2250 reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer) | |
| 2251 ->GetParameters(); | |
| 2252 return JsepRtpParametersToJavaRtpParameters(jni, parameters); | |
| 2253 } | |
| 2254 | |
| 2255 JOW(jstring, RtpSender_nativeId)( | |
| 2256 JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) { | |
| 2257 return JavaStringFromStdString( | |
| 2258 jni, reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)->id()); | |
| 2259 } | |
| 2260 | |
| 2261 JOW(void, RtpSender_free)(JNIEnv* jni, jclass, jlong j_rtp_sender_pointer) { | |
| 2262 reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)->Release(); | |
| 2263 } | |
| 2264 | |
| 2265 JOW(jlong, RtpReceiver_nativeGetTrack)(JNIEnv* jni, | |
| 2266 jclass, | |
| 2267 jlong j_rtp_receiver_pointer, | |
| 2268 jlong j_track_pointer) { | |
| 2269 return jlongFromPointer( | |
| 2270 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer) | |
| 2271 ->track() | |
| 2272 .release()); | |
| 2273 } | |
| 2274 | |
| 2275 JOW(jboolean, RtpReceiver_nativeSetParameters) | |
| 2276 (JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer, jobject j_parameters) { | |
| 2277 if (IsNull(jni, j_parameters)) { | |
| 2278 return false; | |
| 2279 } | |
| 2280 webrtc::RtpParameters parameters; | |
| 2281 JavaRtpParametersToJsepRtpParameters(jni, j_parameters, ¶meters); | |
| 2282 return reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer) | |
| 2283 ->SetParameters(parameters); | |
| 2284 } | |
| 2285 | |
| 2286 JOW(jobject, RtpReceiver_nativeGetParameters) | |
| 2287 (JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) { | |
| 2288 webrtc::RtpParameters parameters = | |
| 2289 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer) | |
| 2290 ->GetParameters(); | |
| 2291 return JsepRtpParametersToJavaRtpParameters(jni, parameters); | |
| 2292 } | |
| 2293 | |
| 2294 JOW(jstring, RtpReceiver_nativeId)( | |
| 2295 JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) { | |
| 2296 return JavaStringFromStdString( | |
| 2297 jni, | |
| 2298 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id()); | |
| 2299 } | |
| 2300 | |
| 2301 JOW(void, RtpReceiver_free) | |
| 2302 (JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) { | |
| 2303 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->Release(); | |
| 2304 } | |
| 2305 | |
| 2306 JOW(jlong, RtpReceiver_nativeSetObserver) | |
| 2307 (JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer, jobject j_observer) { | |
| 2308 RtpReceiverObserver* rtpReceiverObserver = | |
| 2309 new RtpReceiverObserver(jni, j_observer); | |
| 2310 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer) | |
| 2311 ->SetObserver(rtpReceiverObserver); | |
| 2312 return jlongFromPointer(rtpReceiverObserver); | |
| 2313 } | |
| 2314 | |
| 2315 JOW(void, RtpReceiver_nativeUnsetObserver) | |
| 2316 (JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer, jlong j_observer_pointer) { | |
| 2317 reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer) | |
| 2318 ->SetObserver(nullptr); | |
| 2319 RtpReceiverObserver* observer = | |
| 2320 reinterpret_cast<RtpReceiverObserver*>(j_observer_pointer); | |
| 2321 if (observer) { | |
| 2322 delete observer; | |
| 2323 } | |
| 2324 } | |
| 2325 | |
| 2326 JOW(jboolean, DtmfSender_nativeCanInsertDtmf) | |
| 2327 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) { | |
| 2328 return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer) | |
| 2329 ->CanInsertDtmf(); | |
| 2330 } | |
| 2331 | |
| 2332 JOW(jboolean, DtmfSender_nativeInsertDtmf) | |
| 2333 (JNIEnv* jni, | |
| 2334 jclass, | |
| 2335 jlong j_dtmf_sender_pointer, | |
| 2336 jstring tones, | |
| 2337 jint duration, | |
| 2338 jint inter_tone_gap) { | |
| 2339 return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer) | |
| 2340 ->InsertDtmf(JavaToStdString(jni, tones), duration, inter_tone_gap); | |
| 2341 } | |
| 2342 | |
| 2343 JOW(jstring, DtmfSender_nativeTones) | |
| 2344 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) { | |
| 2345 return JavaStringFromStdString( | |
| 2346 jni, | |
| 2347 reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)->tones()); | |
| 2348 } | |
| 2349 | |
| 2350 JOW(jint, DtmfSender_nativeDuration) | |
| 2351 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) { | |
| 2352 return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer) | |
| 2353 ->duration(); | |
| 2354 } | |
| 2355 | |
| 2356 JOW(jint, DtmfSender_nativeInterToneGap) | |
| 2357 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) { | |
| 2358 return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer) | |
| 2359 ->inter_tone_gap(); | |
| 2360 } | |
| 2361 | |
| 2362 JOW(void, DtmfSender_free) | |
| 2363 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) { | |
| 2364 reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)->Release(); | |
| 2365 } | |
| 2366 | |
| 2367 } // namespace webrtc_jni | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2992103002:
Relanding: Break peerconnection_jni.cc into multiple files, in "pc" directory. (Closed)
