update

src/controller/basicController.js

@@ -2,9 +2,11 @@ import { pubClient } from "../connection/redis.js";
 import { EVENT } from "../enum/event.js";
 import { roomController } from "./roomController.js";
 import { syncActionController } from "./syncActionController.js";
+import { SyncBaseViewActionController } from "./syncBaseViewController.js";
 
 export async function basicController(socket) {
   //   webSyncAction(socket);
   await roomController(socket);
   await syncActionController(socket);
+  // await SyncBaseViewActionController(socket);
 }

src/controller/roomController.js

@@ -2,8 +2,9 @@ import { pubClient } from "../connection/redis.js";
 import { ROLES, CODEMEG, EVENT, FROMTYPE } from "../enum/index.js";
 import { io } from "../core/io.js";
 import { logger } from "../core/logger.js";
-import { updateUser, removeRoomAllUsers } from "../service/userService.js";
+import { updateUser, removeRoomAllUsers, getAllRoomUsers } from "../service/userService.js";
 import { watchRoomService } from "../service/watchRoomService.js";
+import { setRoomConfig, getRoomConfig } from "../service/roomConfigService.js";
 import { getSig } from "../core/getSig.js";
 
 /**
@@ -74,10 +75,11 @@ const joinRoomAction = async (roomId, userId, user, socket) => {
   if (!isJoinRoom) {
     logger.info("加入房间 :", { userId, roomId, user });
     socket.join(roomId);
+    const AllRoomUsers = await getAllRoomUsers(roomId);
     socket.broadcast.emit(EVENT.roomIn, {
       user,
-      // roomsPerson: sortRoomUser(roomsPerson),
-      // roomsConfig: this._roomsConfig[roomId],
+      roomsPerson: AllRoomUsers,
+      roomsConfig: {},
     });
   } else {
     logger.info(`已加入房间 :`, { userId });
@@ -117,7 +119,7 @@ const closeRoomAction = async (roomId, userId, user, socket) => {
 };
 export async function roomController(socket) {
   let user = socket.handshake.query;
-  const { roomId, userId, sceneNum, isClient, role, userLimitNum, sceneNumber, roomType, from } = user;
+  const { roomId, userId, sceneNum, isClient, role, userLimitNum, sceneNumber, roomType, from, enableTalk } = user;
   if (user) {
     // const webRoomId = `${roomId}_${sceneNum}_web`;
     // const clientRoom = `${userId}${roomId}`;
@@ -139,8 +141,11 @@ export async function roomController(socket) {
         if ([FROMTYPE.MiniAPP].includes(Number(from))) {
           logger.debug("房主自动创建房间 :", { roomId: roomUniqueId, userId: userUniqueId, user });
           buildRoom(roomUniqueId, userUniqueId, user);
+          await setRoomConfig(roomUniqueId, {
+            userLimitNum,
+            enableTalk: enableTalk,
+          });
         }
-
         socket.join(roomUniqueId);
       }
     } else {
@@ -151,22 +156,64 @@ export async function roomController(socket) {
 
     socket.on(EVENT.startCall, startCallAction.bind(null, roomUniqueId, userUniqueId, user, socket));
     socket.on(EVENT.stopCall, stopCallAction.bind(null, roomUniqueId, userUniqueId, user, socket));
+
     socket.on(EVENT.action, (data) => {
-      //console.log(data, 'clientSyncAction')
+      console.log("room -action");
       socket.broadcast.to(roomUniqueId).emit(EVENT.action, data);
     });
-    socket.onAny((event) => {
-      console.log(`got ${event}`);
+
+    // 通知 baseView 减少大量通知
+    socket.on(EVENT.webSyncAction, (data) => {
+      if ([FROMTYPE.base].includes(Number(from))) {
+        socket.broadcast.to(roomUniqueId).emit(EVENT.webSyncAction, data);
+      }
+    });
+
+    socket.onAny((event, data) => {
+      // console.log(`onAny：get ${event}`);
+      console.log(`onAny：get ${event}, data:${JSON.stringify(data)}`);
     });
+
+    // test
+
+    socket.on(EVENT.changeOnlineStatus, async (data) => {
+      user.onlineStatus = data.status;
+      const AllRoomUsers = await getAllRoomUsers(roomUniqueId);
+      let actionName = user.onlineStatus ? "inRoom" : "leaveRoom";
+      socket.broadcast.to(roomUniqueId).emit(EVENT.roomPersonChange, {
+        roomsPerson: AllRoomUsers,
+        actionName,
+        user,
+      });
+    });
+
     socket.on("disconnect", async (reason) => {
       // leaveRoom({ clientRoom, userUniqueId, roomUniqueId, socket });
       // watchRoomWithMaster(roomUniqueId, socket);
       console.log("reason", reason);
-      if (reason === "transport close") {
+      if (reason === "transport close" || reason === "client namespace disconnect") {
         // 主动离开
+
+        shotGunLeaveAction(
+          {
+            syncId,
+            roomId: roomUniqueId,
+            userId: userUniqueId,
+          },
+          socket,
+          user,
+        );
       } else {
         // 被动离开
-        disconnectAction(roomUniqueId, userUniqueId, socket, user);
+        disconnectAction(
+          {
+            syncId,
+            roomId: roomUniqueId,
+            userId: userUniqueId,
+          },
+          socket,
+          user,
+        );
       }
     });
     socket.on("reconnect", () => {
@@ -174,7 +221,18 @@ export async function roomController(socket) {
     });
   }
 }
-const disconnectAction = async (roomId, userId, socket, user) => {
+const shotGunLeaveAction = async (ids, socket, user) => {
+  console.log("主动离开");
+  const { syncId, roomId, userId } = ids;
+  // await pubClient.del(syncId);
+  // if (isHoster(user.role)) {
+  //   await pubClient.del(roomId);
+  // }
+  // await pubClient.del(userId);
+};
+
+const disconnectAction = async (ids, socket, user) => {
+  const { roomId, userId } = ids;
   const userObj = { ...user, isConnected: false };
   updateUser(userId, userObj);
   watchRoomService(roomId, userId, socket);
@@ -182,8 +240,9 @@ const disconnectAction = async (roomId, userId, socket, user) => {
 
 const startCallAction = async (roomId, userId, user, socket) => {
   console.log("startCallAction");
+  // try {
   if (!isHoster(user.role)) {
-    joinRoomAction(roomId, userId, user, socket);
+    await joinRoomAction(roomId, userId, user, socket);
   } else {
     const hasRoom = await pubClient.hVals(roomId);
     if (hasRoom.length === 0) {
@@ -192,15 +251,23 @@ const startCallAction = async (roomId, userId, user, socket) => {
     }
   }
   user.isInRoom = true;
+  const AllRoomUsers = await getAllRoomUsers(roomId);
+
+  logger.info("roomId", roomId);
+  logger.info("AllRoomUsers", AllRoomUsers.length, AllRoomUsers);
   socket.broadcast.to(roomId).emit(EVENT.someOneInRoom, {
     user,
-    roomsPerson: [user],
+    roomsPerson: AllRoomUsers,
   });
+
   socket.emit(EVENT.roomIn, {
     user,
-    roomsPerson: [user],
+    roomsPerson: AllRoomUsers,
     roomsConfig: {},
   });
+  // } catch (error) {
+  //   logger.error("startCallAction:", error);
+  // }
 };
 
 const stopCallAction = (roomId, userId, user, socket) => {

src/controller/syncActionController.js

@@ -1,6 +1,7 @@
 import { logger } from "../core/logger.js";
 import { pubClient } from "../connection/redis.js";
 import { ROLES, CODEMEG, EVENT } from "../enum/index.js";
+import { getAllRoomUsers, updateRoomUser } from "../service/userService.js";
 
 const joinSyncClient = async (syncId, userId, from, socket) => {
   logger.debug("syncId", { syncId, userId, from });
@@ -14,32 +15,40 @@ const joinSyncClient = async (syncId, userId, from, socket) => {
 
 export async function syncActionController(socket) {
   let user = socket.handshake.query;
-  const { roomId, userId, sceneNum, isClient, role, userLimitNum, roomType, from } = user;
-
+  const { roomId, userId, sceneNum, sceneNumber, isClient, role, userLimitNum, roomType, from } = user;
+  const oneSceneNum = sceneNumber || sceneNum;
   const syncId = `sync-${userId}-${roomId}`;
+  const roomUniqueId = `room-${roomId}_${oneSceneNum}_web`;
   if (user) {
     if ("roomId" in user && "userId" in user) {
       joinSyncClient(syncId, userId, from, socket);
     }
     socket.on(EVENT.clientSyncAction, (data) => {
-      //console.log(data, 'clientSyncAction')
       socket.broadcast.to(syncId).emit(EVENT.clientSyncAction, data);
+      // socket.broadcast.to(roomUniqueId).emit(EVENT.clientSyncAction, data);
     });
-    socket.on(EVENT.action, (data) => {
-      //console.log(data, 'clientSyncAction')
-      socket.broadcast.to(syncId).emit(EVENT.action, data);
-    });
-    socket.on(EVENT.webSyncAction, (data) => {
-      // console.log("syncActionController-webSyncAction", data);
-      socket.broadcast.to(syncId).emit(EVENT.webSyncAction, data);
-    });
 
-    socket.on(EVENT.changeVoiceStatus, (data) => {
+    // 三体一端反传给房间
+    // socket.on(EVENT.action, (data) => {
+    //   //console.log(data, 'clientSyncAction')
+    //   console.log("syncId-action");
+    //   socket.broadcast.to(roomUniqueId).emit(EVENT.action, data);
+    // });
+
+    socket.on(EVENT.changeVoiceStatus, async (data) => {
       socket.broadcast.to(syncId).emit(EVENT.changeVoiceStatus, data);
-      logger.info("changeVoiceStatus", { data, syncId });
-      //   socket.broadcast.to(roomId).emit(EVENT.changeVoiceStatus, {
-      //     roomsPerson: sortRoomUser(_roomPerson),
-      //   });
+      const updateUser = {
+        ...user,
+        voiceStatus: data.status,
+      };
+      console.log("updateUser", updateUser);
+      const isUpdate = await updateRoomUser(roomUniqueId, userId, updateUser);
+      const AllRoomUsers = await getAllRoomUsers(roomUniqueId);
+      console.log("isUpdate", isUpdate);
+      logger.info("changeVoiceStatus", { data, AllRoomUsers });
+      socket.broadcast.to(roomId).emit(EVENT.changeVoiceStatus, {
+        roomsPerson: AllRoomUsers,
+      });
     });
   }
 }

src/controller/syncBaseViewController.js

@@ -0,0 +1,44 @@
+import { logger } from "../core/logger.js";
+import { pubClient } from "../connection/redis.js";
+import { ROLES, CODEMEG, EVENT, FROMTYPE } from "../enum/index.js";
+
+const joinSyncClient = async (syncId, userId, from, socket) => {
+  logger.debug("syncBaseView", { syncId, userId, from });
+  try {
+    await pubClient.hSet(syncId, from, userId);
+    socket.join(syncId);
+  } catch (error) {
+    logger.error("joinSyncClient", error);
+  }
+};
+
+export async function SyncBaseViewActionController(socket) {
+  let user = socket.handshake.query;
+  const { roomId, userId, sceneNum, isClient, role, userLimitNum, roomType, from } = user;
+
+  const syncId = `sync-baseView-${userId}`;
+  console.log("SyncBaseViewActionController", user && Number(from) === FROMTYPE.base);
+  if (user && Number(from) === FROMTYPE.base) {
+    console.log("SyncBaseViewActionController", syncId);
+    if ("roomId" in user && "userId" in user) {
+      joinSyncClient(syncId, userId, from, socket);
+    }
+    socket.on(EVENT.clientSyncAction, (data) => {
+      //console.log(data, 'clientSyncAction')
+      socket.broadcast.to(syncId).emit(EVENT.clientSyncAction, data);
+    });
+    socket.on(EVENT.action, (data) => {
+      //console.log(data, 'clientSyncAction')
+      socket.broadcast.to(syncId).emit(EVENT.action, data);
+    });
+    socket.on(EVENT.webSyncAction, (data) => {
+      // console.log("syncActionController-webSyncAction", data);
+      socket.broadcast.to(syncId).emit(EVENT.webSyncAction, data);
+    });
+
+    // socket.on(EVENT.changeVoiceStatus, (data) => {
+    //   socket.broadcast.to(syncId).emit(EVENT.changeVoiceStatus, data);
+    //   logger.info("changeVoiceStatus", { data, syncId });
+    // });
+  }
+}

src/service/roomConfigService.js

@@ -0,0 +1,12 @@
+import { pubClient } from "../connection/redis.js";
+
+const setRoomConfig = (roomId, config) => {
+  const roomConfigKey = `room-config-${roomId}`;
+  return pubClient.hSet(roomConfigKey, config);
+};
+const getRoomConfig = (roomId, config) => {
+  const roomConfigKey = `room-config-${roomId}`;
+  return pubClient.hVals(roomConfigKey);
+};
+
+export { setRoomConfig, getRoomConfig };

src/service/userService.js

@@ -4,6 +4,15 @@ const updateUser = async (userId, userObj) => {
   await pubClient.hSet(userId, userObj.from, JSON.stringify(userObj));
   await pubClient.expire(userId, 60 * 60 * 24);
 };
+const updateRoomUser = async (roomId, userId, userObj) => {
+  try {
+    await pubClient.hSet(userId, userObj.from, JSON.stringify(userObj));
+    await pubClient.hSet(roomId, userId, JSON.stringify(userObj));
+    return Promise.resolve(true);
+  } catch (error) {
+    return Promise.resolve(false);
+  }
+};
 
 const removeRoomAllUsers = (roomId) => {
   return pubClient.del(roomId);
@@ -13,4 +22,14 @@ const removeRoomUser = (roomId, useId) => {
   return pubClient.hDel(roomId, useId);
 };
 
-export { updateUser, removeRoomAllUsers, removeRoomUser };
+const getAllRoomUsers = async (roomId) => {
+  try {
+    const AllRoomUsers = await pubClient.hVals(roomId);
+    const allUsers = AllRoomUsers.map((i) => JSON.parse(i));
+    return Promise.resolve(allUsers);
+  } catch (error) {
+    return Promise.resolve([]);
+  }
+};
+
+export { updateUser, updateRoomUser, removeRoomAllUsers, removeRoomUser, getAllRoomUsers };

src/service/watchRoomService.js

@@ -14,11 +14,11 @@ const passiveLeave = async (roomId, userId, socket) => {
       if (user && !user.isConnected) {
         const { userId, isConnected, from, roomId, sceneNum } = user;
         console.log("user", user);
-        const roomUniqueId = `room-${roomId}_${sceneNum}_web`;
-        const userUniqueId = `user-${userId}`;
-        const isExistRoomUser = await pubClient.hVals(roomUniqueId, userUniqueId);
-        logger.info("passiveLeave", isExistRoomUser);
-        leaveRoomAction(roomUniqueId, userUniqueId, user, socket);
+        // const roomUniqueId = `room-${roomId}_${sceneNum}_web`;
+        // const userUniqueId = `user-${userId}`;
+        // const isExistRoomUser = await pubClient.hVals(roomUniqueId, userUniqueId);
+        // logger.info("passiveLeave", isExistRoomUser);
+        // leaveRoomAction(roomUniqueId, userUniqueId, user, socket);
         console.log("10秒离开");
       }
     }