wechatIM/server/fashilong.js

var server = require("http").createServer();
const TLSSigAPIv2 = require('tls-sig-api-v2')
const appids = require('./../config/appid')
const api = new TLSSigAPIv2.Api(appids.fashilong.appid, appids.fashilong.key)
const PORT = 3031
const LEADER = 'leader'
function getSig (userId) {
  return api.genSig(userId, 86400)
}

const EVENT = {
  someOneInRoom: 'someOneInRoom',   // 有人进入房间
  someOneLeaveRoom: 'someOneLeaveRoom', // 有人离开房间
  startCall: 'startCall',           // 开始通话
  stopCall: 'stopCall',             // 结束通话
  webSyncAction: 'webSyncAction',   // 通知h5的事件
  clientSyncAction: 'clientSyncAction', // 通知非H5的事件
  action: 'action',                 // 通知所有连接设备的事件
  roomClose: 'roomClose',           // 房间已结束/房主已离开
  roomIn: 'roomIn',                 // 通知设备成功进入房间
  changeVoiceStatus: 'changeVoiceStatus', // 通知某设备语音状态
  changeOnlineStatus: 'changeOnlineStatus', // 通知某设备的在线状态
  roomPersonChange: 'roomPersonChange',   // 房间人数变化事件
  changeRoomEnableTalk: 'changeRoomEnableTalk'  // 改变房间是否可通话的配置
}

const CODEMAP = {
  3001: '房间已被解散',
  3002: '房主主动解散'
}

