2013-07-10 02:45:36 +02:00
|
|
|
/*
|
|
|
|
* libjingle
|
2014-05-31 00:26:06 +02:00
|
|
|
* Copyright 2014, Google Inc.
|
2013-07-10 02:45:36 +02:00
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
|
* and/or other materials provided with the distribution.
|
|
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
|
|
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
#import "APPRTCConnectionManager.h"
|
2013-07-10 02:45:36 +02:00
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
#import <AVFoundation/AVFoundation.h>
|
|
|
|
#import "APPRTCAppClient.h"
|
|
|
|
#import "GAEChannelClient.h"
|
2013-08-01 20:29:45 +02:00
|
|
|
#import "RTCICECandidate.h"
|
2013-07-10 02:45:36 +02:00
|
|
|
#import "RTCMediaConstraints.h"
|
|
|
|
#import "RTCMediaStream.h"
|
|
|
|
#import "RTCPair.h"
|
|
|
|
#import "RTCPeerConnection.h"
|
|
|
|
#import "RTCPeerConnectionDelegate.h"
|
|
|
|
#import "RTCPeerConnectionFactory.h"
|
|
|
|
#import "RTCSessionDescription.h"
|
2014-05-31 00:26:06 +02:00
|
|
|
#import "RTCSessionDescriptionDelegate.h"
|
2014-04-22 23:05:38 +02:00
|
|
|
#import "RTCStatsDelegate.h"
|
2014-03-10 21:41:22 +01:00
|
|
|
#import "RTCVideoCapturer.h"
|
2014-05-31 00:26:06 +02:00
|
|
|
#import "RTCVideoSource.h"
|
2013-07-10 02:45:36 +02:00
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
@interface APPRTCConnectionManager ()
|
|
|
|
<APPRTCAppClientDelegate, GAEMessageHandler, RTCPeerConnectionDelegate,
|
|
|
|
RTCSessionDescriptionDelegate, RTCStatsDelegate>
|
2013-07-10 02:45:36 +02:00
|
|
|
|
2014-03-25 01:11:56 +01:00
|
|
|
@property(nonatomic, strong) APPRTCAppClient* client;
|
|
|
|
@property(nonatomic, strong) RTCPeerConnection* peerConnection;
|
|
|
|
@property(nonatomic, strong) RTCPeerConnectionFactory* peerConnectionFactory;
|
2014-05-31 00:26:06 +02:00
|
|
|
@property(nonatomic, strong) RTCVideoSource* videoSource;
|
2014-03-25 01:11:56 +01:00
|
|
|
@property(nonatomic, strong) NSMutableArray* queuedRemoteCandidates;
|
2013-07-10 02:45:36 +02:00
|
|
|
|
|
|
|
@end
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
@implementation APPRTCConnectionManager {
|
2014-04-22 23:05:38 +02:00
|
|
|
NSTimer* _statsTimer;
|
|
|
|
}
|
2013-07-10 02:45:36 +02:00
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
- (instancetype)initWithDelegate:(id<APPRTCConnectionManagerDelegate>)delegate
|
|
|
|
logger:(id<APPRTCLogger>)logger {
|
|
|
|
if (self = [super init]) {
|
|
|
|
self.delegate = delegate;
|
|
|
|
self.logger = logger;
|
|
|
|
self.peerConnectionFactory = [[RTCPeerConnectionFactory alloc] init];
|
|
|
|
// TODO(tkchin): turn this into a button.
|
|
|
|
// Uncomment for stat logs.
|
|
|
|
// _statsTimer =
|
|
|
|
// [NSTimer scheduledTimerWithTimeInterval:10
|
|
|
|
// target:self
|
|
|
|
// selector:@selector(didFireStatsTimer:)
|
|
|
|
// userInfo:nil
|
|
|
|
// repeats:YES];
|
|
|
|
}
|
|
|
|
return self;
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
- (void)dealloc {
|
|
|
|
[self disconnect];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
- (BOOL)connectToRoomWithURL:(NSURL*)url {
|
2013-07-10 02:45:36 +02:00
|
|
|
if (self.client) {
|
2014-05-31 00:26:06 +02:00
|
|
|
// Already have a connection.
|
2013-07-10 02:45:36 +02:00
|
|
|
return NO;
|
|
|
|
}
|
2014-05-31 00:26:06 +02:00
|
|
|
self.client = [[APPRTCAppClient alloc] initWithDelegate:self
|
|
|
|
messageHandler:self];
|
2013-07-10 02:45:36 +02:00
|
|
|
[self.client connectToRoom:url];
|
|
|
|
return YES;
|
|
|
|
}
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
- (void)disconnect {
|
|
|
|
if (!self.client) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
[self.client
|
|
|
|
sendData:[@"{\"type\": \"bye\"}" dataUsingEncoding:NSUTF8StringEncoding]];
|
|
|
|
[self.peerConnection close];
|
|
|
|
self.peerConnection = nil;
|
|
|
|
self.client = nil;
|
2014-06-04 22:19:39 +02:00
|
|
|
self.videoSource = nil;
|
2014-05-31 00:26:06 +02:00
|
|
|
self.queuedRemoteCandidates = nil;
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
#pragma mark - APPRTCAppClientDelegate
|
2013-07-10 02:45:36 +02:00
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
- (void)appClient:(APPRTCAppClient*)appClient
|
|
|
|
didErrorWithMessage:(NSString*)message {
|
|
|
|
[self.delegate connectionManager:self
|
|
|
|
didErrorWithMessage:message];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
- (void)appClient:(APPRTCAppClient*)appClient
|
|
|
|
didReceiveICEServers:(NSArray*)servers {
|
2013-07-10 02:45:36 +02:00
|
|
|
self.queuedRemoteCandidates = [NSMutableArray array];
|
2014-03-25 01:11:56 +01:00
|
|
|
RTCMediaConstraints* constraints = [[RTCMediaConstraints alloc]
|
|
|
|
initWithMandatoryConstraints:
|
|
|
|
@[
|
|
|
|
[[RTCPair alloc] initWithKey:@"OfferToReceiveAudio" value:@"true"],
|
|
|
|
[[RTCPair alloc] initWithKey:@"OfferToReceiveVideo" value:@"true"]
|
|
|
|
]
|
|
|
|
optionalConstraints:
|
|
|
|
@[
|
|
|
|
[[RTCPair alloc] initWithKey:@"internalSctpDataChannels"
|
|
|
|
value:@"true"],
|
|
|
|
[[RTCPair alloc] initWithKey:@"DtlsSrtpKeyAgreement"
|
|
|
|
value:@"true"]
|
|
|
|
]];
|
2013-07-10 02:45:36 +02:00
|
|
|
self.peerConnection =
|
2013-08-01 20:29:45 +02:00
|
|
|
[self.peerConnectionFactory peerConnectionWithICEServers:servers
|
2013-07-10 02:45:36 +02:00
|
|
|
constraints:constraints
|
2014-05-31 00:26:06 +02:00
|
|
|
delegate:self];
|
2014-03-25 01:11:56 +01:00
|
|
|
RTCMediaStream* lms =
|
2013-07-10 02:45:36 +02:00
|
|
|
[self.peerConnectionFactory mediaStreamWithLabel:@"ARDAMS"];
|
2014-03-10 21:41:22 +01:00
|
|
|
|
2014-03-31 22:22:19 +02:00
|
|
|
// 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.
|
|
|
|
RTCVideoTrack* localVideoTrack;
|
2014-05-31 00:26:06 +02:00
|
|
|
|
|
|
|
// TODO(tkchin): local video capture for OSX. See
|
|
|
|
// https://code.google.com/p/webrtc/issues/detail?id=3417.
|
|
|
|
#if !TARGET_IPHONE_SIMULATOR && TARGET_OS_IPHONE
|
2014-03-25 01:11:56 +01:00
|
|
|
NSString* cameraID = nil;
|
|
|
|
for (AVCaptureDevice* captureDevice in
|
|
|
|
[AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo]) {
|
|
|
|
if (captureDevice.position == AVCaptureDevicePositionFront) {
|
|
|
|
cameraID = [captureDevice localizedName];
|
|
|
|
break;
|
|
|
|
}
|
2014-03-10 21:41:22 +01:00
|
|
|
}
|
|
|
|
NSAssert(cameraID, @"Unable to get the front camera id");
|
|
|
|
|
2014-03-25 01:11:56 +01:00
|
|
|
RTCVideoCapturer* capturer =
|
|
|
|
[RTCVideoCapturer capturerWithDeviceName:cameraID];
|
2014-03-25 06:16:29 +01:00
|
|
|
self.videoSource = [self.peerConnectionFactory
|
2014-03-25 01:11:56 +01:00
|
|
|
videoSourceWithCapturer:capturer
|
|
|
|
constraints:self.client.videoConstraints];
|
2014-03-31 22:22:19 +02:00
|
|
|
localVideoTrack =
|
2014-03-25 01:11:56 +01:00
|
|
|
[self.peerConnectionFactory videoTrackWithID:@"ARDAMSv0"
|
2014-03-25 06:16:29 +01:00
|
|
|
source:self.videoSource];
|
2014-03-10 21:41:22 +01:00
|
|
|
if (localVideoTrack) {
|
2014-03-25 01:11:56 +01:00
|
|
|
[lms addVideoTrack:localVideoTrack];
|
2014-03-10 21:41:22 +01:00
|
|
|
}
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.delegate connectionManager:self
|
|
|
|
didReceiveLocalVideoTrack:localVideoTrack];
|
2014-03-31 22:22:19 +02:00
|
|
|
#endif
|
2014-03-10 21:41:22 +01:00
|
|
|
|
2013-08-01 20:29:45 +02:00
|
|
|
[lms addAudioTrack:[self.peerConnectionFactory audioTrackWithID:@"ARDAMSa0"]];
|
2014-11-04 12:31:29 +01:00
|
|
|
[self.peerConnection addStream:lms];
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.logger logMessage:@"onICEServers - added local stream."];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#pragma mark - GAEMessageHandler methods
|
|
|
|
|
|
|
|
- (void)onOpen {
|
2014-02-10 19:47:11 +01:00
|
|
|
if (!self.client.initiator) {
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.logger logMessage:@"Callee; waiting for remote offer"];
|
2014-03-25 01:11:56 +01:00
|
|
|
return;
|
2014-02-10 19:47:11 +01:00
|
|
|
}
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.logger logMessage:@"GAE onOpen - create offer."];
|
2014-03-25 01:11:56 +01:00
|
|
|
RTCPair* audio =
|
2013-07-10 02:45:36 +02:00
|
|
|
[[RTCPair alloc] initWithKey:@"OfferToReceiveAudio" value:@"true"];
|
2014-03-25 01:11:56 +01:00
|
|
|
RTCPair* video =
|
|
|
|
[[RTCPair alloc] initWithKey:@"OfferToReceiveVideo" value:@"true"];
|
|
|
|
NSArray* mandatory = @[ audio, video ];
|
|
|
|
RTCMediaConstraints* constraints =
|
2013-07-10 02:45:36 +02:00
|
|
|
[[RTCMediaConstraints alloc] initWithMandatoryConstraints:mandatory
|
|
|
|
optionalConstraints:nil];
|
|
|
|
[self.peerConnection createOfferWithDelegate:self constraints:constraints];
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.logger logMessage:@"PC - createOffer."];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
2014-03-31 22:16:49 +02:00
|
|
|
- (void)onMessage:(NSDictionary*)messageData {
|
|
|
|
NSString* type = messageData[@"type"];
|
|
|
|
NSAssert(type, @"Missing type: %@", messageData);
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.logger logMessage:[NSString stringWithFormat:@"GAE onMessage type - %@",
|
|
|
|
type]];
|
2014-03-31 22:16:49 +02:00
|
|
|
if ([type isEqualToString:@"candidate"]) {
|
|
|
|
NSString* mid = messageData[@"id"];
|
|
|
|
NSNumber* sdpLineIndex = messageData[@"label"];
|
|
|
|
NSString* sdp = messageData[@"candidate"];
|
2014-03-25 01:11:56 +01:00
|
|
|
RTCICECandidate* candidate =
|
2013-08-01 20:29:45 +02:00
|
|
|
[[RTCICECandidate alloc] initWithMid:mid
|
2013-07-10 02:45:36 +02:00
|
|
|
index:sdpLineIndex.intValue
|
|
|
|
sdp:sdp];
|
|
|
|
if (self.queuedRemoteCandidates) {
|
|
|
|
[self.queuedRemoteCandidates addObject:candidate];
|
|
|
|
} else {
|
2013-08-01 20:29:45 +02:00
|
|
|
[self.peerConnection addICECandidate:candidate];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
2014-03-31 22:16:49 +02:00
|
|
|
} else if ([type isEqualToString:@"offer"] ||
|
|
|
|
[type isEqualToString:@"answer"]) {
|
|
|
|
NSString* sdpString = messageData[@"sdp"];
|
2014-03-25 01:11:56 +01:00
|
|
|
RTCSessionDescription* sdp = [[RTCSessionDescription alloc]
|
2014-03-31 22:16:49 +02:00
|
|
|
initWithType:type
|
2014-05-31 00:26:06 +02:00
|
|
|
sdp:[[self class] preferISAC:sdpString]];
|
2013-07-10 02:45:36 +02:00
|
|
|
[self.peerConnection setRemoteDescriptionWithDelegate:self
|
|
|
|
sessionDescription:sdp];
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.logger logMessage:@"PC - setRemoteDescription."];
|
2014-03-31 22:16:49 +02:00
|
|
|
} else if ([type isEqualToString:@"bye"]) {
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.delegate connectionManagerDidReceiveHangup:self];
|
2013-07-10 02:45:36 +02:00
|
|
|
} else {
|
2014-03-31 22:16:49 +02:00
|
|
|
NSAssert(NO, @"Invalid message: %@", messageData);
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)onClose {
|
2014-05-31 00:26:06 +02:00
|
|
|
[self.logger logMessage:@"GAE onClose."];
|
|
|
|
[self.delegate connectionManagerDidReceiveHangup:self];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:11:56 +01:00
|
|
|
- (void)onError:(int)code withDescription:(NSString*)description {
|
2014-05-31 00:26:06 +02:00
|
|
|
NSString* message = [NSString stringWithFormat:@"GAE onError: %d, %@",
|
|
|
|
code, description];
|
|
|
|
[self.logger logMessage:message];
|
|
|
|
[self.delegate connectionManager:self
|
|
|
|
didErrorWithMessage:message];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
#pragma mark - RTCPeerConnectionDelegate
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
signalingStateChanged:(RTCSignalingState)stateChanged {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
NSLog(@"PCO onSignalingStateChange: %d", stateChanged);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
addedStream:(RTCMediaStream*)stream {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
NSLog(@"PCO onAddStream.");
|
|
|
|
NSAssert([stream.audioTracks count] == 1 || [stream.videoTracks count] == 1,
|
|
|
|
@"Expected audio or video track");
|
|
|
|
NSAssert([stream.audioTracks count] <= 1,
|
|
|
|
@"Expected at most 1 audio stream");
|
|
|
|
NSAssert([stream.videoTracks count] <= 1,
|
|
|
|
@"Expected at most 1 video stream");
|
|
|
|
if ([stream.videoTracks count] != 0) {
|
|
|
|
[self.delegate connectionManager:self
|
|
|
|
didReceiveRemoteVideoTrack:stream.videoTracks[0]];
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
removedStream:(RTCMediaStream*)stream {
|
|
|
|
dispatch_async(dispatch_get_main_queue(),
|
|
|
|
^{ NSLog(@"PCO onRemoveStream."); });
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnectionOnRenegotiationNeeded:(RTCPeerConnection*)peerConnection {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
NSLog(@"PCO onRenegotiationNeeded - ignoring because AppRTC has a "
|
|
|
|
"predefined negotiation strategy");
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
gotICECandidate:(RTCICECandidate*)candidate {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
NSLog(@"PCO onICECandidate.\n Mid[%@] Index[%li] Sdp[%@]",
|
|
|
|
candidate.sdpMid,
|
|
|
|
(long)candidate.sdpMLineIndex,
|
|
|
|
candidate.sdp);
|
|
|
|
NSDictionary* json = @{
|
|
|
|
@"type" : @"candidate",
|
|
|
|
@"label" : @(candidate.sdpMLineIndex),
|
|
|
|
@"id" : candidate.sdpMid,
|
|
|
|
@"candidate" : candidate.sdp
|
|
|
|
};
|
|
|
|
NSError* error;
|
|
|
|
NSData* data =
|
|
|
|
[NSJSONSerialization dataWithJSONObject:json options:0 error:&error];
|
|
|
|
if (!error) {
|
|
|
|
[self.client sendData:data];
|
|
|
|
} else {
|
|
|
|
NSAssert(NO,
|
|
|
|
@"Unable to serialize JSON object with error: %@",
|
|
|
|
error.localizedDescription);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
iceGatheringChanged:(RTCICEGatheringState)newState {
|
|
|
|
dispatch_async(dispatch_get_main_queue(),
|
|
|
|
^{ NSLog(@"PCO onIceGatheringChange. %d", newState); });
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
iceConnectionChanged:(RTCICEConnectionState)newState {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
NSLog(@"PCO onIceConnectionChange. %d", newState);
|
|
|
|
if (newState == RTCICEConnectionConnected)
|
|
|
|
[self.logger logMessage:@"ICE Connection Connected."];
|
|
|
|
NSAssert(newState != RTCICEConnectionFailed, @"ICE Connection failed!");
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
didOpenDataChannel:(RTCDataChannel*)dataChannel {
|
|
|
|
NSAssert(NO, @"AppRTC doesn't use DataChannels");
|
|
|
|
}
|
|
|
|
|
|
|
|
#pragma mark - RTCSessionDescriptionDelegate
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
didCreateSessionDescription:(RTCSessionDescription*)origSdp
|
|
|
|
error:(NSError*)error {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
if (error) {
|
|
|
|
[self.logger logMessage:@"SDP onFailure."];
|
|
|
|
NSAssert(NO, error.description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
[self.logger logMessage:@"SDP onSuccess(SDP) - set local description."];
|
|
|
|
RTCSessionDescription* sdp = [[RTCSessionDescription alloc]
|
|
|
|
initWithType:origSdp.type
|
|
|
|
sdp:[[self class] preferISAC:origSdp.description]];
|
|
|
|
[self.peerConnection setLocalDescriptionWithDelegate:self
|
|
|
|
sessionDescription:sdp];
|
|
|
|
[self.logger logMessage:@"PC setLocalDescription."];
|
|
|
|
NSDictionary* json = @{@"type" : sdp.type, @"sdp" : sdp.description};
|
|
|
|
NSError* jsonError;
|
|
|
|
NSData* data = [NSJSONSerialization dataWithJSONObject:json
|
|
|
|
options:0
|
|
|
|
error:&jsonError];
|
|
|
|
NSAssert(!jsonError, @"Error: %@", jsonError.description);
|
|
|
|
[self.client sendData:data];
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
didSetSessionDescriptionWithError:(NSError*)error {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
if (error) {
|
|
|
|
[self.logger logMessage:@"SDP onFailure."];
|
|
|
|
NSAssert(NO, error.description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
[self.logger logMessage:@"SDP onSuccess() - possibly drain candidates"];
|
|
|
|
if (!self.client.initiator) {
|
|
|
|
if (self.peerConnection.remoteDescription &&
|
|
|
|
!self.peerConnection.localDescription) {
|
|
|
|
[self.logger logMessage:@"Callee, setRemoteDescription succeeded"];
|
|
|
|
RTCPair* audio = [[RTCPair alloc] initWithKey:@"OfferToReceiveAudio"
|
|
|
|
value:@"true"];
|
|
|
|
RTCPair* video = [[RTCPair alloc] initWithKey:@"OfferToReceiveVideo"
|
|
|
|
value:@"true"];
|
|
|
|
NSArray* mandatory = @[ audio, video ];
|
|
|
|
RTCMediaConstraints* constraints = [[RTCMediaConstraints alloc]
|
|
|
|
initWithMandatoryConstraints:mandatory
|
|
|
|
optionalConstraints:nil];
|
|
|
|
[self.peerConnection createAnswerWithDelegate:self
|
|
|
|
constraints:constraints];
|
|
|
|
[self.logger logMessage:@"PC - createAnswer."];
|
|
|
|
} else {
|
|
|
|
[self.logger logMessage:@"SDP onSuccess - drain candidates"];
|
|
|
|
[self drainRemoteCandidates];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (self.peerConnection.remoteDescription) {
|
|
|
|
[self.logger logMessage:@"SDP onSuccess - drain candidates"];
|
|
|
|
[self drainRemoteCandidates];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
#pragma mark - RTCStatsDelegate methods
|
|
|
|
|
|
|
|
- (void)peerConnection:(RTCPeerConnection*)peerConnection
|
|
|
|
didGetStats:(NSArray*)stats {
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
NSString* message = [NSString stringWithFormat:@"Stats:\n %@", stats];
|
|
|
|
[self.logger logMessage:message];
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
#pragma mark - Private
|
2013-07-10 02:45:36 +02:00
|
|
|
|
2013-09-05 23:49:58 +02:00
|
|
|
// Match |pattern| to |string| and return the first group of the first
|
|
|
|
// match, or nil if no match was found.
|
2014-03-25 01:11:56 +01:00
|
|
|
+ (NSString*)firstMatch:(NSRegularExpression*)pattern
|
|
|
|
withString:(NSString*)string {
|
2013-09-05 23:49:58 +02:00
|
|
|
NSTextCheckingResult* result =
|
2014-03-25 01:11:56 +01:00
|
|
|
[pattern firstMatchInString:string
|
|
|
|
options:0
|
|
|
|
range:NSMakeRange(0, [string length])];
|
2013-09-05 23:49:58 +02:00
|
|
|
if (!result)
|
|
|
|
return nil;
|
|
|
|
return [string substringWithRange:[result rangeAtIndex:1]];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Mangle |origSDP| to prefer the ISAC/16k audio codec.
|
2014-03-25 01:11:56 +01:00
|
|
|
+ (NSString*)preferISAC:(NSString*)origSDP {
|
2013-09-05 23:49:58 +02:00
|
|
|
int mLineIndex = -1;
|
|
|
|
NSString* isac16kRtpMap = nil;
|
|
|
|
NSArray* lines = [origSDP componentsSeparatedByString:@"\n"];
|
|
|
|
NSRegularExpression* isac16kRegex = [NSRegularExpression
|
|
|
|
regularExpressionWithPattern:@"^a=rtpmap:(\\d+) ISAC/16000[\r]?$"
|
|
|
|
options:0
|
|
|
|
error:nil];
|
|
|
|
for (int i = 0;
|
|
|
|
(i < [lines count]) && (mLineIndex == -1 || isac16kRtpMap == nil);
|
|
|
|
++i) {
|
|
|
|
NSString* line = [lines objectAtIndex:i];
|
|
|
|
if ([line hasPrefix:@"m=audio "]) {
|
|
|
|
mLineIndex = i;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
isac16kRtpMap = [self firstMatch:isac16kRegex withString:line];
|
|
|
|
}
|
|
|
|
if (mLineIndex == -1) {
|
|
|
|
NSLog(@"No m=audio line, so can't prefer iSAC");
|
|
|
|
return origSDP;
|
|
|
|
}
|
|
|
|
if (isac16kRtpMap == nil) {
|
|
|
|
NSLog(@"No ISAC/16000 line, so can't prefer iSAC");
|
|
|
|
return origSDP;
|
|
|
|
}
|
|
|
|
NSArray* origMLineParts =
|
|
|
|
[[lines objectAtIndex:mLineIndex] componentsSeparatedByString:@" "];
|
|
|
|
NSMutableArray* newMLine =
|
|
|
|
[NSMutableArray arrayWithCapacity:[origMLineParts count]];
|
|
|
|
int origPartIndex = 0;
|
|
|
|
// Format is: m=<media> <port> <proto> <fmt> ...
|
|
|
|
[newMLine addObject:[origMLineParts objectAtIndex:origPartIndex++]];
|
|
|
|
[newMLine addObject:[origMLineParts objectAtIndex:origPartIndex++]];
|
|
|
|
[newMLine addObject:[origMLineParts objectAtIndex:origPartIndex++]];
|
|
|
|
[newMLine addObject:isac16kRtpMap];
|
|
|
|
for (; origPartIndex < [origMLineParts count]; ++origPartIndex) {
|
2014-03-31 22:16:49 +02:00
|
|
|
if (![isac16kRtpMap
|
|
|
|
isEqualToString:[origMLineParts objectAtIndex:origPartIndex]]) {
|
2013-09-05 23:49:58 +02:00
|
|
|
[newMLine addObject:[origMLineParts objectAtIndex:origPartIndex]];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NSMutableArray* newLines = [NSMutableArray arrayWithCapacity:[lines count]];
|
|
|
|
[newLines addObjectsFromArray:lines];
|
|
|
|
[newLines replaceObjectAtIndex:mLineIndex
|
|
|
|
withObject:[newMLine componentsJoinedByString:@" "]];
|
|
|
|
return [newLines componentsJoinedByString:@"\n"];
|
|
|
|
}
|
|
|
|
|
2013-07-10 02:45:36 +02:00
|
|
|
- (void)drainRemoteCandidates {
|
2014-03-25 01:11:56 +01:00
|
|
|
for (RTCICECandidate* candidate in self.queuedRemoteCandidates) {
|
2013-08-01 20:29:45 +02:00
|
|
|
[self.peerConnection addICECandidate:candidate];
|
2013-07-10 02:45:36 +02:00
|
|
|
}
|
|
|
|
self.queuedRemoteCandidates = nil;
|
|
|
|
}
|
|
|
|
|
2014-05-31 00:26:06 +02:00
|
|
|
- (void)didFireStatsTimer:(NSTimer*)timer {
|
2014-04-22 23:05:38 +02:00
|
|
|
if (self.peerConnection) {
|
|
|
|
[self.peerConnection getStatsWithDelegate:self
|
|
|
|
mediaStreamTrack:nil
|
|
|
|
statsOutputLevel:RTCStatsOutputLevelDebug];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-10 02:45:36 +02:00
|
|
|
@end
|