janky/src/Janky/repositories/useRemoteStreams.ts

Janus Interface

import { useEffect, useState } from "react"
import eventEmitter from "./eventEmitter";
import { PUBLISHING_EVENTS } from "../events";

interface RemoteStreamType {
    rid: number;
    pubID: string;
    stream: MediaStream
};

type UseRemoteStreamsType = () => { remoteStreams: RemoteStreamType[] };

const useRemoteStreams: UseRemoteStreamsType = () => {
    const [remoteStreams, setRemoteStreams] = useState<RemoteStreamType[]>([]);

    useEffect(() => {
        const handleNewTracks = (track: MediaStreamTrack, on: boolean, pubID: string, rid: number) => {
            setRemoteStreams((prevStreams) => {
                
                const existingStream = prevStreams.find((stream) => stream.pubID === pubID);
                if (existingStream) {
                    // Add/remove the track to the existing stream
                    on ? existingStream.stream.addTrack(track) : existingStream.stream.removeTrack(track);
                  
                    // Check if the stream has any remaining tracks
                    if (existingStream.stream.getTracks().length === 0) {
                        // Remove the whole remoteStream entry
                        return prevStreams.filter((stream) => stream.pubID !== pubID);
                    }
                    return [...prevStreams]; // Update the state with the same array reference
                }

                if(!on)
                    return prevStreams;
                // Create a new media stream and add the track
                const newStream = new MediaStream();
                newStream.addTrack(track);
                const newStreams = [
                    ...prevStreams,
                    {
                        stream: newStream,
                        rid,
                        pubID
                    }
                ];
                return newStreams;
            });
        };
        
        if(!eventEmitter.listeners(PUBLISHING_EVENTS.RECIVED_TRACK).length) {
            eventEmitter.on(PUBLISHING_EVENTS.RECIVED_TRACK, handleNewTracks);
        }


        const removeStream = (rid: number) => {
            const newStreams = remoteStreams.filter(rs => rs.rid !== rid);
            setRemoteStreams(newStreams);
        }
        if(!eventEmitter.listeners(PUBLISHING_EVENTS.UNPUBLISH).length) {
            eventEmitter.on(PUBLISHING_EVENTS.UNPUBLISH, removeStream);
        }

    }, []);


    return { remoteStreams };
};

export default useRemoteStreams;