enable set_configuration and get_configuration

Author: yngrtc

webrtc/src/ice_transport/ice_server.rs

@@ -5,7 +5,7 @@ use crate::ice_transport::ice_credential_type::RTCIceCredentialType;
 
 /// ICEServer describes a single STUN and TURN server that can be used by
 /// the ICEAgent to establish a connection with a peer.
-#[derive(Default, Debug, Clone, Serialize, Deserialize, Hash)]
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize, Hash)]
 pub struct RTCIceServer {
     pub urls: Vec<String>,
     pub username: String,

webrtc/src/peer_connection/mod.rs

@@ -191,7 +191,7 @@ pub struct RTCPeerConnection {
     stats_id: String,
     idp_login_url: Option<String>,
 
-    configuration: RTCConfiguration,
+    configuration: Mutex<RTCConfiguration>,
 
     interceptor_rtcp_writer: Arc<dyn RTCPWriter + Send + Sync>,
 
@@ -256,7 +256,7 @@ impl RTCPeerConnection {
             interceptor,
             interceptor_rtcp_writer,
             internal,
-            configuration,
+            configuration: Mutex::new(configuration),
             idp_login_url: None,
         })
     }
@@ -647,80 +647,78 @@ impl RTCPeerConnection {
         }
     }
 
-    /*TODO: // set_configuration updates the configuration of this PeerConnection object.
-    pub async fn set_configuration(&mut self, configuration: Configuration) -> Result<()> {
-        //nolint:gocognit
+    // set_configuration updates the configuration of this PeerConnection object.
+    pub async fn set_configuration(&self, configuration: RTCConfiguration) -> Result<()> {
         // https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-setconfiguration (step #2)
+        let mut config_lock = self.configuration.lock().await;
+
         if self.internal.is_closed.load(Ordering::SeqCst) {
-            return Err(Error::ErrConnectionClosed.into());
+            return Err(Error::ErrConnectionClosed);
         }
 
         // https://www.w3.org/TR/webrtc/#set-the-configuration (step #3)
         if !configuration.peer_identity.is_empty() {
-            if configuration.peer_identity != self.configuration.peer_identity {
-                return Err(Error::ErrModifyingPeerIdentity.into());
+            if configuration.peer_identity != config_lock.peer_identity {
+                return Err(Error::ErrModifyingPeerIdentity);
             }
-            self.configuration.peer_identity = configuration.peer_identity;
+            config_lock.peer_identity = configuration.peer_identity;
         }
 
         // https://www.w3.org/TR/webrtc/#set-the-configuration (step #4)
         if !configuration.certificates.is_empty() {
-            if configuration.certificates.len() != self.configuration.certificates.len() {
-                return Err(Error::ErrModifyingCertificates.into());
+            if configuration.certificates.len() != config_lock.certificates.len() {
+                return Err(Error::ErrModifyingCertificates);
             }
 
-            self.configuration.certificates = configuration.certificates;
+            config_lock.certificates = configuration.certificates;
         }
 
         // https://www.w3.org/TR/webrtc/#set-the-configuration (step #5)
-        if configuration.bundle_policy != BundlePolicy::Unspecified {
-            if configuration.bundle_policy != self.configuration.bundle_policy {
-                return Err(Error::ErrModifyingBundlePolicy.into());
-            }
-            self.configuration.bundle_policy = configuration.bundle_policy;
+
+        if configuration.bundle_policy != config_lock.bundle_policy {
+            return Err(Error::ErrModifyingBundlePolicy);
         }
+        config_lock.bundle_policy = configuration.bundle_policy;
 
         // https://www.w3.org/TR/webrtc/#set-the-configuration (step #6)
-        if configuration.rtcp_mux_policy != RTCPMuxPolicy::Unspecified {
-            if configuration.rtcp_mux_policy != self.configuration.rtcp_mux_policy {
-                return Err(Error::ErrModifyingRTCPMuxPolicy.into());
-            }
-            self.configuration.rtcp_mux_policy = configuration.rtcp_mux_policy;
+        if configuration.rtcp_mux_policy != config_lock.rtcp_mux_policy {
+            return Err(Error::ErrModifyingRTCPMuxPolicy);
         }
+        config_lock.rtcp_mux_policy = configuration.rtcp_mux_policy;
 
         // https://www.w3.org/TR/webrtc/#set-the-configuration (step #7)
         if configuration.ice_candidate_pool_size != 0 {
-            if self.configuration.ice_candidate_pool_size != configuration.ice_candidate_pool_size
+            if config_lock.ice_candidate_pool_size != configuration.ice_candidate_pool_size
                 && self.local_description().await.is_some()
             {
-                return Err(Error::ErrModifyingICECandidatePoolSize.into());
+                return Err(Error::ErrModifyingICECandidatePoolSize);
             }
-            self.configuration.ice_candidate_pool_size = configuration.ice_candidate_pool_size;
+            config_lock.ice_candidate_pool_size = configuration.ice_candidate_pool_size;
         }
 
         // https://www.w3.org/TR/webrtc/#set-the-configuration (step #8)
-        if configuration.ice_transport_policy != ICETransportPolicy::Unspecified {
-            self.configuration.ice_transport_policy = configuration.ice_transport_policy
-        }
+
+        config_lock.ice_transport_policy = configuration.ice_transport_policy;
 
         // https://www.w3.org/TR/webrtc/#set-the-configuration (step #11)
         if !configuration.ice_servers.is_empty() {
             // https://www.w3.org/TR/webrtc/#set-the-configuration (step #11.3)
             for server in &configuration.ice_servers {
                 server.validate()?;
             }
-            self.configuration.ice_servers = configuration.ice_servers
+            config_lock.ice_servers = configuration.ice_servers
         }
         Ok(())
-    }*/
+    }
 
     /// get_configuration returns a Configuration object representing the current
     /// configuration of this PeerConnection object. The returned object is a
     /// copy and direct mutation on it will not take affect until set_configuration
     /// has been called with Configuration passed as its only argument.
     /// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-getconfiguration>
