kasunk99-livestream-core 0.1.3 → 0.2.0

package/dist/hooks/useHostSocket.d.ts

@@ -0,0 +1,31 @@
+/**
+ * useHostSocket — broadcaster / host lifecycle hook.
+ *
+ * Manages camera preview, mediasoup send transport, screen share, mic, and
+ * camera-flip. Session refs (socket, streams, producers) live in a module-level
+ * singleton so they survive navigation between tabs. Reactive UI state lives in a
+ * module-level store (hostState) so the component can remount without losing
+ * "live", "joining", etc.
+ *
+ * Usage:
+ *   const host = useHostSocket({ hostUserId: userId });
+ *   // host.startPreview(), host.startLive(), host.stopLive(), …
+ */
+import { type HostState } from '../host/hostState';
+export type UseHostSocketOptions = {
+    /** App-level user ID forwarded to the server on join-room (optional). */
+    hostUserId?: string;
+};
+export type UseHostSocketReturn = HostState & {
+    setDisplayName: (name: string) => void;
+    startPreview: () => Promise<void>;
+    stopPreview: () => void;
+    startLive: () => Promise<void>;
+    stopLive: () => Promise<void>;
+    switchCamera: () => void;
+    toggleMic: () => void;
+    startScreenShare: () => Promise<void>;
+    stopScreenShare: () => Promise<void>;
+};
+export declare function useHostSocket(options?: UseHostSocketOptions): UseHostSocketReturn;
+//# sourceMappingURL=useHostSocket.d.ts.map

package/dist/hooks/useHostSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHostSocket.d.ts","sourceRoot":"","sources":["../../src/hooks/useHostSocket.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAYH,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAoB3B,MAAM,MAAM,oBAAoB,GAAG;IACjC,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG;IAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,gBAAgB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC,CAAC;AAMF,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,mBAAmB,CA0kBrF"}

package/dist/hooks/useHostSocket.js

