Update iOS AppRTCDemo to use the updated Objective-C API.

webrtc/examples/objc/AppRTCDemo/ARDAppClient.m

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #import "ARDAppClient+Internal.h"
 
 #if defined(WEBRTC_IOS)
 #import "webrtc/base/objc/RTCTracing.h"
-#import "RTCAVFoundationVideoSource.h"
+#import "webrtc/api/objc/RTCAVFoundationVideoSource.h"
 #endif
-#import "RTCFileLogger.h"
-#import "RTCICEServer.h"
-#import "RTCLogging.h"
-#import "RTCMediaConstraints.h"
-#import "RTCMediaStream.h"
-#import "RTCPair.h"
-#import "RTCPeerConnectionInterface.h"
-#import "RTCVideoCapturer.h"
+#import "webrtc/api/objc/RTCAudioTrack.h"
+#import "webrtc/api/objc/RTCConfiguration.h"
+#import "webrtc/api/objc/RTCIceServer.h"
+#import "webrtc/api/objc/RTCMediaConstraints.h"
+#import "webrtc/api/objc/RTCMediaStream.h"
+#import "webrtc/api/objc/RTCPeerConnectionFactory.h"
+#import "webrtc/base/objc/RTCFileLogger.h"
+#import "webrtc/base/objc/RTCLogging.h"
 
 #import "ARDAppEngineClient.h"
 #import "ARDCEODTURNClient.h"
 #import "ARDJoinResponse.h"
 #import "ARDMessageResponse.h"
 #import "ARDSDPUtils.h"
 #import "ARDSignalingMessage.h"
 #import "ARDUtilities.h"
 #import "ARDWebSocketChannel.h"
-#import "RTCICECandidate+JSON.h"
+#import "RTCIceCandidate+JSON.h"
 #import "RTCSessionDescription+JSON.h"
 
 static NSString * const kARDDefaultSTUNServerUrl =
     @"stun:stun.l.google.com:19302";
 // TODO(tkchin): figure out a better username for CEOD statistics.
 static NSString * const kARDTurnRequestUrl =
     @"https://computeengineondemand.appspot.com"
     @"/turn?username=iapprtc&key=4080218913";
 
 static NSString * const kARDAppClientErrorDomain = @"ARDAppClient";