-    pub fn get_configuration(&self) -> &RTCConfiguration {
-        &self.configuration
+    pub async fn get_configuration(&self) -> RTCConfiguration {
+        let configuration = self.configuration.lock().await;
+        configuration.clone()
     }
 
     pub fn get_stats_id(&self) -> &str {

webrtc/src/peer_connection/peer_connection_test.rs

@@ -14,6 +14,7 @@ use crate::api::interceptor_registry::register_default_interceptors;
 use crate::api::media_engine::{MediaEngine, MIME_TYPE_VP8};
 use crate::api::APIBuilder;
 use crate::ice_transport::ice_candidate_pair::RTCIceCandidatePair;
+use crate::ice_transport::ice_credential_type::RTCIceCredentialType;
 use crate::ice_transport::ice_server::RTCIceServer;
 use crate::peer_connection::configuration::RTCConfiguration;
 use crate::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;
@@ -388,6 +389,98 @@ async fn test_peer_connection_close_is_send() -> Result<()> {
     tokio::join!(handle).0.unwrap()
 }
 
+#[tokio::test]
+async fn test_set_get_configuration() {
+    // initialize MediaEngine and InterceptorRegistry
+    let media_engine = MediaEngine::default();
+    let registry = Registry::default();
+
+    // create API instance
+    let api = APIBuilder::new()
+        .with_media_engine(media_engine)
+        .with_interceptor_registry(registry)
+        .build();
+
+    // create configuration
+    let initial_config = RTCConfiguration {
+        ice_servers: vec![RTCIceServer {
+            urls: vec!["stun:stun.l.google.com:19302".to_string()],
+            username: "".to_string(),
+            credential: "".to_string(),
+            credential_type: RTCIceCredentialType::Unspecified,
+        }],
+        ..Default::default()
+    };
+
+    // create RTCPeerConnection instance
+    let peer = Arc::new(
+        api.new_peer_connection(initial_config.clone())
+            .await
+            .expect("Failed to create RTCPeerConnection"),
+    );
+
+    // get configuration and println
+    let config_before = peer.get_configuration().await;
+    println!("Initial ICE Servers: {:?}", config_before.ice_servers);
+    println!(
+        "Initial ICE Transport Policy: {:?}",
+        config_before.ice_transport_policy
+    );
+    println!("Initial Bundle Policy: {:?}", config_before.bundle_policy);
+    println!(
+        "Initial RTCP Mux Policy: {:?}",
+        config_before.rtcp_mux_policy
+    );
+    println!("Initial Peer Identity: {:?}", config_before.peer_identity);
+    println!("Initial Certificates: {:?}", config_before.certificates);
+    println!(
+        "Initial ICE Candidate Pool Size: {:?}",
+        config_before.ice_candidate_pool_size
+    );
+    println!("");
+
+    // create new configuration
+    let new_config = RTCConfiguration {
+        ice_servers: vec![RTCIceServer {
+            urls: vec![
+                "turn:turn.22333.fun".to_string(),
+                "turn:cn.22333.fun".to_string(),
+            ],
+            username: "live777".to_string(),
+            credential: "live777".to_string(),
+            credential_type: RTCIceCredentialType::Password,
+        }],
+        ..Default::default()
+    };
+
+    // set new configuration
+    peer.set_configuration(new_config.clone())
+        .await
+        .expect("Failed to set configuration");
+
+    // get new configuration and println
+    let updated_config = peer.get_configuration().await;
+    println!("Updated ICE Servers: {:?}", updated_config.ice_servers);
+    println!(
+        "Updated ICE Transport Policy: {:?}",
+        updated_config.ice_transport_policy
+    );
+    println!("Updated Bundle Policy: {:?}", updated_config.bundle_policy);
+    println!(
+        "Updated RTCP Mux Policy: {:?}",
+        updated_config.rtcp_mux_policy
+    );
+    println!("Updated Peer Identity: {:?}", updated_config.peer_identity);
+    println!("Updated Certificates: {:?}", updated_config.certificates);
+    println!(
+        "Updated ICE Candidate Pool Size: {:?}",
+        updated_config.ice_candidate_pool_size
+    );
+
+    // verify
+    assert_eq!(updated_config.ice_servers, new_config.ice_servers);
+}
+
 async fn peer() -> Result<()> {
     let mut m = MediaEngine::default();
     m.register_default_codecs()?;