init

src/rtc/mod.rs

@@ -1,25 +1,64 @@
 mod client;
-mod manager;
 mod messages;
 mod metrics;
 pub mod ws_entrypoint;
 
 use crate::config::NetworkConfig;
-use metrics::VoiceMetrics;
-use rustrtc::{RtcConfiguration, RtcConfigurationBuilder};
+use crate::repositories::Repositories;
+use crate::rtc::client::RTCClient;
+use crate::services::Services;
+use event_bus::EventBus;
+use rustrtc::{PeerConnection, RtcConfiguration, RtcConfigurationBuilder};
 use std::sync::Arc;
+// 1. Client crée une RTCPeerConnection
+// 2. Client crée une SDP offer
+// 3. Client envoie l'offer via WebSocket
+// 4. Serveur crée sa PeerConnection
+// 5. Serveur applique l'offer
+// 6. Serveur crée une SDP answer
+// 7. Serveur renvoie l'answer via WebSocket
+// 8. Client et serveur échangent les candidats ICE
+// 9. ICE sélectionne un chemin réseau
+// 10. La connexion WebRTC devient active
 
+#[derive(Debug, Clone)]
 pub struct RTCManager {
     pub config: RtcConfiguration,
+    pub repositories: Arc<Repositories>,
+    pub services: Arc<Services>,
+    pub event_bus: Arc<EventBus>,
 }
 
 impl RTCManager {
-    pub fn new(network: &NetworkConfig, metrics: Arc<VoiceMetrics>) -> Self {
+    pub fn new(
+        network: &NetworkConfig,
+        repositories: Arc<Repositories>,
+        services: Arc<Services>,
+        event_bus: Arc<EventBus>,
+    ) -> Self {
         let builder = RtcConfigurationBuilder::new()
             .ice_udp_mux(true)
             .ice_udp_mux_port(network.udp_port)
             .bind_ip(network.host.to_string());
-        let rtc_config = builder.build();
-        Self { config: rtc_config }
+        let config = builder.build();
+
+        Self {
+            config,
+            repositories,
+            services,
+            event_bus,
+        }
+    }
+
+    /// Session Description Protocol - Permet de se mettre d'accord sur les paramètres media
+    pub async fn handle_sdp_offer(&self, rtc_client: RTCClient, offer_sdp: String) {}
+
+    /// Interactive Connectivity Establishment - Permet de négocier un chemin réseau
+    pub async fn handle_ice_candidate(&self) {}
+
+    pub fn new_peer_connection(&self) -> Arc<PeerConnection> {
+        let pc = Arc::new(PeerConnection::new(self.config.clone()));
+        // todo : some logging ?
+        pc
     }
 }