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