| OLD | NEW |
|---|
| (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 "RTCConfiguration+Private.h" | |
| 12 | |
| 13 #include <memory> | |
| 14 | |
| 15 #import "RTCIceServer+Private.h" | |
| 16 #import "WebRTC/RTCLogging.h" | |
| 17 | |
| 18 #include "webrtc/base/rtccertificategenerator.h" | |
| 19 #include "webrtc/base/sslidentity.h" | |
| 20 | |
| 21 @implementation RTCConfiguration | |
| 22 | |
| 23 @synthesize iceServers = _iceServers; | |
| 24 @synthesize iceTransportPolicy = _iceTransportPolicy; | |
| 25 @synthesize bundlePolicy = _bundlePolicy; | |
| 26 @synthesize rtcpMuxPolicy = _rtcpMuxPolicy; | |
| 27 @synthesize tcpCandidatePolicy = _tcpCandidatePolicy; | |
| 28 @synthesize candidateNetworkPolicy = _candidateNetworkPolicy; | |
| 29 @synthesize continualGatheringPolicy = _continualGatheringPolicy; | |
| 30 @synthesize audioJitterBufferMaxPackets = _audioJitterBufferMaxPackets; | |
| 31 @synthesize audioJitterBufferFastAccelerate = _audioJitterBufferFastAccelerate; | |
| 32 @synthesize iceConnectionReceivingTimeout = _iceConnectionReceivingTimeout; | |
| 33 @synthesize iceBackupCandidatePairPingInterval = | |
| 34 _iceBackupCandidatePairPingInterval; | |
| 35 @synthesize keyType = _keyType; | |
| 36 @synthesize iceCandidatePoolSize = _iceCandidatePoolSize; | |
| 37 @synthesize shouldPruneTurnPorts = _shouldPruneTurnPorts; | |
| 38 @synthesize shouldPresumeWritableWhenFullyRelayed = | |
| 39 _shouldPresumeWritableWhenFullyRelayed; | |
| 40 @synthesize iceCheckMinInterval = _iceCheckMinInterval; | |
| 41 | |
| 42 - (instancetype)init { | |
| 43 // Copy defaults. | |
| 44 webrtc::PeerConnectionInterface::RTCConfiguration config( | |
| 45 webrtc::PeerConnectionInterface::RTCConfigurationType::kAggressive); | |
| 46 return [self initWithNativeConfiguration:config]; | |
| 47 } | |
| 48 | |
| 49 - (instancetype)initWithNativeConfiguration: | |
| 50 (const webrtc::PeerConnectionInterface::RTCConfiguration &)config { | |
| 51 if (self = [super init]) { | |
| 52 NSMutableArray *iceServers = [NSMutableArray array]; | |
| 53 for (const webrtc::PeerConnectionInterface::IceServer& server : config.serve
rs) { | |
| 54 RTCIceServer *iceServer = [[RTCIceServer alloc] initWithNativeServer:serve
r]; | |
| 55 [iceServers addObject:iceServer]; | |
| 56 } | |
| 57 _iceServers = iceServers; | |
| 58 _iceTransportPolicy = | |
| 59 [[self class] transportPolicyForTransportsType:config.type]; | |
| 60 _bundlePolicy = | |
| 61 [[self class] bundlePolicyForNativePolicy:config.bundle_policy]; | |
| 62 _rtcpMuxPolicy = | |
| 63 [[self class] rtcpMuxPolicyForNativePolicy:config.rtcp_mux_policy]; | |
| 64 _tcpCandidatePolicy = [[self class] tcpCandidatePolicyForNativePolicy: | |
| 65 config.tcp_candidate_policy]; | |
| 66 _candidateNetworkPolicy = [[self class] | |
| 67 candidateNetworkPolicyForNativePolicy:config.candidate_network_policy]; | |
| 68 webrtc::PeerConnectionInterface::ContinualGatheringPolicy nativePolicy = | |
| 69 config.continual_gathering_policy; | |
| 70 _continualGatheringPolicy = | |
| 71 [[self class] continualGatheringPolicyForNativePolicy:nativePolicy]; | |
| 72 _audioJitterBufferMaxPackets = config.audio_jitter_buffer_max_packets; | |
| 73 _audioJitterBufferFastAccelerate = config.audio_jitter_buffer_fast_accelerat
e; | |
| 74 _iceConnectionReceivingTimeout = config.ice_connection_receiving_timeout; | |
| 75 _iceBackupCandidatePairPingInterval = | |
| 76 config.ice_backup_candidate_pair_ping_interval; | |
| 77 _keyType = RTCEncryptionKeyTypeECDSA; | |
| 78 _iceCandidatePoolSize = config.ice_candidate_pool_size; | |
| 79 _shouldPruneTurnPorts = config.prune_turn_ports; | |
| 80 _shouldPresumeWritableWhenFullyRelayed = | |
| 81 config.presume_writable_when_fully_relayed; | |
| 82 if (config.ice_check_min_interval) { | |
| 83 _iceCheckMinInterval = | |
| 84 [NSNumber numberWithInt:*config.ice_check_min_interval]; | |
| 85 } | |
| 86 } | |
| 87 return self; | |
| 88 } | |
| 89 | |
| 90 - (NSString *)description { | |
| 91 return [NSString stringWithFormat: | |
| 92 @"RTCConfiguration: {\n%@\n%@\n%@\n%@\n%@\n%@\n%@\n%d\n%d\n%d\n%d\n%d\n%d\
n%d\n%@\n}\n", | |
| 93 _iceServers, | |
| 94 [[self class] stringForTransportPolicy:_iceTransportPolicy], | |
| 95 [[self class] stringForBundlePolicy:_bundlePolicy], | |
| 96 [[self class] stringForRtcpMuxPolicy:_rtcpMuxPolicy], | |
| 97 [[self class] stringForTcpCandidatePolicy:_tcpCandidatePolicy], | |
| 98 [[self class] stringForCandidateNetworkPolicy:_candidateNetworkPolicy], | |
| 99 [[self class] | |
| 100 stringForContinualGatheringPolicy:_continualGatheringPolicy], | |
| 101 _audioJitterBufferMaxPackets, | |
| 102 _audioJitterBufferFastAccelerate, | |
| 103 _iceConnectionReceivingTimeout, | |
| 104 _iceBackupCandidatePairPingInterval, | |
| 105 _iceCandidatePoolSize, | |
| 106 _shouldPruneTurnPorts, | |
| 107 _shouldPresumeWritableWhenFullyRelayed, | |
| 108 _iceCheckMinInterval]; | |
| 109 } | |
| 110 | |
| 111 #pragma mark - Private | |
| 112 | |
| 113 - (webrtc::PeerConnectionInterface::RTCConfiguration *) | |
| 114 createNativeConfiguration { | |
| 115 std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration> | |
| 116 nativeConfig(new webrtc::PeerConnectionInterface::RTCConfiguration( | |
| 117 webrtc::PeerConnectionInterface::RTCConfigurationType::kAggressive)); | |
| 118 | |
| 119 for (RTCIceServer *iceServer in _iceServers) { | |
| 120 nativeConfig->servers.push_back(iceServer.nativeServer); | |
| 121 } | |
| 122 nativeConfig->type = | |
| 123 [[self class] nativeTransportsTypeForTransportPolicy:_iceTransportPolicy]; | |
| 124 nativeConfig->bundle_policy = | |
| 125 [[self class] nativeBundlePolicyForPolicy:_bundlePolicy]; | |
| 126 nativeConfig->rtcp_mux_policy = | |
| 127 [[self class] nativeRtcpMuxPolicyForPolicy:_rtcpMuxPolicy]; | |
| 128 nativeConfig->tcp_candidate_policy = | |
| 129 [[self class] nativeTcpCandidatePolicyForPolicy:_tcpCandidatePolicy]; | |
| 130 nativeConfig->candidate_network_policy = [[self class] | |
| 131 nativeCandidateNetworkPolicyForPolicy:_candidateNetworkPolicy]; | |
| 132 nativeConfig->continual_gathering_policy = [[self class] | |
| 133 nativeContinualGatheringPolicyForPolicy:_continualGatheringPolicy]; | |
| 134 nativeConfig->audio_jitter_buffer_max_packets = _audioJitterBufferMaxPackets; | |
| 135 nativeConfig->audio_jitter_buffer_fast_accelerate = | |
| 136 _audioJitterBufferFastAccelerate ? true : false; | |
| 137 nativeConfig->ice_connection_receiving_timeout = | |
| 138 _iceConnectionReceivingTimeout; | |
| 139 nativeConfig->ice_backup_candidate_pair_ping_interval = | |
| 140 _iceBackupCandidatePairPingInterval; | |
| 141 rtc::KeyType keyType = | |
| 142 [[self class] nativeEncryptionKeyTypeForKeyType:_keyType]; | |
| 143 // Generate non-default certificate. | |
| 144 if (keyType != rtc::KT_DEFAULT) { | |
| 145 rtc::scoped_refptr<rtc::RTCCertificate> certificate = | |
| 146 rtc::RTCCertificateGenerator::GenerateCertificate( | |
| 147 rtc::KeyParams(keyType), rtc::Optional<uint64_t>()); | |
| 148 if (!certificate) { | |
| 149 RTCLogError(@"Failed to generate certificate."); | |
| 150 return nullptr; | |
| 151 } | |
| 152 nativeConfig->certificates.push_back(certificate); | |
| 153 } | |
| 154 nativeConfig->ice_candidate_pool_size = _iceCandidatePoolSize; | |
| 155 nativeConfig->prune_turn_ports = _shouldPruneTurnPorts ? true : false; | |
| 156 nativeConfig->presume_writable_when_fully_relayed = | |
| 157 _shouldPresumeWritableWhenFullyRelayed ? true : false; | |
| 158 if (_iceCheckMinInterval != nil) { | |
| 159 nativeConfig->ice_check_min_interval = | |
| 160 rtc::Optional<int>(_iceCheckMinInterval.intValue); | |
| 161 } | |
| 162 | |
| 163 return nativeConfig.release(); | |
| 164 } | |
| 165 | |
| 166 + (webrtc::PeerConnectionInterface::IceTransportsType) | |
| 167 nativeTransportsTypeForTransportPolicy:(RTCIceTransportPolicy)policy { | |
| 168 switch (policy) { | |
| 169 case RTCIceTransportPolicyNone: | |
| 170 return webrtc::PeerConnectionInterface::kNone; | |
| 171 case RTCIceTransportPolicyRelay: | |
| 172 return webrtc::PeerConnectionInterface::kRelay; | |
| 173 case RTCIceTransportPolicyNoHost: | |
| 174 return webrtc::PeerConnectionInterface::kNoHost; | |
| 175 case RTCIceTransportPolicyAll: | |
| 176 return webrtc::PeerConnectionInterface::kAll; | |
| 177 } | |
| 178 } | |
| 179 | |
| 180 + (RTCIceTransportPolicy)transportPolicyForTransportsType: | |
| 181 (webrtc::PeerConnectionInterface::IceTransportsType)nativeType { | |
| 182 switch (nativeType) { | |
| 183 case webrtc::PeerConnectionInterface::kNone: | |
| 184 return RTCIceTransportPolicyNone; | |
| 185 case webrtc::PeerConnectionInterface::kRelay: | |
| 186 return RTCIceTransportPolicyRelay; | |
| 187 case webrtc::PeerConnectionInterface::kNoHost: | |
| 188 return RTCIceTransportPolicyNoHost; | |
| 189 case webrtc::PeerConnectionInterface::kAll: | |
| 190 return RTCIceTransportPolicyAll; | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 + (NSString *)stringForTransportPolicy:(RTCIceTransportPolicy)policy { | |
| 195 switch (policy) { | |
| 196 case RTCIceTransportPolicyNone: | |
| 197 return @"NONE"; | |
| 198 case RTCIceTransportPolicyRelay: | |
| 199 return @"RELAY"; | |
| 200 case RTCIceTransportPolicyNoHost: | |
| 201 return @"NO_HOST"; | |
| 202 case RTCIceTransportPolicyAll: | |
| 203 return @"ALL"; | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 + (webrtc::PeerConnectionInterface::BundlePolicy)nativeBundlePolicyForPolicy: | |
| 208 (RTCBundlePolicy)policy { | |
| 209 switch (policy) { | |
| 210 case RTCBundlePolicyBalanced: | |
| 211 return webrtc::PeerConnectionInterface::kBundlePolicyBalanced; | |
| 212 case RTCBundlePolicyMaxCompat: | |
| 213 return webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat; | |
| 214 case RTCBundlePolicyMaxBundle: | |
| 215 return webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle; | |
| 216 } | |
| 217 } | |
| 218 | |
| 219 + (RTCBundlePolicy)bundlePolicyForNativePolicy: | |
| 220 (webrtc::PeerConnectionInterface::BundlePolicy)nativePolicy { | |
| 221 switch (nativePolicy) { | |
| 222 case webrtc::PeerConnectionInterface::kBundlePolicyBalanced: | |
| 223 return RTCBundlePolicyBalanced; | |
| 224 case webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat: | |
| 225 return RTCBundlePolicyMaxCompat; | |
| 226 case webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle: | |
| 227 return RTCBundlePolicyMaxBundle; | |
| 228 } | |
| 229 } | |
| 230 | |
| 231 + (NSString *)stringForBundlePolicy:(RTCBundlePolicy)policy { | |
| 232 switch (policy) { | |
| 233 case RTCBundlePolicyBalanced: | |
| 234 return @"BALANCED"; | |
| 235 case RTCBundlePolicyMaxCompat: | |
| 236 return @"MAX_COMPAT"; | |
| 237 case RTCBundlePolicyMaxBundle: | |
| 238 return @"MAX_BUNDLE"; | |
| 239 } | |
| 240 } | |
| 241 | |
| 242 + (webrtc::PeerConnectionInterface::RtcpMuxPolicy)nativeRtcpMuxPolicyForPolicy: | |
| 243 (RTCRtcpMuxPolicy)policy { | |
| 244 switch (policy) { | |
| 245 case RTCRtcpMuxPolicyNegotiate: | |
| 246 return webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate; | |
| 247 case RTCRtcpMuxPolicyRequire: | |
| 248 return webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire; | |
| 249 } | |
| 250 } | |
| 251 | |
| 252 + (RTCRtcpMuxPolicy)rtcpMuxPolicyForNativePolicy: | |
| 253 (webrtc::PeerConnectionInterface::RtcpMuxPolicy)nativePolicy { | |
| 254 switch (nativePolicy) { | |
| 255 case webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate: | |
| 256 return RTCRtcpMuxPolicyNegotiate; | |
| 257 case webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire: | |
| 258 return RTCRtcpMuxPolicyRequire; | |
| 259 } | |
| 260 } | |
| 261 | |
| 262 + (NSString *)stringForRtcpMuxPolicy:(RTCRtcpMuxPolicy)policy { | |
| 263 switch (policy) { | |
| 264 case RTCRtcpMuxPolicyNegotiate: | |
| 265 return @"NEGOTIATE"; | |
| 266 case RTCRtcpMuxPolicyRequire: | |
| 267 return @"REQUIRE"; | |
| 268 } | |
| 269 } | |
| 270 | |
| 271 + (webrtc::PeerConnectionInterface::TcpCandidatePolicy) | |
| 272 nativeTcpCandidatePolicyForPolicy:(RTCTcpCandidatePolicy)policy { | |
| 273 switch (policy) { | |
| 274 case RTCTcpCandidatePolicyEnabled: | |
| 275 return webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled; | |
| 276 case RTCTcpCandidatePolicyDisabled: | |
| 277 return webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled; | |
| 278 } | |
| 279 } | |
| 280 | |
| 281 + (webrtc::PeerConnectionInterface::CandidateNetworkPolicy) | |
| 282 nativeCandidateNetworkPolicyForPolicy:(RTCCandidateNetworkPolicy)policy { | |
| 283 switch (policy) { | |
| 284 case RTCCandidateNetworkPolicyAll: | |
| 285 return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyAll; | |
| 286 case RTCCandidateNetworkPolicyLowCost: | |
| 287 return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyLowCost; | |
| 288 } | |
| 289 } | |
| 290 | |
| 291 + (RTCTcpCandidatePolicy)tcpCandidatePolicyForNativePolicy: | |
| 292 (webrtc::PeerConnectionInterface::TcpCandidatePolicy)nativePolicy { | |
| 293 switch (nativePolicy) { | |
| 294 case webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled: | |
| 295 return RTCTcpCandidatePolicyEnabled; | |
| 296 case webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled: | |
| 297 return RTCTcpCandidatePolicyDisabled; | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 + (NSString *)stringForTcpCandidatePolicy:(RTCTcpCandidatePolicy)policy { | |
| 302 switch (policy) { | |
| 303 case RTCTcpCandidatePolicyEnabled: | |
| 304 return @"TCP_ENABLED"; | |
| 305 case RTCTcpCandidatePolicyDisabled: | |
| 306 return @"TCP_DISABLED"; | |
| 307 } | |
| 308 } | |
| 309 | |
| 310 + (RTCCandidateNetworkPolicy)candidateNetworkPolicyForNativePolicy: | |
| 311 (webrtc::PeerConnectionInterface::CandidateNetworkPolicy)nativePolicy { | |
| 312 switch (nativePolicy) { | |
| 313 case webrtc::PeerConnectionInterface::kCandidateNetworkPolicyAll: | |
| 314 return RTCCandidateNetworkPolicyAll; | |
| 315 case webrtc::PeerConnectionInterface::kCandidateNetworkPolicyLowCost: | |
| 316 return RTCCandidateNetworkPolicyLowCost; | |
| 317 } | |
| 318 } | |
| 319 | |
| 320 + (NSString *)stringForCandidateNetworkPolicy: | |
| 321 (RTCCandidateNetworkPolicy)policy { | |
| 322 switch (policy) { | |
| 323 case RTCCandidateNetworkPolicyAll: | |
| 324 return @"CANDIDATE_ALL_NETWORKS"; | |
| 325 case RTCCandidateNetworkPolicyLowCost: | |
| 326 return @"CANDIDATE_LOW_COST_NETWORKS"; | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 + (webrtc::PeerConnectionInterface::ContinualGatheringPolicy) | |
| 331 nativeContinualGatheringPolicyForPolicy: | |
| 332 (RTCContinualGatheringPolicy)policy { | |
| 333 switch (policy) { | |
| 334 case RTCContinualGatheringPolicyGatherOnce: | |
| 335 return webrtc::PeerConnectionInterface::GATHER_ONCE; | |
| 336 case RTCContinualGatheringPolicyGatherContinually: | |
| 337 return webrtc::PeerConnectionInterface::GATHER_CONTINUALLY; | |
| 338 } | |
| 339 } | |
| 340 | |
| 341 + (RTCContinualGatheringPolicy)continualGatheringPolicyForNativePolicy: | |
| 342 (webrtc::PeerConnectionInterface::ContinualGatheringPolicy)nativePolicy { | |
| 343 switch (nativePolicy) { | |
| 344 case webrtc::PeerConnectionInterface::GATHER_ONCE: | |
| 345 return RTCContinualGatheringPolicyGatherOnce; | |
| 346 case webrtc::PeerConnectionInterface::GATHER_CONTINUALLY: | |
| 347 return RTCContinualGatheringPolicyGatherContinually; | |
| 348 } | |
| 349 } | |
| 350 | |
| 351 + (NSString *)stringForContinualGatheringPolicy: | |
| 352 (RTCContinualGatheringPolicy)policy { | |
| 353 switch (policy) { | |
| 354 case RTCContinualGatheringPolicyGatherOnce: | |
| 355 return @"GATHER_ONCE"; | |
| 356 case RTCContinualGatheringPolicyGatherContinually: | |
| 357 return @"GATHER_CONTINUALLY"; | |
| 358 } | |
| 359 } | |
| 360 | |
| 361 + (rtc::KeyType)nativeEncryptionKeyTypeForKeyType: | |
| 362 (RTCEncryptionKeyType)keyType { | |
| 363 switch (keyType) { | |
| 364 case RTCEncryptionKeyTypeRSA: | |
| 365 return rtc::KT_RSA; | |
| 366 case RTCEncryptionKeyTypeECDSA: | |
| 367 return rtc::KT_ECDSA; | |
| 368 } | |
| 369 } | |
| 370 | |
| 371 @end | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2890733003:
Reland of Split iOS sdk in to separate targets (Closed)
