@vibexnpm/talkx 8.13.0 → 9.1.0

package/src/webrtc/PeerConnectionManager.js

@@ -1,476 +0,0 @@
-/**
- * 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;
-    }
-
-    /** 그룹 시작 중 answer를 먼저 보낸 peer에 로컬 트랙을 보낼 협상을 재개한다. */
-    async resumeAutoNegotiation(peerId) {
-        const peer = this.peers.get(peerId);
-        if (!peer || peer.connection.signalingState !== 'stable') return false;
-        peer.skipAutoNegotiation = false;
-        await peer.connection.onnegotiationneeded();
-        return true;
-    }
-
-    /**
-     * 연결 이벤트 핸들러 설정
-     * @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 || peerState.makingOffer || connection.signalingState !== 'stable') {
-                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;