Merge pull request #125 from SloMR/feat/ImproveStableConnection

Client: Improves WebRTC connection stability

Author: ai-chain-dev

client/src/app/core/services/communication/webrtc-signaling.service.ts

@@ -331,6 +331,17 @@ export class WebRTCSignalingService {
       return;
     }
 
+    // Check and close existing connection first to prevent memory leaks
+    const existingConnection = this.peerConnections.get(targetUser);
+    if (existingConnection) {
+      this.logger.warn(
+        'createPeerConnection',
+        `Peer connection already exists for ${targetUser}, closing old one`
+      );
+      existingConnection.close();
+      this.peerConnections.delete(targetUser);
+    }
+
     const peerConnection = new RTCPeerConnection(RTC_CONFIGURATION);
 
     let iceGatheringTimeout: ReturnType<typeof setTimeout> | null = null;
@@ -635,10 +646,14 @@ export class WebRTCSignalingService {
       }
     }
 
+    // Set lock while processing offer to prevent concurrent connection attempts
+    this.connectionLocks.add(targetUser);
+
     const peerConnection = this.createPeerConnection(targetUser);
 
     if (!peerConnection) {
       this.logger.error('handleOffer', `PeerConnection missing for ${targetUser}`);
+      this.connectionLocks.delete(targetUser);
       return;
     }
 
@@ -651,6 +666,8 @@ export class WebRTCSignalingService {
         return peerConnection.setLocalDescription(answer);
       })
       .then(() => {
+        // Release lock after answer is sent
+        this.connectionLocks.delete(targetUser);
         const response: SignalMessage = {
           type: SignalMessageType.ANSWER,
           data: peerConnection.localDescription,
@@ -661,6 +678,8 @@ export class WebRTCSignalingService {
         this.processCandidateQueue(targetUser);
       })
       .catch((error) => {
+        // Release lock on error
+        this.connectionLocks.delete(targetUser);
         this.logger.error('handleOffer', `Error handling offer: ${error}`);
         if (this.wsService.isConnected()) {
           this.toaster.warning(
@@ -741,6 +760,17 @@ export class WebRTCSignalingService {
       clearTimeout(existingTimeout);
     }
 
+    // Clear reconnection timeout to prevent collision with state mismatch recovery
+    const reconnectionTimeout = this.reconnectionTimeouts.get(targetUser);
+    if (reconnectionTimeout) {
+      clearTimeout(reconnectionTimeout);
+      this.reconnectionTimeouts.delete(targetUser);
+      this.logger.debug(
+        'handleStateMismatch',
+        `Cleared reconnection timeout for ${targetUser} to prevent collision`
+      );
+    }
+
     const timeoutId = setTimeout(() => {
       this.stateMismatchTimeouts.delete(targetUser);
       this.initiateConnection(targetUser);

client/src/app/features/chat/chat.component.ts

@@ -1667,10 +1667,26 @@ export class ChatComponent implements OnInit, OnDestroy, AfterViewInit {
     this.connectionInitTimeouts = [];
 
     this.logger.info('initiateConnectionsWithMembers', 'Initiating connections with other members');
-    const otherMembers = this.members.filter((m) => m !== this.userService.user);
+
+    // Filter out self AND already connected/connecting peers
+    const otherMembers = this.members.filter((m) => {
+      if (m === this.userService.user) {
+        return false;
+      }
+
+      // Skip if already connected or connecting
+      const isConnectedOrConnecting = this.webrtcService.isConnectedOrConnecting(m);
+      if (isConnectedOrConnecting) {
+        this.logger.debug(
+          'initiateConnectionsWithMembers',
+          `Skipping ${m} - already connected/connecting`
+        );
+      }
+      return !isConnectedOrConnecting;
+    });
 
     if (otherMembers.length === 0) {
-      this.logger.warn('initiateConnectionsWithMembers', 'No other members to connect to');
+      this.logger.info('initiateConnectionsWithMembers', 'No new members to connect to');
       return;
     }
 
@@ -1680,9 +1696,9 @@ export class ChatComponent implements OnInit, OnDestroy, AfterViewInit {
       // Determine if we should be the caller for this member
       const shouldInitiate = this.userService.user.localeCompare(member) < 0;
 
-      // Callers start at 1000ms, callees wait an additional 800ms
+      // Callers start at 1000ms, callees wait an additional 500ms
       const baseDelay = 1000;
-      const staggerDelay = shouldInitiate ? 0 : 800;
+      const staggerDelay = shouldInitiate ? 0 : 500;
       const indexDelay = index * 100; // Small delay between multiple members
 
       const timeoutId = setTimeout(