myvtm/addin/res/ManagerDesktop/js/webSocketBase.js

/**
 * websocket核心模块，实现实体接口调用，消息广播，transid管理
 */
var WebSocketBase = {};
WebSocketBase.socket = new ws('ws://99.12.23.78:9002');
WebSocketBase.retryTimes = 0;
WebSocketBase.interval = 0;
WebSocketBase.isreconnecting = false;
WebSocketBase.callbacksList = {};
WebSocketBase.registerEvents = {};
WebSocketBase.sendQueue = [];
WebSocketBase.registerQueue = [];
WebSocketBase.sessionSet = {}; //会话列表，实体名为key,session为value
WebSocketBase.sessionStateSet = {};  //会话状态列表，sessionID为key，SessionState为value

WebSocketBase.SessionState = {
  Initialize: 0,
  Connecting: 1,
  Connected: 2,
  NotConnected: 3,
  Fault: 4
}

//正在连接
WebSocketBase.socket.onconnecting = function (evn) {
  logEvent("socket:onconnecting:" + JSON.stringify(evn));
};

//已连接
WebSocketBase.socket.onopen = function () {
  logEvent("socket:opened");
  clearInterval(WebSocketBase.interval);
  WebSocketBase.isreconnecting = false;
  WebSocketBase.fireQueue();
};

//出错
WebSocketBase.socket.onerror = function () {
  logEvent("socket:onerror");
};

//已关闭
WebSocketBase.socket.onclose = function () {
  logEvent("socket:closed");
  WebSocketBase.reconnect();
};

//收到server返回消息
WebSocketBase.socket.onmessage = function (evn) {
  var retData = JSON.parse(evn.data);
  var transID = retData["transID"];
  var msgType = retData["messageType"];
  if (msgType != MessageType.broadCast && !WebSocketBase.callbacksList[transID] && !WebSocketBase.registerEvents[transID]) {
    //oneway没有回调
    logEvent("transID not found");
    return;
  }

  switch (msgType) {
    //事件类型
    case MessageType.event:
      //case MessageType.register://临时测试
      for (var i = 0; i < WebSocketBase.registerEvents[transID].length; i++) {
        WebSocketBase.registerEvents[transID][i](evn.data);
      }
      break;

    //接口调用返回
    case MessageType.requestAck:
    //创建会话返回
    case MessageType.sessionAck:
      for (var j = 0; j < WebSocketBase.callbacksList[transID].length; j++) {
        WebSocketBase.callbacksList[transID][j](evn.data);
      }

      if (WebSocketBase.callbacksList[transID]) {
        delete WebSocketBase.callbacksList[transID];
      }
      break;
    case MessageType.endSession:
      logEvent("SessionEnd" + JSON.stringify(retData));
      if (WebSocketBase.sessionStateSet[retData["sessionID"]]) {
        WebSocketBase.sessionStateSet[retData["sessionID"]] = WebSocketBase.SessionState.NotConnected;
      }
      break;
    case MessageType.broadCast:
      logEvent('broadCast');
      var data = retData["data"];
      InnerEventEmitter.dispatch('InnerBroadcast', data);
      break;
    default:
      break;
  }
};


//socket重连
WebSocketBase.reconnect = function () {
  if (!WebSocketBase.isreconnecting) {
    WebSocketBase.isreconnecting = true;
    WebSocketBase.retryTimes = 0;
    WebSocketBase.interval = setInterval(() => {
      WebSocketBase.retryTimes = WebSocketBase.conn(WebSocketBase.retryTimes, WebSocketBase.interval, WebSocketBase.socket)
    }, 10000);//间隔5s重连一次    
  }
};

WebSocketBase.conn = function (retryTimes, intervalID, socket) {
  retryTimes += 1;
  //重连10次仍未连接则退出

  logEvent("socket reconnect:" + retryTimes);
  socket.open();

  return retryTimes;
};

//发送消息
WebSocketBase.sendMsg = function (msg, callback) {
  logEvent("sendMsg");
  if (msg.messageType != MessageType.beginSession) {
    msg.sessionID = WebSocketBase.sessionSet[msg.entity];

    //如果是接口调用，且session没创建，则先创建会话再发送
    if (WebSocketBase.sessionStateSet[msg.sessionID] != WebSocketBase.SessionState.Connected) {
      WebSocketBase.startAndSend(msg, callback);
      return;
    }
  }

  //socket已连接,发送
  if (WebSocketBase.socket.readyState == WebSocket.OPEN) {
    logEvent("socket:sendMsg" + JSON.stringify(msg));
    var transId = msg.transID;
    WebSocketBase.socket.send(JSON.stringify(msg));

    if (!callback)
      return;

    if (!WebSocketBase.callbacksList[transId]) {
      WebSocketBase.callbacksList[transId] = [];
    }

    WebSocketBase.callbacksList[transId].push(callback);
  }
  //socket未连接,丢到队列里面
  else if (WebSocketBase.socket.readyState == WebSocket.CONNECTING) {
    var data = { msg: msg, callback: callback };
    WebSocketBase.sendQueue.push(data);
  }
};