@@ -0,0 +1,565 @@
+/**
+ * useHostSocket — broadcaster / host lifecycle hook.
+ *
+ * Manages camera preview, mediasoup send transport, screen share, mic, and
+ * camera-flip. Session refs (socket, streams, producers) live in a module-level
+ * singleton so they survive navigation between tabs. Reactive UI state lives in a
+ * module-level store (hostState) so the component can remount without losing
+ * "live", "joining", etc.
+ *
+ * Usage:
+ *   const host = useHostSocket({ hostUserId: userId });
+ *   // host.startPreview(), host.startLive(), host.stopLive(), …
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { Platform, PermissionsAndroid } from 'react-native';
+import { io } from 'socket.io-client';
+import { mediaDevices } from 'react-native-webrtc';
+import * as mediasoupClient from 'mediasoup-client';
+import { getApiKey, getSignalingUrl } from '../config';
+import { createStream } from '../services/livestream.service';
+import { ensureMediasoupGlobals } from '../services/mediasoup-init';
+import { hostSession } from '../host/hostSession';
+import { getHostState, patchHostState, resetHostState, subscribeHostState, } from '../host/hostState';
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function getStreamURL(stream) {
+    const s = stream;
+    return s && typeof s.toURL === 'function' ? s.toURL() : null;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Hook
+// ─────────────────────────────────────────────────────────────────────────────
+export function useHostSocket(options = {}) {
+    const { hostUserId } = options;
+    // Subscribe to module-level state so all hook instances stay in sync
+    // and the state survives remount (tab navigation).
+    const [state, setLocalState] = useState(getHostState);
+    useEffect(() => {
+        // If the store has a streamURL but our local copy doesn't (fresh mount),
+        // restore it from the active stream so the preview shows immediately.
+        const current = getHostState();
+        if (!current.streamURL) {
+            const activeStream = current.captureMode === 'screen' ? hostSession.screenStream : hostSession.localStream;
+            const url = getStreamURL(activeStream);
+            if (url)
+                patchHostState({ streamURL: url });
+        }
+        return subscribeHostState(setLocalState);
+    }, []);
+    // ── Cleanup ────────────────────────────────────────────────────────────────
+    const fullCleanup = useCallback(() => {
+        // ── ORDERING IS CRITICAL — read the comments before changing ──
+        //
+        // react-native-webrtc uses a single-threaded Java executor for ALL WebRTC
+        // operations.  Two deadlocks must be avoided:
+        //
+        // DEADLOCK A — transport before producers:
+        //   producer.close() → pc.removeTrack() → onnegotiationneeded → createOffer
+        //   queued on executor.  transport.close() → pc.close() 2 ms later on the
+        //   same single-threaded executor → deadlock.
+        //   FIX: transport.close() first → transportClosed() marks producers
+        //   _closed=true → producer.close() becomes a no-op (no pc.removeTrack).
+        //
+        // DEADLOCK B — screen capture must be stopped BEFORE this function runs:
+        //   peerConnectionDispose() (triggered async after pc.close()) frees the
+        //   SurfaceTextureHelper that ScreenCapturerAndroid uses.  If screen
+        //   track.stop() runs AFTER that, stopCapture() blocks the executor for up
+        //   to 60 s waiting for a surface that is already gone → app freeze.
+        //   FIX: stop screen tracks synchronously in stopLive() BEFORE calling
+        //   fullCleanup().  By the time we reach here, hostSession.screenStream
+        //   is already null.
+        // Step 1 — transport first (calls transportClosed on producers, sets _closed=true)
+        const transportToClose = hostSession.sendTransport;
+        hostSession.sendTransport = null;
+        try {
+            if (transportToClose && !transportToClose.closed)
+                transportToClose.close();
+        }
+        catch { /* ignore */ }
+        // Step 2 — producers (no-ops: transportClosed already set _closed=true)
+        try {
+            hostSession.audioProducer?.close();
+        }
+        catch { /* ignore */ }
+        hostSession.audioProducer = null;
+        try {
+            hostSession.videoProducer?.close();
+        }
+        catch { /* ignore */ }
+        hostSession.videoProducer = null;
+        // Snapshot stream refs and null them out so re-entrant stopScreenShare() bails.
+        const screenStreamToStop = hostSession.screenStream;
+        hostSession.screenStream = null;
+        const localStreamToStop = hostSession.localStream;
+        hostSession.localStream = null;
+        hostSession.device = null;
+        // Disconnect socket → server marks stream 'ended'.  Keep object alive for reuse.
+        try {
+            hostSession.socket?.disconnect();
+        }
+        catch { /* ignore */ }
+        resetHostState();
+        // Step 3 — stop camera/mic tracks deferred: Camera2 stopCapture() is fast but
+        // we still give the executor a moment to finish the PC close first.
+        setTimeout(() => {
+            try {
+                screenStreamToStop?.getTracks()
+                    ?.forEach((t) => { try {
+                    t.stop?.();
+                }
+                catch { /* ignore */ } });
+            }
+            catch { /* ignore */ }
+            try {
+                localStreamToStop?.getTracks()
+                    ?.forEach((t) => { try {
+                    t.stop?.();
+                }
+                catch { /* ignore */ } });
+            }
+            catch { /* ignore */ }
+        }, 300);
+    }, []);
+    // ── Socket ─────────────────────────────────────────────────────────────────
+    // Created once, persists across navigation. On each mount we only
+    // attach/detach named handlers — we never disconnect here.
+    useEffect(() => {
+        const signalingUrl = getSignalingUrl();
+        if (!signalingUrl) {
+            patchHostState({ error: 'Livestream server not configured', status: '' });
+            return;
+        }
+        if (!ensureMediasoupGlobals()) {
+            patchHostState({
+                error: 'WebRTC not available. Use a dev client with react-native-webrtc.',
+                status: '',
+            });
+            return;
+        }
+        if (!hostSession.socket) {
+            const apiKey = getApiKey();
+            const socket = io(signalingUrl, {
+                transports: ['websocket', 'polling'],
+                reconnection: true,
+                autoConnect: true,
+                timeout: 10000,
+                ...(apiKey ? { auth: { apiKey }, extraHeaders: { 'x-api-key': apiKey } } : {}),
+            });
+            hostSession.socket = socket;
+        }
+        else if (!hostSession.socket.connected) {
+            // Voluntarily disconnected by fullCleanup — reconnect the same object.
+            hostSession.socket.connect();
+        }
+        const socket = hostSession.socket;
+        const onConnect = () => patchHostState({ error: null, status: 'Connected. Tap Start preview to begin.' });
+        const onConnectError = (err) => patchHostState({ error: err?.message ?? 'Connection failed', status: '' });
+        const onDisconnect = () => {
+            patchHostState({ status: 'Disconnected from server', live: false, joining: false });
+            fullCleanup();
+        };
+        const onIceServers = (servers) => {
+            hostSession.iceServers = Array.isArray(servers) ? servers : [];
+        };
+        socket.on('connect', onConnect);
+        socket.on('connect_error', onConnectError);
+        socket.on('disconnect', onDisconnect);
+        socket.on('ice-servers', onIceServers);
+        return () => {
+            socket.off('connect', onConnect);
+            socket.off('connect_error', onConnectError);
+            socket.off('disconnect', onDisconnect);
+            socket.off('ice-servers', onIceServers);
+        };
+    }, [fullCleanup]);
+    // ── Permissions ────────────────────────────────────────────────────────────
+    const requestCameraMicPermissions = useCallback(async () => {
+        if (Platform.OS !== 'android')
+            return;
+        const result = await PermissionsAndroid.requestMultiple([
+            PermissionsAndroid.PERMISSIONS.CAMERA,
+            PermissionsAndroid.PERMISSIONS.RECORD_AUDIO,
+        ]);
+        const camOk = result[PermissionsAndroid.PERMISSIONS.CAMERA] === PermissionsAndroid.RESULTS.GRANTED;
+        const micOk = result[PermissionsAndroid.PERMISSIONS.RECORD_AUDIO] === PermissionsAndroid.RESULTS.GRANTED;
+        if (!camOk || !micOk) {
+            throw new Error('Camera and microphone permissions are required to go live.');
+        }
+    }, []);
+    // ── Preview ────────────────────────────────────────────────────────────────
+    const startPreview = useCallback(async () => {
+        const { joining: j, live: l, isFrontCamera: front } = getHostState();
+        if (j || l || hostSession.localStream)
+            return;
+        if (hostSession.socket && !hostSession.socket.connected) {
+            hostSession.socket.connect();
+        }
+        try {
+            patchHostState({ error: null, status: 'Requesting camera/mic permissions...' });
+            await requestCameraMicPermissions();
+            patchHostState({ status: 'Opening camera preview...' });
+            const stream = (await mediaDevices.getUserMedia({
+                audio: true,
+                video: {
+                    facingMode: front ? 'user' : 'environment',
+                    frameRate: 30,
+                    width: 720,
+                    height: 1280,
+                },
+            }));
+            hostSession.localStream = stream;
+            patchHostState({
+                streamURL: getStreamURL(stream),
+                status: 'Preview ready. Tap Go live to start streaming.',
+            });
+        }
+        catch (err) {
+            patchHostState({ error: err instanceof Error ? err.message : 'Failed to open camera', status: '' });
+            fullCleanup();
+        }
+    }, [fullCleanup, requestCameraMicPermissions]);
+    const stopPreview = useCallback(() => {
+        const { joining: j, live: l } = getHostState();
+        if (j || l)
+            return;
+        fullCleanup();
+    }, [fullCleanup]);
+    // ── Camera switch ──────────────────────────────────────────────────────────
+    const switchCamera = useCallback(() => {
+        if (getHostState().captureMode !== 'camera')
+            return;
+        const stream = hostSession.localStream;
+        if (!stream)
+            return;
+        const track = stream.getVideoTracks()[0];
+        if (track?._switchCamera) {
+            track._switchCamera();
+            patchHostState({ isFrontCamera: !getHostState().isFrontCamera });
+        }
+    }, []);
+    // ── Mic mute ───────────────────────────────────────────────────────────────
+    const toggleMic = useCallback(() => {
+        const stream = hostSession.localStream;
+        if (!stream)
+            return;
+        const audioTrack = stream.getAudioTracks()[0];
+        if (!audioTrack)
+            return;
+        const newEnabled = !audioTrack.enabled;
+        audioTrack.enabled = newEnabled;
+        patchHostState({ isMicMuted: !newEnabled });
+    }, []);
+    // ── Screen share ───────────────────────────────────────────────────────────
+    //
+    // replaceTrack() is unreliable when switching between different capture types
+    // (camera → screen). Close the existing video producer and publish a new one
+    // so the server emits new-producer to viewers, who then re-consume the correct
+    // feed automatically.
+    const replaceVideoProducer = useCallback(async (newTrack) => {
+        const transport = hostSession.sendTransport;
+        if (!transport || transport.closed)
+            return; // preview-only, no transport yet
+        try {
+            hostSession.videoProducer?.close();
+        }
+        catch { /* ignore */ }
+        hostSession.videoProducer = null;
+        const producer = await transport.produce({
+            track: newTrack,
+            encodings: [{ maxBitrate: 1000000 }],
+            codecOptions: { videoSimulcastLayers: [] },
+        });
+        hostSession.videoProducer = producer;
+    }, []);
+    const stopScreenShare = useCallback(async () => {
+        if (!hostSession.screenStream)
+            return; // fullCleanup already ran, bail
+        const screenStreamToStop = hostSession.screenStream;
+        hostSession.screenStream = null;
+        try {
+            screenStreamToStop.getTracks()
+                .forEach((t) => { try {
+                t.stop?.();
+            }
+            catch { /* ignore */ } });
+        }
+        catch { /* ignore */ }
+        try {
+            const { isFrontCamera: front } = getHostState();
+            const newCamStream = (await mediaDevices.getUserMedia({
+                audio: false,
+                video: {
+                    facingMode: front ? 'user' : 'environment',
+                    frameRate: 30,
+                    width: 720,
+                    height: 1280,
+                },
+            }));
+            // fullCleanup may have run while awaiting getUserMedia
+            if (!hostSession.localStream) {
+                newCamStream.getTracks()
+                    .forEach((t) => { try {
+                    t.stop?.();
+                }
+                catch { /* ignore */ } });
+                patchHostState({ captureMode: 'camera' });
+                return;
+            }
+            const newVideoTrack = newCamStream.getVideoTracks()[0];
+            if (!newVideoTrack) {
+                patchHostState({ captureMode: 'camera' });
+                return;
+            }
+            const stream = hostSession.localStream;
+            if (stream) {
+                stream.getVideoTracks().forEach((t) => {
+                    try {
+                        t.stop?.();
+                    }
+                    catch { /* ignore */ }
+                    stream.removeTrack(t);
+                });
+                stream.addTrack(newVideoTrack);
+            }
+            patchHostState({ streamURL: getStreamURL(hostSession.localStream) });
+            await replaceVideoProducer(newVideoTrack);
+        }
+        catch {
+            // ignore — worst case user taps Stop preview to recover
+        }
+        patchHostState({ captureMode: 'camera' });
+    }, [replaceVideoProducer]);
+    const startScreenShare = useCallback(async () => {
+        try {
+            const screenStream = await mediaDevices.getDisplayMedia({ video: true, audio: false });
+            const screenVideoTrack = screenStream.getVideoTracks()[0];
+            if (!screenVideoTrack) {
+                screenStream.getTracks()
+                    .forEach((t) => { try {
+                    t.stop?.();
+                }
+                catch { /* ignore */ } });
+                return;
+            }
+            hostSession.screenStream = screenStream;
+            // Free the camera hardware while screen sharing
+            hostSession.localStream?.getVideoTracks()
+                ?.forEach((t) => { try {
+                t.stop?.();
+            }
+            catch { /* ignore */ } });
+            // Point preview at the native screenStream — avoids the black-screen bug
+            // caused by copying a screen-capture track into a different MediaStream object.
+            patchHostState({ streamURL: getStreamURL(screenStream), captureMode: 'screen' });
+            await replaceVideoProducer(screenVideoTrack);
+            // Auto-revert when user dismisses screen share from the Android notification bar
+            screenVideoTrack.addEventListener?.('ended', () => {
+                void stopScreenShare();
+            });
+        }
+        catch (err) {
+            patchHostState({ error: err instanceof Error ? err.message : 'Screen share failed' });
+        }
+    }, [replaceVideoProducer, stopScreenShare]);
+    // ── Go live ────────────────────────────────────────────────────────────────
+    const startLive = useCallback(async () => {
+        const { joining: j, live: l, displayName: dn } = getHostState();
+        if (j || l)
+            return;
+        const socket = hostSession.socket;
+        if (!socket?.connected) {
+            patchHostState({ error: 'Connecting to server... try again in a moment.' });
+            return;
+        }
+        if (!hostSession.localStream) {
+            patchHostState({ error: 'Start preview first, then tap Go live.' });
+            return;
+        }
+        patchHostState({ joining: true, error: null, status: 'Creating stream...' });
+        try {
+            const stream = hostSession.localStream;
+            const streamRes = await createStream({ title: 'Mobile stream' });
+            if ('error' in streamRes)
+                throw new Error(streamRes.error);
+            const { roomId } = streamRes.stream;
+            patchHostState({ roomId, status: 'Joining room...' });
+            const JOIN_TIMEOUT_MS = 12000;
+            const joinRes = await Promise.race([
+                new Promise((resolve, reject) => {
+                    socket.emit('join-room', {
+                        roomId,
+                        role: 'host',
+                        displayName: dn.trim() || undefined,
+                        ...(hostUserId ? { hostUserId } : {}),
+                    }, (res) => {
+                        if (res?.error)
+                            reject(new Error(res.error));
+                        else
+                            resolve(res);
+                    });
+                }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Join timed out. Check server URL and network.')), JOIN_TIMEOUT_MS)),
+            ]);
+            if (!joinRes.rtpCapabilities)
+                throw new Error('Server did not return RTP capabilities');
+            if (Array.isArray(joinRes.iceServers) && joinRes.iceServers.length > 0) {
+                hostSession.iceServers = joinRes.iceServers;
+            }
+            patchHostState({ status: 'Initializing mediasoup device...' });
+            const device = new mediasoupClient.Device();
+            await device.load({
+                routerRtpCapabilities: joinRes.rtpCapabilities,
+            });
+            hostSession.device = device;
+            patchHostState({ status: 'Creating WebRTC transport...' });
+            const transportInfo = await new Promise((resolve, reject) => {
+                socket.emit('create-webrtc-transport', {}, (res) => {
+                    if (res?.error)
+                        reject(new Error(res.error));
+                    else if (res?.id && res.iceParameters && res.dtlsParameters)
+                        resolve(res);
+                    else
+                        reject(new Error('Invalid transport response'));
+                });
+            });
+            const transportOptions = {
+                id: transportInfo.id,
+                iceParameters: transportInfo.iceParameters,
+                iceCandidates: transportInfo.iceCandidates ?? [],
+                dtlsParameters: transportInfo.dtlsParameters,
+            };
+            if (hostSession.iceServers.length > 0)
+                transportOptions.iceServers = hostSession.iceServers;
+            const transport = device.createSendTransport(transportOptions);
+            hostSession.sendTransport = transport;
+            transport.on('connect', ({ dtlsParameters }, callback, errback) => {
+                socket.emit('connect-transport', { transportId: transport.id, dtlsParameters }, (res) => {
+                    if (res?.error)
+                        errback(new Error(res.error));
+                    else
+                        callback();
+                });
+            });
+            transport.on('produce', ({ kind, rtpParameters, appData }, callback, errback) => {
+                socket.emit('produce', { transportId: transport.id, kind, rtpParameters, appData }, (res) => {
+                    if (res?.error || !res?.id)
+                        errback(new Error(res?.error ?? 'Produce failed'));
+                    else
+                        callback({ id: res.id });
+                });
+            });
+            transport.on('connectionstatechange', (connState) => {
+                // Skip stale events after fullCleanup clears the ref
+                if (hostSession.sendTransport !== transport)
+                    return;
+                if (connState === 'connected') {
+                    patchHostState({ status: 'You are live', live: true });
+                }
+                else if (connState === 'failed' || connState === 'closed' || connState === 'disconnected') {
+                    patchHostState({ live: false, status: 'Connection lost. Check network or try again.' });
+                }
+            });
+            patchHostState({ status: 'Publishing tracks...' });
+            // Audio always from localStream (mic).
+            // Video from screenStream when screen-sharing (camera track was stopped),
+            // otherwise from localStream. Skip any tracks already ended.
+            const { captureMode: mode } = getHostState();
+            const audioTrack = stream.getAudioTracks().find((t) => t.readyState !== 'ended');
+            const videoSource = mode === 'screen' && hostSession.screenStream ? hostSession.screenStream : stream;
+            const videoTrack = videoSource.getVideoTracks().find((t) => t.readyState !== 'ended');
+            const tracksToPublish = [audioTrack, videoTrack].filter((t) => t != null);
+            if (tracksToPublish.length === 0)
+                throw new Error('No live tracks available. Restart preview.');
+            for (const track of tracksToPublish) {
+                const producer = await transport.produce({
+                    track: track,
+                    encodings: track.kind === 'video' ? [{ maxBitrate: 1000000 }] : undefined,
+                    codecOptions: track.kind === 'video'
+                        ? { videoSimulcastLayers: [] }
+                        : undefined,
+                });
+                if (track.kind === 'video')
+                    hostSession.videoProducer = producer;
+                if (track.kind === 'audio')
+                    hostSession.audioProducer = producer;
+            }
+            patchHostState({ joining: false, live: true, status: 'You are live' });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to start stream';
+            console.warn('[useHostSocket] startLive failed:', message);
+            patchHostState({ joining: false, live: false, error: message, status: '' });
+            fullCleanup();
+        }
+    }, [fullCleanup, hostUserId]);
+    const stopLive = useCallback(async () => {
+        const { captureMode } = getHostState();
+        if (captureMode === 'screen' && hostSession.screenStream) {
+            // ── Sequential screen-share teardown ───────────────────────────────
+            // react-native-webrtc uses a single-threaded executor for ALL WebRTC ops.
+            // ScreenCapturerAndroid.stopCapture() blocks that executor for up to 60 s
+            // while waiting for the render thread (captureStopped CountDownLatch).
+            // RTCPeerConnection.dispose() (triggered async after pc.close()) frees the
+            // SurfaceTextureHelper that the render thread writes into.
+            // If stop() runs AFTER dispose(), the render thread is stuck → 60 s freeze.
+            //
+            // Fix: stop the screen tracks HERE, wait for the MediaProjection 'ended'
+            // event (i.e. the native capture has fully drained), THEN call fullCleanup().
+            // By the time fullCleanup() runs, the screen capturer is already gone and
+            // peerConnectionDispose() has nothing to contend with.
+            const screenStream = hostSession.screenStream;
+            hostSession.screenStream = null; // guard: stopScreenShare bails on re-entry
+            patchHostState({ status: 'Stopping screen share...' });
+            await new Promise((resolve) => {
+                const videoTrack = screenStream.getVideoTracks()[0];
+                if (videoTrack && videoTrack.readyState !== 'ended' && videoTrack.addEventListener) {
+                    const onEnded = () => {
+                        videoTrack.removeEventListener?.('ended', onEnded);
+                        resolve();
+                    };
+                    videoTrack.addEventListener('ended', onEnded);
+                    // Stop all screen tracks — fires 'ended' when MediaProjection fully releases
+                    screenStream.getTracks()
+                        .forEach((t) => { try {
+                        t.stop?.();
+                    }
+                    catch { /* ignore */ } });
+                    // Fallback: if 'ended' never fires (some devices), unblock after 800 ms
+                    setTimeout(() => {
+                        videoTrack.removeEventListener?.('ended', onEnded);
+                        resolve();
+                    }, 800);
+                }
+                else {
+                    screenStream.getTracks()
+                        .forEach((t) => { try {
+                        t.stop?.();
+                    }
+                    catch { /* ignore */ } });
+                    resolve();
+                }
+            });
+            // MediaProjection is fully stopped — executor is free. Safe to close transport.
+        }
+        fullCleanup();
+        patchHostState({ status: 'Stream stopped' });
+    }, [fullCleanup]);
+    // ── Helpers ────────────────────────────────────────────────────────────────
+    const setDisplayName = useCallback((name) => {
+        patchHostState({ displayName: name });
+    }, []);
+    return {
+        ...state,
+        setDisplayName,
+        startPreview,
+        stopPreview,
+        startLive,
+        stopLive,
+        switchCamera,
+        toggleMic,
+        startScreenShare,
+        stopScreenShare,
+    };
+}

