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"

[hjon_webrtc, 2016/02/12 18:26:58]

I seem to recall that we held off on this because of symbol conflicts, though
it's not noted in https://codereview.webrtc.org/1558453002/. Thoughts on how to
proceed?

-#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/RTCConfiguration.h"
+#import "webrtc/api/objc/RTCIceServer.h"
+#import "webrtc/api/objc/RTCMediaConstraints.h"
+#import "webrtc/api/objc/RTCMediaStream.h"
+#import "webrtc/api/objc/RTCVideoCapturer.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<RTCStatsReport *> *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 {
+    didChangeSignalingState:(RTCSignalingState)stateChanged {
   RTCLog(@"Signaling state changed: %d", 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 {
+    didChangeIceConnectionState:(RTCIceConnectionState)newState {
   RTCLog(@"ICE state changed: %d", newState);
   dispatch_async(dispatch_get_main_queue(), ^{
     [_delegate appClient:self didChangeConnectionState:newState];
   });
 }
 
 - (void)peerConnection:(RTCPeerConnection *)peerConnection
-    iceGatheringChanged:(RTCICEGatheringState)newState {
+    didChangeIceGatheringState:(RTCIceGatheringState)newState {
   RTCLog(@"ICE gathering state changed: %d", 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);
@@ skipping 62 matching lines @@
 - (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]];

[hjon_webrtc, 2016/02/12 18:26:58]

Did you have any thoughts on how you wanted to handle these with the blocks API?
Such as everything inline versus having the blocks call out to methods with
common code?

+    [_peerConnection offerForConstraints:[self defaultOfferConstraints]
+                       completionHandler:^(RTCSessionDescription *sdp,
+                                           NSError *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 22 matching lines @@
       RTCSessionDescription *sdpPreferringH264 =
           [ARDSDPUtils descriptionForDescription:description
                              preferredVideoCodec:@"H264"];
       [_peerConnection setRemoteDescriptionWithDelegate:self
                                      sessionDescription:sdpPreferringH264];
       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 26 matching lines @@
   }
 }
 
 - (RTCMediaStream *)createLocalMediaStream {
   RTCMediaStream* localStream = [_factory mediaStreamWithLabel:@"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:@""];
+  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