ddd test

src/app/infrastructure/realtime/streams/peer-media-facade.ts

@@ -0,0 +1,129 @@
+import { Observable } from 'rxjs';
+import { ChatEvent } from '../../../core/models';
+import { ScreenShareStartOptions } from '../screen-share.config';
+import { PeerData } from '../realtime.types';
+import { MediaManager } from '../media/media.manager';
+import { PeerConnectionManager } from '../peer-connection-manager/peer-connection.manager';
+import { ScreenShareManager } from '../media/screen-share.manager';
+
+interface PeerMediaFacadeDependencies {
+  peerManager: PeerConnectionManager;
+  mediaManager: MediaManager;
+  screenShareManager: ScreenShareManager;
+}
+
+export class PeerMediaFacade {
+  constructor(
+    private readonly dependencies: PeerMediaFacadeDependencies
+  ) {}
+
+  get onMessageReceived(): Observable<ChatEvent> {
+    return this.dependencies.peerManager.messageReceived$.asObservable();
+  }
+
+  get onPeerConnected(): Observable<string> {
+    return this.dependencies.peerManager.peerConnected$.asObservable();
+  }
+
+  get onPeerDisconnected(): Observable<string> {
+    return this.dependencies.peerManager.peerDisconnected$.asObservable();
+  }
+
+  get onRemoteStream(): Observable<{ peerId: string; stream: MediaStream }> {
+    return this.dependencies.peerManager.remoteStream$.asObservable();
+  }
+
+  get onVoiceConnected(): Observable<void> {
+    return this.dependencies.mediaManager.voiceConnected$.asObservable();
+  }
+
+  getActivePeers(): Map<string, PeerData> {
+    return this.dependencies.peerManager.activePeerConnections;
+  }
+
+  async renegotiate(peerId: string): Promise<void> {
+    return await this.dependencies.peerManager.renegotiate(peerId);
+  }
+
+  broadcastMessage(event: ChatEvent): void {
+    this.dependencies.peerManager.broadcastMessage(event);
+  }
+
+  sendToPeer(peerId: string, event: ChatEvent): void {
+    this.dependencies.peerManager.sendToPeer(peerId, event);
+  }
+
+  async sendToPeerBuffered(peerId: string, event: ChatEvent): Promise<void> {
+    return await this.dependencies.peerManager.sendToPeerBuffered(peerId, event);
+  }
+
+  broadcastCurrentStates(): void {
+    this.dependencies.peerManager.broadcastCurrentStates();
+  }
+
+  getConnectedPeerIds(): string[] {
+    return this.dependencies.peerManager.getConnectedPeerIds();
+  }
+
+  getRemoteStream(peerId: string): MediaStream | null {
+    return this.dependencies.peerManager.remotePeerStreams.get(peerId) ?? null;
+  }
+
+  getRemoteVoiceStream(peerId: string): MediaStream | null {
+    return this.dependencies.peerManager.remotePeerVoiceStreams.get(peerId) ?? null;
+  }
+
+  getRemoteScreenShareStream(peerId: string): MediaStream | null {
+    return this.dependencies.peerManager.remotePeerScreenShareStreams.get(peerId) ?? null;
+  }
+
+  clearRemoteScreenShareStream(peerId: string): void {
+    this.dependencies.peerManager.clearRemoteScreenShareStream(peerId);
+  }
+
+  closeAllPeers(): void {
+    this.dependencies.peerManager.closeAllPeers();
+  }
+
+  getLocalStream(): MediaStream | null {
+    return this.dependencies.mediaManager.getLocalStream();
+  }
+
+  getRawMicStream(): MediaStream | null {
+    return this.dependencies.mediaManager.getRawMicStream();
+  }
+
+  isScreenShareActive(): boolean {
+    return this.dependencies.screenShareManager.getIsScreenActive();
+  }
+
+  async startScreenShare(options: ScreenShareStartOptions): Promise<MediaStream> {
+    return await this.dependencies.screenShareManager.startScreenShare(options);
+  }
+
+  stopScreenShare(): void {
+    this.dependencies.screenShareManager.stopScreenShare();
+  }
+
+  requestScreenShareForPeer(peerId: string): void {
+    this.dependencies.screenShareManager.requestScreenShareForPeer(peerId);
+  }
+
+  stopScreenShareForPeer(peerId: string): void {
+    this.dependencies.screenShareManager.stopScreenShareForPeer(peerId);
+  }
+
+  clearScreenShareRequest(peerId: string): void {
+    this.dependencies.screenShareManager.clearScreenShareRequest(peerId);
+  }
+
+  syncScreenShareToPeer(peerId: string): void {
+    this.dependencies.screenShareManager.syncScreenShareToPeer(peerId);
+  }
+
+  destroy(): void {
+    this.dependencies.peerManager.destroy();
+    this.dependencies.mediaManager.destroy();
+    this.dependencies.screenShareManager.destroy();
+  }
+}

