观影室起步

2025-12-06 21:39:37 +08:00
parent 4f126e89f0
commit 003050d134
18 changed files with 2895 additions and 7 deletions
@@ -0,0 +1,350 @@
+// Socket.IO 观影室服务器逻辑（共享代码）
+import { Server as SocketIOServer, Socket } from 'socket.io';
+import type {
+  Room,
+  Member,
+  PlayState,
+  LiveState,
+  ChatMessage,
+  ServerToClientEvents,
+  ClientToServerEvents,
+  RoomMemberInfo,
+} from '@/types/watch-room';
+
+type TypedSocket = Socket<ClientToServerEvents, ServerToClientEvents>;
+
+export class WatchRoomServer {
+  private rooms: Map<string, Room> = new Map();
+  private members: Map<string, Map<string, Member>> = new Map(); // roomId -> userId -> Member
+  private socketToRoom: Map<string, RoomMemberInfo> = new Map(); // socketId -> RoomMemberInfo
+  private cleanupInterval: NodeJS.Timeout | null = null;
+
+  constructor(private io: SocketIOServer<ClientToServerEvents, ServerToClientEvents>) {
+    this.setupEventHandlers();
+    this.startCleanupTimer();
+  }
+
+  private setupEventHandlers() {
+    this.io.on('connection', (socket: TypedSocket) => {
+      console.log(`[WatchRoom] Client connected: ${socket.id}`);
+
+      // 创建房间
+      socket.on('room:create', (data, callback) => {
+        try {
+          const roomId = this.generateRoomId();
+          const userId = socket.id;
+
+          const room: Room = {
+            id: roomId,
+            name: data.name,
+            description: data.description,
+            password: data.password,
+            isPublic: data.isPublic,
+            ownerId: userId,
+            ownerName: data.userName,
+            memberCount: 1,
+            currentState: null,
+            createdAt: Date.now(),
+            lastOwnerHeartbeat: Date.now(),
+          };
+
+          const member: Member = {
+            id: userId,
+            name: data.userName,
+            isOwner: true,
+            lastHeartbeat: Date.now(),
+          };
+
+          this.rooms.set(roomId, room);
+          this.members.set(roomId, new Map([[userId, member]]));
+          this.socketToRoom.set(socket.id, {
+            roomId,
+            userId,
+            userName: data.userName,
+            isOwner: true,
+          });
+
+          socket.join(roomId);
+
+          console.log(`[WatchRoom] Room created: ${roomId} by ${data.userName}`);
+          callback({ success: true, room });
+        } catch (error) {
+          console.error('[WatchRoom] Error creating room:', error);
+          callback({ success: false, error: '创建房间失败' });
+        }
+      });
+
+      // 加入房间
+      socket.on('room:join', (data, callback) => {
+        try {
+          const room = this.rooms.get(data.roomId);
+          if (!room) {
+            return callback({ success: false, error: '房间不存在' });
+          }
+
+          // 检查密码
+          if (room.password && room.password !== data.password) {
+            return callback({ success: false, error: '密码错误' });
+          }
+
+          const userId = socket.id;
+          const member: Member = {
+            id: userId,
+            name: data.userName,
+            isOwner: false,
+            lastHeartbeat: Date.now(),
+          };
+
+          const roomMembers = this.members.get(data.roomId);
+          if (roomMembers) {
+            roomMembers.set(userId, member);
+            room.memberCount = roomMembers.size;
+            this.rooms.set(data.roomId, room);
+          }
+
+          this.socketToRoom.set(socket.id, {
+            roomId: data.roomId,
+            userId,
+            userName: data.userName,
+            isOwner: false,
+          });
+
+          socket.join(data.roomId);
+
+          // 通知房间内其他成员
+          socket.to(data.roomId).emit('room:member-joined', member);
+
+          console.log(`[WatchRoom] User ${data.userName} joined room ${data.roomId}`);
+
+          const members = Array.from(roomMembers?.values() || []);
+          callback({ success: true, room, members });
+        } catch (error) {
+          console.error('[WatchRoom] Error joining room:', error);
+          callback({ success: false, error: '加入房间失败' });
+        }
+      });
+
+      // 离开房间
+      socket.on('room:leave', () => {
+        this.handleLeaveRoom(socket);
+      });
+
+      // 获取房间列表
+      socket.on('room:list', (callback) => {
+        const publicRooms = Array.from(this.rooms.values()).filter((room) => room.isPublic);
+        callback(publicRooms);
+      });
+
+      // 播放状态更新
+      socket.on('play:update', (state) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo || !roomInfo.isOwner) return;
+
+        const room = this.rooms.get(roomInfo.roomId);
+        if (room) {
+          room.currentState = state;
+          this.rooms.set(roomInfo.roomId, room);
+          socket.to(roomInfo.roomId).emit('play:update', state);
+        }
+      });
+
+      // 播放进度跳转
+      socket.on('play:seek', (currentTime) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        socket.to(roomInfo.roomId).emit('play:seek', currentTime);
+      });
+
+      // 播放
+      socket.on('play:play', () => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        socket.to(roomInfo.roomId).emit('play:play');
+      });
+
+      // 暂停
+      socket.on('play:pause', () => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        socket.to(roomInfo.roomId).emit('play:pause');
+      });
+
+      // 切换视频/集数
+      socket.on('play:change', (state) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo || !roomInfo.isOwner) return;
+
+        const room = this.rooms.get(roomInfo.roomId);
+        if (room) {
+          room.currentState = state;
+          this.rooms.set(roomInfo.roomId, room);
+          socket.to(roomInfo.roomId).emit('play:change', state);
+        }
+      });
+
+      // 切换直播频道
+      socket.on('live:change', (state) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo || !roomInfo.isOwner) return;
+
+        const room = this.rooms.get(roomInfo.roomId);
+        if (room) {
+          room.currentState = state;
+          this.rooms.set(roomInfo.roomId, room);
+          socket.to(roomInfo.roomId).emit('live:change', state);
+        }
+      });
+
+      // 聊天消息
+      socket.on('chat:message', (data) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        const message: ChatMessage = {
+          id: this.generateMessageId(),
+          userId: roomInfo.userId,
+          userName: roomInfo.userName,
+          content: data.content,
+          type: data.type,
+          timestamp: Date.now(),
+        };
+
+        this.io.to(roomInfo.roomId).emit('chat:message', message);
+      });
+
+      // WebRTC 信令
+      socket.on('voice:offer', (data) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        this.io.to(data.targetUserId).emit('voice:offer', {
+          userId: socket.id,
+          offer: data.offer,
+        });
+      });
+
+      socket.on('voice:answer', (data) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        this.io.to(data.targetUserId).emit('voice:answer', {
+          userId: socket.id,
+          answer: data.answer,
+        });
+      });
+
+      socket.on('voice:ice', (data) => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        this.io.to(data.targetUserId).emit('voice:ice', {
+          userId: socket.id,
+          candidate: data.candidate,
+        });
+      });
+
+      // 心跳
+      socket.on('heartbeat', () => {
+        const roomInfo = this.socketToRoom.get(socket.id);
+        if (!roomInfo) return;
+
+        const roomMembers = this.members.get(roomInfo.roomId);
+        const member = roomMembers?.get(roomInfo.userId);
+        if (member) {
+          member.lastHeartbeat = Date.now();
+          roomMembers?.set(roomInfo.userId, member);
+        }
+
+        // 如果是房主，更新房间心跳
+        if (roomInfo.isOwner) {
+          const room = this.rooms.get(roomInfo.roomId);
+          if (room) {
+            room.lastOwnerHeartbeat = Date.now();
+            this.rooms.set(roomInfo.roomId, room);
+          }
+        }
+      });
+
+      // 断开连接
+      socket.on('disconnect', () => {
+        console.log(`[WatchRoom] Client disconnected: ${socket.id}`);
+        this.handleLeaveRoom(socket);
+      });
+    });
+  }
+
+  private handleLeaveRoom(socket: TypedSocket) {
+    const roomInfo = this.socketToRoom.get(socket.id);
+    if (!roomInfo) return;
+
+    const { roomId, userId, isOwner } = roomInfo;
+
+    // 从房间成员中移除
+    const roomMembers = this.members.get(roomId);
+    if (roomMembers) {
+      roomMembers.delete(userId);
+
+      const room = this.rooms.get(roomId);
+      if (room) {
+        room.memberCount = roomMembers.size;
+        this.rooms.set(roomId, room);
+      }
+
+      // 通知其他成员
+      socket.to(roomId).emit('room:member-left', userId);
+
+      // 如果是房主离开，记录时间但不立即删除房间
+      if (isOwner) {
+        console.log(`[WatchRoom] Owner left room ${roomId}, will auto-delete after 5 minutes`);
+      }
+
+      // 如果房间没人了，立即删除
+      if (roomMembers.size === 0) {
+        this.deleteRoom(roomId);
+      }
+    }
+
+    socket.leave(roomId);
+    this.socketToRoom.delete(socket.id);
+  }
+
+  private deleteRoom(roomId: string) {
+    console.log(`[WatchRoom] Deleting room ${roomId}`);
+    this.io.to(roomId).emit('room:deleted');
+    this.rooms.delete(roomId);
+    this.members.delete(roomId);
+  }
+
+  // 定时清理房间（房主断开5分钟后删除）
+  private startCleanupTimer() {
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      const timeout = 5 * 60 * 1000; // 5分钟
+
+      for (const [roomId, room] of this.rooms.entries()) {
+        // 检查房主是否超时
+        if (now - room.lastOwnerHeartbeat > timeout) {
+          console.log(`[WatchRoom] Room ${roomId} owner timeout, deleting...`);
+          this.deleteRoom(roomId);
+        }
+      }
+    }, 30000); // 每30秒检查一次
+  }
+
+  private generateRoomId(): string {
+    return Math.random().toString(36).substring(2, 8).toUpperCase();
+  }
+
+  private generateMessageId(): string {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+
+  public destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+  }
+}
@@ -0,0 +1,130 @@
+// Socket.IO 客户端管理
+import { io, Socket } from 'socket.io-client';
+import type {
+  ServerToClientEvents,
+  ClientToServerEvents,
+  WatchRoomConfig,
+} from '@/types/watch-room';
+
+export type WatchRoomSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+
+class WatchRoomSocketManager {
+  private socket: WatchRoomSocket | null = null;
+  private config: WatchRoomConfig | null = null;
+  private heartbeatInterval: NodeJS.Timeout | null = null;
+
+  async connect(config: WatchRoomConfig): Promise<WatchRoomSocket> {
+    if (this.socket?.connected) {
+      return this.socket;
+    }
+
+    this.config = config;
+
+    const socketOptions: any = {
+      transports: ['websocket', 'polling'],
+      reconnection: true,
+      reconnectionDelay: 1000,
+      reconnectionDelayMax: 5000,
+      reconnectionAttempts: 5,
+    };
+
+    if (config.serverType === 'internal') {
+      // 内部服务器 - 连接到同一个域名的Socket.IO服务器
+      this.socket = io({
+        ...socketOptions,
+        path: '/socket.io', // 使用服务器配置的path
+      });
+    } else {
+      // 外部服务器
+      if (!config.externalServerUrl) {
+        throw new Error('External server URL is required');
+      }
+
+      this.socket = io(config.externalServerUrl, {
+        ...socketOptions,
+        auth: {
+          token: config.externalServerAuth,
+        },
+        extraHeaders: config.externalServerAuth
+          ? {
+              Authorization: `Bearer ${config.externalServerAuth}`,
+            }
+          : undefined,
+      });
+    }
+
+    // 设置事件监听
+    this.setupEventListeners();
+
+    // 开始心跳
+    this.startHeartbeat();
+
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error('Socket not initialized'));
+        return;
+      }
+
+      this.socket.on('connect', () => {
+        console.log('[WatchRoom] Connected to server');
+        resolve(this.socket!);
+      });
+
+      this.socket.on('connect_error', (error) => {
+        console.error('[WatchRoom] Connection error:', error);
+        reject(error);
+      });
+    });
+  }
+
+  disconnect() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+
+  getSocket(): WatchRoomSocket | null {
+    return this.socket;
+  }
+
+  isConnected(): boolean {
+    return this.socket?.connected ?? false;
+  }
+
+  private setupEventListeners() {
+    if (!this.socket) return;
+
+    this.socket.on('connect', () => {
+      console.log('[WatchRoom] Socket connected');
+    });
+
+    this.socket.on('disconnect', (reason) => {
+      console.log('[WatchRoom] Socket disconnected:', reason);
+    });
+
+    this.socket.on('error', (error) => {
+      console.error('[WatchRoom] Socket error:', error);
+    });
+  }
+
+  private startHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+    }
+
+    this.heartbeatInterval = setInterval(() => {
+      if (this.socket?.connected) {
+        this.socket.emit('heartbeat');
+      }
+    }, 5000); // 每5秒发送一次心跳
+  }
+}
+
+// 单例实例
+export const watchRoomSocketManager = new WatchRoomSocketManager();