package/dist/host/hostSession.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Module-level singleton — lives outside React so it survives component
+ * unmount/remount when the user navigates between tabs.
+ */
+import type { Socket } from 'socket.io-client';
+import type * as mediasoupClient from 'mediasoup-client';
+import type { MediaStream } from 'react-native-webrtc';
+export declare const hostSession: {
+    socket: Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap> | null;
+    device: mediasoupClient.types.Device | null;
+    sendTransport: mediasoupClient.types.Transport<mediasoupClient.types.AppData> | null;
+    localStream: MediaStream | null;
+    screenStream: MediaStream | null;
+    audioProducer: mediasoupClient.types.Producer<mediasoupClient.types.AppData> | null;
+    videoProducer: mediasoupClient.types.Producer<mediasoupClient.types.AppData> | null;
+    iceServers: RTCIceServer[];
+};
+//# sourceMappingURL=hostSession.d.ts.map

package/dist/host/hostSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostSession.d.ts","sourceRoot":"","sources":["../../src/host/hostSession.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,KAAK,eAAe,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,eAAO,MAAM,WAAW;;;;;;;;;CASvB,CAAC"}

package/dist/host/hostSession.js

@@ -0,0 +1,10 @@
+export const hostSession = {
+    socket: null,
+    device: null,
+    sendTransport: null,
+    localStream: null,
+    screenStream: null,
+    audioProducer: null,
+    videoProducer: null,
+    iceServers: [],
+};

