@@ -77,7 +77,24 @@ impl PeerConnectionInternal {
77
77
stats_interceptor : Arc < stats:: StatsInterceptor > ,
78
78
mut configuration : RTCConfiguration ,
79
79
) -> Result < ( Arc < Self > , RTCConfiguration ) > {
80
- let mut pc = PeerConnectionInternal {
80
+ // Create the ice gatherer
81
+ let ice_gatherer = Arc :: new ( api. new_ice_gatherer ( RTCIceGatherOptions {
82
+ ice_servers : configuration. get_ice_servers ( ) ,
83
+ ice_gather_policy : configuration. ice_transport_policy ,
84
+ } ) ?) ;
85
+
86
+ // Create the ICE transport
87
+ let ice_transport = Arc :: new ( api. new_ice_transport ( Arc :: clone ( & ice_gatherer) ) ) ;
88
+
89
+ // Create the DTLS transport
90
+ let certificates = configuration. certificates . drain ( ..) . collect ( ) ;
91
+ let dtls_transport =
92
+ Arc :: new ( api. new_dtls_transport ( Arc :: clone ( & ice_transport) , certificates) ?) ;
93
+
94
+ // Create the SCTP transport
95
+ let sctp_transport = Arc :: new ( api. new_sctp_transport ( Arc :: clone ( & dtls_transport) ) ?) ;
96
+
97
+ let pc = Arc :: new ( PeerConnectionInternal {
81
98
greater_mid : AtomicIsize :: new ( -1 ) ,
82
99
sdp_origin : Mutex :: new ( Default :: default ( ) ) ,
83
100
last_offer : Mutex :: new ( "" . to_owned ( ) ) ,
@@ -89,16 +106,16 @@ impl PeerConnectionInternal {
89
106
is_negotiation_needed : Arc :: new ( AtomicBool :: new ( false ) ) ,
90
107
negotiation_needed_state : Arc :: new ( AtomicU8 :: new ( NegotiationNeededState :: Empty as u8 ) ) ,
91
108
signaling_state : Arc :: new ( AtomicU8 :: new ( RTCSignalingState :: Stable as u8 ) ) ,
92
- ice_transport : Arc :: new ( Default :: default ( ) ) ,
93
- dtls_transport : Arc :: new ( Default :: default ( ) ) ,
109
+ ice_transport,
110
+ dtls_transport,
94
111
ice_connection_state : Arc :: new ( AtomicU8 :: new ( RTCIceConnectionState :: New as u8 ) ) ,
95
- sctp_transport : Arc :: new ( Default :: default ( ) ) ,
112
+ sctp_transport,
96
113
rtp_transceivers : Arc :: new ( Default :: default ( ) ) ,
97
114
on_track_handler : Arc :: new ( ArcSwapOption :: empty ( ) ) ,
98
115
on_signaling_state_change_handler : ArcSwapOption :: empty ( ) ,
99
116
on_ice_connection_state_change_handler : Arc :: new ( ArcSwapOption :: empty ( ) ) ,
100
117
on_data_channel_handler : Arc :: new ( Default :: default ( ) ) ,
101
- ice_gatherer : Arc :: new ( Default :: default ( ) ) ,
118
+ ice_gatherer,
102
119
current_local_description : Arc :: new ( Default :: default ( ) ) ,
103
120
current_remote_description : Arc :: new ( Default :: default ( ) ) ,
104
121
pending_local_description : Arc :: new ( Default :: default ( ) ) ,
@@ -114,39 +131,77 @@ impl PeerConnectionInternal {
114
131
stats_interceptor,
115
132
on_peer_connection_state_change_handler : Arc :: new ( ArcSwapOption :: empty ( ) ) ,
116
133
pending_remote_description : Arc :: new ( Default :: default ( ) ) ,
117
- } ;
118
-
119
- // Create the ice gatherer
120
- pc. ice_gatherer = Arc :: new ( api. new_ice_gatherer ( RTCIceGatherOptions {
121
- ice_servers : configuration. get_ice_servers ( ) ,
122
- ice_gather_policy : configuration. ice_transport_policy ,
123
- } ) ?) ;
124
-
125
- // Create the ice transport
126
- pc. ice_transport = pc. create_ice_transport ( api) . await ;
134
+ } ) ;
127
135
128
- // Create the DTLS transport
129
- let certificates = configuration. certificates . drain ( ..) . collect ( ) ;
130
- pc. dtls_transport =
131
- Arc :: new ( api. new_dtls_transport ( Arc :: clone ( & pc. ice_transport ) , certificates) ?) ;
136
+ // Wire up the ice transport connection state change handler
137
+ let ice_connection_state = Arc :: clone ( & pc. ice_connection_state ) ;
138
+ let peer_connection_state = Arc :: clone ( & pc. peer_connection_state ) ;
139
+ let is_closed = Arc :: clone ( & pc. is_closed ) ;
140
+ let dtls_transport = Arc :: clone ( & pc. dtls_transport ) ;
141
+ let on_ice_connection_state_change_handler =
142
+ Arc :: clone ( & pc. on_ice_connection_state_change_handler ) ;
143
+ let on_peer_connection_state_change_handler =
144
+ Arc :: clone ( & pc. on_peer_connection_state_change_handler ) ;
145
+
146
+ pc. ice_transport . on_connection_state_change ( Box :: new (
147
+ move |state : RTCIceTransportState | {
148
+ let cs = match state {
149
+ RTCIceTransportState :: New => RTCIceConnectionState :: New ,
150
+ RTCIceTransportState :: Checking => RTCIceConnectionState :: Checking ,
151
+ RTCIceTransportState :: Connected => RTCIceConnectionState :: Connected ,
152
+ RTCIceTransportState :: Completed => RTCIceConnectionState :: Completed ,
153
+ RTCIceTransportState :: Failed => RTCIceConnectionState :: Failed ,
154
+ RTCIceTransportState :: Disconnected => RTCIceConnectionState :: Disconnected ,
155
+ RTCIceTransportState :: Closed => RTCIceConnectionState :: Closed ,
156
+ _ => {
157
+ log:: warn!( "on_connection_state_change: unhandled ICE state: {}" , state) ;
158
+ return Box :: pin ( async { } ) ;
159
+ }
160
+ } ;
132
161
133
- // Create the SCTP transport
134
- pc. sctp_transport = Arc :: new ( api. new_sctp_transport ( Arc :: clone ( & pc. dtls_transport ) ) ?) ;
162
+ let dtls_transport = Arc :: clone ( & dtls_transport) ;
163
+ let ice_connection_state = Arc :: clone ( & ice_connection_state) ;
164
+ let on_ice_connection_state_change_handler =
165
+ Arc :: clone ( & on_ice_connection_state_change_handler) ;
166
+ let on_peer_connection_state_change_handler =
167
+ Arc :: clone ( & on_peer_connection_state_change_handler) ;
168
+ let is_closed = Arc :: clone ( & is_closed) ;
169
+ let peer_connection_state = Arc :: clone ( & peer_connection_state) ;
170
+ Box :: pin ( async move {
171
+ RTCPeerConnection :: do_ice_connection_state_change (
172
+ & on_ice_connection_state_change_handler,
173
+ & ice_connection_state,
174
+ cs,
175
+ )
176
+ . await ;
177
+
178
+ let dtls_transport_state = dtls_transport. state ( ) ;
179
+ RTCPeerConnection :: update_connection_state (
180
+ & on_peer_connection_state_change_handler,
181
+ & is_closed,
182
+ & peer_connection_state,
183
+ cs,
184
+ dtls_transport_state,
185
+ )
186
+ . await ;
187
+ } )
188
+ } ,
189
+ ) ) ;
135
190
136
191
// Wire up the on datachannel handler
137
192
let on_data_channel_handler = Arc :: clone ( & pc. on_data_channel_handler ) ;
138
193
pc. sctp_transport
139
194
. on_data_channel ( Box :: new ( move |d : Arc < RTCDataChannel > | {
140
- let on_data_channel_handler2 = Arc :: clone ( & on_data_channel_handler) ;
195
+ let on_data_channel_handler = Arc :: clone ( & on_data_channel_handler) ;
141
196
Box :: pin ( async move {
142
- if let Some ( handler) = & * on_data_channel_handler2 . load ( ) {
197
+ if let Some ( handler) = & * on_data_channel_handler . load ( ) {
143
198
let mut f = handler. lock ( ) . await ;
144
199
f ( d) . await ;
145
200
}
146
201
} )
147
202
} ) ) ;
148
203
149
- Ok ( ( Arc :: new ( pc ) , configuration) )
204
+ Ok ( ( pc , configuration) )
150
205
}
151
206
152
207
pub ( super ) async fn start_rtp (
@@ -1141,63 +1196,6 @@ impl PeerConnectionInternal {
1141
1196
}
1142
1197
}
1143
1198
1144
- pub ( super ) async fn create_ice_transport ( & self , api : & API ) -> Arc < RTCIceTransport > {
1145
- let ice_transport = Arc :: new ( api. new_ice_transport ( Arc :: clone ( & self . ice_gatherer ) ) ) ;
1146
-
1147
- let ice_connection_state = Arc :: clone ( & self . ice_connection_state ) ;
1148
- let peer_connection_state = Arc :: clone ( & self . peer_connection_state ) ;
1149
- let is_closed = Arc :: clone ( & self . is_closed ) ;
1150
- let dtls_transport = Arc :: clone ( & self . dtls_transport ) ;
1151
- let on_ice_connection_state_change_handler =
1152
- Arc :: clone ( & self . on_ice_connection_state_change_handler ) ;
1153
- let on_peer_connection_state_change_handler =
1154
- Arc :: clone ( & self . on_peer_connection_state_change_handler ) ;
1155
-
1156
- ice_transport. on_connection_state_change ( Box :: new ( move |state : RTCIceTransportState | {
1157
- let cs = match state {
1158
- RTCIceTransportState :: New => RTCIceConnectionState :: New ,
1159
- RTCIceTransportState :: Checking => RTCIceConnectionState :: Checking ,
1160
- RTCIceTransportState :: Connected => RTCIceConnectionState :: Connected ,
1161
- RTCIceTransportState :: Completed => RTCIceConnectionState :: Completed ,
1162
- RTCIceTransportState :: Failed => RTCIceConnectionState :: Failed ,
1163
- RTCIceTransportState :: Disconnected => RTCIceConnectionState :: Disconnected ,
1164
- RTCIceTransportState :: Closed => RTCIceConnectionState :: Closed ,
1165
- _ => {
1166
- log:: warn!( "on_connection_state_change: unhandled ICE state: {}" , state) ;
1167
- return Box :: pin ( async { } ) ;
1168
- }
1169
- } ;
1170
-
1171
- let ice_connection_state2 = Arc :: clone ( & ice_connection_state) ;
1172
- let on_ice_connection_state_change_handler2 =
1173
- Arc :: clone ( & on_ice_connection_state_change_handler) ;
1174
- let on_peer_connection_state_change_handler2 =
1175
- Arc :: clone ( & on_peer_connection_state_change_handler) ;
1176
- let is_closed2 = Arc :: clone ( & is_closed) ;
1177
- let dtls_transport_state = dtls_transport. state ( ) ;
1178
- let peer_connection_state2 = Arc :: clone ( & peer_connection_state) ;
1179
- Box :: pin ( async move {
1180
- RTCPeerConnection :: do_ice_connection_state_change (
1181
- & on_ice_connection_state_change_handler2,
1182
- & ice_connection_state2,
1183
- cs,
1184
- )
1185
- . await ;
1186
-
1187
- RTCPeerConnection :: update_connection_state (
1188
- & on_peer_connection_state_change_handler2,
1189
- & is_closed2,
1190
- & peer_connection_state2,
1191
- cs,
1192
- dtls_transport_state,
1193
- )
1194
- . await ;
1195
- } )
1196
- } ) ) ;
1197
-
1198
- ice_transport
1199
- }
1200
-
1201
1199
/// has_local_description_changed returns whether local media (rtp_transceivers) has changed
1202
1200
/// caller of this method should hold `pc.mu` lock
1203
1201
pub ( super ) async fn has_local_description_changed ( & self , desc : & RTCSessionDescription ) -> bool {
0 commit comments