Updated setup to vite and moved to hooks instead of class

src/API/HUD/camera.ts

@@ -0,0 +1,152 @@
+import { Instance, SignalData } from 'simple-peer';
+import api from '..';
+import { socket } from '../socket';
+import Peer from 'simple-peer';
+
+const wait = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+type OfferData = {
+    offer: SignalData,
+}
+
+type PeerInstance = Instance & { _remoteStreams: MediaStream[] }
+
+type MediaStreamPlayer = {
+    peerConnection: PeerInstance | null;
+    steamid: string;
+}
+
+type ListenerType = ({ listener: (stream: MediaStream) => void, event: 'create', steamid: string } | ({ listener: () => void, event: 'destroy', steamid: string }));
+
+type MediaStreamManager = {
+    blocked: string[];
+    blockedListeners: ((blocked: string[]) => void)[],
+    players: MediaStreamPlayer[];
+    onStreamCreate: (listener: (stream: MediaStream) => void, steamid: string) => void;
+    onStreamDestroy: (listener: () => void, steamid: string) => void;
+    onBlockedUpdate: (listener: (steamids: string[]) => void) => void;
+    removeListener: (listener: any) => void;
+    listeners: ListenerType[];
+}
+
+const mediaStreams: MediaStreamManager = {
+    blocked: [],
+    blockedListeners: [],
+    players: [],
+    listeners: [],
+    onStreamCreate: (listener: (stream: MediaStream) => void, steamid: string) => {
+        mediaStreams.listeners.push({ listener, event: "create", steamid });
+    },
+    onBlockedUpdate: (listener: (blocked: string[]) => void) => {
+        mediaStreams.blockedListeners.push(listener);
+    },
+    onStreamDestroy: (listener: () => void, steamid: string) => {
+        mediaStreams.listeners.push({ listener, event: "destroy", steamid });
+    },
+    removeListener: (listenerToRemove: any) => {
+        mediaStreams.listeners = mediaStreams.listeners.filter(listener => listener !== listenerToRemove);
+        mediaStreams.blockedListeners = mediaStreams.blockedListeners.filter(listener => listener !== listenerToRemove);
+    }
+};
+
+const getConnectionInfo = (steamid: string) => mediaStreams.players.find(player => player.steamid === steamid) || null;
+
+const closeConnection = (steamid: string) => {
+    const connectionInfo = getConnectionInfo(steamid);
+    try {
+        if (connectionInfo) {
+            if (connectionInfo.peerConnection) {
+                connectionInfo.peerConnection.removeAllListeners();
+                connectionInfo.peerConnection.destroy();
+            }
+            connectionInfo.peerConnection = null;
+        }
+    } catch {
+
+    }
+
+    for (const listener of mediaStreams.listeners.filter(listener => listener.steamid === steamid)) {
+        if (listener.event === "destroy") listener.listener();
+    }
+    mediaStreams.players = mediaStreams.players.filter(player => player.steamid !== steamid);
+    console.log(mediaStreams.players)
+}
+
+const initiateConnection = async () => {
+    const camera = await api.camera.get();
+    await wait(1000);
+
+    socket.emit("registerAsHUD", camera.uuid);
+
+    socket.on('playersCameraStatus', (players: { steamid: string, label: string, allow: boolean, active: boolean }[]) => {
+        const blockedSteamids = players.filter(player => !player.allow).map(player => player.steamid);
+        mediaStreams.blocked = blockedSteamids;
+
+        for (const listener of mediaStreams.blockedListeners) {
+            listener(blockedSteamids);
+        }
+    });
+
+    socket.on('offerFromPlayer', async (roomId: string, offerData: OfferData, steamid: string) => {
+        // It's not from available player, ignore incoming request
+        /*if(!camera.availablePlayers.find(player => player.steamid === steamid)){
+            console.log("Wrong player");
+            return;
+        }*/
+        const currentConnection = getConnectionInfo(steamid);
+
+        // Connection already made, ignore incoming request
+        if (currentConnection) {
+            console.log("Connection has been made already");
+            return;
+        }
+
+        if (camera.uuid !== roomId) return;
+
+        const peerConnection = new Peer({ initiator: false, trickle: false }) as PeerInstance;
+
+        const mediaStreamPlayer: MediaStreamPlayer = { peerConnection, steamid };
+
+        mediaStreams.players.push(mediaStreamPlayer);
+
+        peerConnection.on('signal', answer => {
+            console.log("SIGNAL COMING IN");
+            const offer = JSON.parse(JSON.stringify(answer)) as RTCSessionDescriptionInit;
+            socket.emit("offerFromHUD", roomId, { offer }, steamid);
+        });
+
+        peerConnection.on('error', (err) => {
+            console.log(err)
+            closeConnection(steamid);
+        });
+
+        peerConnection.on('stream', () => {
+            console.log("STREAM COMING IN");
+            const currentConnection = getConnectionInfo(steamid);
+            if (!currentConnection) {
+                console.log("Connection not established");
+                closeConnection(steamid);
+                return;
+            }
+            if (peerConnection._remoteStreams.length === 0) {
+                console.log('no stream?');
+                return;
+            }
+            for (const listener of mediaStreams.listeners.filter(listener => listener.steamid === steamid)) {
+                if (listener.event === "create") listener.listener(peerConnection._remoteStreams[0]);
+            }
+        });
+
+        peerConnection.on('close', () => {
+            console.log("CLOSE COMING IN");
+            const currentConnection = getConnectionInfo(steamid);
+            if (!currentConnection) return;
+
+            closeConnection(steamid);
+        });
+        console.log("Sending offer");
+        peerConnection.signal(offerData.offer);
+    });
+}
+
+export { mediaStreams, initiateConnection };