package/dist/host/hostState.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Module-level reactive state for the host session.
+ *
+ * Lives outside React (like Zustand) so the UI state survives tab navigation
+ * — the component can unmount/remount without losing "live", "joining", etc.
+ *
+ * Usage:
+ *   patchHostState({ live: true });        // update from anywhere
+ *   const unsub = subscribeHostState(cb);  // subscribe from a hook
+ *   getHostState();                        // read synchronously
+ */
+export type HostState = {
+    status: string;
+    error: string | null;
+    joining: boolean;
+    live: boolean;
+    roomId: string;
+    displayName: string;
+    isFrontCamera: boolean;
+    isMicMuted: boolean;
+    captureMode: 'camera' | 'screen';
+    streamURL: string | null;
+};
+export declare function getHostState(): HostState;
+export declare function patchHostState(update: Partial<HostState>): void;
+export declare function resetHostState(): void;
+export declare function subscribeHostState(listener: (s: HostState) => void): () => void;
+//# sourceMappingURL=hostState.d.ts.map

package/dist/host/hostState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostState.d.ts","sourceRoot":"","sources":["../../src/host/hostState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACjC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAkBF,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAG/D;AAED,wBAAgB,cAAc,IAAI,IAAI,CAGrC;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI,CAK/E"}

