@phystack/hub-client 4.5.19-dev → 4.5.20-dev

package/src/services/webrtc/datachannel.ts

@@ -1,421 +0,0 @@
-// Initialize WebRTC globals if we're in Node environment
-(async function initializeWebRTCGlobals() {
-  // Only run in Node environment
-  if (typeof window !== 'undefined') return;
-
-  try {
-    // Dynamically import wrtc
-    const wrtc = require('@roamhq/wrtc');
-
-    // Set all WebRTC globals
-    if (typeof global.MediaStream === 'undefined' && wrtc.MediaStream) {
-      global.MediaStream = wrtc.MediaStream;
-      console.log('Global MediaStream initialized');
-    }
-
-    if (typeof global.RTCDataChannel === 'undefined' && wrtc.RTCDataChannel) {
-      global.RTCDataChannel = wrtc.RTCDataChannel;
-      console.log('Global RTCDataChannel initialized');
-    }
-
-    if (typeof global.RTCPeerConnection === 'undefined' && wrtc.RTCPeerConnection) {
-      global.RTCPeerConnection = wrtc.RTCPeerConnection;
-      console.log('Global RTCPeerConnection initialized');
-    }
-
-    if (typeof global.RTCSessionDescription === 'undefined' && wrtc.RTCSessionDescription) {
-      global.RTCSessionDescription = wrtc.RTCSessionDescription;
-      console.log('Global RTCSessionDescription initialized');
-    }
-
-    if (typeof global.RTCIceCandidate === 'undefined' && wrtc.RTCIceCandidate) {
-      global.RTCIceCandidate = wrtc.RTCIceCandidate;
-      console.log('Global RTCIceCandidate initialized');
-    }
-
-    console.log('WebRTC globals successfully initialized');
-  } catch (error) {
-    console.error('Failed to initialize WebRTC globals:', error);
-  }
-})().catch(err => console.error('Error in WebRTC globals initialization:', err));
-
-import { PhygridDataChannel, WebRTCConnectionOptions } from '../../types/webrtc.types';
-import {
-  PeerConnectionState,
-  PeerConnectionCallbacks,
-  attemptConnection as attemptConnectionICE,
-  triggerReconnect as triggerReconnectICE,
-} from './peer-connection-ice';
-
-// Initialize WebRTC globals if we're in Node environment
-(async function initializeWebRTCGlobals() {
-  // Only run in Node environment
-  if (typeof window !== 'undefined') return;
-
-  try {
-    // Dynamically import wrtc
-    const wrtc = require('@roamhq/wrtc');
-
-    // Set all WebRTC globals
-    if (typeof global.MediaStream === 'undefined' && wrtc.MediaStream) {
-      global.MediaStream = wrtc.MediaStream;
-      console.log('Global MediaStream initialized');
-    }
-
-    if (typeof global.RTCPeerConnection === 'undefined' && wrtc.RTCPeerConnection) {
-      global.RTCPeerConnection = wrtc.RTCPeerConnection;
-      console.log('Global RTCPeerConnection initialized');
-    }
-
-    if (typeof global.RTCSessionDescription === 'undefined' && wrtc.RTCSessionDescription) {
-      global.RTCSessionDescription = wrtc.RTCSessionDescription;
-      console.log('Global RTCSessionDescription initialized');
-    }
-
-    if (typeof global.RTCIceCandidate === 'undefined' && wrtc.RTCIceCandidate) {
-      global.RTCIceCandidate = wrtc.RTCIceCandidate;
-      console.log('Global RTCIceCandidate initialized');
-    }
-
-    console.log('WebRTC globals successfully initialized');
-  } catch (error) {
-    console.error('Failed to initialize WebRTC globals:', error);
-  }
-})().catch(err => console.error('Error in WebRTC globals initialization:', err));
-
-export interface WebRTCDataChannelResult {
-  dataChannel: PhygridDataChannel;
-  close: () => void;
-  _rawPeerConnection?: RTCPeerConnection;
-  _rawDataChannel?: RTCDataChannel;
-}
-
-export type WebRTCDataChannelConnectionResult = WebRTCDataChannelResult;
-
-const CONNECTION_TIMEOUT = 15000; // 15 seconds
-const RECONNECT_DELAY = 1000; // 1 second initial reconnect delay
-const INITIAL_RETRY_DELAY = 1000; // 1 second
-const MAX_RETRY_DELAY = 30000; // 30 seconds maximum
-
-export async function createWebRTCDataChannelConnection(
-  options: WebRTCConnectionOptions
-): Promise<WebRTCDataChannelConnectionResult> {
-  let pc: RTCPeerConnection | null = null;
-  let isShuttingDown = false;
-  let isReconnecting = false;
-  let currentConnectionId = 0;
-  let pendingCandidates: RTCIceCandidateInit[] = [];
-  let activeDataChannel: RTCDataChannel | null = null;
-
-  const {
-    targetTwinId,
-    sendTwinMessage,
-    subscribeTwin,
-    onTwinMessage,
-    offTwinMessage,
-    useStun = true,
-    isInitiator = true,
-    channelPrefix = 'channel',
-    mediaOptions = { isMediaConnection: false },
-  } = options;
-
-  // Create the persistent data channel once - this is the key to maintaining state across reconnections
-  const { persistentChannel, setupDataChannel, setCleanupFn } = createPersistentDataChannel();
-
-  // Set up cleanup function
-  setCleanupFn(() => {
-    if (mediaOptions.isMediaConnection && mediaOptions.localStream) {
-      mediaOptions.localStream.getTracks().forEach(track => track.stop());
-    }
-  });
-
-  const callbacks: PeerConnectionCallbacks = {
-    async onCreateConnection(
-      pcInstance: RTCPeerConnection,
-      connectionId: number,
-      localInitiator: boolean
-    ) {
-      console.log(
-        `Creating data channel for connection ID: ${connectionId} ${JSON.stringify(localInitiator)}`
-      );
-      const channelId = `${channelPrefix}-${targetTwinId}`;
-
-      return new Promise<RTCDataChannel | null>(resolve => {
-        if (isInitiator) {
-          const dataChannel = pcInstance.createDataChannel(channelId);
-          dataChannel.binaryType = 'arraybuffer';
-          setupDataChannel(dataChannel, isReconnecting, isShuttingDown, triggerReconnect);
-
-          // This is important - we need to resolve with the data channel
-          // even before it's open, so the ICE process can continue
-          resolve(dataChannel);
-        } else {
-          pcInstance.ondatachannel = event => {
-            console.log('Data channel received in hub-client');
-            const dataChannel = event.channel;
-            dataChannel.binaryType = 'arraybuffer';
-            setupDataChannel(dataChannel, isReconnecting, isShuttingDown, triggerReconnect);
-          };
-          resolve(null);
-        }
-      });
-    },
-
-    onCloseCleanup() {
-      if (mediaOptions.isMediaConnection && mediaOptions.localStream) {
-        mediaOptions.localStream.getTracks().forEach(track => track.stop());
-      }
-    },
-
-    async onSubscribe() {
-      await subscribeTwin(targetTwinId);
-    },
-
-    async sendSignalingMessage(type, data) {
-      await sendTwinMessage(targetTwinId, {
-        type: `${channelPrefix}-${targetTwinId}:${type}`,
-        data,
-      });
-    },
-
-    setupMessageHandling(messageHandler) {
-      onTwinMessage(targetTwinId, messageHandler);
-    },
-
-    removeMessageHandling(messageHandler) {
-      console.log(`Removing message listener for twin ${targetTwinId}`);
-      offTwinMessage(targetTwinId, messageHandler);
-    },
-
-    reportConnectionState(info: string) {
-      console.log(info);
-    },
-
-    reportError(info: string, error?: any) {
-      console.error(info, error || '');
-    },
-
-    async retryConnection(retries: number, toggledUseStun?: boolean, nextDelay?: number) {
-      // Important: we need to reset isReconnecting before starting a new connection attempt
-      isReconnecting = false;
-
-      return attemptConnectionICE(
-        state,
-        { ...options, useStun: toggledUseStun ?? useStun },
-        retries,
-        toggledUseStun ?? useStun,
-        nextDelay ?? INITIAL_RETRY_DELAY,
-        INITIAL_RETRY_DELAY,
-        CONNECTION_TIMEOUT,
-        MAX_RETRY_DELAY,
-        callbacks
-      );
-    },
-
-    safeReject(error) {
-      throw error;
-    },
-  };
-
-  const state: PeerConnectionState = {
-    pc,
-    isShuttingDown,
-    isReconnecting,
-    currentConnectionId,
-    pendingCandidates,
-    activeDataChannel,
-    useStun,
-    channelPrefix,
-    targetTwinId,
-    isInitiator,
-    connectionType: 'datachannel',
-  };
-
-  function triggerReconnect(attempt: number) {
-    if (isReconnecting || isShuttingDown) {
-      console.log(
-        `triggerReconnect() called but already reconnecting or shutting down (attempt ${attempt})`
-      );
-      return;
-    }
-
-    isReconnecting = true;
-
-    triggerReconnectICE(state, attempt, RECONNECT_DELAY, callbacks);
-  }
-
-  const result = await attemptConnectionICE(
-    state,
-    { ...options },
-    0,
-    useStun,
-    INITIAL_RETRY_DELAY,
-    INITIAL_RETRY_DELAY,
-    CONNECTION_TIMEOUT,
-    MAX_RETRY_DELAY,
-    callbacks
-  );
-
-  // Return the persistent data channel
-  return {
-    dataChannel: persistentChannel,
-    _rawPeerConnection: result._rawPeerConnection,
-    _rawDataChannel: result._rawDataChannel,
-    close: () => {
-      isShuttingDown = true;
-      if (result.close) {
-        result.close();
-      }
-    },
-  };
-}
-
-const createPersistentDataChannel = (): {
-  persistentChannel: PhygridDataChannel;
-  setupDataChannel: (
-    dc: RTCDataChannel,
-    isReconnecting: boolean,
-    isShuttingDown: boolean,
-    triggerReconnect: (attempt: number) => void
-  ) => void;
-  setCleanupFn: (fn: () => void) => void;
-} => {
-  const messageListeners: ((data: any) => void)[] = [];
-  const closeListeners: (() => void)[] = [];
-
-  let currentDataChannel: RTCDataChannel | null = null;
-  let activeDataChannel: RTCDataChannel | null = null;
-  let reconnectAttempts = 0;
-  let cleanupFn: (() => void) | null = null;
-
-  const setCleanupFn = (fn: () => void) => {
-    cleanupFn = fn;
-  };
-
-  const persistentChannel: PhygridDataChannel = {
-    send: (data: any) => {
-      if (activeDataChannel && activeDataChannel.readyState === 'open') {
-        try {
-          // Convert data to string if it's an object
-          if (typeof data === 'object' && data !== null) {
-            activeDataChannel.send(JSON.stringify(data));
-          } else {
-            activeDataChannel.send(data);
-          }
-        } catch (error) {
-          console.error('Error sending data:', error);
-        }
-      } else {
-        console.warn(
-          'Channel not ready, dropping message. State:',
-          activeDataChannel ? activeDataChannel.readyState : 'no channel'
-        );
-      }
-    },
-    onMessage: (callback: (data: any) => void) => {
-      console.log('Adding message listener to persistent channel');
-      messageListeners.push(callback);
-    },
-    offMessage: (callback: (data: any) => void) => {
-      const index = messageListeners.indexOf(callback);
-      if (index !== -1) {
-        messageListeners.splice(index, 1);
-      }
-    },
-    onClose: (callback: () => void) => {
-      closeListeners.push(callback);
-    },
-    offClose: (callback: () => void) => {
-      const index = closeListeners.indexOf(callback);
-      if (index !== -1) {
-        closeListeners.splice(index, 1);
-      }
-    },
-    close: () => {
-      if (currentDataChannel && currentDataChannel.readyState !== 'closed') {
-        currentDataChannel.close();
-      }
-      if (cleanupFn) cleanupFn();
-    },
-  };
-
-  const setupDataChannel = (
-    dc: RTCDataChannel,
-    isReconnecting: boolean,
-    isShuttingDown: boolean,
-    triggerReconnect: (attempt: number) => void
-  ) => {
-    console.log('Setting up data channel with listeners');
-    currentDataChannel = dc;
-    activeDataChannel = dc;
-
-    dc.onopen = () => {
-      console.log('Data channel opened in setupDataChannel, readyState:', dc.readyState);
-      currentDataChannel = dc;
-      activeDataChannel = dc;
-    };
-
-    dc.onmessage = event => {
-      console.log('Received message in data channel:', typeof event.data);
-      let parsedData = event.data;
-
-      // Try to parse JSON if it's a string
-      if (typeof event.data === 'string') {
-        try {
-          parsedData = JSON.parse(event.data);
-        } catch (e) {
-          // Not JSON, use as is
-          parsedData = event.data;
-        }
-      }
-
-      // Forward to all listeners
-      if (messageListeners.length === 0) {
-        console.warn('No message listeners registered for data channel');
-      }
-
-      messageListeners.forEach(listener => {
-        try {
-          listener(parsedData);
-        } catch (error) {
-          console.error('Error handling message:', error);
-        }
-      });
-    };
-
-    dc.onclose = () => {
-      console.log('Data channel closed');
-
-      // Notify all close listeners
-      closeListeners.forEach(listener => {
-        try {
-          listener();
-        } catch (error) {
-          console.error('Error in close listener:', error);
-        }
-      });
-
-      // Only trigger reconnect if not explicitly shutting down
-      if (!isShuttingDown && !isReconnecting) {
-        console.log('Data channel closed unexpectedly, triggering reconnect');
-        triggerReconnect(reconnectAttempts++);
-      }
-      activeDataChannel = null;
-    };
-
-    dc.onerror = error => {
-      console.error('Data channel error:', error);
-      // Errors might also require reconnection
-      if (!isShuttingDown && !isReconnecting) {
-        console.log('Data channel error, triggering reconnect');
-        triggerReconnect(reconnectAttempts++);
-      }
-    };
-  };
-
-  return {
-    persistentChannel,
-    setupDataChannel,
-    setCleanupFn,
-  };
-};