Merge remote-tracking branch 'remotes/upstream/develop' into tiles-start-positions

front/src/Stores/PeerStore.ts

@@ -1,36 +1,121 @@
-import { derived, writable, Writable } from "svelte/store";
-import type {UserSimplePeerInterface} from "../WebRtc/SimplePeer";
-import type {SimplePeer} from "../WebRtc/SimplePeer";
+import { readable, writable } from "svelte/store";
+import type { RemotePeer, SimplePeer } from "../WebRtc/SimplePeer";
+import { VideoPeer } from "../WebRtc/VideoPeer";
+import { ScreenSharingPeer } from "../WebRtc/ScreenSharingPeer";
 
 /**
- * A store that contains the camera state requested by the user (on or off).
+ * A store that contains the list of (video) peers we are connected to.
  */
 function createPeerStore() {
-    let users = new Map<number, UserSimplePeerInterface>();
+    let peers = new Map<number, VideoPeer>();
 
-    const { subscribe, set, update } = writable(users);
+    const { subscribe, set, update } = writable(peers);
 
     return {
         subscribe,
         connectToSimplePeer: (simplePeer: SimplePeer) => {
-            users = new Map<number, UserSimplePeerInterface>();
-            set(users);
+            peers = new Map<number, VideoPeer>();
+            set(peers);
             simplePeer.registerPeerConnectionListener({
-                onConnect(user: UserSimplePeerInterface) {
-                    update(users => {
-                        users.set(user.userId, user);
-                        return users;
-                    });
+                onConnect(peer: RemotePeer) {
+                    if (peer instanceof VideoPeer) {
+                        update((users) => {
+                            users.set(peer.userId, peer);
+                            return users;
+                        });
+                    }
                 },
                 onDisconnect(userId: number) {
-                    update(users => {
+                    update((users) => {
                         users.delete(userId);
                         return users;
                     });
-                }
-            })
-        }
+                },
+            });
+        },
+    };
+}
+
+/**
+ * A store that contains the list of screen sharing peers we are connected to.
+ */
+function createScreenSharingPeerStore() {
+    let peers = new Map<number, ScreenSharingPeer>();
+
+    const { subscribe, set, update } = writable(peers);
+
+    return {
+        subscribe,
+        connectToSimplePeer: (simplePeer: SimplePeer) => {
+            peers = new Map<number, ScreenSharingPeer>();
+            set(peers);
+            simplePeer.registerPeerConnectionListener({
+                onConnect(peer: RemotePeer) {
+                    if (peer instanceof ScreenSharingPeer) {
+                        update((users) => {
+                            users.set(peer.userId, peer);
+                            return users;
+                        });
+                    }
+                },
+                onDisconnect(userId: number) {
+                    update((users) => {
+                        users.delete(userId);
+                        return users;
+                    });
+                },
+            });
+        },
     };
 }
 
 export const peerStore = createPeerStore();
+export const screenSharingPeerStore = createScreenSharingPeerStore();
+
+/**
+ * A store that contains ScreenSharingPeer, ONLY if those ScreenSharingPeer are emitting a stream towards us!
+ */
+function createScreenSharingStreamStore() {
+    let peers = new Map<number, ScreenSharingPeer>();
+
+    return readable<Map<number, ScreenSharingPeer>>(peers, function start(set) {
+        let unsubscribes: (() => void)[] = [];
+
+        const unsubscribe = screenSharingPeerStore.subscribe((screenSharingPeers) => {
+            for (const unsubscribe of unsubscribes) {
+                unsubscribe();
+            }
+            unsubscribes = [];
+
+            peers = new Map<number, ScreenSharingPeer>();
+
+            screenSharingPeers.forEach((screenSharingPeer: ScreenSharingPeer, key: number) => {
+                if (screenSharingPeer.isReceivingScreenSharingStream()) {
+                    peers.set(key, screenSharingPeer);
+                }
+
+                unsubscribes.push(
+                    screenSharingPeer.streamStore.subscribe((stream) => {
+                        if (stream) {
+                            peers.set(key, screenSharingPeer);
+                        } else {
+                            peers.delete(key);
+                        }
+                        set(peers);
+                    })
+                );
+            });
+
+            set(peers);
+        });
+
+        return function stop() {
+            unsubscribe();
+            for (const unsubscribe of unsubscribes) {
+                unsubscribe();
+            }
+        };
+    });
+}
+
+export const screenSharingStreamStore = createScreenSharingStreamStore();