//发送队列待发送的消息
WebSocketBase.fireQueue = function () {
  logEvent("fireQueue()");
  while (WebSocketBase.sendQueue.length && WebSocketBase.socket.readyState == WebSocket.OPEN) {
    var data = WebSocketBase.sendQueue.shift();
    WebSocketBase.sendMsg(data.msg, data.callback);
  }

  while (WebSocketBase.registerQueue.length && WebSocketBase.socket.readyState == WebSocket.OPEN) {
    var data = WebSocketBase.registerQueue.shift();
    WebSocketBase.registerEvent(data.msg, data.callback);
  }

};

//注册事件
WebSocketBase.registerEvent = function (registerMsg, callback) {
  if (WebSocketBase.socket.readyState == WebSocket.OPEN) {
    logEvent("registerEvent" + JSON.stringify(registerMsg));
    var registerId = registerMsg.transID;
    WebSocketBase.socket.send(JSON.stringify(registerMsg));
    if (!WebSocketBase.registerEvents[registerId]) {
      WebSocketBase.registerEvents[registerId] = [];
    }
    WebSocketBase.registerEvents[registerId].push(callback);
  }
  //socket未连接,丢到队列里面
  else if (WebSocketBase.socket.readyState == WebSocket.CONNECTING) {
    var data = { msg: registerMsg, callback: callback };
    WebSocketBase.registerQueue.push(data);
  }
};

//取消注册事件
WebSocketBase.unregisterEvent = function (unregisterMsg) {
  logEvent("unregisterMsg" + JSON.stringify(registerMsg));
  WebSocketBase.socket.send(JSON.stringify(registerMsg));
};

//会话start
WebSocketBase.startSession = function (msg, callback) {
  logEvent("startSession");
  msg.messageType = MessageType.beginSession;
  WebSocketBase.sendMsg(msg, (data) => {
    logEvent("startSession ret: " + JSON.stringify(data));
    var jsondata = JSON.parse(data);
    if (jsondata["errorCode"] == ErrorCodeEnum.Error_Succeed && jsondata["sessionID"]) {
      WebSocketBase.sessionSet[msg.entity] = jsondata["sessionID"];
      WebSocketBase.sessionStateSet[jsondata["sessionID"]] = WebSocketBase.SessionState.Connected;
    }
    else {
      logEvent("startSession failed!");
    }
    callback(jsondata);
  });
};

//创建会话并发送消息
WebSocketBase.startAndSend = function (msg, callback) {
  logEvent("startAndSend");
  var sessionMsg = new Session();
  sessionMsg.entity = msg.entity;
  sessionMsg.class = msg.class;
  WebSocketBase.startSession(sessionMsg, (jsondata) => {
    if (jsondata["errorCode"] == ErrorCodeEnum.Error_Succeed) {
      WebSocketBase.sendMsg(msg, callback);
    }
    else {
      logEvent("startAndSend(), create session failed!");
    }
  });
};

//发送事件
WebSocketBase.logSpEvent = function (eventCode, securityLevel, message) {
  var evtMsg = new LogEvent();
  evtMsg.eventCode = eventCode;
  evtMsg.securityLevel = securityLevel;
  evtMsg.message = message;
  logEvent("logSpEvent:" + JSON.stringify(evtMsg));
  WebSocketBase.socket.send(JSON.stringify(evtMsg));
};
//发送广播
WebSocketBase.broadCast = function (broadMsg) {
  logEvent("broadCast:" + JSON.stringify(broadMsg));
  WebSocketBase.socket.send(JSON.stringify(broadMsg));
};

//设置系统变量
WebSocketBase.setSysVar = function (name, value, callback) {
  var msg = new SetVarReq();
  msg.name = name;
  msg.value = value;
  WebSocketBase.sendMsg(msg, callback);
};

//获取系统变量
WebSocketBase.getSysVar = function (name, callback) {
  var msg = new GetVarReq();
  msg.name = name;
  WebSocketBase.sendMsg(msg, callback);
};