package/dist/host/hostState.js

@@ -0,0 +1,42 @@
+/**
+ * Module-level reactive state for the host session.
+ *
+ * Lives outside React (like Zustand) so the UI state survives tab navigation
+ * — the component can unmount/remount without losing "live", "joining", etc.
+ *
+ * Usage:
+ *   patchHostState({ live: true });        // update from anywhere
+ *   const unsub = subscribeHostState(cb);  // subscribe from a hook
+ *   getHostState();                        // read synchronously
+ */
+const initial = {
+    status: '',
+    error: null,
+    joining: false,
+    live: false,
+    roomId: '',
+    displayName: '',
+    isFrontCamera: true,
+    isMicMuted: false,
+    captureMode: 'camera',
+    streamURL: null,
+};
+let _state = { ...initial };
+const _listeners = new Set();
+export function getHostState() {
+    return _state;
+}
+export function patchHostState(update) {
+    _state = { ..._state, ...update };
+    _listeners.forEach((l) => l(_state));
+}
+export function resetHostState() {
+    _state = { ...initial };
+    _listeners.forEach((l) => l(_state));
+}
+export function subscribeHostState(listener) {
+    _listeners.add(listener);
+    return () => {
+        _listeners.delete(listener);
+    };
+}

package/dist/index.d.ts

