@vibexnpm/talkx 2.3.1

package/src/webrtc/PeerConnectionManager.js

@@ -0,0 +1,467 @@
+/**
+ * PeerConnectionManager
+ * WebRTC Peer 연결 관리 (Perfect Negotiation 패턴)
+ */
+
+import EventEmitter from '../utils/EventEmitter.js';
+import Logger from '../utils/Logger.js';
+import { ErrorTypes, DefaultConfig, LogLevel } from '../constants.js';
+
+class PeerConnectionManager extends EventEmitter {
+    /**
+     * @param {Object} options
+     * @param {Object[]} [options.iceServers] - ICE 서버 설정
+     * @param {number} [options.logLevel] - 로그 레벨
+     */
+    constructor(options = {}) {
+        super();
+
+        this.iceServers = options.iceServers || DefaultConfig.iceServers;
+        this.logger = new Logger(options.logLevel || LogLevel.WARN, 'PeerConnectionManager');
+
+        // 피어 연결 맵: peerId -> { connection, polite, makingOffer, ignoreOffer }
+        this.peers = new Map();
+
+        // 로컬 스트림
+        this.localStream = null;
+    }
+
+    /**
+     * 로컬 스트림 설정
+     * @param {MediaStream} stream
+     */
+    setLocalStream(stream) {
+        this.localStream = stream;
+
+        // 기존 연결에 트랙 추가
+        this.peers.forEach((peer) => {
+            this._addTracksToConnection(peer.connection);
+        });
+    }
+
+    /**
+     * ICE 서버 설정
+     * @param {Object[]} servers
+     */
+    setIceServers(servers) {
+        this.iceServers = servers;
+    }
+
+    /**
+     * 피어 연결 생성
+     * @param {string} peerId - 피어 ID
+     * @param {boolean} polite - Polite 피어 여부 (Perfect Negotiation)
+     * @param {Object} [options] - 추가 옵션
+     * @param {boolean} [options.skipAutoNegotiation=false] - 자동 negotiation 건너뛰기
+     * @returns {RTCPeerConnection}
+     */
+    createPeerConnection(peerId, polite = false, options = {}) {
+        if (this.peers.has(peerId)) {
+            this.logger.warn(`Peer connection already exists: ${peerId}`);
+            return this.peers.get(peerId).connection;
+        }
+
+        const config = {
+            iceServers: this.iceServers,
+            iceCandidatePoolSize: 10
+        };
+
+        const connection = new RTCPeerConnection(config);
+
+        const peerState = {
+            connection,
+            polite,
+            makingOffer: false,
+            ignoreOffer: false,
+            isSettingRemoteAnswerPending: false,
+            skipAutoNegotiation: options.skipAutoNegotiation || false
+        };
+
+        this.peers.set(peerId, peerState);
+
+        // 이벤트 핸들러 설정
+        this._setupConnectionHandlers(peerId, connection, peerState);
+
+        // 로컬 트랙 추가
+        if (this.localStream) {
+            this._addTracksToConnection(connection);
+        }
+
+        this.logger.info(`Peer connection created: ${peerId} (polite: ${polite}, skipAutoNegotiation: ${peerState.skipAutoNegotiation})`);
+        return connection;
+    }
+
+    /**
+     * 연결 이벤트 핸들러 설정
+     * @private
+     * @param {string} peerId - 피어 ID
+     * @param {RTCPeerConnection} connection - 피어 연결
+     * @param {Object} peerState - 피어 상태 객체
+     */
+    _setupConnectionHandlers(peerId, connection, peerState) {
+        // ICE Candidate 이벤트
+        connection.onicecandidate = (event) => {
+            if (event.candidate) {
+                this.emit('iceCandidate', {
+                    peerId,
+                    candidate: event.candidate
+                });
+            }
+        };
+
+        // ICE 연결 상태 변경
+        connection.oniceconnectionstatechange = () => {
+            this.logger.debug(`ICE connection state (${peerId}): ${connection.iceConnectionState}`);
+
+            this.emit('iceConnectionStateChange', {
+                peerId,
+                state: connection.iceConnectionState
+            });
+
+            if (connection.iceConnectionState === 'failed') {
+                this.emit('error', {
+                    type: ErrorTypes.ICE_CONNECTION_FAILED,
+                    peerId,
+                    message: 'ICE connection failed'
+                });
+            }
+        };
+
+        // 연결 상태 변경
+        connection.onconnectionstatechange = () => {
+            this.logger.debug(`Connection state (${peerId}): ${connection.connectionState}`);
+
+            this.emit('connectionStateChange', {
+                peerId,
+                state: connection.connectionState
+            });
+
+            if (connection.connectionState === 'connected') {
+                this.emit('peerConnected', { peerId });
+            } else if (connection.connectionState === 'disconnected' || connection.connectionState === 'failed') {
+                this.emit('peerDisconnected', { peerId });
+            }
+        };
+
+        // 협상 필요 (Perfect Negotiation)
+        connection.onnegotiationneeded = async () => {
+            // 1:1 통화에서 수동으로 offer를 생성할 때는 자동 negotiation 건너뛰기
+            if (peerState.skipAutoNegotiation) {
+                this.logger.debug(`Skipping auto negotiation for ${peerId} (manual offer will be sent)`);
+                return;
+            }
+
+            try {
+                peerState.makingOffer = true;
+                await connection.setLocalDescription();
+
+                this.emit('negotiationNeeded', {
+                    peerId,
+                    description: connection.localDescription
+                });
+
+            } catch (error) {
+                this.logger.error(`Negotiation error (${peerId}):`, error);
+            } finally {
+                peerState.makingOffer = false;
+            }
+        };
+
+        // 원격 트랙 수신
+        connection.ontrack = (event) => {
+            this.logger.info(`Remote track received from ${peerId}:`, event.track.kind);
+
+            this.emit('remoteTrack', {
+                peerId,
+                track: event.track,
+                streams: event.streams
+            });
+        };
+
+        // 데이터 채널 수신
+        connection.ondatachannel = (event) => {
+            this.logger.info(`Data channel received from ${peerId}`);
+            this.emit('dataChannel', {
+                peerId,
+                channel: event.channel
+            });
+        };
+    }
+
+    /**
+     * 연결에 트랙 추가
+     * @private
+     * @param {RTCPeerConnection} connection - 피어 연결
+     */
+    _addTracksToConnection(connection) {
+        if (!this.localStream) return;
+
+        const existingSenders = connection.getSenders();
+
+        this.localStream.getTracks().forEach(track => {
+            // 이미 추가된 트랙인지 확인
+            const existingSender = existingSenders.find(sender =>
+                sender.track && sender.track.kind === track.kind
+            );
+
+            if (!existingSender) {
+                connection.addTrack(track, this.localStream);
+            }
+        });
+    }
+
+    /**
+     * Offer 생성 및 전송
+     * @param {string} peerId
+     * @returns {Promise<RTCSessionDescription>}
+     */
+    async createOffer(peerId) {
+        const peer = this.peers.get(peerId);
+        if (!peer) {
+            throw new Error(`Peer not found: ${peerId}`);
+        }
+
+        try {
+            const offer = await peer.connection.createOffer();
+            await peer.connection.setLocalDescription(offer);
+
+            this.logger.debug(`Offer created for ${peerId}`);
+            return peer.connection.localDescription;
+
+        } catch (error) {
+            this.logger.error(`Failed to create offer for ${peerId}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Answer 생성
+     * @param {string} peerId
+     * @returns {Promise<RTCSessionDescription>}
+     */
+    async createAnswer(peerId) {
+        const peer = this.peers.get(peerId);
+        if (!peer) {
+            throw new Error(`Peer not found: ${peerId}`);
+        }
+
+        try {
+            const answer = await peer.connection.createAnswer();
+            await peer.connection.setLocalDescription(answer);
+
+            this.logger.debug(`Answer created for ${peerId}`);
+            return peer.connection.localDescription;
+
+        } catch (error) {
+            this.logger.error(`Failed to create answer for ${peerId}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * 원격 Description 설정 (Perfect Negotiation)
+     * @param {string} peerId
+     * @param {RTCSessionDescription} description
+     */
+    async handleRemoteDescription(peerId, description) {
+        const peer = this.peers.get(peerId);
+        if (!peer) {
+            throw new Error(`Peer not found: ${peerId}`);
+        }
+
+        const { connection, polite, makingOffer } = peer;
+
+        // Perfect Negotiation: offer 충돌 감지
+        const offerCollision = description.type === 'offer' &&
+            (makingOffer || connection.signalingState !== 'stable');
+
+        // Impolite는 충돌 시 상대 offer 무시
+        peer.ignoreOffer = !polite && offerCollision;
+
+        if (peer.ignoreOffer) {
+            this.logger.debug(`Ignoring offer collision from ${peerId} (I am impolite)`);
+            return;
+        }
+
+        try {
+            // Perfect Negotiation: Polite가 충돌 시 자신의 offer를 roll back
+            if (offerCollision && polite) {
+                this.logger.debug(`Offer collision detected, rolling back local offer for ${peerId} (I am polite)`);
+                await connection.setLocalDescription({ type: 'rollback' });
+            }
+
+            peer.isSettingRemoteAnswerPending = description.type === 'answer';
+            await connection.setRemoteDescription(description);
+            peer.isSettingRemoteAnswerPending = false;
+
+            this.logger.debug(`Remote ${description.type} set for ${peerId}`);
+
+            // Offer를 받았으면 Answer 생성
+            if (description.type === 'offer') {
+                const answer = await this.createAnswer(peerId);
+                this.emit('answerCreated', { peerId, answer });
+            }
+
+        } catch (error) {
+            this.logger.error(`Failed to set remote description for ${peerId}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * ICE Candidate 추가
+     * @param {string} peerId
+     * @param {RTCIceCandidate} candidate
+     * @returns {Promise<boolean>} 추가 성공 여부 (false면 나중에 다시 시도 필요)
+     */
+    async addIceCandidate(peerId, candidate) {
+        const peer = this.peers.get(peerId);
+        if (!peer) {
+            this.logger.warn(`Peer not found for ICE candidate: ${peerId}`);
+            return false;
+        }
+
+        // remoteDescription이 설정되지 않았으면 추가 불가
+        if (!peer.connection.remoteDescription) {
+            this.logger.debug(`Remote description not set yet for ${peerId}, ICE candidate queued`);
+            return false;
+        }
+
+        try {
+            await peer.connection.addIceCandidate(candidate);
+            this.logger.debug(`ICE candidate added for ${peerId}`);
+            return true;
+        } catch (error) {
+            if (!peer.ignoreOffer) {
+                this.logger.error(`Failed to add ICE candidate for ${peerId}:`, error);
+            }
+            return false;
+        }
+    }
+
+    /**
+     * 특정 피어 연결 가져오기
+     * @param {string} peerId
+     * @returns {RTCPeerConnection|null}
+     */
+    getPeerConnection(peerId) {
+        const peer = this.peers.get(peerId);
+        return peer ? peer.connection : null;
+    }
+
+    /**
+     * 모든 피어 ID 목록
+     * @returns {string[]}
+     */
+    getPeerIds() {
+        return Array.from(this.peers.keys());
+    }
+
+    /**
+     * 피어 연결 종료
+     * @param {string} peerId
+     */
+    closePeerConnection(peerId) {
+        const peer = this.peers.get(peerId);
+        if (!peer) {
+            return;
+        }
+
+        peer.connection.close();
+        this.peers.delete(peerId);
+
+        this.emit('peerClosed', { peerId });
+        this.logger.info(`Peer connection closed: ${peerId}`);
+    }
+
+    /**
+     * 모든 피어 연결 종료
+     */
+    closeAllPeerConnections() {
+        this.peers.forEach((peer, peerId) => {
+            peer.connection.close();
+            this.logger.debug(`Peer connection closed: ${peerId}`);
+        });
+        this.peers.clear();
+        this.emit('allPeersClosed', {});
+    }
+
+    /**
+     * 트랙 교체
+     * @param {MediaStreamTrack} oldTrack - 교체할 기존 트랙
+     * @param {MediaStreamTrack} newTrack - 새 트랙
+     * @returns {Promise<void>}
+     */
+    async replaceTrack(oldTrack, newTrack) {
+        const promises = [];
+
+        this.peers.forEach((peer, peerId) => {
+            const sender = peer.connection.getSenders().find(s =>
+                s.track && s.track.kind === oldTrack.kind
+            );
+
+            if (sender) {
+                promises.push(
+                    sender.replaceTrack(newTrack)
+                        .then(() => this.logger.debug(`Track replaced for ${peerId}`))
+                        .catch(error => this.logger.error(`Failed to replace track for ${peerId}:`, error))
+                );
+            }
+        });
+
+        await Promise.all(promises);
+    }
+
+    /**
+     * 연결 통계 가져오기
+     * @param {string} peerId
+     * @returns {Promise<RTCStatsReport|null>}
+     */
+    async getStats(peerId) {
+        const peer = this.peers.get(peerId);
+        if (!peer) {
+            return null;
+        }
+
+        return peer.connection.getStats();
+    }
+
+    /**
+     * 모든 연결 상태 요약
+     * @returns {Object}
+     */
+    getConnectionSummary() {
+        const summary = {};
+
+        this.peers.forEach((peer, peerId) => {
+            summary[peerId] = {
+                connectionState: peer.connection.connectionState,
+                iceConnectionState: peer.connection.iceConnectionState,
+                signalingState: peer.connection.signalingState,
+                polite: peer.polite
+            };
+        });
+
+        return summary;
+    }
+
+    /**
+     * 로그 레벨 설정
+     * @param {number} level
+     */
+    setLogLevel(level) {
+        this.logger.setLevel(level);
+    }
+
+    /**
+     * 리소스 정리
+     */
+    destroy() {
+        this.closeAllPeerConnections();
+        this.localStream = null;
+        this.removeAllListeners();
+        this.logger.info('PeerConnectionManager destroyed');
+    }
+}
+
+export default PeerConnectionManager;