@noatgnu/cupcake-mint-chocolate 1.2.4 → 1.2.6

package/fesm2022/noatgnu-cupcake-mint-chocolate.mjs

@@ -1,9 +1,11 @@
 import * as i0 from '@angular/core';
 import { Component, Injectable, inject } from '@angular/core';
-import { BaseApiService } from '@noatgnu/cupcake-core';
+import * as i1 from '@noatgnu/cupcake-core';
+import { BaseApiService, CUPCAKE_CORE_CONFIG } from '@noatgnu/cupcake-core';
 import { HttpClient, HttpParams } from '@angular/common/http';
 import { Subject, BehaviorSubject } from 'rxjs';
 import { filter } from 'rxjs/operators';
+import { webSocket } from 'rxjs/webSocket';
 
 class CupcakeMintChocolate {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: CupcakeMintChocolate, deps: [], target: i0.ɵɵFactoryTarget.Component });
@@ -85,6 +87,40 @@ const MessageTypeLabels = {
     [MessageType.SYSTEM]: 'System Message'
 };
 
+var WebRTCSessionType;
+(function (WebRTCSessionType) {
+    WebRTCSessionType["VIDEO_CALL"] = "video_call";
+    WebRTCSessionType["AUDIO_CALL"] = "audio_call";
+    WebRTCSessionType["SCREEN_SHARE"] = "screen_share";
+    WebRTCSessionType["DATA_CHANNEL"] = "data_channel";
+})(WebRTCSessionType || (WebRTCSessionType = {}));
+var WebRTCSessionStatus;
+(function (WebRTCSessionStatus) {
+    WebRTCSessionStatus["WAITING"] = "waiting";
+    WebRTCSessionStatus["ACTIVE"] = "active";
+    WebRTCSessionStatus["ENDED"] = "ended";
+})(WebRTCSessionStatus || (WebRTCSessionStatus = {}));
+var PeerRole;
+(function (PeerRole) {
+    PeerRole["HOST"] = "host";
+    PeerRole["VIEWER"] = "viewer";
+    PeerRole["PARTICIPANT"] = "participant";
+})(PeerRole || (PeerRole = {}));
+var PeerConnectionState;
+(function (PeerConnectionState) {
+    PeerConnectionState["CONNECTING"] = "connecting";
+    PeerConnectionState["CONNECTED"] = "connected";
+    PeerConnectionState["DISCONNECTED"] = "disconnected";
+    PeerConnectionState["FAILED"] = "failed";
+})(PeerConnectionState || (PeerConnectionState = {}));
+var SignalType;
+(function (SignalType) {
+    SignalType["OFFER"] = "offer";
+    SignalType["ANSWER"] = "answer";
+    SignalType["ICE_CANDIDATE"] = "ice_candidate";
+    SignalType["CHECK"] = "check";
+})(SignalType || (SignalType = {}));
+
 class NotificationService extends BaseApiService {
     /**
      * Get all notifications with optional filtering
@@ -645,6 +681,599 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImpor
                 }]
         }] });
 
+class WebRTCSignallingService {
+    authService;
+    zone;
+    ws;
+    wsSubscription;
+    baseUrl = '';
+    _connected = new BehaviorSubject(false);
+    _peerId = new BehaviorSubject(null);
+    _sessionId = new BehaviorSubject(null);
+    _peers = new BehaviorSubject([]);
+    _messages = new Subject();
+    _iceServers = new BehaviorSubject([]);
+    connected$ = this._connected.asObservable();
+    peerId$ = this._peerId.asObservable();
+    sessionId$ = this._sessionId.asObservable();
+    peers$ = this._peers.asObservable();
+    messages$ = this._messages.asObservable();
+    iceServers$ = this._iceServers.asObservable();
+    config = inject(CUPCAKE_CORE_CONFIG);
+    constructor(authService, zone) {
+        this.authService = authService;
+        this.zone = zone;
+        this.baseUrl = this.getBaseUrl();
+    }
+    getBaseUrl() {
+        if (this.config && this.config.websocketUrl) {
+            return this.config.websocketUrl;
+        }
+        if (this.config && this.config.apiUrl) {
+            const apiUrl = this.config.apiUrl.replace(/^https?:\/\//, '');
+            const protocol = this.config.apiUrl.startsWith('https') ? 'wss:' : 'ws:';
+            return `${protocol}//${apiUrl}`;
+        }
+        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const host = window.location.host;
+        return `${protocol}//${host}`;
+    }
+    connect(sessionId) {
+        this.disconnect();
+        const token = this.authService.getAccessToken();
+        if (!token) {
+            console.error('No authentication token available');
+            return;
+        }
+        const wsUrl = `${this.baseUrl}/ws/ccmc/webrtc/${sessionId}/?token=${token}`;
+        this.ws = webSocket({
+            url: wsUrl,
+            openObserver: {
+                next: () => {
+                    console.log('WebRTC signalling connection opened');
+                    this.zone.run(() => {
+                        this._connected.next(true);
+                    });
+                }
+            },
+            closeObserver: {
+                next: () => {
+                    console.log('WebRTC signalling connection closed');
+                    this.zone.run(() => {
+                        this._connected.next(false);
+                        this._peerId.next(null);
+                    });
+                }
+            },
+            deserializer: msg => {
+                try {
+                    return JSON.parse(msg.data);
+                }
+                catch (e) {
+                    console.error('Error parsing WebSocket message:', e);
+                    return msg.data;
+                }
+            }
+        });
+        this.wsSubscription = this.ws.subscribe({
+            next: (message) => {
+                this.zone.run(() => {
+                    this.handleMessage(message);
+                });
+            },
+            error: (error) => {
+                console.error('WebRTC signalling error:', error);
+                this.zone.run(() => {
+                    this._connected.next(false);
+                });
+                setTimeout(() => {
+                    if (this._sessionId.value) {
+                        console.log('Attempting to reconnect...');
+                        this.connect(this._sessionId.value);
+                    }
+                }, 5000);
+            },
+            complete: () => {
+                console.log('WebRTC signalling connection completed');
+                this.zone.run(() => {
+                    this._connected.next(false);
+                });
+            }
+        });
+    }
+    disconnect() {
+        if (this.wsSubscription) {
+            this.wsSubscription.unsubscribe();
+            this.wsSubscription = undefined;
+        }
+        if (this.ws) {
+            this.ws.complete();
+            this.ws = undefined;
+        }
+        this._connected.next(false);
+        this._peerId.next(null);
+        this._sessionId.next(null);
+        this._peers.next([]);
+    }
+    sendCheck(peerRole = PeerRole.PARTICIPANT) {
+        this.send({
+            type: 'check',
+            peerRole: peerRole
+        });
+    }
+    sendOffer(toPeerId, sdp) {
+        this.send({
+            type: 'offer',
+            toPeerId: toPeerId,
+            sdp: sdp
+        });
+    }
+    sendAnswer(toPeerId, sdp) {
+        this.send({
+            type: 'answer',
+            toPeerId: toPeerId,
+            sdp: sdp
+        });
+    }
+    sendIceCandidate(toPeerId, candidate) {
+        this.send({
+            type: 'ice_candidate',
+            toPeerId: toPeerId,
+            candidate: candidate
+        });
+    }
+    sendPeerState(connectionState, hasVideo, hasAudio, hasScreenShare) {
+        this.send({
+            type: 'peer_state',
+            connectionState,
+            hasVideo,
+            hasAudio,
+            hasScreenShare
+        });
+    }
+    send(message) {
+        if (!this.ws) {
+            console.error('WebSocket not connected');
+            return;
+        }
+        try {
+            this.ws.next(message);
+        }
+        catch (error) {
+            console.error('Error sending message:', error);
+        }
+    }
+    handleMessage(message) {
+        switch (message.type) {
+            case 'connection.established':
+                this.handleConnectionEstablished(message);
+                break;
+            case 'check.response':
+                this.handleCheckResponse(message);
+                break;
+            case 'peer.check':
+            case 'offer':
+            case 'answer':
+            case 'ice_candidate':
+            case 'peer.state_update':
+                this._messages.next(message);
+                break;
+            case 'error':
+                console.error('WebRTC signalling error:', message.message);
+                break;
+            default:
+                console.warn('Unknown message type:', message.type);
+        }
+    }
+    handleConnectionEstablished(message) {
+        if (message.peerId) {
+            this._peerId.next(message.peerId);
+        }
+        if (message.sessionId) {
+            this._sessionId.next(message.sessionId);
+        }
+        if (message.iceServers) {
+            this._iceServers.next(message.iceServers);
+        }
+        console.log('WebRTC signalling connection established:', message);
+    }
+    handleCheckResponse(message) {
+        if (message.peers) {
+            this._peers.next(message.peers);
+            console.log('Received peer list:', message.peers);
+        }
+    }
+    get peerId() {
+        return this._peerId.value;
+    }
+    get sessionId() {
+        return this._sessionId.value;
+    }
+    get connected() {
+        return this._connected.value;
+    }
+    get peers() {
+        return this._peers.value;
+    }
+    get iceServers() {
+        return this._iceServers.value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebRTCSignallingService, deps: [{ token: i1.AuthService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebRTCSignallingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebRTCSignallingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthService }, { type: i0.NgZone }] });
+
+class WebRTCService {
+    signalling;
+    zone;
+    peerConnections = new Map();
+    localStream;
+    signallingSubscription;
+    _localStreamReady = new BehaviorSubject(false);
+    _remoteStreams = new BehaviorSubject(new Map());
+    _connectionState = new BehaviorSubject('disconnected');
+    _activePeers = new BehaviorSubject([]);
+    localStreamReady$ = this._localStreamReady.asObservable();
+    remoteStreams$ = this._remoteStreams.asObservable();
+    connectionState$ = this._connectionState.asObservable();
+    activePeers$ = this._activePeers.asObservable();
+    defaultConfig = {
+        iceServers: [
+            { urls: 'stun:stun.l.google.com:19302' },
+            { urls: 'stun:stun1.l.google.com:19302' }
+        ],
+        iceCandidatePoolSize: 10,
+        iceTransportPolicy: 'all',
+        bundlePolicy: 'max-bundle',
+        rtcpMuxPolicy: 'require'
+    };
+    defaultMediaConstraints = {
+        video: {
+            width: { ideal: 1280 },
+            height: { ideal: 720 },
+            frameRate: { ideal: 30 }
+        },
+        audio: true
+    };
+    constructor(signalling, zone) {
+        this.signalling = signalling;
+        this.zone = zone;
+    }
+    async startSession(sessionId, role = PeerRole.PARTICIPANT, enableVideo = true, enableAudio = true) {
+        this._connectionState.next('connecting');
+        if (role === PeerRole.HOST || enableVideo || enableAudio) {
+            await this.startLocalMedia(enableVideo, enableAudio);
+        }
+        this.signalling.connect(sessionId);
+        this.signallingSubscription = this.signalling.messages$.subscribe({
+            next: (message) => {
+                this.handleSignallingMessage(message);
+            }
+        });
+        setTimeout(() => {
+            this.signalling.sendCheck(role);
+        }, 1000);
+        this.signalling.peers$.subscribe(peers => {
+            this._activePeers.next(peers);
+        });
+    }
+    async startLocalMedia(enableVideo = true, enableAudio = true) {
+        try {
+            const constraints = {
+                video: enableVideo ? this.defaultMediaConstraints.video : false,
+                audio: enableAudio ? this.defaultMediaConstraints.audio : false
+            };
+            this.localStream = await navigator.mediaDevices.getUserMedia(constraints);
+            this._localStreamReady.next(true);
+            this.updatePeerState(undefined, enableVideo, enableAudio, false);
+            console.log('Local media started:', this.localStream);
+        }
+        catch (error) {
+            console.error('Error accessing media devices:', error);
+            throw error;
+        }
+    }
+    async startScreenShare() {
+        try {
+            const screenStream = await navigator.mediaDevices.getDisplayMedia({
+                video: true,
+                audio: false
+            });
+            if (this.localStream) {
+                this.localStream.getTracks().forEach(track => track.stop());
+            }
+            this.localStream = screenStream;
+            this._localStreamReady.next(true);
+            this.replaceTracksInAllPeers();
+            this.updatePeerState(undefined, false, false, true);
+            screenStream.getVideoTracks()[0].addEventListener('ended', () => {
+                this.stopScreenShare();
+            });
+            console.log('Screen sharing started');
+        }
+        catch (error) {
+            console.error('Error starting screen share:', error);
+            throw error;
+        }
+    }
+    stopScreenShare() {
+        if (this.localStream) {
+            this.localStream.getTracks().forEach(track => track.stop());
+            this.localStream = undefined;
+            this._localStreamReady.next(false);
+        }
+        this.updatePeerState(undefined, false, false, false);
+        console.log('Screen sharing stopped');
+    }
+    endSession() {
+        this.peerConnections.forEach((conn, peerId) => {
+            this.closePeerConnection(peerId);
+        });
+        if (this.localStream) {
+            this.localStream.getTracks().forEach(track => track.stop());
+            this.localStream = undefined;
+            this._localStreamReady.next(false);
+        }
+        if (this.signallingSubscription) {
+            this.signallingSubscription.unsubscribe();
+        }
+        this.signalling.disconnect();
+        this._connectionState.next('disconnected');
+        this._remoteStreams.next(new Map());
+        this._activePeers.next([]);
+        console.log('WebRTC session ended');
+    }
+    async handleSignallingMessage(message) {
+        try {
+            switch (message.type) {
+                case 'peer.check':
+                    if (message.fromPeerId) {
+                        await this.handlePeerCheck(message.fromPeerId, message.fromUserId, message.fromUsername, message.peerRole);
+                    }
+                    break;
+                case 'offer':
+                    if (message.fromPeerId && message.sdp) {
+                        await this.handleOffer(message.fromPeerId, message.fromUserId, message.fromUsername, message.sdp);
+                    }
+                    break;
+                case 'answer':
+                    if (message.fromPeerId && message.sdp) {
+                        await this.handleAnswer(message.fromPeerId, message.sdp);
+                    }
+                    break;
+                case 'ice_candidate':
+                    if (message.fromPeerId && message.candidate) {
+                        await this.handleIceCandidate(message.fromPeerId, message.candidate);
+                    }
+                    break;
+                case 'peer.state_update':
+                    this.handlePeerStateUpdate(message);
+                    break;
+            }
+        }
+        catch (error) {
+            console.error('Error handling signalling message:', error);
+        }
+    }
+    async handlePeerCheck(peerId, userId, username, role) {
+        if (!this.peerConnections.has(peerId)) {
+            console.log(`New peer discovered: ${username} (${peerId}) as ${role}`);
+            const pc = await this.createPeerConnection(peerId, userId, username, role);
+            const shouldInitiate = this.shouldInitiateConnection(role);
+            if (shouldInitiate) {
+                const offer = await pc.createOffer();
+                await pc.setLocalDescription(offer);
+                if (pc.localDescription) {
+                    this.signalling.sendOffer(peerId, pc.localDescription);
+                    const connection = this.peerConnections.get(peerId);
+                    if (connection) {
+                        connection.offered = true;
+                    }
+                }
+            }
+        }
+    }
+    async handleOffer(peerId, userId, username, sdp) {
+        let pc;
+        if (!this.peerConnections.has(peerId)) {
+            pc = await this.createPeerConnection(peerId, userId, username, PeerRole.PARTICIPANT);
+        }
+        else {
+            pc = this.peerConnections.get(peerId).pc;
+        }
+        await pc.setRemoteDescription(new RTCSessionDescription(sdp));
+        const answer = await pc.createAnswer();
+        await pc.setLocalDescription(answer);
+        if (pc.localDescription) {
+            this.signalling.sendAnswer(peerId, pc.localDescription);
+            const connection = this.peerConnections.get(peerId);
+            if (connection) {
+                connection.answered = true;
+            }
+        }
+        const connection = this.peerConnections.get(peerId);
+        if (connection && connection.queuedCandidates.length > 0) {
+            await Promise.all(connection.queuedCandidates.map(candidate => pc.addIceCandidate(candidate)));
+            connection.queuedCandidates = [];
+        }
+    }
+    async handleAnswer(peerId, sdp) {
+        const connection = this.peerConnections.get(peerId);
+        if (!connection) {
+            console.warn(`Received answer from unknown peer: ${peerId}`);
+            return;
+        }
+        await connection.pc.setRemoteDescription(new RTCSessionDescription(sdp));
+        if (connection.queuedCandidates.length > 0) {
+            await Promise.all(connection.queuedCandidates.map(candidate => connection.pc.addIceCandidate(candidate)));
+            connection.queuedCandidates = [];
+        }
+    }
+    async handleIceCandidate(peerId, candidate) {
+        const connection = this.peerConnections.get(peerId);
+        if (!connection) {
+            console.warn(`Received ICE candidate from unknown peer: ${peerId}`);
+            return;
+        }
+        const iceCandidate = new RTCIceCandidate(candidate);
+        if (connection.pc.remoteDescription) {
+            await connection.pc.addIceCandidate(iceCandidate);
+        }
+        else {
+            connection.queuedCandidates.push(iceCandidate);
+        }
+    }
+    handlePeerStateUpdate(message) {
+        console.log('Peer state update:', message);
+    }
+    async createPeerConnection(peerId, userId, username, role) {
+        const iceServers = this.signalling.iceServers;
+        const config = iceServers.length > 0
+            ? { ...this.defaultConfig, iceServers }
+            : this.defaultConfig;
+        const pc = new RTCPeerConnection(config);
+        const dataChannel = pc.createDataChannel('data', { ordered: true });
+        this.setupDataChannelHandlers(dataChannel, peerId);
+        if (this.localStream) {
+            this.localStream.getTracks().forEach(track => {
+                pc.addTrack(track, this.localStream);
+            });
+        }
+        this.setupPeerConnectionHandlers(pc, peerId);
+        const connection = {
+            peerId,
+            userId,
+            username,
+            pc,
+            dataChannel,
+            role,
+            offered: false,
+            answered: false,
+            connected: false,
+            queuedCandidates: []
+        };
+        this.peerConnections.set(peerId, connection);
+        console.log(`Created peer connection for ${username} (${peerId})`);
+        return pc;
+    }
+    setupPeerConnectionHandlers(pc, peerId) {
+        pc.onicecandidate = (event) => {
+            if (event.candidate) {
+                this.signalling.sendIceCandidate(peerId, event.candidate.toJSON());
+            }
+        };
+        pc.ontrack = (event) => {
+            console.log(`Received track from peer ${peerId}:`, event.track.kind);
+            this.zone.run(() => {
+                const stream = event.streams[0];
+                const connection = this.peerConnections.get(peerId);
+                if (connection) {
+                    connection.stream = stream;
+                }
+                const streams = this._remoteStreams.value;
+                streams.set(peerId, stream);
+                this._remoteStreams.next(streams);
+            });
+        };
+        pc.onconnectionstatechange = () => {
+            console.log(`Connection state with peer ${peerId}: ${pc.connectionState}`);
+            this.zone.run(() => {
+                const connection = this.peerConnections.get(peerId);
+                if (!connection)
+                    return;
+                if (pc.connectionState === 'connected') {
+                    connection.connected = true;
+                    this._connectionState.next('connected');
+                }
+                else if (pc.connectionState === 'failed' || pc.connectionState === 'disconnected') {
+                    this.closePeerConnection(peerId);
+                }
+            });
+        };
+        pc.ondatachannel = (event) => {
+            const receivedChannel = event.channel;
+            this.setupDataChannelHandlers(receivedChannel, peerId);
+            const connection = this.peerConnections.get(peerId);
+            if (connection) {
+                connection.dataChannel = receivedChannel;
+            }
+        };
+    }
+    setupDataChannelHandlers(dataChannel, peerId) {
+        dataChannel.onopen = () => {
+            console.log(`Data channel opened with peer ${peerId}`);
+        };
+        dataChannel.onmessage = (event) => {
+            console.log(`Data received from peer ${peerId}:`, event.data);
+        };
+        dataChannel.onclose = () => {
+            console.log(`Data channel closed with peer ${peerId}`);
+        };
+        dataChannel.onerror = (error) => {
+            console.error(`Data channel error with peer ${peerId}:`, error);
+        };
+    }
+    closePeerConnection(peerId) {
+        const connection = this.peerConnections.get(peerId);
+        if (!connection)
+            return;
+        connection.pc.close();
+        this.peerConnections.delete(peerId);
+        const streams = this._remoteStreams.value;
+        streams.delete(peerId);
+        this._remoteStreams.next(streams);
+        console.log(`Closed peer connection with ${peerId}`);
+    }
+    shouldInitiateConnection(peerRole) {
+        const myPeers = Array.from(this.peerConnections.values());
+        const iAmHost = myPeers.some(p => p.role === PeerRole.HOST);
+        return iAmHost && peerRole !== PeerRole.HOST;
+    }
+    replaceTracksInAllPeers() {
+        if (!this.localStream)
+            return;
+        this.peerConnections.forEach((connection) => {
+            const senders = connection.pc.getSenders();
+            this.localStream.getTracks().forEach(track => {
+                const sender = senders.find(s => s.track?.kind === track.kind);
+                if (sender) {
+                    sender.replaceTrack(track).catch(error => {
+                        console.error(`Error replacing ${track.kind} track:`, error);
+                    });
+                }
+                else {
+                    connection.pc.addTrack(track, this.localStream);
+                }
+            });
+        });
+    }
+    updatePeerState(connectionState, hasVideo, hasAudio, hasScreenShare) {
+        this.signalling.sendPeerState(connectionState, hasVideo, hasAudio, hasScreenShare);
+    }
+    get localMediaStream() {
+        return this.localStream;
+    }
+    get isConnected() {
+        return this._connectionState.value === 'connected';
+    }
+    get activePeerConnections() {
+        return Array.from(this.peerConnections.values());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebRTCService, deps: [{ token: WebRTCSignallingService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebRTCService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebRTCService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: WebRTCSignallingService }, { type: i0.NgZone }] });
+
 // Communication and messaging services
 
 /*
@@ -655,5 +1284,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { CommunicationWebSocketService, CupcakeMintChocolate, DeliveryStatus, DeliveryStatusLabels, MessageService, MessageThreadService, MessageType, MessageTypeLabels, NotificationPriority, NotificationPriorityLabels, NotificationService, NotificationType, NotificationTypeLabels, ThreadParticipantService };
+export { CommunicationWebSocketService, CupcakeMintChocolate, DeliveryStatus, DeliveryStatusLabels, MessageService, MessageThreadService, MessageType, MessageTypeLabels, NotificationPriority, NotificationPriorityLabels, NotificationService, NotificationType, NotificationTypeLabels, PeerConnectionState, PeerRole, SignalType, ThreadParticipantService, WebRTCService, WebRTCSessionStatus, WebRTCSessionType, WebRTCSignallingService };
 //# sourceMappingURL=noatgnu-cupcake-mint-chocolate.mjs.map