module.exports = class WebSocketServer {
  constructor() {
    this._pageMap = new Map();
    this._roomIDS = new Map();
    this._roomPerson = new Map()
    this._roomsConfig = {}
  }

  create() {
    this.io = require("socket.io")(server, {
      path: "/fsl-node",
      serveClient: false,
      // below are engine.IO options
      pingInterval: 10000,
      pingTimeout: 5000,
      cookie: false,
    });
    server.listen(PORT, { origins: "*" });

    this.io.on("connection", (socket) => {
      let user = socket.handshake.query
      const { roomId, userId, sceneNum, isClient, role, userLimitNum, roomType } = user
      const webRoomId = `${roomId}_${sceneNum}_web`
      const clientRoom = `${userId}${roomId}`
      // 加入客户端与H5单独的通讯房间 
      socket.join(clientRoom, () => {
      })
      socket.on(EVENT.clientSyncAction, (data) => {
        console.log(data,'clientSyncAction')
        socket.broadcast.to(clientRoom).emit(EVENT.clientSyncAction, data)
      })

      socket.on(EVENT.changeVoiceStatus, data => {
        let _roomPerson = this._roomPerson.get(roomId) || []
        user.voiceStatus = data.status
        _roomPerson.forEach(item => {
          if (item.userId === user.userId) {
            item.voiceStatus = user.voiceStatus
          }
        })
        this._roomPerson.set(roomId, _roomPerson)
        socket.broadcast.to(roomId).emit(EVENT.changeVoiceStatus, {roomsPerson: sortRoomUser(_roomPerson)})
      })

      // 房主，保存房间配置
      if (isClient && role === LEADER && !this._roomsConfig[roomId]) {
        console.log('in', user)
        this._roomsConfig[roomId] = {
          userLimitNum,
          enableTalk: user.enableTalk
        }
      }

      // 1v1保存房主
      if (roomType === '1v1' && !this._roomsConfig[roomId]) {
        console.log(roomType, roomId, user)
        this._roomsConfig[roomId] = {
          leaderId: userId
        }
      }

      socket.on(EVENT.changeRoomEnableTalk, data => {
        this._roomsConfig[roomId].enableTalk = data
        socket.broadcast.to(roomId).emit(EVENT.changeRoomEnableTalk, this._roomsConfig[roomId])
      })

      // 若有房间人数限制
      if (userLimitNum && this._roomPerson.get(roomId) && sortRoomUser(this._roomPerson.get(roomId)).length >= userLimitNum) {
        setTimeout(() => {
          socket.emit('roomInFail', { type: 'full', msg: '房间人数已满' })
        }, 1000)
        return this
      }
      let is1v1 = false
      if (this._roomsConfig[roomId]) {
        is1v1 = this._roomsConfig[roomId].leaderId === userId
      }
      console.log(this._roomsConfig[roomId], userId, !is1v1, user.role !== LEADER, (this._roomPerson.get(roomId) && !this._roomPerson.get(roomId).find(item => item.role === LEADER)))
      // 非房主进来房间，判断房间是否存在，以及房间内是否有房主，若无则通知房间已关闭
      if (!is1v1 && user.role !== LEADER && ((this._roomPerson.get(roomId) && !this._roomPerson.get(roomId).find(item => item.role === LEADER)) || (!this._roomPerson.get(roomId)))) {
        setTimeout(() => {
          socket.emit(EVENT.roomClose, { code: 3001, msg: CODEMAP[3001]})
        }, 1000)
        return this
      }

      // 加入所有连接数的通讯房间
      socket.join(roomId, () => {
        // 只有h5才能加入H5端的房间
        if (!isClient) {
          let roomsPerson = this._roomPerson.get(roomId) || []
          if (userId) {
            user.sig = getSig(userId)
          }
          let clientPerson = this._roomPerson.get(clientRoom) || []
          clientPerson.forEach(item => {
            if (item.userId === user.userId && item.avatar) {
              user.avatar = item.avatar
              user.voiceStatus = item.voiceStatus
              user.onlineStatus = item.onlineStatus
              user.nickname = decodeURIComponent(item.nickname)
            }
          })
          roomsPerson.push(user)
          this._roomPerson.set(roomId, roomsPerson)
        } else {
          // 通知客户端的房间配置
          let roomsPerson = this._roomPerson.get(roomId) || []
          socket.emit(EVENT.roomIn, { user, roomsPerson: sortRoomUser(roomsPerson), roomsConfig: this._roomsConfig[roomId]})
        }
      })
      let clientPerson = this._roomPerson.get(clientRoom) || []
      if (isClient) {   
        clientPerson.push(user)
        this._roomPerson.set(clientRoom, clientPerson)
      }
      
      if (!isClient) {
        socket.join(webRoomId, () => {
          // let roomsPerson = this._roomPerson.get(roomId) || []
          // socket.broadcast.to(roomId).emit(EVENT.someOneInRoom, { user, roomsPerson: sortRoomUser(roomsPerson) })

        })
      }
      // 开始通话
      socket.on(EVENT.startCall, () => {
        if (!isClient) {
          let roomsPerson = this._roomPerson.get(roomId) || []
          // 返回h5房间内的信息
          socket.emit(EVENT.roomIn, { user, roomsPerson: sortRoomUser(roomsPerson), roomsConfig: this._roomsConfig[roomId]})
          // 判断是否某些情况断线重连
          if (!user.isInRoom) {
            socket.broadcast.to(roomId).emit(EVENT.someOneInRoom, { user, roomsPerson: sortRoomUser(roomsPerson) })
          }
          user.isInRoom = true
          updateRoomUser(roomsPerson, user)
        }
      })

      socket.on(EVENT.changeOnlineStatus, data => {
        user.onlineStatus = data.status
        let roomPerson = this._roomPerson.get(roomId)
        let __roomPerson = updateRoomUser(roomPerson, user)
        let actionName = user.onlineStatus ? 'inRoom' : 'leaveRoom'
        socket.broadcast.to(roomId).emit(EVENT.roomPersonChange, {roomsPerson: sortRoomUser(__roomPerson), actionName, user})
      })

      socket.on(EVENT.stopCall, () => {
        socket.leave(roomId)
        console.log(role, user, 'stopCall')
        if (role === LEADER) {
          socket.broadcast.to(roomId).emit(EVENT.roomClose, { code: 3002, msg: CODEMAP[3002]})
          delete this._roomsConfig[roomId]
        }
        let roomsPerson = this._roomPerson.get(roomId) || []
        roomsPerson = removeRoomUser(roomsPerson, user)
        this._roomPerson.set(roomId, roomsPerson)
        socket.broadcast.to(roomId).emit(EVENT.someOneLeaveRoom, { user, roomsPerson: sortRoomUser(roomsPerson) })
        user.isInRoom = false
        updateRoomUser(roomsPerson, user)
      })

      socket.on(EVENT.webSyncAction, (data) => {
        socket.broadcast.to(webRoomId).emit(EVENT.webSyncAction, data)
      })

      socket.on(EVENT.action, (data) => {
        socket.broadcast.to(roomId).emit(EVENT.action, data)
      })

      socket.on("disconnect", (reason) => {
        socket.leave(roomId)
        if (!isClient) {
          let roomsPerson = this._roomPerson.get(roomId) || []
          roomsPerson = removeRoomUser(roomsPerson, user)
          this._roomPerson.set(roomId, roomsPerson)
          // socket.broadcast.to(roomId).emit(EVENT.someOneLeaveRoom, { user, roomsPerson })
          socket.leave(webRoomId)
          socket.leave(roomId)
        }
      })

      socket.on('reconnect', () => {
        socket.join(roomId)
        if (!isClient) {
          let roomsPerson = this._roomPerson.get(roomId) || []
          roomsPerson.push(user)
          this._roomPerson.set(roomId, roomsPerson)
          socket.join(webRoomId)
          socket.join(roomId)
        }
      })

      socket.on("error", function (reason) {
        console.log("异常关闭", reason)
      })
      return this;

    })

  }

  close() {
    this.server.disconnect(true);
  }

};

function removeRoomUser (roomsPerson, user) {
  for (let i = 0; i < roomsPerson.length; i++) {
    if (roomsPerson[i].userId === user.userId) {
      roomsPerson.splice(i, 1)
    }
  }
  return roomsPerson
}

// 过滤房间内相同的人
function sortRoomUser (roomsPerson) {
  if (!roomsPerson) return []
  const res = new Map()
  return roomsPerson.filter((a) => !res.has(a.userId) && res.set(a.userId, 1))
}

function updateRoomUser (roomsPerson, user) {
  if (!roomsPerson) return []
  roomsPerson.forEach(item => {
    if (item.userId === user.userId) {
      item = Object.assign(item, user)
    }
  })
  return roomsPerson
}