src/app/infrastructure/realtime/streams/remote-screen-share-request-controller.ts

@@ -0,0 +1,113 @@
+import { ChatEvent } from '../../../core/models';
+import {
+  P2P_TYPE_SCREEN_SHARE_REQUEST,
+  P2P_TYPE_SCREEN_SHARE_STOP,
+  P2P_TYPE_SCREEN_STATE
+} from '../realtime.constants';
+
+interface RemoteScreenShareRequestControllerDependencies {
+  getConnectedPeerIds(): string[];
+  sendToPeer(peerId: string, event: ChatEvent): void;
+  clearRemoteScreenShareStream(peerId: string): void;
+  requestScreenShareForPeer(peerId: string): void;
+  stopScreenShareForPeer(peerId: string): void;
+  clearScreenShareRequest(peerId: string): void;
+}
+
+export class RemoteScreenShareRequestController {
+  private remoteScreenShareRequestsEnabled = false;
+  private readonly desiredRemoteScreenSharePeers = new Set<string>();
+  private readonly activeRemoteScreenSharePeers = new Set<string>();
+
+  constructor(
+    private readonly dependencies: RemoteScreenShareRequestControllerDependencies
+  ) {}
+
+  handlePeerConnected(peerId: string): void {
+    if (this.remoteScreenShareRequestsEnabled && this.desiredRemoteScreenSharePeers.has(peerId)) {
+      this.requestRemoteScreenShares([peerId]);
+    }
+  }
+
+  handlePeerDisconnected(peerId: string): void {
+    this.activeRemoteScreenSharePeers.delete(peerId);
+    this.dependencies.clearScreenShareRequest(peerId);
+  }
+
+  handlePeerControlMessage(event: ChatEvent): void {
+    if (!event.fromPeerId) {
+      return;
+    }
+
+    if (event.type === P2P_TYPE_SCREEN_STATE && event.isScreenSharing === false) {
+      this.dependencies.clearRemoteScreenShareStream(event.fromPeerId);
+      return;
+    }
+
+    if (event.type === P2P_TYPE_SCREEN_SHARE_REQUEST) {
+      this.dependencies.requestScreenShareForPeer(event.fromPeerId);
+      return;
+    }
+
+    if (event.type === P2P_TYPE_SCREEN_SHARE_STOP) {
+      this.dependencies.stopScreenShareForPeer(event.fromPeerId);
+    }
+  }
+
+  syncRemoteScreenShareRequests(peerIds: string[], enabled: boolean): void {
+    const nextDesiredPeers = new Set(
+      peerIds.filter((peerId): peerId is string => !!peerId)
+    );
+
+    if (!enabled) {
+      this.remoteScreenShareRequestsEnabled = false;
+      this.desiredRemoteScreenSharePeers.clear();
+      this.stopRemoteScreenShares([...this.activeRemoteScreenSharePeers]);
+      return;
+    }
+
+    this.remoteScreenShareRequestsEnabled = true;
+
+    for (const activePeerId of [...this.activeRemoteScreenSharePeers]) {
+      if (!nextDesiredPeers.has(activePeerId)) {
+        this.stopRemoteScreenShares([activePeerId]);
+      }
+    }
+
+    this.desiredRemoteScreenSharePeers.clear();
+    nextDesiredPeers.forEach((peerId) => this.desiredRemoteScreenSharePeers.add(peerId));
+    this.requestRemoteScreenShares([...nextDesiredPeers]);
+  }
+
+  clear(): void {
+    this.remoteScreenShareRequestsEnabled = false;
+    this.desiredRemoteScreenSharePeers.clear();
+    this.activeRemoteScreenSharePeers.clear();
+  }
+
+  private requestRemoteScreenShares(peerIds: string[]): void {
+    const connectedPeerIds = new Set(this.dependencies.getConnectedPeerIds());
+
+    for (const peerId of peerIds) {
+      if (!connectedPeerIds.has(peerId) || this.activeRemoteScreenSharePeers.has(peerId)) {
+        continue;
+      }
+
+      this.dependencies.sendToPeer(peerId, { type: P2P_TYPE_SCREEN_SHARE_REQUEST });
+      this.activeRemoteScreenSharePeers.add(peerId);
+    }
+  }
+
+  private stopRemoteScreenShares(peerIds: string[]): void {
+    const connectedPeerIds = new Set(this.dependencies.getConnectedPeerIds());
+
+    for (const peerId of peerIds) {
+      if (this.activeRemoteScreenSharePeers.has(peerId) && connectedPeerIds.has(peerId)) {
+        this.dependencies.sendToPeer(peerId, { type: P2P_TYPE_SCREEN_SHARE_STOP });
+      }
+
+      this.activeRemoteScreenSharePeers.delete(peerId);
+      this.dependencies.clearRemoteScreenShareStream(peerId);
+    }
+  }
+}