streemo-video-call-sdk 0.1.0

package/dist/useWebRTCCall.js

@@ -0,0 +1,775 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { createServerTokenProvider, defaultApiBaseUrl, defaultWsBaseUrlFromApi, } from './tokenProvider';
+import { mapSDKErrorToUIMessage } from './sdkErrors';
+import { getVideoSDKConfig } from './sdkConfig';
+const RENEGOTIATION_RETRY_DELAY_MS = 6000;
+const RENEGOTIATION_MAX_RETRIES = 3;
+const DISCONNECTED_CLEANUP_DELAY_MS = 10000;
+const NETWORK_STATS_POLL_MS = 5000;
+const AUDIO_CONSTRAINTS = {
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true,
+    channelCount: 1,
+};
+const VIDEO_CONSTRAINTS = {
+    width: { ideal: 1280, max: 1920 },
+    height: { ideal: 720, max: 1080 },
+    frameRate: { ideal: 24, max: 30 },
+    facingMode: 'user',
+};
+async function tuneLocalStream(stream) {
+    const audioTrack = stream.getAudioTracks()[0];
+    const videoTrack = stream.getVideoTracks()[0];
+    if (audioTrack) {
+        audioTrack.contentHint = 'speech';
+        try {
+            await audioTrack.applyConstraints(AUDIO_CONSTRAINTS);
+        }
+        catch {
+            // Browser may ignore unsupported audio processing constraints.
+        }
+    }
+    if (videoTrack) {
+        videoTrack.contentHint = 'motion';
+        try {
+            await videoTrack.applyConstraints(VIDEO_CONSTRAINTS);
+        }
+        catch {
+            // Browser may ignore unsupported video quality constraints.
+        }
+    }
+}
+async function tuneSenderEncodings(peer) {
+    const tasks = peer.getSenders().map(async (sender) => {
+        const track = sender.track;
+        if (!track)
+            return;
+        const params = sender.getParameters();
+        if (!params.encodings || params.encodings.length === 0) {
+            params.encodings = [{}];
+        }
+        const encoding = params.encodings[0];
+        if (track.kind === 'audio') {
+            encoding.maxBitrate = 64000;
+        }
+        if (track.kind === 'video') {
+            encoding.maxBitrate = 1200000;
+            encoding.maxFramerate = 24;
+            encoding.scaleResolutionDownBy = 1;
+        }
+        try {
+            await sender.setParameters(params);
+        }
+        catch {
+            // Some browsers can reject runtime encoding changes.
+        }
+    });
+    await Promise.all(tasks);
+}
+function getVideoProfile(level) {
+    switch (level) {
+        case 'low':
+            return {
+                maxBitrate: 350_000,
+                maxFramerate: 15,
+                scaleResolutionDownBy: 2,
+            };
+        case 'medium':
+            return {
+                maxBitrate: 700_000,
+                maxFramerate: 20,
+                scaleResolutionDownBy: 1.5,
+            };
+        case 'high':
+        default:
+            return {
+                maxBitrate: 1_200_000,
+                maxFramerate: 24,
+                scaleResolutionDownBy: 1,
+            };
+    }
+}
+async function applyVideoQualityProfile(peer, level) {
+    const profile = getVideoProfile(level);
+    const tasks = peer.getSenders().map(async (sender) => {
+        if (sender.track?.kind !== 'video')
+            return;
+        const params = sender.getParameters();
+        if (!params.encodings || params.encodings.length === 0) {
+            params.encodings = [{}];
+        }
+        const encoding = params.encodings[0];
+        encoding.maxBitrate = profile.maxBitrate;
+        encoding.maxFramerate = profile.maxFramerate;
+        encoding.scaleResolutionDownBy = profile.scaleResolutionDownBy;
+        try {
+            await sender.setParameters(params);
+        }
+        catch {
+            // Some browsers reject runtime adaptation for sender parameters.
+        }
+    });
+    await Promise.all(tasks);
+}
+function nextQualityLevel(current, target) {
+    const levels = ['low', 'medium', 'high'];
+    const currentIdx = levels.indexOf(current);
+    const targetIdx = levels.indexOf(target);
+    if (currentIdx === targetIdx)
+        return current;
+    if (currentIdx < targetIdx)
+        return levels[currentIdx + 1];
+    return levels[currentIdx - 1];
+}
+function resolveTokenProvider(params) {
+    if (params.tokenProvider)
+        return params.tokenProvider;
+    if (params.auth) {
+        return createServerTokenProvider({
+            apiBaseUrl: params.apiBaseUrl || defaultApiBaseUrl(),
+            auth: params.auth,
+        });
+    }
+    return null;
+}
+function resolveWsBaseUrl(params) {
+    if (params.wsBaseUrl)
+        return params.wsBaseUrl.replace(/\/+$/, '');
+    const apiBase = params.apiBaseUrl || defaultApiBaseUrl();
+    if (apiBase)
+        return defaultWsBaseUrlFromApi(apiBase);
+    return '';
+}
+async function resolveRoomToken(params) {
+    if (params.roomToken)
+        return params.roomToken;
+    const provider = resolveTokenProvider(params);
+    if (!provider) {
+        throw new Error('roomToken or tokenProvider/apiBaseUrl+auth is required');
+    }
+    const ctx = {
+        roomId: params.roomId,
+        userId: params.userId,
+    };
+    return provider(ctx);
+}
+export function useWebRTCCall(params) {
+    const sdkConfig = getVideoSDKConfig();
+    const mergedParams = {
+        ...params,
+        apiBaseUrl: params.apiBaseUrl ?? sdkConfig.apiBaseUrl,
+        wsBaseUrl: params.wsBaseUrl ?? sdkConfig.wsBaseUrl,
+        auth: params.auth ?? sdkConfig.auth,
+    };
+    const { roomId, userId, enabled } = mergedParams;
+    const { roomToken, wsBaseUrl, tokenProvider, apiBaseUrl, auth } = mergedParams;
+    const wsRef = useRef(null);
+    const peersRef = useRef(new Map());
+    const localStreamRef = useRef(null);
+    const remoteStreamsRef = useRef({});
+    const localParticipantIdRef = useRef(null);
+    const renegotiationTimersRef = useRef(new Map());
+    const renegotiationAttemptsRef = useRef(new Map());
+    const disconnectedCleanupTimersRef = useRef(new Map());
+    const remoteStreamCleanupRef = useRef(new Map());
+    const networkStatsTimersRef = useRef(new Map());
+    const qualityLevelRef = useRef(new Map());
+    const makingOfferRef = useRef(new Map());
+    const ignoreOfferRef = useRef(new Map());
+    const isSettingRemoteAnswerPendingRef = useRef(new Map());
+    const politeRef = useRef(new Map());
+    const [localStream, setLocalStream] = useState(null);
+    const [remoteStreams, setRemoteStreams] = useState({});
+    const [participants, setParticipants] = useState([]);
+    const [connected, setConnected] = useState(false);
+    const [error, setError] = useState(null);
+    const [remoteTrackStates, setRemoteTrackStates] = useState({});
+    const [micEnabled, setMicEnabled] = useState(true);
+    const [cameraEnabled, setCameraEnabled] = useState(true);
+    const [hasMicTrack, setHasMicTrack] = useState(false);
+    const [hasCameraTrack, setHasCameraTrack] = useState(false);
+    const clearRenegotiationRetry = useCallback((targetUserId) => {
+        const timer = renegotiationTimersRef.current.get(targetUserId);
+        if (timer) {
+            clearTimeout(timer);
+            renegotiationTimersRef.current.delete(targetUserId);
+        }
+        renegotiationAttemptsRef.current.delete(targetUserId);
+    }, []);
+    const clearDisconnectedCleanup = useCallback((targetUserId) => {
+        const timer = disconnectedCleanupTimersRef.current.get(targetUserId);
+        if (timer) {
+            clearTimeout(timer);
+            disconnectedCleanupTimersRef.current.delete(targetUserId);
+        }
+    }, []);
+    const clearRemoteStreamObservers = useCallback((targetUserId) => {
+        const cleanup = remoteStreamCleanupRef.current.get(targetUserId);
+        if (cleanup) {
+            cleanup();
+            remoteStreamCleanupRef.current.delete(targetUserId);
+        }
+    }, []);
+    const clearNetworkAdaptation = useCallback((targetUserId) => {
+        const timer = networkStatsTimersRef.current.get(targetUserId);
+        if (timer) {
+            clearInterval(timer);
+            networkStatsTimersRef.current.delete(targetUserId);
+        }
+        qualityLevelRef.current.delete(targetUserId);
+    }, []);
+    const computeTargetQualityLevel = useCallback(async (peer) => {
+        const stats = await peer.getStats();
+        let rttSeconds = null;
+        let packetLossPercent = null;
+        stats.forEach((report) => {
+            const stat = report;
+            if (stat.type === 'candidate-pair' && stat.state === 'succeeded') {
+                const currentRTT = stat.currentRoundTripTime;
+                if (typeof currentRTT === 'number') {
+                    rttSeconds = rttSeconds === null ? currentRTT : Math.max(rttSeconds, currentRTT);
+                }
+            }
+            if (stat.type === 'remote-inbound-rtp' && stat.kind === 'video') {
+                const fractionLost = stat.fractionLost;
+                if (typeof fractionLost === 'number') {
+                    packetLossPercent = Math.max(0, fractionLost * 100);
+                }
+            }
+        });
+        if ((rttSeconds ?? 0) > 0.35 || (packetLossPercent ?? 0) > 8) {
+            return 'low';
+        }
+        if ((rttSeconds ?? 0) > 0.2 || (packetLossPercent ?? 0) > 3) {
+            return 'medium';
+        }
+        return 'high';
+    }, []);
+    const startNetworkAdaptation = useCallback((targetUserId, peer) => {
+        clearNetworkAdaptation(targetUserId);
+        qualityLevelRef.current.set(targetUserId, 'high');
+        const timer = setInterval(() => {
+            void (async () => {
+                if (peer.connectionState === 'closed' || peer.connectionState === 'failed') {
+                    clearNetworkAdaptation(targetUserId);
+                    return;
+                }
+                const hasVideoSender = peer.getSenders().some((sender) => sender.track?.kind === 'video');
+                if (!hasVideoSender)
+                    return;
+                let targetLevel;
+                try {
+                    targetLevel = await computeTargetQualityLevel(peer);
+                }
+                catch {
+                    return;
+                }
+                const currentLevel = qualityLevelRef.current.get(targetUserId) ?? 'high';
+                const nextLevel = nextQualityLevel(currentLevel, targetLevel);
+                if (nextLevel === currentLevel)
+                    return;
+                qualityLevelRef.current.set(targetUserId, nextLevel);
+                await applyVideoQualityProfile(peer, nextLevel);
+            })();
+        }, NETWORK_STATS_POLL_MS);
+        networkStatsTimersRef.current.set(targetUserId, timer);
+    }, [clearNetworkAdaptation, computeTargetQualityLevel]);
+    const removePeer = useCallback((targetUserId, removeParticipant = false) => {
+        clearRenegotiationRetry(targetUserId);
+        clearDisconnectedCleanup(targetUserId);
+        clearRemoteStreamObservers(targetUserId);
+        clearNetworkAdaptation(targetUserId);
+        makingOfferRef.current.delete(targetUserId);
+        ignoreOfferRef.current.delete(targetUserId);
+        isSettingRemoteAnswerPendingRef.current.delete(targetUserId);
+        politeRef.current.delete(targetUserId);
+        const peer = peersRef.current.get(targetUserId);
+        if (peer) {
+            peer.ontrack = null;
+            peer.onicecandidate = null;
+            peer.onconnectionstatechange = null;
+            peer.close();
+        }
+        peersRef.current.delete(targetUserId);
+        setRemoteStreams((prev) => {
+            const copy = { ...prev };
+            delete copy[targetUserId];
+            remoteStreamsRef.current = copy;
+            return copy;
+        });
+        setRemoteTrackStates((prev) => {
+            const copy = { ...prev };
+            delete copy[targetUserId];
+            return copy;
+        });
+        if (removeParticipant) {
+            setParticipants((prev) => prev.filter((id) => id !== targetUserId));
+        }
+    }, [clearDisconnectedCleanup, clearNetworkAdaptation, clearRemoteStreamObservers, clearRenegotiationRetry]);
+    const hasRemoteVideoTrack = useCallback((targetUserId) => {
+        const stream = remoteStreamsRef.current[targetUserId];
+        if (!stream)
+            return false;
+        return stream
+            .getVideoTracks()
+            .some((track) => track.readyState === 'live' && track.enabled);
+    }, []);
+    const syncLocalTrackFlags = useCallback(() => {
+        const stream = localStreamRef.current;
+        if (!stream) {
+            setHasMicTrack(false);
+            setHasCameraTrack(false);
+            setMicEnabled(false);
+            setCameraEnabled(false);
+            return;
+        }
+        const audioTrack = stream.getAudioTracks()[0];
+        const videoTrack = stream.getVideoTracks()[0];
+        setHasMicTrack(Boolean(audioTrack));
+        setHasCameraTrack(Boolean(videoTrack));
+        setMicEnabled(Boolean(audioTrack?.enabled));
+        setCameraEnabled(Boolean(videoTrack?.enabled));
+    }, []);
+    const send = useCallback((message) => {
+        const ws = wsRef.current;
+        if (!ws || ws.readyState !== WebSocket.OPEN)
+            return;
+        ws.send(JSON.stringify({
+            roomId,
+            userId,
+            ...message,
+        }));
+    }, [roomId, userId]);
+    const gracefulLeave = useCallback(() => {
+        const ws = wsRef.current;
+        if (!ws || ws.readyState !== WebSocket.OPEN)
+            return;
+        try {
+            ws.send(JSON.stringify({
+                roomId,
+                userId,
+                type: 'participant_left',
+                payload: { source: 'page_unload', leftAt: new Date().toISOString() },
+            }));
+        }
+        catch {
+            // Ignore unload-time send errors.
+        }
+        ws.close();
+    }, [roomId, userId]);
+    const updateRemoteTrackState = useCallback((targetUserId, stream, peer) => {
+        const audio = stream.getAudioTracks().some((track) => track.readyState === 'live' && track.enabled);
+        const video = stream.getVideoTracks().some((track) => track.readyState === 'live' && track.enabled);
+        setRemoteTrackStates((prev) => ({
+            ...prev,
+            [targetUserId]: {
+                audio,
+                video,
+                connectionState: peer.connectionState,
+            },
+        }));
+    }, []);
+    const ensurePeer = useCallback((targetUserId) => {
+        const existing = peersRef.current.get(targetUserId);
+        if (existing)
+            return existing;
+        const peer = new RTCPeerConnection({
+            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+        });
+        const localParticipantID = localParticipantIdRef.current;
+        politeRef.current.set(targetUserId, localParticipantID ? localParticipantID > targetUserId : true);
+        const localStream = localStreamRef.current;
+        const hasLocalAudio = Boolean(localStream?.getAudioTracks().length);
+        const hasLocalVideo = Boolean(localStream?.getVideoTracks().length);
+        if (!hasLocalAudio) {
+            peer.addTransceiver('audio', { direction: 'recvonly' });
+        }
+        if (!hasLocalVideo) {
+            peer.addTransceiver('video', { direction: 'recvonly' });
+        }
+        localStreamRef.current?.getTracks().forEach((track) => {
+            peer.addTrack(track, localStreamRef.current);
+        });
+        void tuneSenderEncodings(peer);
+        startNetworkAdaptation(targetUserId, peer);
+        peer.onicecandidate = (event) => {
+            if (!event.candidate)
+                return;
+            send({
+                type: 'ice_candidate',
+                targetUserId,
+                payload: event.candidate.toJSON(),
+            });
+        };
+        peer.ontrack = (event) => {
+            const [stream] = event.streams;
+            clearRemoteStreamObservers(targetUserId);
+            setRemoteStreams((prev) => {
+                const next = { ...prev, [targetUserId]: stream };
+                remoteStreamsRef.current = next;
+                return next;
+            });
+            updateRemoteTrackState(targetUserId, stream, peer);
+            const update = () => updateRemoteTrackState(targetUserId, stream, peer);
+            stream.getTracks().forEach((track) => {
+                track.addEventListener('mute', update);
+                track.addEventListener('unmute', update);
+                track.addEventListener('ended', update);
+            });
+            stream.addEventListener('addtrack', update);
+            stream.addEventListener('removetrack', update);
+            remoteStreamCleanupRef.current.set(targetUserId, () => {
+                stream.getTracks().forEach((track) => {
+                    track.removeEventListener('mute', update);
+                    track.removeEventListener('unmute', update);
+                    track.removeEventListener('ended', update);
+                });
+                stream.removeEventListener('addtrack', update);
+                stream.removeEventListener('removetrack', update);
+            });
+            if (stream.getVideoTracks().some((track) => track.readyState === 'live' && track.enabled)) {
+                clearRenegotiationRetry(targetUserId);
+            }
+        };
+        peer.onconnectionstatechange = () => {
+            const stream = remoteStreamsRef.current[targetUserId];
+            if (stream) {
+                updateRemoteTrackState(targetUserId, stream, peer);
+            }
+            else {
+                setRemoteTrackStates((prev) => ({
+                    ...prev,
+                    [targetUserId]: {
+                        audio: false,
+                        video: false,
+                        connectionState: peer.connectionState,
+                    },
+                }));
+            }
+            if (peer.connectionState === 'failed' || peer.connectionState === 'closed') {
+                removePeer(targetUserId, true);
+                return;
+            }
+            if (peer.connectionState === 'disconnected') {
+                clearDisconnectedCleanup(targetUserId);
+                const timer = setTimeout(() => {
+                    const current = peersRef.current.get(targetUserId);
+                    if (!current)
+                        return;
+                    if (current.connectionState === 'disconnected') {
+                        removePeer(targetUserId, true);
+                    }
+                }, DISCONNECTED_CLEANUP_DELAY_MS);
+                disconnectedCleanupTimersRef.current.set(targetUserId, timer);
+                return;
+            }
+            clearDisconnectedCleanup(targetUserId);
+        };
+        peersRef.current.set(targetUserId, peer);
+        return peer;
+    }, [clearDisconnectedCleanup, clearRemoteStreamObservers, clearRenegotiationRetry, removePeer, send, startNetworkAdaptation, updateRemoteTrackState]);
+    const createOffer = useCallback(async (targetUserId) => {
+        const peer = ensurePeer(targetUserId);
+        if (peer.signalingState !== 'stable') {
+            return;
+        }
+        makingOfferRef.current.set(targetUserId, true);
+        try {
+            const offer = await peer.createOffer();
+            await peer.setLocalDescription(offer);
+            send({
+                type: 'offer',
+                targetUserId,
+                payload: offer,
+            });
+        }
+        finally {
+            makingOfferRef.current.set(targetUserId, false);
+        }
+    }, [ensurePeer, send]);
+    const scheduleRenegotiationRetry = useCallback((targetUserId) => {
+        const existingTimer = renegotiationTimersRef.current.get(targetUserId);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(async () => {
+            const peer = peersRef.current.get(targetUserId);
+            if (!peer) {
+                clearRenegotiationRetry(targetUserId);
+                return;
+            }
+            if (hasRemoteVideoTrack(targetUserId)) {
+                clearRenegotiationRetry(targetUserId);
+                return;
+            }
+            const attempts = renegotiationAttemptsRef.current.get(targetUserId) ?? 0;
+            if (attempts >= RENEGOTIATION_MAX_RETRIES) {
+                clearRenegotiationRetry(targetUserId);
+                return;
+            }
+            renegotiationAttemptsRef.current.set(targetUserId, attempts + 1);
+            await createOffer(targetUserId);
+            scheduleRenegotiationRetry(targetUserId);
+        }, RENEGOTIATION_RETRY_DELAY_MS);
+        renegotiationTimersRef.current.set(targetUserId, timer);
+    }, [clearRenegotiationRetry, createOffer, hasRemoteVideoTrack]);
+    const handleSignalMessage = useCallback(async (message) => {
+        if (message.userId === userId)
+            return;
+        switch (message.type) {
+            case 'welcome':
+                localParticipantIdRef.current = message.userId;
+                break;
+            case 'join':
+            case 'participant_joined':
+                setParticipants((prev) => Array.from(new Set([...prev, message.userId])));
+                await createOffer(message.userId);
+                scheduleRenegotiationRetry(message.userId);
+                break;
+            case 'participant_left':
+                removePeer(message.userId, true);
+                break;
+            case 'offer': {
+                setParticipants((prev) => Array.from(new Set([...prev, message.userId])));
+                let peer = ensurePeer(message.userId);
+                const makingOffer = makingOfferRef.current.get(message.userId) ?? false;
+                const isSettingRemoteAnswerPending = isSettingRemoteAnswerPendingRef.current.get(message.userId) ?? false;
+                const polite = politeRef.current.get(message.userId) ?? true;
+                const offerCollision = makingOffer || (peer.signalingState !== 'stable' && !isSettingRemoteAnswerPending);
+                const ignoreOffer = !polite && offerCollision;
+                ignoreOfferRef.current.set(message.userId, ignoreOffer);
+                if (ignoreOffer) {
+                    return;
+                }
+                if (offerCollision) {
+                    try {
+                        await peer.setLocalDescription({ type: 'rollback' });
+                    }
+                    catch {
+                        removePeer(message.userId);
+                        peer = ensurePeer(message.userId);
+                    }
+                }
+                await peer.setRemoteDescription(new RTCSessionDescription(message.payload));
+                const answer = await peer.createAnswer();
+                await peer.setLocalDescription(answer);
+                send({
+                    type: 'answer',
+                    targetUserId: message.userId,
+                    payload: answer,
+                });
+                break;
+            }
+            case 'answer': {
+                setParticipants((prev) => Array.from(new Set([...prev, message.userId])));
+                const peer = peersRef.current.get(message.userId);
+                if (!peer)
+                    return;
+                if (ignoreOfferRef.current.get(message.userId)) {
+                    return;
+                }
+                if (peer.signalingState !== 'have-local-offer') {
+                    return;
+                }
+                isSettingRemoteAnswerPendingRef.current.set(message.userId, true);
+                try {
+                    await peer.setRemoteDescription(new RTCSessionDescription(message.payload));
+                }
+                finally {
+                    isSettingRemoteAnswerPendingRef.current.set(message.userId, false);
+                }
+                scheduleRenegotiationRetry(message.userId);
+                break;
+            }
+            case 'ice_candidate': {
+                setParticipants((prev) => Array.from(new Set([...prev, message.userId])));
+                const peer = ensurePeer(message.userId);
+                await peer.addIceCandidate(new RTCIceCandidate(message.payload));
+                break;
+            }
+            default:
+                break;
+        }
+    }, [createOffer, ensurePeer, removePeer, scheduleRenegotiationRetry, send, userId]);
+    useEffect(() => {
+        if (!enabled || !roomId || !userId)
+            return;
+        const peers = peersRef.current;
+        const currentParams = {
+            roomId,
+            userId,
+            enabled,
+            roomToken,
+            wsBaseUrl,
+            tokenProvider,
+            apiBaseUrl,
+            auth,
+        };
+        const setup = async () => {
+            try {
+                const resolvedRoomToken = await resolveRoomToken(currentParams);
+                const resolvedWsBaseUrl = resolveWsBaseUrl(currentParams);
+                if (!resolvedWsBaseUrl) {
+                    setError('wsBaseUrl or apiBaseUrl is required');
+                    return;
+                }
+                if (!window.isSecureContext) {
+                    setError('getUserMedia requires HTTPS (or localhost).');
+                    return;
+                }
+                if (!navigator.mediaDevices?.getUserMedia) {
+                    setError('Browser does not support mediaDevices/getUserMedia.');
+                    return;
+                }
+                let acquiredLocalStream;
+                try {
+                    acquiredLocalStream = await navigator.mediaDevices.getUserMedia({
+                        audio: AUDIO_CONSTRAINTS,
+                        video: VIDEO_CONSTRAINTS,
+                    });
+                }
+                catch (err) {
+                    if (err instanceof DOMException && ['NotFoundError', 'OverconstrainedError'].includes(err.name)) {
+                        acquiredLocalStream = await navigator.mediaDevices.getUserMedia({
+                            audio: AUDIO_CONSTRAINTS,
+                            video: false,
+                        });
+                        setError('Camera is unavailable. Joined in audio-only mode.');
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                await tuneLocalStream(acquiredLocalStream);
+                localStreamRef.current = acquiredLocalStream;
+                setLocalStream(acquiredLocalStream);
+                syncLocalTrackFlags();
+                const wsURL = `${resolvedWsBaseUrl}/v1/ws?roomId=${encodeURIComponent(roomId)}&token=${encodeURIComponent(resolvedRoomToken)}`;
+                const ws = new WebSocket(wsURL);
+                wsRef.current = ws;
+                ws.onopen = () => {
+                    setConnected(true);
+                    send({ type: 'join', payload: { joinedAt: new Date().toISOString() } });
+                };
+                ws.onclose = () => {
+                    setConnected(false);
+                };
+                ws.onerror = () => {
+                    setError('WebSocket connection error');
+                };
+                ws.onmessage = (event) => {
+                    const message = JSON.parse(event.data);
+                    void handleSignalMessage(message);
+                };
+            }
+            catch (err) {
+                const mappedMessage = mapSDKErrorToUIMessage(err);
+                if (mappedMessage !== 'Unexpected error while connecting to call server.') {
+                    setError(mappedMessage);
+                    return;
+                }
+                if (err instanceof DOMException && err.name === 'NotAllowedError') {
+                    setError('No camera/microphone access. Please allow permissions in browser settings.');
+                    return;
+                }
+                setError(err instanceof Error ? err.message : 'Call initialization failed');
+            }
+        };
+        void setup();
+        return () => {
+            wsRef.current?.close();
+            peers.forEach((_, peerID) => removePeer(peerID));
+            peers.clear();
+            renegotiationTimersRef.current.forEach((timer) => clearTimeout(timer));
+            renegotiationTimersRef.current.clear();
+            renegotiationAttemptsRef.current.clear();
+            disconnectedCleanupTimersRef.current.forEach((timer) => clearTimeout(timer));
+            disconnectedCleanupTimersRef.current.clear();
+            remoteStreamCleanupRef.current.forEach((cleanup) => cleanup());
+            remoteStreamCleanupRef.current.clear();
+            networkStatsTimersRef.current.forEach((timer) => clearInterval(timer));
+            networkStatsTimersRef.current.clear();
+            qualityLevelRef.current.clear();
+            makingOfferRef.current.clear();
+            ignoreOfferRef.current.clear();
+            isSettingRemoteAnswerPendingRef.current.clear();
+            politeRef.current.clear();
+            localParticipantIdRef.current = null;
+            remoteStreamsRef.current = {};
+            localStreamRef.current?.getTracks().forEach((track) => track.stop());
+            localStreamRef.current = null;
+            syncLocalTrackFlags();
+        };
+    }, [
+        apiBaseUrl,
+        auth,
+        enabled,
+        handleSignalMessage,
+        removePeer,
+        roomId,
+        roomToken,
+        send,
+        syncLocalTrackFlags,
+        tokenProvider,
+        userId,
+        wsBaseUrl,
+    ]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const onPageHide = () => {
+            gracefulLeave();
+        };
+        const onBeforeUnload = () => {
+            gracefulLeave();
+        };
+        window.addEventListener('pagehide', onPageHide);
+        window.addEventListener('beforeunload', onBeforeUnload);
+        return () => {
+            window.removeEventListener('pagehide', onPageHide);
+            window.removeEventListener('beforeunload', onBeforeUnload);
+        };
+    }, [enabled, gracefulLeave]);
+    const toggleMic = useCallback(() => {
+        const stream = localStreamRef.current;
+        if (!stream)
+            return;
+        const audioTracks = stream.getAudioTracks();
+        if (audioTracks.length === 0)
+            return;
+        const nextEnabled = !micEnabled;
+        audioTracks.forEach((track) => {
+            track.enabled = nextEnabled;
+        });
+        setMicEnabled(nextEnabled);
+    }, [micEnabled]);
+    const toggleCamera = useCallback(() => {
+        const stream = localStreamRef.current;
+        if (!stream)
+            return;
+        const videoTracks = stream.getVideoTracks();
+        if (videoTracks.length === 0)
+            return;
+        const nextEnabled = !cameraEnabled;
+        videoTracks.forEach((track) => {
+            track.enabled = nextEnabled;
+        });
+        setCameraEnabled(nextEnabled);
+    }, [cameraEnabled]);
+    return {
+        localStream,
+        remoteStreams,
+        participants,
+        remoteTrackStates,
+        connected,
+        error,
+        micEnabled,
+        cameraEnabled,
+        hasMicTrack,
+        hasCameraTrack,
+        toggleMic,
+        toggleCamera,
+    };
+}
+//# sourceMappingURL=useWebRTCCall.js.map