@@ -4,12 +4,17 @@
  */
 export { setLivestreamConfig, getLivestreamConfig, getBaseUrl, getApiKey, getSignalingUrl, getSignalingWsUrl, getDisplayName, } from './config';
 export type { LivestreamConfig } from './config';
-export { fetchActiveStreams } from './services/livestream.service';
-export type { FetchStreamsResult } from './services/livestream.service';
+export { fetchActiveStreams, createStream, mintViewerToken } from './services/livestream.service';
+export type { FetchStreamsResult, CreateStreamResult, MintViewerTokenResult } from './services/livestream.service';
 export { ensureMediasoupGlobals } from './services/mediasoup-init';
 export { useViewerSocket } from './hooks/useViewerSocket';
 export { useLiveStreams } from './hooks/useLiveStreams';
 export { LiveStreamFeed } from './components/LiveStreamFeed';
 export { LiveStreamViewerItem } from './components/LiveStreamViewerItem';
 export type { LiveStreamInfo, ProducerInfo, JoinRoomResult, RoomState } from './types';
+export { hostSession } from './host/hostSession';
+export { getHostState, patchHostState, resetHostState, subscribeHostState, } from './host/hostState';
+export type { HostState } from './host/hostState';
+export { useHostSocket } from './hooks/useHostSocket';
+export type { UseHostSocketOptions, UseHostSocketReturn } from './hooks/useHostSocket';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,UAAU,EACV,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,YAAY,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,UAAU,EACV,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAClG,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACnH,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGvF,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EACL,YAAY,EACZ,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -3,9 +3,13 @@
  * Configure with setLivestreamConfig() before using components/hooks.
  */
 export { setLivestreamConfig, getLivestreamConfig, getBaseUrl, getApiKey, getSignalingUrl, getSignalingWsUrl, getDisplayName, } from './config';