@@ skipping 136 matching lines @@
 - (void)setShouldGetStats:(BOOL)shouldGetStats {
   if (_shouldGetStats == shouldGetStats) {
     return;
   }
   if (shouldGetStats) {
     __weak ARDAppClient *weakSelf = self;
     _statsTimer = [[ARDTimerProxy alloc] initWithInterval:1
                                                   repeats:YES
                                              timerHandler:^{
       ARDAppClient *strongSelf = weakSelf;
-      [strongSelf.peerConnection getStatsWithDelegate:strongSelf
-                                     mediaStreamTrack:nil
-                                     statsOutputLevel:RTCStatsOutputLevelDebug];
+      [strongSelf.peerConnection statsForTrack:nil
+                              statsOutputLevel:RTCStatsOutputLevelDebug
+                             completionHandler:^(NSArray *stats) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+          ARDAppClient *strongSelf = weakSelf;
+          [strongSelf.delegate appClient:strongSelf didGetStats:stats];
+        });
+      }];
     }];
   } else {
     [_statsTimer invalidate];
     _statsTimer = nil;
   }
   _shouldGetStats = shouldGetStats;
 }
 
 - (void)setState:(ARDAppClientState)state {
   if (_state == state) {
@@ skipping 141 matching lines @@
       [self disconnect];
       break;
   }
 }
 
 #pragma mark - RTCPeerConnectionDelegate
 // Callbacks for this delegate occur on non-main thread and need to be
 // dispatched back to main queue as needed.
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
-    signalingStateChanged:(RTCSignalingState)stateChanged {
-  RTCLog(@"Signaling state changed: %d", stateChanged);
+    didChangeSignalingState:(RTCSignalingState)stateChanged {
+  RTCLog(@"Signaling state changed: %ld", (long)stateChanged);
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
-           addedStream:(RTCMediaStream *)stream {
+          didAddStream:(RTCMediaStream *)stream {
   dispatch_async(dispatch_get_main_queue(), ^{
     RTCLog(@"Received %lu video tracks and %lu audio tracks",
         (unsigned long)stream.videoTracks.count,
         (unsigned long)stream.audioTracks.count);
     if (stream.videoTracks.count) {
       RTCVideoTrack *videoTrack = stream.videoTracks[0];
       [_delegate appClient:self didReceiveRemoteVideoTrack:videoTrack];
     }
   });
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
-        removedStream:(RTCMediaStream *)stream {
+       didRemoveStream:(RTCMediaStream *)stream {
   RTCLog(@"Stream was removed.");
 }
 
-- (void)peerConnectionOnRenegotiationNeeded:
-    (RTCPeerConnection *)peerConnection {
+- (void)peerConnectionShouldNegotiate:(RTCPeerConnection *)peerConnection {
   RTCLog(@"WARNING: Renegotiation needed but unimplemented.");
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
-    iceConnectionChanged:(RTCICEConnectionState)newState {
-  RTCLog(@"ICE state changed: %d", newState);
+    didChangeIceConnectionState:(RTCIceConnectionState)newState {
+  RTCLog(@"ICE state changed: %ld", (long)newState);
   dispatch_async(dispatch_get_main_queue(), ^{
     [_delegate appClient:self didChangeConnectionState:newState];
   });
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
-    iceGatheringChanged:(RTCICEGatheringState)newState {
-  RTCLog(@"ICE gathering state changed: %d", newState);
+    didChangeIceGatheringState:(RTCIceGatheringState)newState {
+  RTCLog(@"ICE gathering state changed: %ld", (long)newState);
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
-       gotICECandidate:(RTCICECandidate *)candidate {
+    didGenerateIceCandidate:(RTCIceCandidate *)candidate {
   dispatch_async(dispatch_get_main_queue(), ^{
     ARDICECandidateMessage *message =
         [[ARDICECandidateMessage alloc] initWithCandidate:candidate];
     [self sendSignalingMessage:message];
   });
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
     didOpenDataChannel:(RTCDataChannel *)dataChannel {
 }
 
-#pragma mark - RTCStatsDelegate
-
-- (void)peerConnection:(RTCPeerConnection *)peerConnection
-           didGetStats:(NSArray *)stats {
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [_delegate appClient:self didGetStats:stats];
-  });
-}
-
 #pragma mark - RTCSessionDescriptionDelegate
 // Callbacks for this delegate occur on non-main thread and need to be
 // dispatched back to main queue as needed.
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
     didCreateSessionDescription:(RTCSessionDescription *)sdp
                           error:(NSError *)error {
   dispatch_async(dispatch_get_main_queue(), ^{
     if (error) {
       RTCLogError(@"Failed to create session description. Error: %@", error);
       [self disconnect];
       NSDictionary *userInfo = @{
         NSLocalizedDescriptionKey: @"Failed to create session description.",
       };
       NSError *sdpError =
           [[NSError alloc] initWithDomain:kARDAppClientErrorDomain
                                      code:kARDAppClientErrorCreateSDP
                                  userInfo:userInfo];
       [_delegate appClient:self didError:sdpError];
       return;
     }
     // Prefer H264 if available.
     RTCSessionDescription *sdpPreferringH264 =
         [ARDSDPUtils descriptionForDescription:sdp
                            preferredVideoCodec:@"H264"];
-    [_peerConnection setLocalDescriptionWithDelegate:self
-                                  sessionDescription:sdpPreferringH264];
+    __weak ARDAppClient *weakSelf = self;
+    [_peerConnection setLocalDescription:sdpPreferringH264
+                       completionHandler:^(NSError *error) {
+      ARDAppClient *strongSelf = weakSelf;
+      [strongSelf peerConnection:strongSelf.peerConnection
+          didSetSessionDescriptionWithError:error];
+    }];
     ARDSessionDescriptionMessage *message =
         [[ARDSessionDescriptionMessage alloc]
             initWithDescription:sdpPreferringH264];
     [self sendSignalingMessage:message];
   });
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
     didSetSessionDescriptionWithError:(NSError *)error {
   dispatch_async(dispatch_get_main_queue(), ^{
     if (error) {
       RTCLogError(@"Failed to set session description. Error: %@", error);
       [self disconnect];
       NSDictionary *userInfo = @{
         NSLocalizedDescriptionKey: @"Failed to set session description.",
       };
       NSError *sdpError =
           [[NSError alloc] initWithDomain:kARDAppClientErrorDomain
                                      code:kARDAppClientErrorSetSDP
                                  userInfo:userInfo];
       [_delegate appClient:self didError:sdpError];
       return;
     }
     // If we're answering and we've just set the remote offer we need to create
     // an answer and set the local description.
     if (!_isInitiator && !_peerConnection.localDescription) {
       RTCMediaConstraints *constraints = [self defaultAnswerConstraints];
-      [_peerConnection createAnswerWithDelegate:self
-                                    constraints:constraints];
-
+      __weak ARDAppClient *weakSelf = self;
+      [_peerConnection answerForConstraints:constraints
+                          completionHandler:^(RTCSessionDescription *sdp,
+                                              NSError *error) {
+        ARDAppClient *strongSelf = weakSelf;
+        [strongSelf peerConnection:strongSelf.peerConnection
+            didCreateSessionDescription:sdp
+                                  error:error];
+      }];
     }
   });
 }
 
 #pragma mark - Private
 
 - (BOOL)hasJoinedRoomServerRoom {
   return _clientId.length;
 }
 
 // Begins the peer connection connection process if we have both joined a room
 // on the room server and tried to obtain a TURN server. Otherwise does nothing.
 // A peer connection object will be created with a stream that contains local
 // audio and video capture. If this client is the caller, an offer is created as
 // well, otherwise the client will wait for an offer to arrive.
 - (void)startSignalingIfReady {
   if (!_isTurnComplete || !self.hasJoinedRoomServerRoom) {
     return;
   }
   self.state = kARDAppClientStateConnected;
 
   // Create peer connection.
   RTCMediaConstraints *constraints = [self defaultPeerConnectionConstraints];
   RTCConfiguration *config = [[RTCConfiguration alloc] init];
   config.iceServers = _iceServers;
-  _peerConnection = [_factory peerConnectionWithConfiguration:config
-                                                  constraints:constraints
-                                                     delegate:self];
+  _peerConnection = [[RTCPeerConnection alloc] initWithFactory:_factory
+                                                 configuration:config
+                                                   constraints:constraints
+                                                      delegate:self];
   // Create AV media stream and add it to the peer connection.
   RTCMediaStream *localStream = [self createLocalMediaStream];
   [_peerConnection addStream:localStream];
   if (_isInitiator) {
     // Send offer.
-    [_peerConnection createOfferWithDelegate:self
-                                 constraints:[self defaultOfferConstraints]];
+    __weak ARDAppClient *weakSelf = self;
+    [_peerConnection offerForConstraints:[self defaultOfferConstraints]
+                       completionHandler:^(RTCSessionDescription *sdp,
+                                           NSError *error) {
+      ARDAppClient *strongSelf = weakSelf;
+      [strongSelf peerConnection:strongSelf.peerConnection
+          didCreateSessionDescription:sdp
+                                error:error];
+    }];
   } else {
     // Check if we've received an offer.
     [self drainMessageQueueIfReady];
   }
 }
 
 // Processes the messages that we've received from the room server and the
 // signaling channel. The offer or answer message must be processed before other
 // signaling messages, however they can arrive out of order. Hence, this method
 // only processes pending messages if there is a peer connection object and
@@ skipping 15 matching lines @@
   switch (message.type) {
     case kARDSignalingMessageTypeOffer:
     case kARDSignalingMessageTypeAnswer: {
       ARDSessionDescriptionMessage *sdpMessage =
           (ARDSessionDescriptionMessage *)message;
       RTCSessionDescription *description = sdpMessage.sessionDescription;
       // Prefer H264 if available.
       RTCSessionDescription *sdpPreferringH264 =
           [ARDSDPUtils descriptionForDescription:description
                              preferredVideoCodec:@"H264"];
-      [_peerConnection setRemoteDescriptionWithDelegate:self
-                                     sessionDescription:sdpPreferringH264];
+      __weak ARDAppClient *weakSelf = self;
+      [_peerConnection setRemoteDescription:sdpPreferringH264
+                          completionHandler:^(NSError *error) {
+        ARDAppClient *strongSelf = weakSelf;
+        [strongSelf peerConnection:strongSelf.peerConnection
+            didSetSessionDescriptionWithError:error];
+      }];
       break;
     }
     case kARDSignalingMessageTypeCandidate: {
       ARDICECandidateMessage *candidateMessage =
           (ARDICECandidateMessage *)message;
-      [_peerConnection addICECandidate:candidateMessage.candidate];
+      [_peerConnection addIceCandidate:candidateMessage.candidate];
       break;
     }
     case kARDSignalingMessageTypeBye:
       // Other client disconnected.
       // TODO(tkchin): support waiting in room for next client. For now just
       // disconnect.
       [self disconnect];
       break;
   }
 }
@@ skipping 20 matching lines @@
         [strongSelf.delegate appClient:strongSelf didError:messageError];
         return;
       }
     }];
   } else {
     [_channel sendMessage:message];
   }
 }
 
 - (RTCMediaStream *)createLocalMediaStream {
-  RTCMediaStream* localStream = [_factory mediaStreamWithLabel:@"ARDAMS"];
-  RTCVideoTrack* localVideoTrack = [self createLocalVideoTrack];
+  RTCMediaStream *localStream =
+      [[RTCMediaStream alloc] initWithFactory:_factory streamId:@"ARDAMS"];
+  RTCVideoTrack *localVideoTrack = [self createLocalVideoTrack];
   if (localVideoTrack) {
     [localStream addVideoTrack:localVideoTrack];
     [_delegate appClient:self didReceiveLocalVideoTrack:localVideoTrack];
   }
-  [localStream addAudioTrack:[_factory audioTrackWithID:@"ARDAMSa0"]];
+  RTCAudioTrack *localAudioTrack =
+        [[RTCAudioTrack alloc] initWithFactory:_factory
+                                       trackId:@"ARDAMSa0"];
+  [localStream addAudioTrack:localAudioTrack];
   return localStream;
 }
 
 - (RTCVideoTrack *)createLocalVideoTrack {
   RTCVideoTrack* localVideoTrack = nil;
   // The iOS simulator doesn't provide any sort of camera capture
   // support or emulation (http://goo.gl/rHAnC1) so don't bother
   // trying to open a local stream.
   // TODO(tkchin): local video capture for OSX. See
   // https://code.google.com/p/webrtc/issues/detail?id=3417.
@@ skipping 45 matching lines @@
           initWithMandatoryConstraints:nil
                    optionalConstraints:nil];
   return constraints;
 }
 
 - (RTCMediaConstraints *)defaultAnswerConstraints {
   return [self defaultOfferConstraints];
 }
 
 - (RTCMediaConstraints *)defaultOfferConstraints {
-  NSArray *mandatoryConstraints = @[
-      [[RTCPair alloc] initWithKey:@"OfferToReceiveAudio" value:@"true"],
-      [[RTCPair alloc] initWithKey:@"OfferToReceiveVideo" value:@"true"]
-  ];
+  NSDictionary *mandatoryConstraints = @{
+    @"OfferToReceiveAudio" : @"true",
+    @"OfferToReceiveVideo" : @"true"
+  };
   RTCMediaConstraints* constraints =
       [[RTCMediaConstraints alloc]
           initWithMandatoryConstraints:mandatoryConstraints
                    optionalConstraints:nil];
   return constraints;
 }
 
 - (RTCMediaConstraints *)defaultPeerConnectionConstraints {
   if (_defaultPeerConnectionConstraints) {
     return _defaultPeerConnectionConstraints;
   }
   NSString *value = _isLoopback ? @"false" : @"true";
-  NSArray *optionalConstraints = @[
-      [[RTCPair alloc] initWithKey:@"DtlsSrtpKeyAgreement" value:value]
-  ];
+  NSDictionary *optionalConstraints = @{ @"DtlsSrtpKeyAgreement" : value };
   RTCMediaConstraints* constraints =
       [[RTCMediaConstraints alloc]
           initWithMandatoryConstraints:nil
                    optionalConstraints:optionalConstraints];
   return constraints;
 }
 
-- (RTCICEServer *)defaultSTUNServer {
-  NSURL *defaultSTUNServerURL = [NSURL URLWithString:kARDDefaultSTUNServerUrl];
-  return [[RTCICEServer alloc] initWithURI:defaultSTUNServerURL
-                                  username:@""
-                                  password:@""];
+- (RTCIceServer *)defaultSTUNServer {
+  return [[RTCIceServer alloc] initWithURLStrings:@[kARDDefaultSTUNServerUrl]
+                                         username:@""
+                                       credential:@""];
 }
 
 #pragma mark - Errors
 
 + (NSError *)errorForJoinResultType:(ARDJoinResultType)resultType {
   NSError *error = nil;
   switch (resultType) {
     case kARDJoinResultTypeSuccess:
       break;
     case kARDJoinResultTypeUnknown: {
@@ skipping 40 matching lines @@
                                          code:kARDAppClientErrorInvalidRoom
                                      userInfo:@{
         NSLocalizedDescriptionKey: @"Invalid room.",
       }];
       break;
   }
   return error;
 }
 
 @end