2024年07月19日

 
    pub async fn on_ice_candidate(&self, rtcice_candidate: String) -> Result<(), Box<dyn Error>> {
        if self
            .rtc_peer_connection
            .remote_description()
            .await
            .is_none()
        {
            let local_sender_cloen = self.local_sender.clone();
 
            tokio::spawn(async move {
                time::sleep(std::time::Duration::from_millis(5)).await;
 
                local_sender_cloen
                    .try_send(("on-ice-candidate".to_owned(), rtcice_candidate))
                    .unwrap_or_else(|e| log::error!("{:?}", e));
            });
 
            return Ok(());
        }
 
        let candidate: RTCIceCandidateInit = serde_json::from_str(&rtcice_candidate)?;
 
        let candidate_topic = format!(
            "{}/{}/{}/webrtc/candidate",
            self.remote_type_code.clone(),
            self.remote_type_no.clone(),
            self.remote_session_id.clone()
        );
 
        let candidate_object = RootMessageDto {
            session_id: Default::default(),
            type_code: Some(self.local_type_code.clone()),
            type_no: Some(self.local_type_no.clone()),
            data_encryption_mode: Some(String::from("PLAIN")),
            version: Some(String::from("1.0.0")),
            data: Some(CandidateMessageDataDto {
                candidate: candidate.candidate,
                sdp_mid: candidate.sdp_mid,
                sdp_mline_index: candidate.sdp_mline_index,
                username_fragment: candidate.username_fragment,
            }),
        };
 
        let candidate_string = serde_json::to_string(&candidate_object)?;
 
        self.signalling_sender
            .try_send((candidate_topic, candidate_string))?;
 
        Ok(())
    }
 

 
        let last_ping_time_clone = last_ping_time.clone();
 
        let local_sender_clone = local_sender.clone();
 
        tokio::spawn(async move {
            let mut interval = interval(std::time::Duration::from_secs(15));
 
            loop {
                interval.tick().await;
 
                match last_ping_time_clone.lock() {
                    Ok(last_ping_time) => {
                        let elapsed = Instant::now().duration_since(last_ping_time.clone());
 
                        if elapsed.as_secs() >= 15 {
                            local_sender_clone
                                .try_send(("stop".to_owned(), "".to_owned()))
                                .unwrap_or_else(|e| log::error!("{:?}", e));
 
                            break;
                        }
                    }
                    Err(e) => {
                        log::error!("{:?}", e);
                    }
                }
            }
        });
 
        let local_sender_clone = local_sender.clone();
 
        rtc_peer_connection.on_peer_connection_state_change(Box::new(
            move |rtc_peer_connection_state: RTCPeerConnectionState| {
                let local_sender_clone_clone = local_sender_clone.clone();
 
                Box::pin(async move {
                    log::debug!("Peer Connection State change: {rtc_peer_connection_state}");
 
                    if matches!(
                        rtc_peer_connection_state,
                        RTCPeerConnectionState::Failed | RTCPeerConnectionState::Disconnected
                    ) {
                        local_sender_clone_clone
                            .try_send(("stop".to_owned(), "".to_owned()))
                            .unwrap_or_else(|e| log::error!("{:?}", e));
                    }
                })
            },
        ));