-export { fetchActiveStreams } from './services/livestream.service';
+export { fetchActiveStreams, createStream, mintViewerToken } from './services/livestream.service';
 export { ensureMediasoupGlobals } from './services/mediasoup-init';
 export { useViewerSocket } from './hooks/useViewerSocket';
 export { useLiveStreams } from './hooks/useLiveStreams';
 export { LiveStreamFeed } from './components/LiveStreamFeed';
 export { LiveStreamViewerItem } from './components/LiveStreamViewerItem';
+// ── Host / broadcaster ────────────────────────────────────────────────────────
+export { hostSession } from './host/hostSession';
+export { getHostState, patchHostState, resetHostState, subscribeHostState, } from './host/hostState';
+export { useHostSocket } from './hooks/useHostSocket';

package/dist/services/livestream.service.d.ts

@@ -16,7 +16,23 @@ export type MintViewerTokenResult = {
     token?: never;
     error: string;
 };
+export type CreateStreamResult = {
+    stream: {
+        id: string;
+        roomId: string;
+        title: string | null;
+        status: string;
+    };
+    error?: never;
+} | {
+    stream?: never;
+    error: string;
+};
 export declare function fetchActiveStreams(): Promise<FetchStreamsResult>;
+export declare function createStream(params?: {
+    title?: string | null;
+    roomId?: string | null;
+}): Promise<CreateStreamResult>;
 export declare function mintViewerToken(params: {
     roomId: string;
     viewerId?: string | null;

package/dist/services/livestream.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"livestream.service.d.ts","sourceRoot":"","sources":["../../src/services/livestream.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,MAAM,kBAAkB,GAC1B;IAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAC5C;IAAE,OAAO,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAUnC,MAAM,MAAM,qBAAqB,GAC7B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAChC;IAAE,KAAK,CAAC,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAErC,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CA+BtE;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAyBjC;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}
+{"version":3,"file":"livestream.service.d.ts","sourceRoot":"","sources":["../../src/services/livestream.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,MAAM,kBAAkB,GAC1B;IAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAC5C;IAAE,OAAO,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAUnC,MAAM,MAAM,qBAAqB,GAC7B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAChC;IAAE,KAAK,CAAC,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAErC,MAAM,MAAM,kBAAkB,GAC1B;IAAE,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAC/F;IAAE,MAAM,CAAC,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtC,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CA+BtE;AAED,wBAAsB,YAAY,CAAC,MAAM,CAAC,EAAE;IAC1C,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAsC9B;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAyBjC;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/services/livestream.service.js

@@ -43,6 +43,52 @@ export async function fetchActiveStreams() {
         return { streams: [], error: message };
     }
 }
+export async function createStream(params) {
+    const base = getBaseUrl();
+    if (!base)
+        return { error: 'Livestream server not configured' };
+    const apiKey = getApiKey();
+    if (!apiKey)
+        return { error: 'Livestream API key not configured' };
+    try {
+        const url = `${base.replace(/\/$/, '')}/api/streams`;
+        const body = {};
+        if (typeof params?.title === 'string')
+            body.title = params.title;
+        if (typeof params?.roomId === 'string')
+            body.roomId = params.roomId;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'x-api-key': apiKey,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            return { error: `HTTP ${res.status}` };
+        const data = (await res.json());
+        if (data?.error)
+            return { error: data.error };
+        const s = data?.stream || {};
+        const id = typeof s?.id === 'string' ? s.id : '';
+        const roomId = typeof s?.roomId === 'string' ? s.roomId : typeof s?.room_id === 'string' ? s.room_id : '';
+        if (!id || !roomId)
+            return { error: 'Invalid stream response' };
+        return {
+            stream: {
+                id,
+                roomId,
+                title: typeof s?.title === 'string' ? s.title : null,
+                status: typeof s?.status === 'string' ? s.status : 'created',
+            },
+        };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : 'Unknown error';
+        return { error: message };
+    }
+}
 export async function mintViewerToken(params) {
     const base = getBaseUrl();
     if (!base)

package/package.json

@@ -1,35 +1,35 @@
-{
-  "name": "kasunk99-livestream-core",
-  "version": "0.1.3",
-  "description": "Reusable livestream viewer/host module for React Native (Expo) — mediasoup + Socket.IO",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md",
-    "package.json"
-  ],
-  "scripts": {
-    "clean": "rimraf dist",
-    "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "npm run clean && npm run build"
-  },
-  "peerDependencies": {
-    "mediasoup-client": "^3.6.0",
-    "react": ">=18.0.0",
-    "react-native": "*",
-    "react-native-webrtc": ">=118.0.0",
-    "socket.io-client": "^4.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.0",
-    "@types/react": "^18.2.0",
-    "@types/react-native": "^0.72.8",
-    "mediasoup-client": "^3.18.7",
-    "react-native": "^0.84.1",
-    "react-native-webrtc": "^124.0.7",
-    "rimraf": "^6.1.3",
-    "socket.io-client": "^4.8.3",
-    "typescript": "~5.3.0"
-  }
-}
+{
+  "name": "kasunk99-livestream-core",
+  "version": "0.2.0",
+  "description": "Reusable livestream viewer/host module for React Native (Expo) — mediasoup + Socket.IO",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "peerDependencies": {
+    "mediasoup-client": "^3.6.0",
+    "react": ">=18.0.0",
+    "react-native": "*",
+    "react-native-webrtc": ">=118.0.0",
+    "socket.io-client": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.72.8",
+    "mediasoup-client": "^3.18.7",
+    "react-native": "^0.84.1",
+    "react-native-webrtc": "^124.0.7",
+    "rimraf": "^6.1.3",
+    "socket.io-client": "^4.8.3",
+    "typescript": "~5.3.0"
+  }
+}