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

package/src/services/webrtc/mediastream.ts

@@ -1,602 +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 {
-  PhygridMediaStream,
-  WebRTCConnectionOptions,
-  ExtendedMediaStreamTrack,
-} from '../../types/webrtc.types';
-import {
-  PeerConnectionState,
-  PeerConnectionCallbacks,
-  attemptConnection as attemptConnectionICE,
-  triggerReconnect as triggerReconnectICE,
-} from './peer-connection-ice';
-
-export interface WebRTCMediaStreamResult {
-  mediaStream: PhygridMediaStream;
-  close: () => void;
-  _rawPeerConnection?: RTCPeerConnection;
-  _rawMediaStream?: MediaStream;
-}
-
-export type WebRTCMediaStreamConnectionResult = WebRTCMediaStreamResult;
-
-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
-const FRAME_INACTIVITY_TIMEOUT = 5000; // 5 seconds without frames is considered inactive
-
-export async function createWebRTCMediaStreamConnection(
-  options: WebRTCConnectionOptions
-): Promise<WebRTCMediaStreamConnectionResult> {
-  let pc: RTCPeerConnection | null = null;
-  let isShuttingDown = false;
-  let isReconnecting = false;
-  let currentConnectionId = 0;
-  let pendingCandidates: RTCIceCandidateInit[] = [];
-  let activeMediaStream: MediaStream | null = null;
-  let persistentLocalStream: MediaStream | undefined;
-
-  const {
-    targetTwinId,
-    sendTwinMessage,
-    subscribeTwin,
-    onTwinMessage,
-    offTwinMessage,
-    useStun = true,
-    isInitiator = true,
-    channelPrefix = 'stream',
-    mediaOptions = { isMediaConnection: true },
-  } = options;
-
-  // Create the persistent media stream once - this is the key to maintaining state across reconnections
-  const { persistentMediaStream, setupMediaStream, setCleanupFn } = createPersistentMediaStream();
-
-  // Set up cleanup function
-  setCleanupFn(() => {
-    if (mediaOptions.isMediaConnection && mediaOptions.localStream) {
-      mediaOptions.localStream.getTracks().forEach(track => track.stop());
-    }
-  });
-
-  if (!isInitiator && mediaOptions.isMediaConnection) {
-    if (!mediaOptions.localStream) {
-      mediaOptions.localStream = new MediaStream();
-      console.log('Created persistent local MediaStream for the non-initiator side.');
-    }
-    persistentLocalStream = mediaOptions.localStream;
-  }
-
-  const callbacks: PeerConnectionCallbacks = {
-    async onCreateConnection(
-      pcInstance: RTCPeerConnection,
-      connectionId: number,
-      localInitiator: boolean
-    ) {
-      console.log(
-        `Setting up media stream for connection ID: ${connectionId} ${JSON.stringify(localInitiator)}`
-      );
-
-      if (mediaOptions.isMediaConnection) {
-        if (localInitiator) {
-          console.log('Setting up recvonly transceiver for initiator');
-          pcInstance.addTransceiver('video', { direction: 'recvonly' });
-        } else {
-          if (persistentLocalStream) {
-            console.log('Attaching previously added tracks to new PC...');
-            for (const track of persistentLocalStream.getTracks()) {
-              console.log('Adding track to new peer connection:', track.kind, track.id);
-              pcInstance.addTrack(track, persistentLocalStream);
-            }
-          } else {
-            console.log('No localStream found yet. Will wait for app to add tracks...');
-          }
-        }
-
-        pcInstance.ontrack = (event: RTCTrackEvent) => {
-          console.log('Track received in hub-client');
-          if (event.streams && event.streams[0]) {
-            setupMediaStream(event.streams[0], isReconnecting, isShuttingDown, triggerReconnect);
-            activeMediaStream = event.streams[0];
-          }
-        };
-      }
-
-      return 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) {
-      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: null,
-    activeMediaStream,
-    useStun,
-    channelPrefix,
-    targetTwinId,
-    isInitiator,
-    connectionType: 'mediastream',
-  };
-
-  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
-  );
-
-  persistentMediaStream.addTrack = function (track: MediaStreamTrack) {
-    console.log(`Adding track to persistent media stream: ${track.kind} - ${track.id}`);
-
-    // Find existing track with same ID
-    const existingTrack = persistentMediaStream._internalTracks?.find(t => t.id === track.id);
-
-    // If exists, remove it first to prevent duplicates
-    if (existingTrack) {
-      console.log(`Track ${track.id} already exists, replacing it`);
-      const trackIndex =
-        persistentMediaStream._internalTracks?.findIndex(t => t.id === track.id) ?? -1;
-      if (trackIndex !== -1 && persistentMediaStream._internalTracks) {
-        persistentMediaStream._internalTracks.splice(trackIndex, 1);
-      }
-    }
-
-    // Add the new track
-    if (persistentMediaStream._internalTracks) {
-      persistentMediaStream._internalTracks.push(track);
-    }
-
-    // Propagate to active stream if it exists
-    if (activeMediaStream) {
-      try {
-        // Check if track already exists in the activeMediaStream
-        const existingActiveTrack = activeMediaStream.getTrackById(track.id);
-        if (existingActiveTrack) {
-          // Replace the track if it exists
-          activeMediaStream.removeTrack(existingActiveTrack);
-        }
-        activeMediaStream.addTrack(track);
-      } catch (error) {
-        console.warn('Error adding track to active MediaStream:', error);
-      }
-    }
-
-    if (!isInitiator && persistentLocalStream) {
-      console.log(
-        'Adding track to persistent local stream for non-initiator side:',
-        track.kind,
-        track.id
-      );
-      // Check if track already exists in the persistentLocalStream
-      const existingLocalTrack = persistentLocalStream.getTrackById(track.id);
-      if (existingLocalTrack) {
-        // Replace the track if it exists
-        persistentLocalStream.removeTrack(existingLocalTrack);
-      }
-      persistentLocalStream.addTrack(track);
-
-      if (state.pc && state.pc.connectionState === 'connected') {
-        console.log('PeerConnection is connected, calling pc.addTrack() now...');
-        const senders = state.pc.getSenders();
-        const existingSender = senders.find(sender => sender.track && sender.track.id === track.id);
-
-        if (existingSender) {
-          console.log('Replacing existing track in sender');
-          existingSender.replaceTrack(track);
-        } else {
-          state.pc.addTrack(track, persistentLocalStream);
-        }
-      } else {
-        console.log(
-          'PeerConnection is not connected yet, will attach track at next onCreateConnection'
-        );
-      }
-    }
-
-    // Notify track listeners about the new track
-    persistentMediaStream._notifyTrackListeners?.(track);
-  };
-
-  const mediaStreamResult: WebRTCMediaStreamResult = {
-    mediaStream: persistentMediaStream,
-    _rawPeerConnection: result._rawPeerConnection,
-    _rawMediaStream: activeMediaStream || undefined,
-    close: () => {
-      isShuttingDown = true;
-      if (result.close) {
-        result.close();
-      }
-    },
-  };
-
-  return mediaStreamResult;
-}
-
-const createPersistentMediaStream = (): {
-  persistentMediaStream: PhygridMediaStream;
-  setupMediaStream: (
-    ms: MediaStream,
-    isReconnecting: boolean,
-    isShuttingDown: boolean,
-    triggerReconnect: (attempt: number) => void
-  ) => void;
-  setCleanupFn: (fn: () => void) => void;
-} => {
-  const trackListeners: ((track: MediaStreamTrack) => void)[] = [];
-  const closeListeners: (() => void)[] = [];
-  const frameListeners: ((frameData: any) => void)[] = [];
-  const tracks: MediaStreamTrack[] = [];
-
-  // Track frame reception timestamps for each track
-  const trackLastFrameTime: Record<string, number> = {};
-  // Frame activity check interval
-  let frameActivityCheckInterval: NodeJS.Timeout | null = null;
-
-  // These variables were keeping references to the media streams but aren't being used.
-  // Removing them to fix the TS6133 errors.
-  let reconnectAttempts = 0;
-  let cleanupFn: (() => void) | null = null;
-  let isActive = false;
-
-  const setCleanupFn = (fn: () => void) => {
-    cleanupFn = fn;
-  };
-
-  const notifyTrackListeners = (track: MediaStreamTrack) => {
-    trackListeners.forEach(listener => {
-      try {
-        listener(track);
-      } catch (error) {
-        console.error('Error in track listener:', error);
-      }
-    });
-  };
-
-  const updateTrackLastFrameTime = (trackId: string) => {
-    trackLastFrameTime[trackId] = Date.now();
-    isActive = true;
-  };
-
-  const notifyFrameListeners = (frameData: any) => {
-    frameListeners.forEach(listener => {
-      try {
-        listener(frameData);
-      } catch (error) {
-        console.error('Error in frame listener:', error);
-      }
-    });
-  };
-
-  // Check if any track has received frames recently
-  const checkFrameActivity = (triggerReconnect: (attempt: number) => void) => {
-    const now = Date.now();
-    let hasActiveTrack = false;
-
-    Object.entries(trackLastFrameTime).forEach(([_, lastTime]) => {
-      const timeSinceLastFrame = now - lastTime;
-      if (timeSinceLastFrame < FRAME_INACTIVITY_TIMEOUT) {
-        hasActiveTrack = true;
-      }
-    });
-
-    if (!hasActiveTrack && isActive) {
-      console.log('No frames received recently on any track, connection might be stale');
-      isActive = false;
-
-      // Trigger reconnect only if we previously had an active connection
-      if (Object.keys(trackLastFrameTime).length > 0) {
-        console.log('Triggering reconnect due to frame inactivity');
-        triggerReconnect(reconnectAttempts++);
-      }
-    }
-  };
-
-  const setupTrackEndedEvent = (
-    track: MediaStreamTrack,
-    ms: MediaStream,
-    isReconnecting: boolean,
-    isShuttingDown: boolean,
-    triggerReconnect: (attempt: number) => void
-  ) => {
-    // Initialize frame timestamp tracking for this track
-    trackLastFrameTime[track.id] = Date.now();
-
-    // Set up onFrame callback to detect actual frame reception
-    const extendedTrack = track as ExtendedMediaStreamTrack;
-    if (typeof extendedTrack.onFrame === 'function') {
-      // Remove any existing onFrame handler to prevent duplicates
-      const originalOnFrame = extendedTrack.onFrame;
-      extendedTrack.onFrame = function (frame: any) {
-        // Update the last frame time
-        updateTrackLastFrameTime(track.id);
-        // Notify frame listeners
-        notifyFrameListeners(frame);
-        // Call the original handler
-        originalOnFrame.call(extendedTrack, frame);
-      };
-    } else {
-      // If onFrame isn't available, fallback to readyState monitoring
-      track.onended = () => {
-        console.log(`Track ${track.id} ended`);
-        delete trackLastFrameTime[track.id];
-
-        const trackIndex = tracks.findIndex(t => t.id === track.id);
-        if (trackIndex !== -1) {
-          tracks.splice(trackIndex, 1);
-        }
-
-        const allTracksEnded = ms.getTracks().every(t => t.readyState === 'ended');
-
-        if (allTracksEnded && !isShuttingDown && !isReconnecting) {
-          console.log('All tracks ended, triggering reconnect');
-          triggerReconnect(reconnectAttempts++);
-        }
-      };
-    }
-  };
-
-  const persistentMediaStream: PhygridMediaStream = {
-    // Internal storage for tracks - not exposed in the interface
-    _internalTracks: tracks,
-
-    // Internal helper to notify track listeners
-    _notifyTrackListeners: notifyTrackListeners,
-
-    getTracks: function (): MediaStreamTrack[] {
-      return [...tracks];
-    },
-
-    onTrack: function (callback: (track: MediaStreamTrack) => void): void {
-      console.log('Adding track listener to persistent media stream');
-      trackListeners.push(callback);
-
-      // Notify for existing tracks
-      tracks.forEach(track => {
-        try {
-          callback(track);
-        } catch (error) {
-          console.error('Error in track listener:', error);
-        }
-      });
-    },
-
-    offTrack: function (callback: (track: MediaStreamTrack) => void): void {
-      const index = trackListeners.indexOf(callback);
-      if (index !== -1) {
-        trackListeners.splice(index, 1);
-      }
-    },
-
-    onFrame: function (callback: (frameData: any) => void): void {
-      console.log('Adding frame listener to persistent media stream');
-      frameListeners.push(callback);
-    },
-
-    offFrame: function (callback: (frameData: any) => void): void {
-      const index = frameListeners.indexOf(callback);
-      if (index !== -1) {
-        frameListeners.splice(index, 1);
-      }
-    },
-
-    onClose: function (callback: () => void): void {
-      closeListeners.push(callback);
-    },
-
-    offClose: function (callback: () => void): void {
-      const index = closeListeners.indexOf(callback);
-      if (index !== -1) {
-        closeListeners.splice(index, 1);
-      }
-    },
-
-    close: function (): void {
-      console.log('Closing persistent media stream');
-
-      // Stop checking for frame activity
-      if (frameActivityCheckInterval) {
-        clearInterval(frameActivityCheckInterval);
-        frameActivityCheckInterval = null;
-      }
-
-      // Clear track data
-      tracks.splice(0, tracks.length);
-
-      // Clear frame timestamps
-      Object.keys(trackLastFrameTime).forEach(key => {
-        delete trackLastFrameTime[key];
-      });
-
-      // Notify close listeners
-      closeListeners.forEach(listener => {
-        try {
-          listener();
-        } catch (error) {
-          console.error('Error in close listener:', error);
-        }
-      });
-
-      // Cleanup function if provided
-      if (cleanupFn) {
-        cleanupFn();
-      }
-
-      isActive = false;
-    },
-
-    addTrack: function (_track: MediaStreamTrack): void {
-      // Implementation will be replaced in createWebRTCMediaStreamConnection
-      console.warn('Default addTrack implementation called - this should be replaced');
-    },
-
-    // Check if stream is currently receiving frames
-    isReceivingFrames: function (): boolean {
-      if (Object.keys(trackLastFrameTime).length === 0) {
-        return false;
-      }
-
-      const now = Date.now();
-      return Object.values(trackLastFrameTime).some(
-        lastTime => now - lastTime < FRAME_INACTIVITY_TIMEOUT
-      );
-    },
-  };
-
-  const setupMediaStream = (
-    ms: MediaStream,
-    isReconnecting: boolean,
-    isShuttingDown: boolean,
-    triggerReconnect: (attempt: number) => void
-  ) => {
-    console.log('Setting up media stream with tracks:', ms.getTracks().length);
-
-    // Clear existing tracks array to prevent duplicates
-    tracks.splice(0, tracks.length);
-
-    // Start or restart frame activity check
-    if (frameActivityCheckInterval) {
-      clearInterval(frameActivityCheckInterval);
-    }
-
-    frameActivityCheckInterval = setInterval(() => {
-      checkFrameActivity(triggerReconnect);
-    }, 1000);
-
-    // Process each track in the stream
-    ms.getTracks().forEach(track => {
-      console.log(
-        `Processing track: ${track.kind} - ${track.id} with readyState: ${track.readyState}`
-      );
-
-      // Add to our tracks array
-      tracks.push(track);
-
-      // Set up track ended and frame monitoring
-      setupTrackEndedEvent(track, ms, isReconnecting, isShuttingDown, triggerReconnect);
-
-      // Notify track listeners
-      notifyTrackListeners(track);
-    });
-  };
-
-  return {
-    persistentMediaStream,
-    setupMediaStream,
-    setCleanupFn,
-  };
-};