Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(149)

Side by Side Diff: webrtc/api/objc/RTCPeerConnection.mm

Issue 1640993002: Update API for Objective-C RTCPeerConnection. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Update against master Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 /*
2 * Copyright 2015 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 #import "RTCPeerConnection.h"
12
13 #import "webrtc/api/objc/RTCPeerConnection+Private.h"
14 #import "webrtc/api/objc/RTCConfiguration+Private.h"
15 #import "webrtc/api/objc/RTCDataChannel+Private.h"
16 #import "webrtc/api/objc/RTCIceCandidate+Private.h"
17 #import "webrtc/api/objc/RTCMediaConstraints+Private.h"
18 #import "webrtc/api/objc/RTCMediaStream+Private.h"
19 #import "webrtc/api/objc/RTCPeerConnectionFactory+Private.h"
20 #import "webrtc/api/objc/RTCSessionDescription+Private.h"
21 #import "webrtc/api/objc/RTCStatsReport+Private.h"
22 #import "webrtc/base/objc/RTCLogging.h"
23 #import "webrtc/base/objc/NSString+StdString.h"
24
25 NSString * const kRTCPeerConnectionErrorDomain =
26 @"org.webrtc.RTCPeerConnection";
27 int const kRTCPeerConnnectionSessionDescriptionError = -1;
28
29 namespace webrtc {
30
31 class CreateSessionDescriptionObserverAdapter
tkchin_webrtc 2016/02/10 18:54:41 I think you can move these to the +Private too
hjon_webrtc 2016/02/11 00:25:08 Acknowledged.
32 : public CreateSessionDescriptionObserver {
33 public:
34 CreateSessionDescriptionObserverAdapter(void (^completionHandler)
35 (RTCSessionDescription *sessionDescription, NSError *error)) {
tkchin_webrtc 2016/02/10 18:54:41 formatting. I can show you irl.
hjon_webrtc 2016/02/11 00:25:08 Done.
36 completion_handler_ = completionHandler;
37 }
38
39 ~CreateSessionDescriptionObserverAdapter() {
40 completion_handler_ = nil;
41 }
42
43 void OnSuccess(SessionDescriptionInterface *desc) override {
44 rtc::scoped_ptr<webrtc::SessionDescriptionInterface> description =
45 rtc::scoped_ptr<webrtc::SessionDescriptionInterface>(desc);
46 RTCSessionDescription *session =
tkchin_webrtc 2016/02/10 18:54:40 C++ pointer style
hjon_webrtc 2016/02/11 00:25:08 Done.
47 [[RTCSessionDescription alloc] initWithNativeDescription:
48 description.get()];
49 if (completion_handler_) {
50 completion_handler_(session, nil);
tkchin_webrtc 2016/02/10 18:54:41 nil out handler after calling it? It should only b
hjon_webrtc 2016/02/11 00:25:08 Done.
51 }
52 }
53
54 void OnFailure(const std::string& error) override {
55 NSString *str = [NSString stringForStdString:error];
tkchin_webrtc 2016/02/10 18:54:41 ditto C++ pointer style
hjon_webrtc 2016/02/11 00:25:09 Done.
56 NSError *err =
57 [NSError errorWithDomain:kRTCPeerConnectionErrorDomain
58 code:kRTCPeerConnnectionSessionDescriptionError
59 userInfo:@{NSLocalizedDescriptionKey : str}];
tkchin_webrtc 2016/02/10 18:54:41 @{ NSLocal... : str }
hjon_webrtc 2016/02/11 00:25:09 Done.
60 if (completion_handler_) {
61 completion_handler_(nil, err);
tkchin_webrtc 2016/02/10 18:54:41 ditto detach
hjon_webrtc 2016/02/11 00:25:09 Done.
62 }
63 }
64
65 private:
66 void (^completion_handler_)
67 (RTCSessionDescription *sessionDescription, NSError *error);
68 };
69
70 class SetSessionDescriptionObserverAdapter :
71 public SetSessionDescriptionObserver {
72 public:
73 SetSessionDescriptionObserverAdapter(void (^completionHandler)
74 (NSError *error)) {
75 completion_handler_ = completionHandler;
76 }
77
78 ~SetSessionDescriptionObserverAdapter() {
79 completion_handler_ = nil;
80 }
81
82 void OnSuccess() override {
83 if (completion_handler_) {
84 completion_handler_(nil);
85 }
86 }
87
88 void OnFailure(const std::string& error) override {
89 NSString *str = [NSString stringForStdString:error];
90 NSError *err =
91 [NSError errorWithDomain:kRTCPeerConnectionErrorDomain
92 code:kRTCPeerConnnectionSessionDescriptionError
93 userInfo:@{NSLocalizedDescriptionKey : str}];
94 if (completion_handler_) {
95 completion_handler_(err);
96 }
97 }
98
99 private:
100 void (^completion_handler_)(NSError *error);
101 };
102
103 PeerConnectionDelegateAdapter::PeerConnectionDelegateAdapter(
104 RTCPeerConnection *peerConnection) {
105 peer_connection_ = peerConnection;
106 }
107
108 PeerConnectionDelegateAdapter::~PeerConnectionDelegateAdapter() {
tkchin_webrtc 2016/02/10 18:54:41 explicitly nil out peer_connection_
hjon_webrtc 2016/02/11 00:25:08 Done.
109 }
110
111 void PeerConnectionDelegateAdapter::OnSignalingChange(
112 PeerConnectionInterface::SignalingState new_state) {
113 RTCSignalingState state =
114 [[RTCPeerConnection class] signalingStateForNativeState:new_state];
115 RTCPeerConnection *peer_connection = peer_connection_;
116 [peer_connection.delegate peerConnection:peer_connection
tkchin_webrtc 2016/02/10 18:54:41 alignment
hjon_webrtc 2016/02/11 00:25:08 Done.
117 didChangeSignalingState:state];
118 }
119
120 void PeerConnectionDelegateAdapter::OnAddStream(
121 MediaStreamInterface *stream) {
122 RTCMediaStream *mediaStream =
123 [[RTCMediaStream alloc] initWithNativeMediaStream:stream];
124 RTCPeerConnection *peer_connection = peer_connection_;
125 [peer_connection.delegate peerConnection:peer_connection
126 addedStream:mediaStream];
tkchin_webrtc 2016/02/10 18:54:41 alignment
hjon_webrtc 2016/02/11 00:25:09 Done.
127 }
128
129 void PeerConnectionDelegateAdapter::OnRemoveStream(
130 MediaStreamInterface *stream) {
131 RTCMediaStream *mediaStream =
132 [[RTCMediaStream alloc] initWithNativeMediaStream:stream];
133 RTCPeerConnection *peer_connection = peer_connection_;
134 [peer_connection.delegate peerConnection:peer_connection
135 removedStream:mediaStream];
tkchin_webrtc 2016/02/10 18:54:41 alignment
hjon_webrtc 2016/02/11 00:25:08 Done.
136 }
137
138 void PeerConnectionDelegateAdapter::OnDataChannel(
139 DataChannelInterface *data_channel) {
140 RTCDataChannel *dataChannel =
141 [[RTCDataChannel alloc] initWithNativeDataChannel:data_channel];
142 RTCPeerConnection *peer_connection = peer_connection_;
143 [peer_connection.delegate peerConnection:peer_connection
144 didOpenDataChannel:dataChannel];
tkchin_webrtc 2016/02/10 18:54:40 alignment
hjon_webrtc 2016/02/11 00:25:09 Done.
145 }
146
147 void PeerConnectionDelegateAdapter::OnRenegotiationNeeded() {
148 RTCPeerConnection *peer_connection = peer_connection_;
149 [peer_connection.delegate peerConnectionNeedsNegotiation:peer_connection];
150 }
151
152 void PeerConnectionDelegateAdapter::OnIceConnectionChange(
153 PeerConnectionInterface::IceConnectionState new_state) {
154 RTCIceConnectionState state =
155 [[RTCPeerConnection class] iceConnectionStateForNativeState:new_state];
156 RTCPeerConnection *peer_connection = peer_connection_;
157 [peer_connection.delegate peerConnection:peer_connection
158 didChangeIceConnectionState:state];
tkchin_webrtc 2016/02/10 18:54:41 alignment
hjon_webrtc 2016/02/11 00:25:09 Done.
159 }
160
161 void PeerConnectionDelegateAdapter::OnIceGatheringChange(
162 PeerConnectionInterface::IceGatheringState new_state) {
163 RTCIceGatheringState state =
164 [[RTCPeerConnection class] iceGatheringStateForNativeState:new_state];
165 RTCPeerConnection *peer_connection = peer_connection_;
166 [peer_connection.delegate peerConnection:peer_connection
167 didChangeIceGatheringState:state];
tkchin_webrtc 2016/02/10 18:54:40 alignment
hjon_webrtc 2016/02/11 00:25:09 Done.
168 }
169
170 void PeerConnectionDelegateAdapter::OnIceCandidate(
171 const IceCandidateInterface *candidate) {
172 RTCIceCandidate *iceCandidate =
173 [[RTCIceCandidate alloc] initWithNativeCandidate:candidate];
174 RTCPeerConnection *peer_connection = peer_connection_;
175 [peer_connection.delegate peerConnection:peer_connection
176 didGenerateIceCandidate:iceCandidate];
tkchin_webrtc 2016/02/10 18:54:40 alignment
hjon_webrtc 2016/02/11 00:25:09 Done.
177 }
178 } // namespace webrtc
179
180
181 @implementation RTCPeerConnection {
182 NSMutableArray *_localStreams;
183 rtc::scoped_ptr<webrtc::PeerConnectionDelegateAdapter> _observer;
184 rtc::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
185 }
186
187 @synthesize delegate = _delegate;
188
189 - (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
190 configuration:(RTCConfiguration *)configuration
191 constraints:(RTCMediaConstraints *)constraints
192 delegate:(id<RTCPeerConnectionDelegate>)delegate {
193 NSParameterAssert(factory);
194 if (self = [super init]) {
195 _observer.reset(new webrtc::PeerConnectionDelegateAdapter(self));
196 webrtc::PeerConnectionInterface::RTCConfiguration config =
197 configuration.nativeConfiguration;
198 webrtc::MediaConstraints *nativeConstraints =
199 constraints.nativeConstraints.get();
200 _peerConnection =
201 factory.nativeFactory->CreatePeerConnection(config,
202 nativeConstraints,
203 nullptr,
204 nullptr,
205 _observer.get());
206 _localStreams = [[NSMutableArray alloc] init];
207 _delegate = delegate;
208 }
209 return self;
210 }
211
212 - (NSArray *)localStreams {
213 return [_localStreams copy];
214 }
215
216 - (RTCSessionDescription *)localDescription {
217 const webrtc::SessionDescriptionInterface *description =
218 _peerConnection->local_description();
219 return description ?
220 [[RTCSessionDescription alloc] initWithNativeDescription:description]
221 : nil;
222 }
223
224 - (RTCSessionDescription *)remoteDescription {
225 const webrtc::SessionDescriptionInterface *description =
226 _peerConnection->remote_description();
227 return description ?
228 [[RTCSessionDescription alloc] initWithNativeDescription:description]
229 : nil;
230 }
231
232 - (RTCSignalingState)signalingState {
233 return [[self class]
234 signalingStateForNativeState:_peerConnection->signaling_state()];
235 }
236
237 - (RTCIceConnectionState)iceConnectionState {
238 return [[self class] iceConnectionStateForNativeState:
239 _peerConnection->ice_connection_state()];
240 }
241
242 - (RTCIceGatheringState)iceGatheringState {
243 return [[self class] iceGatheringStateForNativeState:
244 _peerConnection->ice_gathering_state()];
245 }
246
247 - (void)close {
248 _peerConnection->Close();
249 }
250
251 - (void)addIceCandidate:(RTCIceCandidate *)candidate {
252 rtc::scoped_ptr<const webrtc::IceCandidateInterface> iceCandidate(
253 candidate.nativeCandidate);
254 _peerConnection->AddIceCandidate(iceCandidate.get());
255 }
256
257 - (void)addStream:(RTCMediaStream *)stream {
258 if (_peerConnection->AddStream(stream.nativeMediaStream)) {
259 RTCLogError(@"Failed to create add stream: %@", stream);
tkchin_webrtc 2016/02/10 18:54:40 Failed to add stream
hjon_webrtc 2016/02/11 00:25:08 Done.
260 return;
261 }
262 [_localStreams addObject:stream];
263 }
264
265 - (void)removeStream:(RTCMediaStream *)stream {
266 _peerConnection->RemoveStream(stream.nativeMediaStream);
267 [_localStreams removeObject:stream];
268 }
269
270 - (void)offerForConstraints:(RTCMediaConstraints *)constraints
271 completionHandler:
272 (void (^)(RTCSessionDescription *sessionDescription, NSError *error))
tkchin_webrtc 2016/02/10 18:54:40 formatting
hjon_webrtc 2016/02/11 00:25:09 Done.
273 completionHandler {
274 rtc::scoped_refptr<webrtc::CreateSessionDescriptionObserverAdapter>
275 observer(new rtc::RefCountedObject
276 <webrtc::CreateSessionDescriptionObserverAdapter>(completionHandler));
277 _peerConnection->CreateOffer(observer, constraints.nativeConstraints.get());
278 }
279
280 - (void)answerForConstraints:(RTCMediaConstraints *)constraints
281 completionHandler:
282 (void (^)(RTCSessionDescription *sessionDescription, NSError *error))
tkchin_webrtc 2016/02/10 18:54:41 formatting
hjon_webrtc 2016/02/11 00:25:09 Done.
283 completionHandler {
284 rtc::scoped_refptr<webrtc::CreateSessionDescriptionObserverAdapter>
285 observer(new rtc::RefCountedObject
286 <webrtc::CreateSessionDescriptionObserverAdapter>(completionHandler));
287 _peerConnection->CreateAnswer(observer, constraints.nativeConstraints.get());
288 }
289
290 - (void)setLocalDescription:(RTCSessionDescription *)sdp
291 completionHandler:(void (^)(NSError *error))completionHandler {
292 rtc::scoped_refptr<webrtc::SetSessionDescriptionObserverAdapter> observer(
293 new rtc::RefCountedObject<webrtc::SetSessionDescriptionObserverAdapter>
294 (completionHandler));
tkchin_webrtc 2016/02/10 18:54:40 ( on previous line
hjon_webrtc 2016/02/11 00:25:09 Done.
295 _peerConnection->SetLocalDescription(observer, sdp.nativeDescription);
296 }
297
298 - (void)setRemoteDescription:(RTCSessionDescription *)sdp
299 completionHandler:(void (^)(NSError *error))completionHandler {
300 rtc::scoped_refptr<webrtc::SetSessionDescriptionObserverAdapter> observer(
301 new rtc::RefCountedObject<webrtc::SetSessionDescriptionObserverAdapter>
302 (completionHandler));
tkchin_webrtc 2016/02/10 18:54:40 ( on previous line
hjon_webrtc 2016/02/11 00:25:09 Done.
303 _peerConnection->SetRemoteDescription(observer, sdp.nativeDescription);
304 }
305
306 #pragma mark - Private
307
308 - (rtc::scoped_refptr<webrtc::PeerConnectionInterface>)nativePeerConnection {
tkchin_webrtc 2016/02/10 18:54:41 static methods first, move this after all the clas
hjon_webrtc 2016/02/11 00:25:08 Done.
309 return _peerConnection;
310 }
311
312 + (webrtc::PeerConnectionInterface::SignalingState)nativeSignalingStateForState:
313 (RTCSignalingState)state {
314 switch (state) {
315 case RTCSignalingStateStable:
316 return webrtc::PeerConnectionInterface::kStable;
317 case RTCSignalingStateHaveLocalOffer:
318 return webrtc::PeerConnectionInterface::kHaveLocalOffer;
319 case RTCSignalingStateHaveLocalPrAnswer:
320 return webrtc::PeerConnectionInterface::kHaveLocalPrAnswer;
321 case RTCSignalingStateHaveRemoteOffer:
322 return webrtc::PeerConnectionInterface::kHaveRemoteOffer;
323 case RTCSignalingStateHaveRemotePrAnswer:
324 return webrtc::PeerConnectionInterface::kHaveRemotePrAnswer;
325 case RTCSignalingStateClosed:
326 return webrtc::PeerConnectionInterface::kClosed;
327 }
328 }
329
330 + (RTCSignalingState)signalingStateForNativeState:
331 (webrtc::PeerConnectionInterface::SignalingState)nativeState {
332 switch (nativeState) {
333 case webrtc::PeerConnectionInterface::kStable:
334 return RTCSignalingStateStable;
335 case webrtc::PeerConnectionInterface::kHaveLocalOffer:
336 return RTCSignalingStateHaveLocalOffer;
337 case webrtc::PeerConnectionInterface::kHaveLocalPrAnswer:
338 return RTCSignalingStateHaveLocalPrAnswer;
339 case webrtc::PeerConnectionInterface::kHaveRemoteOffer:
340 return RTCSignalingStateHaveRemoteOffer;
341 case webrtc::PeerConnectionInterface::kHaveRemotePrAnswer:
342 return RTCSignalingStateHaveRemotePrAnswer;
343 case webrtc::PeerConnectionInterface::kClosed:
344 return RTCSignalingStateClosed;
345 }
346 }
347
348 + (NSString *)stringForSignalingState:(RTCSignalingState)state {
349 switch (state) {
350 case RTCSignalingStateStable:
351 return @"STABLE";
352 case RTCSignalingStateHaveLocalOffer:
353 return @"HAVE_LOCAL_OFFER";
354 case RTCSignalingStateHaveLocalPrAnswer:
355 return @"HAVE_LOCAL_PRANSWER";
356 case RTCSignalingStateHaveRemoteOffer:
357 return @"HAVE_REMOTE_OFFER";
358 case RTCSignalingStateHaveRemotePrAnswer:
359 return @"HAVE_REMOTE_PRANSWER";
360 case RTCSignalingStateClosed:
361 return @"CLOSED";
362 }
363 }
364
365 + (webrtc::PeerConnectionInterface::IceConnectionState)
366 nativeIceConnectionStateForState:(RTCIceConnectionState)state {
367 switch (state) {
368 case RTCIceConnectionStateNew:
369 return webrtc::PeerConnectionInterface::kIceConnectionNew;
370 case RTCIceConnectionStateChecking:
371 return webrtc::PeerConnectionInterface::kIceConnectionChecking;
372 case RTCIceConnectionStateConnected:
373 return webrtc::PeerConnectionInterface::kIceConnectionConnected;
374 case RTCIceConnectionStateCompleted:
375 return webrtc::PeerConnectionInterface::kIceConnectionCompleted;
376 case RTCIceConnectionStateFailed:
377 return webrtc::PeerConnectionInterface::kIceConnectionFailed;
378 case RTCIceConnectionStateDisconnected:
379 return webrtc::PeerConnectionInterface::kIceConnectionDisconnected;
380 case RTCIceConnectionStateClosed:
381 return webrtc::PeerConnectionInterface::kIceConnectionClosed;
382 case RTCIceConnectionStateMax:
383 return webrtc::PeerConnectionInterface::kIceConnectionMax;
384 }
385 }
386
387 + (RTCIceConnectionState)iceConnectionStateForNativeState:
388 (webrtc::PeerConnectionInterface::IceConnectionState)nativeState {
389 switch (nativeState) {
390 case webrtc::PeerConnectionInterface::kIceConnectionNew:
391 return RTCIceConnectionStateNew;
392 case webrtc::PeerConnectionInterface::kIceConnectionChecking:
393 return RTCIceConnectionStateChecking;
394 case webrtc::PeerConnectionInterface::kIceConnectionConnected:
395 return RTCIceConnectionStateConnected;
396 case webrtc::PeerConnectionInterface::kIceConnectionCompleted:
397 return RTCIceConnectionStateCompleted;
398 case webrtc::PeerConnectionInterface::kIceConnectionFailed:
399 return RTCIceConnectionStateFailed;
400 case webrtc::PeerConnectionInterface::kIceConnectionDisconnected:
401 return RTCIceConnectionStateDisconnected;
402 case webrtc::PeerConnectionInterface::kIceConnectionClosed:
403 return RTCIceConnectionStateClosed;
404 case webrtc::PeerConnectionInterface::kIceConnectionMax:
405 return RTCIceConnectionStateMax;
406 }
407 }
408
409 + (NSString *)stringForIceConnectionState:(RTCIceConnectionState)state {
410 switch (state) {
411 case RTCIceConnectionStateNew:
412 return @"NEW";
413 case RTCIceConnectionStateChecking:
414 return @"CHECKING";
415 case RTCIceConnectionStateConnected:
416 return @"CONNECTED";
417 case RTCIceConnectionStateCompleted:
418 return @"COMPLETED";
419 case RTCIceConnectionStateFailed:
420 return @"FAILED";
421 case RTCIceConnectionStateDisconnected:
422 return @"DISCONNECTED";
423 case RTCIceConnectionStateClosed:
424 return @"CLOSED";
425 case RTCIceConnectionStateMax:
426 return @"MAX";
427 }
428 }
429
430 + (webrtc::PeerConnectionInterface::IceGatheringState)
431 nativeIceGatheringStateForState:(RTCIceGatheringState)state {
432 switch (state) {
433 case RTCIceGatheringStateNew:
434 return webrtc::PeerConnectionInterface::kIceGatheringNew;
435 case RTCIceGatheringStateGathering:
436 return webrtc::PeerConnectionInterface::kIceGatheringGathering;
437 case RTCIceGatheringStateComplete:
438 return webrtc::PeerConnectionInterface::kIceGatheringComplete;
439 }
440 }
441
442 + (RTCIceGatheringState)iceGatheringStateForNativeState:
443 (webrtc::PeerConnectionInterface::IceGatheringState)nativeState {
444 switch (nativeState) {
445 case webrtc::PeerConnectionInterface::kIceGatheringNew:
446 return RTCIceGatheringStateNew;
447 case webrtc::PeerConnectionInterface::kIceGatheringGathering:
448 return RTCIceGatheringStateGathering;
449 case webrtc::PeerConnectionInterface::kIceGatheringComplete:
450 return RTCIceGatheringStateComplete;
451 }
452 }
453
454 + (NSString *)stringForIceGatheringState:(RTCIceGatheringState)state {
455 switch (state) {
456 case RTCIceGatheringStateNew:
457 return @"NEW";
458 case RTCIceGatheringStateGathering:
459 return @"GATHERING";
460 case RTCIceGatheringStateComplete:
461 return @"COMPLETE";
462 }
463 }
464
465 + (webrtc::PeerConnectionInterface::StatsOutputLevel)
466 nativeStatsOutputLevelForLevel:(RTCStatsOutputLevel)level {
467 switch (level) {
468 case RTCStatsOutputLevelStandard:
469 return webrtc::PeerConnectionInterface::kStatsOutputLevelStandard;
470 case RTCStatsOutputLevelDebug:
471 return webrtc::PeerConnectionInterface::kStatsOutputLevelDebug;
472 }
473 }
474
475 @end
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698