| 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.h" | |
| 12 | |
| 13 #include <memory> | |
| 14 | |
| 15 #include "webrtc/base/sslidentity.h" | |
| 16 | |
| 17 #import "webrtc/api/objc/RTCConfiguration+Private.h" | |
| 18 #import "webrtc/api/objc/RTCIceServer+Private.h" | |
| 19 #import "webrtc/base/objc/RTCLogging.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 audioJitterBufferMaxPackets = _audioJitterBufferMaxPackets; | |
| 29 @synthesize iceConnectionReceivingTimeout = _iceConnectionReceivingTimeout; | |
| 30 @synthesize iceBackupCandidatePairPingInterval = | |
| 31 _iceBackupCandidatePairPingInterval; | |
| 32 @synthesize keyType = _keyType; | |
| 33 | |
| 34 - (instancetype)init { | |
| 35 if (self = [super init]) { | |
| 36 _iceServers = [NSMutableArray array]; | |
| 37 // Copy defaults. | |
| 38 webrtc::PeerConnectionInterface::RTCConfiguration config; | |
| 39 _iceTransportPolicy = | |
| 40 [[self class] transportPolicyForTransportsType:config.type]; | |
| 41 _bundlePolicy = | |
| 42 [[self class] bundlePolicyForNativePolicy:config.bundle_policy]; | |
| 43 _rtcpMuxPolicy = | |
| 44 [[self class] rtcpMuxPolicyForNativePolicy:config.rtcp_mux_policy]; | |
| 45 _tcpCandidatePolicy = [[self class] tcpCandidatePolicyForNativePolicy: | |
| 46 config.tcp_candidate_policy]; | |
| 47 _audioJitterBufferMaxPackets = config.audio_jitter_buffer_max_packets; | |
| 48 _iceConnectionReceivingTimeout = config.ice_connection_receiving_timeout; | |
| 49 _iceBackupCandidatePairPingInterval = | |
| 50 config.ice_backup_candidate_pair_ping_interval; | |
| 51 _keyType = RTCEncryptionKeyTypeECDSA; | |
| 52 } | |
| 53 return self; | |
| 54 } | |
| 55 | |
| 56 - (NSString *)description { | |
| 57 return [NSString stringWithFormat: | |
| 58 @"RTCConfiguration: {\n%@\n%@\n%@\n%@\n%@\n%d\n%d\n%d\n}\n", | |
| 59 _iceServers, | |
| 60 [[self class] stringForTransportPolicy:_iceTransportPolicy], | |
| 61 [[self class] stringForBundlePolicy:_bundlePolicy], | |
| 62 [[self class] stringForRtcpMuxPolicy:_rtcpMuxPolicy], | |
| 63 [[self class] stringForTcpCandidatePolicy:_tcpCandidatePolicy], | |
| 64 _audioJitterBufferMaxPackets, | |
| 65 _iceConnectionReceivingTimeout, | |
| 66 _iceBackupCandidatePairPingInterval]; | |
| 67 } | |
| 68 | |
| 69 #pragma mark - Private | |
| 70 | |
| 71 - (webrtc::PeerConnectionInterface::RTCConfiguration)nativeConfiguration { | |
| 72 webrtc::PeerConnectionInterface::RTCConfiguration nativeConfig; | |
| 73 | |
| 74 for (RTCIceServer *iceServer in _iceServers) { | |
| 75 nativeConfig.servers.push_back(iceServer.nativeServer); | |
| 76 } | |
| 77 nativeConfig.type = | |
| 78 [[self class] nativeTransportsTypeForTransportPolicy:_iceTransportPolicy]; | |
| 79 nativeConfig.bundle_policy = | |
| 80 [[self class] nativeBundlePolicyForPolicy:_bundlePolicy]; | |
| 81 nativeConfig.rtcp_mux_policy = | |
| 82 [[self class] nativeRtcpMuxPolicyForPolicy:_rtcpMuxPolicy]; | |
| 83 nativeConfig.tcp_candidate_policy = | |
| 84 [[self class] nativeTcpCandidatePolicyForPolicy:_tcpCandidatePolicy]; | |
| 85 nativeConfig.audio_jitter_buffer_max_packets = _audioJitterBufferMaxPackets; | |
| 86 nativeConfig.ice_connection_receiving_timeout = | |
| 87 _iceConnectionReceivingTimeout; | |
| 88 nativeConfig.ice_backup_candidate_pair_ping_interval = | |
| 89 _iceBackupCandidatePairPingInterval; | |
| 90 if (_keyType == RTCEncryptionKeyTypeECDSA) { | |
| 91 std::unique_ptr<rtc::SSLIdentity> identity( | |
| 92 rtc::SSLIdentity::Generate(webrtc::kIdentityName, rtc::KT_ECDSA)); | |
| 93 if (identity) { | |
| 94 nativeConfig.certificates.push_back( | |
| 95 rtc::RTCCertificate::Create(std::move(identity))); | |
| 96 } else { | |
| 97 RTCLogWarning(@"Failed to generate ECDSA identity. RSA will be used."); | |
| 98 } | |
| 99 } | |
| 100 | |
| 101 return nativeConfig; | |
| 102 } | |
| 103 | |
| 104 + (webrtc::PeerConnectionInterface::IceTransportsType) | |
| 105 nativeTransportsTypeForTransportPolicy:(RTCIceTransportPolicy)policy { | |
| 106 switch (policy) { | |
| 107 case RTCIceTransportPolicyNone: | |
| 108 return webrtc::PeerConnectionInterface::kNone; | |
| 109 case RTCIceTransportPolicyRelay: | |
| 110 return webrtc::PeerConnectionInterface::kRelay; | |
| 111 case RTCIceTransportPolicyNoHost: | |
| 112 return webrtc::PeerConnectionInterface::kNoHost; | |
| 113 case RTCIceTransportPolicyAll: | |
| 114 return webrtc::PeerConnectionInterface::kAll; | |
| 115 } | |
| 116 } | |
| 117 | |
| 118 + (RTCIceTransportPolicy)transportPolicyForTransportsType: | |
| 119 (webrtc::PeerConnectionInterface::IceTransportsType)nativeType { | |
| 120 switch (nativeType) { | |
| 121 case webrtc::PeerConnectionInterface::kNone: | |
| 122 return RTCIceTransportPolicyNone; | |
| 123 case webrtc::PeerConnectionInterface::kRelay: | |
| 124 return RTCIceTransportPolicyRelay; | |
| 125 case webrtc::PeerConnectionInterface::kNoHost: | |
| 126 return RTCIceTransportPolicyNoHost; | |
| 127 case webrtc::PeerConnectionInterface::kAll: | |
| 128 return RTCIceTransportPolicyAll; | |
| 129 } | |
| 130 } | |
| 131 | |
| 132 + (NSString *)stringForTransportPolicy:(RTCIceTransportPolicy)policy { | |
| 133 switch (policy) { | |
| 134 case RTCIceTransportPolicyNone: | |
| 135 return @"NONE"; | |
| 136 case RTCIceTransportPolicyRelay: | |
| 137 return @"RELAY"; | |
| 138 case RTCIceTransportPolicyNoHost: | |
| 139 return @"NO_HOST"; | |
| 140 case RTCIceTransportPolicyAll: | |
| 141 return @"ALL"; | |
| 142 } | |
| 143 } | |
| 144 | |
| 145 + (webrtc::PeerConnectionInterface::BundlePolicy)nativeBundlePolicyForPolicy: | |
| 146 (RTCBundlePolicy)policy { | |
| 147 switch (policy) { | |
| 148 case RTCBundlePolicyBalanced: | |
| 149 return webrtc::PeerConnectionInterface::kBundlePolicyBalanced; | |
| 150 case RTCBundlePolicyMaxCompat: | |
| 151 return webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat; | |
| 152 case RTCBundlePolicyMaxBundle: | |
| 153 return webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle; | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 + (RTCBundlePolicy)bundlePolicyForNativePolicy: | |
| 158 (webrtc::PeerConnectionInterface::BundlePolicy)nativePolicy { | |
| 159 switch (nativePolicy) { | |
| 160 case webrtc::PeerConnectionInterface::kBundlePolicyBalanced: | |
| 161 return RTCBundlePolicyBalanced; | |
| 162 case webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat: | |
| 163 return RTCBundlePolicyMaxCompat; | |
| 164 case webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle: | |
| 165 return RTCBundlePolicyMaxBundle; | |
| 166 } | |
| 167 } | |
| 168 | |
| 169 + (NSString *)stringForBundlePolicy:(RTCBundlePolicy)policy { | |
| 170 switch (policy) { | |
| 171 case RTCBundlePolicyBalanced: | |
| 172 return @"BALANCED"; | |
| 173 case RTCBundlePolicyMaxCompat: | |
| 174 return @"MAX_COMPAT"; | |
| 175 case RTCBundlePolicyMaxBundle: | |
| 176 return @"MAX_BUNDLE"; | |
| 177 } | |
| 178 } | |
| 179 | |
| 180 + (webrtc::PeerConnectionInterface::RtcpMuxPolicy)nativeRtcpMuxPolicyForPolicy: | |
| 181 (RTCRtcpMuxPolicy)policy { | |
| 182 switch (policy) { | |
| 183 case RTCRtcpMuxPolicyNegotiate: | |
| 184 return webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate; | |
| 185 case RTCRtcpMuxPolicyRequire: | |
| 186 return webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire; | |
| 187 } | |
| 188 } | |
| 189 | |
| 190 + (RTCRtcpMuxPolicy)rtcpMuxPolicyForNativePolicy: | |
| 191 (webrtc::PeerConnectionInterface::RtcpMuxPolicy)nativePolicy { | |
| 192 switch (nativePolicy) { | |
| 193 case webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate: | |
| 194 return RTCRtcpMuxPolicyNegotiate; | |
| 195 case webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire: | |
| 196 return RTCRtcpMuxPolicyRequire; | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 + (NSString *)stringForRtcpMuxPolicy:(RTCRtcpMuxPolicy)policy { | |
| 201 switch (policy) { | |
| 202 case RTCRtcpMuxPolicyNegotiate: | |
| 203 return @"NEGOTIATE"; | |
| 204 case RTCRtcpMuxPolicyRequire: | |
| 205 return @"REQUIRE"; | |
| 206 } | |
| 207 } | |
| 208 | |
| 209 + (webrtc::PeerConnectionInterface::TcpCandidatePolicy) | |
| 210 nativeTcpCandidatePolicyForPolicy:(RTCTcpCandidatePolicy)policy { | |
| 211 switch (policy) { | |
| 212 case RTCTcpCandidatePolicyEnabled: | |
| 213 return webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled; | |
| 214 case RTCTcpCandidatePolicyDisabled: | |
| 215 return webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled; | |
| 216 } | |
| 217 } | |
| 218 | |
| 219 + (RTCTcpCandidatePolicy)tcpCandidatePolicyForNativePolicy: | |
| 220 (webrtc::PeerConnectionInterface::TcpCandidatePolicy)nativePolicy { | |
| 221 switch (nativePolicy) { | |
| 222 case webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled: | |
| 223 return RTCTcpCandidatePolicyEnabled; | |
| 224 case webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled: | |
| 225 return RTCTcpCandidatePolicyDisabled; | |
| 226 } | |
| 227 } | |
| 228 | |
| 229 + (NSString *)stringForTcpCandidatePolicy:(RTCTcpCandidatePolicy)policy { | |
| 230 switch (policy) { | |
| 231 case RTCTcpCandidatePolicyEnabled: | |
| 232 return @"TCP_ENABLED"; | |
| 233 case RTCTcpCandidatePolicyDisabled: | |
| 234 return @"TCP_DISABLED"; | |
| 235 } | |
| 236 } | |
| 237 | |
| 238 @end | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1903663002:
Build dynamic iOS SDK. (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master