// //////////////////////////////////////////////////////////////////////////////
//课堂控制APE
// //////////////////////////////////////////////////////////////////////////////

import Ape from './Ape';
import ApeConsts from './ApeConsts';
import ThirdMessage from './ThirdMessage';
import MessageTypes from 'MessageTypes';
import pdu from 'pdus';
import UTF8 from 'utf-8';
import Loger from 'Loger';
import GlobalConfig from 'GlobalConfig';
import EngineUtils from 'EngineUtils';
import TimerCounter from "TimerCounter";
import Sass from 'Sass';
import LogManager from "LogManager";
let loger = Loger.getLoger('ConferApe');

class ConferApe extends Ape {
  constructor() {
    super(
      ApeConsts.CONFERENCE_SESSION_ID,
      ApeConsts.CONFERENCE_SESSION_NAME,
      ApeConsts.CONFERENCE_SESSION_TAG
    );
    this.isSendInsterRoster=false;//这个很重要，每次MCU连接成功之后只发一次
    this.isLeave=false;//记录自己是否已经离开
    this.rosters = {}; //用户列表
    this.timerCounter = new TimerCounter(); //计时器
    this.startRecordTimer;//开始录制的计时器
    this.recordStatus=false;//记录录制状态
    //第三方消息控制 parent和Iframe直接的通讯
    this.thirdMessage = new ThirdMessage();
    this.thirdMessage.on(ThirdMessage.RECIVE_MESSAGE, this.onThirdReciveParentMessage.bind(this));

    // Ape Models
    this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer);

    this.registerObj(pdu.RCPDU_REG_REGISTER_ROSTER, ApeConsts.CONFERENCE_OBJ_ROSTER_ID,
      ApeConsts.CONFERENCE_OBJ_ROSTER_NAME, ApeConsts.CONFERENCE_OBJ_ROSTER_TAG, 0, new ArrayBuffer);

    this.registerObj(pdu.RCPDU_REG_REGISTER_QUEUE, ApeConsts.CONFERENCE_OBJ_QUEUE_ID,
      ApeConsts.CONFERENCE_OBJ_QUEUE_NAME, ApeConsts.CONFERENCE_OBJ_QUEUE_TAG, 0, new ArrayBuffer);

    this.registerObj(pdu.RCPDU_REG_REGISTER_TABLE, ApeConsts.CONFERENCE_OBJ_TABLE_ID,
      ApeConsts.CONFERENCE_OBJ_TABLE_NAME, ApeConsts.CONFERENCE_OBJ_TABLE_TAG, 0, new ArrayBuffer);

    this.registerObj(pdu.RCPDU_REG_REGISTER_COUNTER, ApeConsts.CONFERENCE_OBJ_COUNTER_ID,
      ApeConsts.CONFERENCE_OBJ_COUNTER_NAME, ApeConsts.CONFERENCE_OBJ_COUNTER_TAG, 0, new ArrayBuffer);

    this.on(pdu.RCPDU_SESSION_JOIN_RESPONSE, this._joinSessionHandler.bind(this));

    this.on(pdu.RCPDU_SEND_CONFERENCE_DATA_REQUEST, this.conferMsgComingHandler.bind(this)); //这个是课堂消息类型，flash里在使用这里不再使用，各个模块的消息由模块自己来处理
    this.on(pdu.RCPDU_CONFERENCE_RECORD_REQUEST, this.onSendConferRecordRequestHandler.bind(this)); //发送录制和停止录制消息
    this.on(pdu.RCPDU_THIRD_BROADCAST_DATA_REQUEST, this.onThirdBroadcastDataHandler.bind(this)); //第三方广播消息
  }

  //加入课堂
  _joinSessionHandler(_data) {
    if(this.isSendInsterRoster){
      loger.warn("已经发送过insertRoster,不能再次发送");
      return
    }
   let nodeInfoRecordPdu = this.getNodeInfo();

    let userDataPdu = new pdu['RCNodeInfoUserDataPdu'];
    userDataPdu.qq = '';
    userDataPdu.skype = '';

    nodeInfoRecordPdu.userData = userDataPdu.toArrayBuffer();
    nodeInfoRecordPdu.deviceType = GlobalConfig.deviceType; //设备类型

    let item = new pdu['RCRegistryRosterItemPdu'];
    item.nodeId = nodeInfoRecordPdu.nodeId;
    item.nodeData = nodeInfoRecordPdu.toArrayBuffer();

    let rosterUpdateItem = new pdu['RCRegistryRosterInsertItemPdu'];
    rosterUpdateItem.type =pdu.RCPDU_REG_ROSTER_UPDATE_PDU;// pdu.RCPDU_REG_ROSTER_INSERT_PDU 暂时用update的类型，MCU第一次会当insert处理，目前insert解包出错
    rosterUpdateItem.items.push(item);

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.CONFERENCE_OBJ_ROSTER_ID;
    updateObjPdu.subType = rosterUpdateItem.type;
    updateObjPdu.userData = rosterUpdateItem.toArrayBuffer();

    //同步
    let adapterItemPdu = new pdu['RCAdapterItemPdu'];
    adapterItemPdu.type = pdu.RCPDU_REG_UPDATE_OBJ;
    adapterItemPdu.itemData = updateObjPdu.toArrayBuffer();

    let adapterPdu = new pdu['RCAdapterPdu'];
    adapterPdu.type = pdu.RCPDU_REG_ADAPTER;
    adapterPdu.item.push(adapterItemPdu);
    this.sendUniform(adapterPdu, true);

    this.isSendInsterRoster=true;
    loger.log('发送insertRoster->', nodeInfoRecordPdu);
  }

  //获取角色信息
  getNodeInfo() {
    let nodeInfoRecordPdu = new pdu['RCNodeInfoRecordPdu'];
    nodeInfoRecordPdu.nodeId = GlobalConfig.nodeId;
    nodeInfoRecordPdu.joinTimestamp= GlobalConfig.joinTimestamp||EngineUtils.creatSoleNumberFromTimestamp();
    nodeInfoRecordPdu.selfSilence = JSON.stringify(GlobalConfig.selfSilence) || "";
    nodeInfoRecordPdu.name = GlobalConfig.userName;
    nodeInfoRecordPdu.role = ApeConsts.userTypesToId[GlobalConfig.userRole] || 1; //NR_NORMAL用户的身份，根据用户登录时的身份设置;
    nodeInfoRecordPdu.level = GlobalConfig.level;
    //nodeInfoRecordPdu.audioRecords= GlobalConfig.audioRecords;
    //nodeInfoRecordPdu.videoRecords= GlobalConfig.videoRecords;
    //nodeInfoRecordPdu.status= GlobalConfig.status;
    nodeInfoRecordPdu.userData = GlobalConfig.userData;
    nodeInfoRecordPdu.userId = GlobalConfig.userId;
    nodeInfoRecordPdu.handUpTime = GlobalConfig.handUpTime;
    nodeInfoRecordPdu.selfDisEnableDrawTime = GlobalConfig.selfDisEnableDrawTime;
    //nodeInfoRecordPdu.deviceType= GlobalConfig.deviceType;
    //nodeInfoRecordPdu.mobileDirection= GlobalConfig.mobileDirection;
    nodeInfoRecordPdu.microphones = GlobalConfig.microphones;
    nodeInfoRecordPdu.cameras = GlobalConfig.cameras;
    nodeInfoRecordPdu.openCamera = GlobalConfig.openCamera;
    nodeInfoRecordPdu.openMicrophones = GlobalConfig.openMicrophones;
    nodeInfoRecordPdu.videoQuality = GlobalConfig.videoQuality;
    nodeInfoRecordPdu.userIp = GlobalConfig.userIp;

    nodeInfoRecordPdu.videoEnabled = GlobalConfig.videoEnabled;
    nodeInfoRecordPdu.audioEnabled =GlobalConfig.audioEnabled;

    nodeInfoRecordPdu.curVideoQuality = GlobalConfig.curVideoQuality;
    nodeInfoRecordPdu.micGain = GlobalConfig.micGain;
    nodeInfoRecordPdu.micNoise = GlobalConfig.micNoise;
    nodeInfoRecordPdu.autoGain = GlobalConfig.autoGain;
    nodeInfoRecordPdu.speakerVolume = GlobalConfig.speakerVolume;
    nodeInfoRecordPdu.micCode = GlobalConfig.micCode;
    nodeInfoRecordPdu.curCamera = GlobalConfig.curCamera;
    nodeInfoRecordPdu.curMicrophone = GlobalConfig.curMicrophone;

    nodeInfoRecordPdu.country = GlobalConfig.country; //国家
    nodeInfoRecordPdu.city = GlobalConfig.city; //城市
    nodeInfoRecordPdu.province = GlobalConfig.province; //服务商
    nodeInfoRecordPdu.isp = GlobalConfig.isp; //服务商
    nodeInfoRecordPdu.msList = [];
    //用户的MS列表
    let msListAll = GlobalConfig.msListFinal;
    for (let k = 0; k < msListAll.length; k++) {
      let msItem = msListAll[k];
      if (msItem) {
        let msListItemPdu = new pdu['MsListItemPdu'];
        msListItemPdu.ip = msItem.ip || "";
        msListItemPdu.port = msItem.port || "";
        msListItemPdu.country = msItem.country || "";
        msListItemPdu.province = msItem.province || "";
        msListItemPdu.city = msItem.city || "";
        msListItemPdu.name = msItem.name || "";
        nodeInfoRecordPdu.msList.push(msListItemPdu);
      }
    }
    //用户当前选择的MS
    nodeInfoRecordPdu.msIpPort = GlobalConfig.MS_PUBLISH_IP + ":" + GlobalConfig.MS_PUBLISH_PORT;

    nodeInfoRecordPdu.deviceType = GlobalConfig.deviceType;
    nodeInfoRecordPdu.language = GlobalConfig.language;
    nodeInfoRecordPdu.explorer = GlobalConfig.explorer;
    nodeInfoRecordPdu.explorerVersion = GlobalConfig.explorerVersion;
    nodeInfoRecordPdu.os = GlobalConfig.os;
    nodeInfoRecordPdu.sdkVersion = GlobalConfig.sdkVersion || "未知版本";
    return nodeInfoRecordPdu;
  }

  //更新角色数据
  updateUserInfo() {
    if(GlobalConfig.classType==ApeConsts.CLASS_TYPE_ZHIBO&&GlobalConfig.isH5==true){
      //直播模式下H5不处理更新信息
      console.log("直播模式下H5不处理用户更新信息");
      return;
    }
    let nodeInfoRecordPdu = this.getNodeInfo();
    //loger.log('更新用户信息->', nodeInfoRecordPdu);
    let userDataPdu = new pdu['RCNodeInfoUserDataPdu'];
    userDataPdu.qq = '';
    userDataPdu.skype = '';

    nodeInfoRecordPdu.userData = userDataPdu.toArrayBuffer();
    nodeInfoRecordPdu.deviceType = GlobalConfig.deviceType; //设备类型

    let item = new pdu['RCRegistryRosterItemPdu'];
    item.nodeId = nodeInfoRecordPdu.nodeId;
    item.nodeData = nodeInfoRecordPdu.toArrayBuffer();

    let rosterUpdateItem = new pdu['RCRegistryRosterUpdateItemPdu'];
    rosterUpdateItem.type = pdu.RCPDU_REG_ROSTER_UPDATE_PDU;
    rosterUpdateItem.items.push(item);

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.CONFERENCE_OBJ_ROSTER_ID;
    updateObjPdu.subType = rosterUpdateItem.type;
    updateObjPdu.userData = rosterUpdateItem.toArrayBuffer();

    //同步
    let adapterItemPdu = new pdu['RCAdapterItemPdu'];
    adapterItemPdu.type = pdu.RCPDU_REG_UPDATE_OBJ;
    adapterItemPdu.itemData = updateObjPdu.toArrayBuffer();

    let adapterPdu = new pdu['RCAdapterPdu'];
    adapterPdu.type = pdu.RCPDU_REG_ADAPTER;
    adapterPdu.item.push(adapterItemPdu);
    this.sendUniform(adapterPdu, true);
  }

  sendConferMsg(_messageInfo) {
    if (this._classInfo == null || EngineUtils.isEmptyObject(this._classInfo)) {
      loger.log('不能发送课堂消息.McuClient还未初始化数据!');
      if (GlobalConfig.getCurrentStatus().code == 0 || GlobalConfig.getCurrentStatus().code == 1) {
        this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_SEND_FAILED_NO_JOIN);
        return;
      }
      return;
    }
    if(GlobalConfig.classType==ApeConsts.CLASS_TYPE_ZHIBO&&GlobalConfig.isH5){
      loger.warn("直播模式H5不能发送课堂控制消息");
      return;
    }
    // to, message
    loger.log('发送课堂控制消息.', _messageInfo);

    let conferSendPdu = new pdu['RCConferenceSendDataRequestPdu'];
    conferSendPdu.type = pdu.RCPDU_SEND_CONFERENCE_DATA_REQUEST;
    conferSendPdu.initiator = this._classInfo.nodeId; //发起人
    conferSendPdu.peer = parseInt(_messageInfo.to); //发送给谁,公聊的时候是0，私聊的时候是指定的用户id

    conferSendPdu.userData = this._rCArrayBufferUtil.strToUint8Array("h5" + _messageInfo.message);
    //conferSendPdu.userData =UTF8.setBytesFromString(_messageInfo.message);
    conferSendPdu.isPublic = true;
    conferSendPdu.actionType = _messageInfo.actionType;
    // if (!(conferSendPdu.isPublic || 0 === conferSendPdu.peer)) {
    if (!conferSendPdu.isPublic && 0 != conferSendPdu.peer) {
      //发送给制定的人
      //loger.log('发送私聊课堂消息.');
      this.send(conferSendPdu);
    } else {
      //发送给所有人
      // loger.log('发送公聊课堂消息.');
      this.sendChatUniform(conferSendPdu);
    }
  }

  //发送录制或停止录制的消息，{"recordStatus":true};true为开始录制，false为停止录制
  sendConferRecordMsg(_param) {
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }
    if (_param == null) {
      loger.warn("控制录制状的消息发送失败，参数错误", _param);
      return;
    }

    /*  message RCConferenceRecordRequestPdu {
     optional uint32 initiator = 1; // 发起录像指令的node id
     optional bool record = 2;      // 录像指令 true：开始录像， false：停止录像
     optional uint32 class_time = 3;    // 课堂进行时间（秒）
     optional string filename = 4;  // 录像文件名称,filename中增加目录部分
     }*/

    if(this.recordStatus==true){
      //已经有录制文件，不再发送
      return;
    }
    //保存当前的录制状态
    GlobalConfig.recordStatus = _param.recordStatus || false;
    let conferRecordSendPdu = new pdu['RCConferenceRecordRequestPdu'];
    conferRecordSendPdu.type = pdu.RCPDU_CONFERENCE_RECORD_REQUEST;
    conferRecordSendPdu.peer = 0; //channel 为0
    conferRecordSendPdu.isPublic = true;

    conferRecordSendPdu.initiator = this._classInfo.nodeId; //发起人
    conferRecordSendPdu.record = GlobalConfig.recordStatus;
    //conferRecordSendPdu.classTime = GlobalConfig.classTimestamp;//不能使用课堂进行时间，这个时间结束课堂的时候会被清除
    conferRecordSendPdu.classTime = GlobalConfig.recordTimestamp; //课堂录制的累积时间，不会被清除
    conferRecordSendPdu.filename = GlobalConfig.recordFileName || GlobalConfig.classId + "_" + EngineUtils.creatTimestampYMD() + ".rec";
    if (GlobalConfig.recordStatus) {
      loger.log("发送录制的指令->开启", conferRecordSendPdu);
    } else {
      loger.log("发送录制的指令->停止", conferRecordSendPdu);
    }
    this.sendChatUniform(conferRecordSendPdu);
  }

  //开启录制
  startRecord() {
    //如果录制的时间长超出设定的最大录制时间就不再录制
    if (GlobalConfig.recordTimestamp >= GlobalConfig.allowRecordMaxTime) {
      loger.warn('不能再录制，录制时间已经达到最大限制', GlobalConfig.recordTimestamp);
      return;
    }
    //如果已经开始录制就不再开启
    if (GlobalConfig.recordStatus && GlobalConfig.rosterNum > 1) {
      loger.warn('目前已经是录制状态->当前课堂人数:' + GlobalConfig.rosterNum);
      return false;
    }
    //如果是host或者当前课堂只有1个人,并且不是H5
    if (this.checkHasRecordControl()) {
      loger.warn('开启录制', "isHost", GlobalConfig.isHost, "recordStatus", GlobalConfig.recordStatus, "当前人数:" +GlobalConfig.rosterNum);
      //如果录制的文件名不存在，需要创建一个名字
      let timestampYMD = EngineUtils.creatTimestampYMD();
      if (!GlobalConfig.recordFileName) {
        GlobalConfig.recordFileName = GlobalConfig.siteId + "/" + timestampYMD + "/" + GlobalConfig.classId + "_" + timestampYMD + ".rec"; //4、文件名称 $RECORD_HOME/`site id`/`日期`/`filename`    例：/data/record/su/20161216/`filename`
      }
      GlobalConfig.classStopTime = EngineUtils.creatTimestampStr();
      this.sendConferRecordMsg({"recordStatus": true});
      this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
      this._emit(MessageTypes.CLASS_RECORD_START); //课堂开始录制
    }
  }

  //检测是否有控制录制操作的权限
  checkHasRecordControl() {
    //loger.warn('检测是否有控制录制操作的权限', "isHost", GlobalConfig.isHost, "recordStatus", GlobalConfig.recordStatus,"当前人数:"+this.rosterLen);
    //1.如果自己是老师或者当前课堂只有一个人
    if (GlobalConfig.isHost || (GlobalConfig.rosterNum <= 1&&GlobalConfig.deviceType!=GlobalConfig.deviceH5)) {
      return true;
    }
    //2.如果自己不是老师，需要判断当前课堂内是否有老师，如果有老师就不做操作
    for (let i in this.rosters) {
      //如果是老师就停止
      let rosterItem = this.rosters[i];
      if (rosterItem && rosterItem.userRole == ApeConsts.host) {
        return false;
      }
    }
    //3.课堂内有多个人并且都不是老师,选择一个nodeId最小的来操作
    for (let k in this.rosters) {
      //如果选择的nodeId是自己就有权限，否则没有权限
      if (k == GlobalConfig.nodeId) {
        return true;
      } else {
        return false;
      }
    }
    return false
  }

  //停止录制
  stopRecord(isForce) {
    //判断是否有权限
    if (this.checkHasRecordControl()) {
      loger.warn('停止录制', "isHost", GlobalConfig.isHost, "recordStatus", GlobalConfig.recordStatus);
      //this.sendUpdaterClassStatusInfo({"actionType":GlobalConfig.classStatus, isStopAllPublishMedia: true});
      this.sendConferMsg({"to": 0, "message": "STOP_ALL_PUBLISH", "actionType": ApeConsts.STOP_ALL_PUBLISH});
      setTimeout(()=> {
        GlobalConfig.classStopTime = EngineUtils.creatTimestampStr();
        this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
        this.sendConferRecordMsg({"recordStatus": false});
      }, 2000);
    } else {
      loger.warn('没有权限停止录制', "isHost", GlobalConfig.isHost, "recordStatus", GlobalConfig.recordStatus);
    }
  }

  //主动离开课堂,发送通知到服务器
  leaveClass() {
    let nodeInfoRecordPdu = this.mcu.mcuClassInfo.self;
    let userDataPdu = new pdu['RCNodeInfoUserDataPdu'];
    userDataPdu.qq = '';
    userDataPdu.skype = '';

    nodeInfoRecordPdu.userData = userDataPdu.toArrayBuffer();
    nodeInfoRecordPdu.deviceType = GlobalConfig.deviceType;

    let item = new pdu['RCRegistryRosterItemPdu'];
    item.nodeId = nodeInfoRecordPdu.nodeId;
    item.nodeData = nodeInfoRecordPdu.toArrayBuffer();

    let rosterUpdateItem = new pdu['RCRegistryRosterDeleteItemPdu'];
    rosterUpdateItem.type = pdu.RCPDU_REG_ROSTER_DELETE_PDU;
    rosterUpdateItem.nodeId = GlobalConfig.nodeId;

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.CONFERENCE_OBJ_ROSTER_ID;
    updateObjPdu.subType = rosterUpdateItem.type;
    updateObjPdu.userData = rosterUpdateItem.toArrayBuffer();

    let adapterItemPdu = new pdu['RCAdapterItemPdu'];
    adapterItemPdu.type = pdu.RCPDU_REG_UPDATE_OBJ;
    adapterItemPdu.itemData = updateObjPdu.toArrayBuffer();

    let adapterPdu = new pdu['RCAdapterPdu'];
    adapterPdu.type = pdu.RCPDU_REG_ADAPTER;
    adapterPdu.item.push(adapterItemPdu);

    this.sendUniform(adapterPdu, true);
  }

  //还原课堂状态
  restorClass() {
    GlobalConfig.classTimestamp = 0;
    GlobalConfig.classStatus = ApeConsts.CLASS_STATUS_WAIT;
    GlobalConfig.classStopTime = EngineUtils.creatTimestampStr();
    //this.stopRecord();//停止录制的接口单独调用
    this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
    //this.sendUpdaterClassStatusInfo({"actionType": 0, isStopAllPublishMedia: true});
    this.sendUpdaterClassStatusInfo({"actionType": ApeConsts.CLASS_STATUS_WAIT, isStopAllPublishMedia: false});
  }

  // 全局禁言
  silenceClass(params) {
    if (!GlobalConfig.isNormal) {
      //同步禁言状态
      if (params && params.silence == true) {
        GlobalConfig.silence = true;
      } else {
        GlobalConfig.silence = false;
      }
      this.sendUpdaterClassStatusInfo(params);
    } else {
      loger.warn('学生没有开启禁言的权限');
    }
  }

  //全局绘制权限控制
  changeDrawStatus(params) {
    if (!GlobalConfig.isNormal) {
      //同步禁言状态
      if (params && params.isEnableDraw == true) {
        GlobalConfig.isEnableDraw = true;
      } else {
        GlobalConfig.isEnableDraw = false;
      }
      this.sendUpdaterClassStatusInfo(params);
    } else {
      loger.warn('学生没有开启绘制的权限');
    }
  }

  //全局送礼物权限控制
  changeGiftStatus(params) {
    loger.log("全局送礼物权限控制",params);
    if (!GlobalConfig.isNormal) {
      if (params && params.isEnableGift == true) {
        GlobalConfig.isEnableGift = true;
      } else {
        GlobalConfig.isEnableGift = false;
      }
      this.sendUpdaterClassStatusInfo(params);
    } else {
      loger.warn('学生没有开启送礼物的权限');
    }
  }

  //控制指定用户的画笔状态
  changeUserDrawStatus(_param) {
    loger.log('控制指定用户的画笔状态->', _param);
    if (_param && _param.isDisEnableDraw == true) {
      GlobalConfig.selfDisEnableDrawTime = EngineUtils.creatTimestamp();//被禁用画笔的时间
    } else {
      GlobalConfig.selfDisEnableDrawTime = 0; //取消禁用画笔
    }
    this.updateUserInfo();
  }

  //开始上课
  startClass(_param) {
    if (GlobalConfig.isHost) {
      let timestamp = EngineUtils.creatTimestampStr();
      GlobalConfig.classStopTime = timestamp;

      /*
       //如果录制的文件名不存在，需要创建一个名字
       let timestampYMD = EngineUtils.creatTimestampYMD();
       GlobalConfig.recordFileName = GlobalConfig.recordFileName ||
       GlobalConfig.siteId + "/" + timestampYMD + "/" + GlobalConfig.classId + "_" + timestampYMD + ".rec"; //4、文件名称 $RECORD_HOME/`site id`/`日期`/`filename`    例：/data/record/su/20161216/`filename`
       */

      if (GlobalConfig.classStatus == ApeConsts.CLASS_STATUS_WAIT) {
        //之前是为开始状态，第一次点开始
        GlobalConfig.classStartTime = timestamp;
      }

      GlobalConfig.classStatus = ApeConsts.CLASS_STATUS_STARTED;
      ////开始录制
      //this.startRecord();
      ////课堂状态改变
      //this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
      //同步课堂状态
      //this.sendUpdaterClassStatusInfo({"actionType": 1, isStopAllPublishMedia: true});
      this.sendUpdaterClassStatusInfo({"actionType": ApeConsts.CLASS_STATUS_STARTED, isStopAllPublishMedia: false});
      ////开始计时
      //this.startTimerCounter();
    } else {
      loger.warn('没有开始课堂的权限');
    }
  }

  //暂停上课 {isForce:true}   isForce->是否强制提交(true为是）
  pauseClass(_param) {
    if (GlobalConfig.classStatus == ApeConsts.CLASS_STATUS_WAIT) {
      loger.warn('还没有开始,不能点暂停');
      return;
    }
    GlobalConfig.classStatus = ApeConsts.CLASS_STATUS_PAUSE;
    GlobalConfig.classStopTime = EngineUtils.creatTimestampStr();

    //this.stopRecord();
    this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE, _param);
    //this.sendUpdaterClassStatusInfo({"actionType": 2, isStopAllPublishMedia: true});
    this.sendUpdaterClassStatusInfo({"actionType": ApeConsts.CLASS_STATUS_PAUSE, isStopAllPublishMedia: false});

    //this.stopTimerCounter();//新版的录制规则，尝试暂停不停止计时器
  }

  //关闭课堂
  closeClass(_param) {
    if (GlobalConfig.classStatus == ApeConsts.CLASS_STATUS_WAIT) {
      loger.warn('还没有开始,不能点关闭');
      return;
    }
    loger.warn("调用关闭课堂->");
    this.stopTimerCounter();
    this.restorClass();
    //停止所有人推流，把所有人都踢出课堂
    this.sendConferMsg({"to": 0, "message": "所有人退出课堂", "actionType": ApeConsts.CLASS_ACTION_CLOSE_ALL});
    this.stopRecord();//关闭课堂的时候停止录制
  }

  //更新设备信息
  updateDeviceInfo(_param) {
    loger.log('更新用户的设备信息->', _param);
    this.updateUserInfo();
  }

  // 禁言控制
  controlSilenceStatus(_param) {
    //控制用户的禁言状态
    if (!_param || !_param.nodeId) {
      loger.log('控制禁言状态->失败->参数错误', _param);
      return;
    }

    if (!(_param.silence)) {
      delete GlobalConfig.silenceUsers[_param.userId || _param.nodeId];
    } else {
      GlobalConfig.silenceUsers[_param.userId || _param.nodeId] = _param;
    }

    this.sendUpdaterClassStatusInfo({silenceUsers: GlobalConfig.silenceUsers});
  }

  changeSilenceStatus(_param) {
    loger.log('切换禁言状态->', _param);
    GlobalConfig.selfSilence = _param.silence || {};
    this.updateUserInfo();
  }

  //将指定nodeId的人踢出课堂
  kickOutRosterFormNodeId(_param) {
    if (GlobalConfig.isNormal) {
      loger.warn("普通身份没有踢人的权限");
      return;
    }
    if (_param && _param.nodeId) {
      this.sendConferMsg({
        "to": parseInt(_param.nodeId),
        "message": "" + _param.nodeId + "踢出课堂",
        "actionType": ApeConsts.CLASS_ACTION_KICK_OUT_ROSTER
      });
    } else {
      loger.warn("踢人失败-参数无效")
    }
  }

  //控制画笔的使用状态
  controlDrawStatus(_param) {
    //控制用户的举手状态
    if (!_param || !_param.nodeId) {
      loger.log('控制画笔的使用状态->失败->参数错误', _param);
      return;
    }
    let msgObj = {};
    msgObj.nodeId = _param.nodeId;
    msgObj.isDisEnableDraw = false;
    if (_param && _param.isDisEnableDraw == true) {
      msgObj.isDisEnableDraw = true;
    }
    this.sendConferMsg({
      "to": _param.nodeId,
      "message": JSON.stringify(msgObj),
      "actionType": ApeConsts.CLASS_ACTION_DRAW_STATUS_CHANGE
    });
  }

  //控制举手状态
  controlHandUpStatus(_param) {
    //控制用户的举手状态
    if (!_param || !_param.nodeId) {
      loger.log('控制举手状态->失败->参数错误', _param);
      return;
    }
    let msgObj = {};
    msgObj.nodeId = _param.nodeId;
    msgObj.isHandUp = false;
    if (_param && _param.isHandUp == true) {
      msgObj.isHandUp = true;
    }
    this.sendConferMsg({
      "to": _param.nodeId,
      "message": JSON.stringify(msgObj),
      "actionType": ApeConsts.CLASS_ACTION_HANDUP_STATUS_CHANGE
    });
  }

  //切换举手状态
  changeHandUpStatus(_param) {
    loger.log('切换举手状态->', _param);
    if (_param && _param.isHandUp == true) {
      //举手
      GlobalConfig.handUpTime = EngineUtils.creatTimestamp();
    } else {
      GlobalConfig.handUpTime = 0; //默认0是没有举手的状态(大于0就是举手)
    }
    this.updateUserInfo();
  }

  //课堂的场景模块发送改变
  sceneTableChange(_param) {
    if (GlobalConfig.isRecordPlayBack) {
      return;
    }
    loger.log('切换文档-媒体-屏幕模块切换->', _param);
    //如果是host身份
    if (GlobalConfig.isHost||GlobalConfig.isAssistant||GlobalConfig.isPresenter) {
      if (_param) {
        GlobalConfig.currentSceneTableId = parseInt(_param.currentSceneTableId) || 0; //当前场景显示的模块 0=文档模块、1=屏幕共享、2=媒体共享
        //保存数据到Sass
        this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
        //同步消息给其他人
        this.sendUpdaterClassStatusInfo({"actionType": ApeConsts.CLASS_STATUS_STARTED, isStopAllPublishMedia: false});
      }
    }

  }

  //更新课堂信息
  sendUpdaterClassStatusInfo(_param) {
    //{"actionType": 1,isStopAllPublishMedia:false}    //actionType课堂状态   isStopAllPublishMedia是否停止当前的所有推流
    //console.log('发送更新课堂信息->');
    if(GlobalConfig.classType==ApeConsts.CLASS_TYPE_ZHIBO&&GlobalConfig.isH5==true){
      return;
    }
    if (_param == null || EngineUtils.isEmptyObject(_param)) {
      loger.log('发送更新课堂信息->参数错误');
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }
    let itemIdx = ApeConsts.CONFERENCE_OBJ_TABLE_ID; // itemIdx=_param.itemIdx;
    let modelPdu = this.packPdu(_param, itemIdx);
    if (modelPdu == null) {
      loger.log('发送更新课堂信息->参数错误');
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    let tableItemPdu = new pdu['RCRegistryTableItemPdu'];
    tableItemPdu.itemIdx = itemIdx;
    tableItemPdu.owner = 0; //收到flash的是这个值，不清楚先写固定
    tableItemPdu.registerObjId = ApeConsts.CONFERENCE_OBJ_TABLE_ID;
    tableItemPdu.itemData = modelPdu.toArrayBuffer();

    //updater
    let tableUpdateItem = new pdu['RCRegistryTableUpdateItemPdu'];
    //optional RCPduType_E type = 1 [default = RCPDU_REG_TABLE_UPDATE_PDU];
    //repeated RCRegistryTableItemPdu items = 2;
    tableUpdateItem.type = pdu.RCPDU_REG_TABLE_UPDATE_PDU; //
    tableUpdateItem.items.push(tableItemPdu);

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.CONFERENCE_OBJ_TABLE_ID;
    updateObjPdu.subType = tableUpdateItem.type;
    updateObjPdu.userData = tableUpdateItem.toArrayBuffer();

    //同步
    let adapterItemPdu = new pdu['RCAdapterItemPdu'];
    adapterItemPdu.type = pdu.RCPDU_REG_UPDATE_OBJ;
    adapterItemPdu.itemData = updateObjPdu.toArrayBuffer();

    let adapterPdu = new pdu['RCAdapterPdu'];
    adapterPdu.type = pdu.RCPDU_REG_ADAPTER;
    adapterPdu.item.push(adapterItemPdu);
    //loger.log('发送更新课堂信息->');
    this.sendUniform(adapterPdu, true);
  }

  /////收到消息处理/////////////////////////////////////////////////////////////////////////////////
  //加入channel成功
  onJoinChannelHandlerSuccess() {
    if (GlobalConfig.isRecordPlayBack) {
      loger.log('课堂模块初始完成->当前是录制回放:' + GlobalConfig.classStatus);
      return;
    }
    loger.log('课堂模块初始完成->当前课堂状态:' + GlobalConfig.classStatus, "recordStatus:" + GlobalConfig.recordStatus);
    this.timerCounter.addTimerCallBack(this.timerCounterUptate.bind(this), 1);
    this.startTimerCounter();
    this.startClass();
    clearTimeout(this.startRecordTimer);
    this.startRecordTimer = setTimeout(()=> {
      this.startRecord();
    }, 2000);
  }

  //开启计时器
  startTimerCounter() {
    this.stopTimerCounter();
    if (this.timerCounter) {
      this.timerCounter.startTimer();
    }
  }

  //停止计时器
  stopTimerCounter() {
    if (this.timerCounter) {
      this.timerCounter.stopTimer();
    }

  }

  timerCounterUptate() {
    if (!this.mcu.connected) {
      loger.warn('MCU 连接已经断开');
      this.stopTimerCounter();
      return;
    }
    //更新课堂进行时间
    if (GlobalConfig.classStatus == ApeConsts.CLASS_STATUS_STARTED) {
      GlobalConfig.classTimestamp = GlobalConfig.classTimestamp + 1; //计时
      //向应用层更新当前课堂进行的时间长度 (秒)
      this._emit(MessageTypes.CLASS_UPDATE_TIMER, {"classTimestamp": GlobalConfig.classTimestamp});

      /* 录制消息已经更新了数据，这个课堂内的就不需要再更新，间隔太短了频率太高
       //以一定的时间间隔同步课堂内所有人的累积上课时间
       if (GlobalConfig.classTimestamp % GlobalConfig.updateClassInfoDelay == 0) {
       //如果是host身份，需要同步时间给其他人，同时把当前的状态上传到服务器
       if (this.checkHasRecordControl()) {
       //保存数据到Sass
       this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
       //同步消息给其他人
       this.sendUpdaterClassStatusInfo({"actionType": ApeConsts.CLASS_STATUS_STARTED, isStopAllPublishMedia: false});
       }
       }*/

      //进行MS动态选点，选择最快的MS服务器地址(录制回放不做处理)
      if (!GlobalConfig.isRecordPlayBack && GlobalConfig.classTimestamp % GlobalConfig.msDynamicChooseIpDelay == 0) {
        //MS推流选点
        this._emit(MessageTypes.SWITCH_MS_IP);
        //MS拉流选点
        this._emit(MessageTypes.SWITCH_RTMP_PULL_IP);
        //HLS拉流选点
        this._emit(MessageTypes.SWITCH_HLS_IP);
      }
    }

    //更新录制进行时间
    GlobalConfig.recordTimestamp = GlobalConfig.recordTimestamp + 1;
    if (this.checkHasRecordControl()) {

      if(GlobalConfig.classType==ApeConsts.CLASS_TYPE_ZHIBO&&GlobalConfig.isH5==true){
        return;
      }
      //以一定的时间间隔同步课堂内所有人的累积上课时间
      if (GlobalConfig.recordTimestamp % GlobalConfig.updateRecordTimeDelay == 0) {
        //保存数据到Sass
        this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
      }

      if (GlobalConfig.recordTimestamp % GlobalConfig.updateClassInfoDelay == 0) {
        //MCU同步消息给其他人
        this.sendUpdaterClassStatusInfo({"actionType": GlobalConfig.classStatus, isStopAllPublishMedia: false});
      }
    }
  }

  tableUpdateHandler(owner, itemIdx, itemData) {
    try {
      let model = this.unPackPdu(owner, itemIdx, itemData);
      //loger.log("课堂更新->",model.classStatusInfo);
      //{"itemIdx":720899,"from":976168842,"owner":976168842,"actionType":null,"classStatusInfo":{"nodeId":976168842,"userId":"user_979813","userName":"user_979813","siteId":"markettest","classId":889112694,"className":"ly828-1v1","classType":1,"classStatus":1,"classStartTime":"2017-8-28-16-33-18","classStopTime":"2017-8-29-11-9-28","classTimestamp":1930,"classBeginTime":"2017-08-28 16:00:00","classEndTime":"2017-08-31 18:00:00","recordStatus":false,"recordTimestamp":2825,"recordFileName":"markettest/20170828/889112694_20170828.rec","recordDownloadUrl":"","serverTimestamp":1503976246,"activeDocId":976170739,"activeDocCurPage":1,"isStopAllPublishMedia":false,"currentSceneTableId":0,"silence":false,"silenceUsers":"{}","isEnableDraw":true}}
      //处理课堂更新的信息
      if (model && model.classStatusInfo) {
        // loger.log("课堂更新->",model.classStatusInfo);
        try {
          model.classStatusInfo.silenceUsers = JSON.parse(model.classStatusInfo.silenceUsers);
        } catch (err) {

        }
        GlobalConfig.setClassStatusInfo(model.classStatusInfo);
        if (model.classStatusInfo.isStopAllPublishMedia) {
          //课堂状态发送改变 需要对当前正在推的流进行停止，因为录制的问题；
          this._emit(MessageTypes.STOP_ALL_MEDIA_PUBLISH);
        }
      }
      // loger.log('课堂数据更新->');
      //通知应用层更新课堂状态
      let classInfo = GlobalConfig.classStatusInfo;
      //loger.log('通知应用层更新课堂状态->CLASS_UPTATE_STATUS')
      this._emit(MessageTypes.CLASS_UPTATE_STATUS, classInfo);

      //如果MCU已经断开连接，停止计时器
      if (!this.mcu.connected) {
        //停止计时
        this.stopTimerCounter();
        return;
      }
    } catch (err) {
      loger.warn('课堂更新->error', err.message);
    }
  }

  conferMsgComingHandler(_data) {
    let chatReceivePdu = pdu['RCConferenceSendDataRequestPdu'].decode(_data);

    let chatMsg = {};
    chatMsg.fromNodeID = chatReceivePdu.initiator;
    chatMsg.toNodeID = chatReceivePdu.peer;
    chatMsg.message = this._rCArrayBufferUtil.uint8ArrayToStr(chatReceivePdu.userData, 2);
    chatMsg.actionType = chatReceivePdu.actionType;
    loger.log("课堂控制消息", chatMsg); //{"fromNodeID":418883112,"toNodeID":0,"message":"所有人退出课堂","actionType":1}
    switch (chatMsg.actionType) {
      case ApeConsts.CLASS_ACTION_CLOSE_ALL:
        loger.log(chatMsg.message);
        //关闭之前停止所有推流
        this._emit(MessageTypes.STOP_ALL_MEDIA_PUBLISH);
        //收到课堂关闭,所有人都退出，执行自己关闭的流程
        setTimeout(()=> {
          this._emit(MessageTypes.CLASS_RUN_EXIT, {'type': 1});
        }, 2000);
        break;
      case ApeConsts.STOP_ALL_PUBLISH:
        this._emit(MessageTypes.STOP_ALL_MEDIA_PUBLISH);
        break;
      case ApeConsts.CLASS_ACTION_KICK_OUT_ROSTER:
        if (chatMsg.toNodeID == GlobalConfig.nodeId) {
          //自己被踢出课堂
          this._emit(MessageTypes.CLASS_RUN_EXIT, {'type': 2});
        }
        break;
      case ApeConsts.CLASS_ACTION_HANDUP_STATUS_CHANGE:
        //console.log('chatMsg', chatMsg);
        let msgObj = null;
        try {
          msgObj = JSON.parse(chatMsg.message);
          if (msgObj && msgObj.nodeId == GlobalConfig.nodeId) {
            this.changeHandUpStatus(msgObj);
          }
        } catch (err) {
          loger.warn('CLASS_ACTION_HANDUP_STATUS_CHANGE->JSON数据解析失败');
        }
        break;
      case ApeConsts.CLASS_ACTION_DRAW_STATUS_CHANGE:
        let drawMsgObj = null;
        try {
          drawMsgObj = JSON.parse(chatMsg.message);
          if (drawMsgObj && drawMsgObj.nodeId == GlobalConfig.nodeId) {
            this.changeUserDrawStatus(drawMsgObj);
          }
        } catch (err) {
          loger.warn('CLASS_ACTION_DRAW_STATUS_CHANGE->JSON数据解析失败');
        }
        break;
      case ApeConsts.USER_ACTION_SILENCE_STATUS_CHANGE:
        let silenceMsg = null;
        try {
          silenceMsg = JSON.parse(chatMsg.message);
          if (silenceMsg && silenceMsg.nodeId == GlobalConfig.nodeId) {
            this.changeSilenceStatus(silenceMsg);
          }
        } catch (err) {
          loger.warn('USER_ACTION_SILENCE_STATUS_CHANGE->JSON数据解析失败');
        }
        break;
      case ApeConsts.MEDIA_ENABLED_CHANGE:
        let mediaMsgObj = null;
        try {
          mediaMsgObj = JSON.parse(chatMsg.message);
          //console.log("MEDIA_ENABLED_CHANGE",mediaMsgObj,chatMsg);
          if (mediaMsgObj) {
            this.receiveChangeUserMediaEnabledStatus(mediaMsgObj);
          }
        } catch (err) {
          loger.warn('MEDIA_ENABLED_CHANGE->JSON数据解析失败',chatMsg.message,err.message);
        }
        break;
      default:
        break;
    }
  }

  //-------------第三方消息------------------------------
  //收到父级页面的消息，需要广播发送出去
  onThirdReciveParentMessage(_msg) {
    loger.log('收到页面的消息->广播给其他模块->', _msg);
    //尝试将外部传入的数据转换为JSON 字符串
    let _message = _msg;
    try {
      _message = JSON.parse(_msg);
    } catch (err) {

    }
    this.sendThirdBroadcastData({to: 0, message: _message});
  }

  //发送第三方广播消息
  sendThirdBroadcastData(_param) {
    loger.log("发送第三方广播消息->", _param);
    if (this._classInfo == null || EngineUtils.isEmptyObject(this._classInfo)) {
      loger.log('发送第三方广播消息->失败->SDK还未初始化数据!');
      if (GlobalConfig.getCurrentStatus().code == 0 || GlobalConfig.getCurrentStatus().code == 1) {
        this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_SEND_FAILED_NO_JOIN);
        return;
      }
      return;
    }

    let thirdBroadcastSendPdu = new pdu['RCThirdSendBroadcastDataRequestPdu'];
    thirdBroadcastSendPdu.type = pdu.RCPDU_THIRD_BROADCAST_DATA_REQUEST;
    thirdBroadcastSendPdu.initiator = this._classInfo.nodeId; //发起人
    thirdBroadcastSendPdu.peer = parseInt(_param.to) || 0; //发送给谁,公聊的时候是0，私聊的时候是指定的用户id
    thirdBroadcastSendPdu.isPublic = true;
    let messageStr = _param.message || "";

    //尝试把信息转换为JSON 字符串，如果是字符串就不需要转
    try {
      messageStr = JSON.stringify(messageStr);
    } catch (err) {

    }
    thirdBroadcastSendPdu.message = this._rCArrayBufferUtil.strToUint8Array("h5" + messageStr);

    if (!thirdBroadcastSendPdu.isPublic && 0 != thirdBroadcastSendPdu.peer) {
      //发送给制定的人
      this.send(thirdBroadcastSendPdu);
    } else {
      //发送给所有人
      this.sendChatUniform(thirdBroadcastSendPdu);
    }
  }

  //监听第三方消息通道消息
  onThirdBroadcastDataHandler(_data) {
    //loger.log("监听第三方消息通道消息->",_data);
    let thirdBroadcastReceivePdu = pdu['RCThirdSendBroadcastDataRequestPdu'].decode(_data);
    let thirdMessage = {};
    thirdMessage.fromNodeID = thirdBroadcastReceivePdu.initiator;
    thirdMessage.toNodeID = thirdBroadcastReceivePdu.peer;
    //loger.log("监听第三方消息通道消息->1", thirdMessage);
    thirdMessage.message = this._rCArrayBufferUtil.uint8ArrayToStr(thirdBroadcastReceivePdu.message, 2);
    loger.log("收到第三方消息通道消息->", thirdMessage);
    this._emit(MessageTypes.RECEIVE_THIRD_MESSGAE, thirdMessage);
    if (this.thirdMessage) {
      this.thirdMessage.sendMessageToParent(thirdMessage.message);
    }
  }

  //------------------第三方消息 end-----------------------------------------

  //监听MCU录制状态消息
  onSendConferRecordRequestHandler(_data) {
    try {
      let conferRecordSendPdu = pdu['RCConferenceRecordRequestPdu'].decode(_data);
      //{"initiator":564398684,"record":true,"classTime":39,"filename":"markettest/20170823/1096250804_20170823.rec"}//开启成功
      //{"initiator":564398684,"record":false,"classTime":39,"filename":"markettest/20170823/1096250804_20170823.rec"} //停止成功
      if(this.recordStatus==conferRecordSendPdu.record){
        //已经开启过录制之后就不再处理
        return;
      }
      loger.warn("录制回放控制操作成功->", conferRecordSendPdu);
      this.recordStatus=conferRecordSendPdu.record;
      if (conferRecordSendPdu) {
        if (conferRecordSendPdu.record == true || conferRecordSendPdu.record == "true") {
          //每次开启录制的时候，需要把当前显示的文档数据更新一次，否则无法录制已经显示的文件
          loger.warn("MCU已经开启录制");
          this._emit(MessageTypes.CLASS_RECORD_SUCCESS);
        } else {
          //停止录制成功
          loger.warn("MCU已经停止录制");
        }
      }
    } catch (err) {
      loger.error("录制回放控制操作错误->", err.message);
    }
  }

  rosterInsertHandler(nodeId, nodeData) {
    if (GlobalConfig.nodeId == nodeId) {
      loger.log("人员进入课堂模块--->自己");
    } else {
      // loger.log("有人加入 rosterInsertHandler");
      this.rosterUpdateHandler(nodeId, nodeData);
    }
  }

  //更新人员列表数据
  rosterUpdateHandler(nodeId, nodeData) {
    nodeData.userRole = ApeConsts.userTypes[nodeData.role];
    //如果是自己的信息，不处理跳过
    if (nodeId == GlobalConfig.nodeId) {
      //loger.log("自己加入课堂的消息->",nodeId,"role-->", nodeData.role, ApeConsts.userTypes[nodeData.role]);
      //自己加入的时候，需要做一下判断操作，如果满足以下3个条件就要暂停课堂：
      // 1.当前课堂只有自己；2.自己的身份不是host;3当前的课堂状态为(CLASS_STATUS_STARTED= 1;//直播中)
      //this.rosterLen = Object.keys(this.rosters).length;
      //GlobalConfig.rosterNum = this.rosterLen;//记录当前的总人数
      /*  if (this.rosterLen <=1 && !GlobalConfig.isHost && GlobalConfig.classStatus == ApeConsts.CLASS_STATUS_STARTED) {
       loger.warn("当前课堂没有老师->暂停课堂");
       this.pauseClass({isForce: true});
       //this.stopRecord(true);
       }*/
      //处理用户信息
      this.unPackRosterInfo(nodeId, nodeData);
      return;
    }

    //新加入的人员不是自己
    //1.判断进入的用户身份，如果进入的人身份是host,助教，监课，并且和自己的身份冲突，自己会被踢掉
    //2.最后进入的人会踢掉之前进入的人，nodeId是按时间戳生成的，最后进入的人nodeId的值比之前进入的人大
    if (parseInt(nodeData.joinTimestamp) > GlobalConfig.joinTimestamp) {
      let newUserInfo = {
        userId: nodeData.userId,
        userName: nodeData.name,
        nodeId: nodeData.nodeId,
        userRole: nodeData.userRole,
        deviceType: nodeData.deviceType
      }
      if (nodeData.role == ApeConsts.NR_HOST && GlobalConfig.isHost) {
        loger.warn("相同身份的人进入->自己被踢出->进入的人员信息", "userName:" + nodeData.name, "userId:" + nodeData.userId, "userRole:" + nodeData.userRole, "nodeId:" + nodeData.nodeId, "deviceType:" + nodeData.deviceType,"joinTimestamp:"+nodeData.joinTimestamp);
        this.kickOutRoster(newUserInfo);
        return;
      } else if (nodeData.userId == GlobalConfig.userId && GlobalConfig.userId != "0") {
        loger.warn("异地登陆->自己被踢出->进入的人员信息", "userName:" + nodeData.name, "userId:" + nodeData.userId, "userRole:" + nodeData.userRole, "nodeId:" + nodeData.nodeId, "deviceType:" + nodeData.deviceType,"joinTimestamp:"+nodeData.joinTimestamp);
        this._emit(MessageTypes.MCU_ERROR, {type: MessageTypes.ERR_CLASS_REMOTE_LANDING, data: newUserInfo});
        this._emit(MessageTypes.CLASS_RUN_EXIT, {'type': 1});
      }
    }
    //处理用户信息
    this.unPackRosterInfo(nodeId, nodeData);
  }

  //处理用户信息
  unPackRosterInfo(nodeId, nodeData) {
    let rosterExists = this.rosters[nodeId];
    this.rosters[nodeId] = nodeData;
    GlobalConfig.rosters = this.rosters;
    let userDataObj = null;
    try {
      userDataObj = pdu['RCNodeInfoUserDataPdu'].decode(nodeData.userData);
    } catch (err) {
      loger.log("RCNodeInfoUserDataPdu decode err", err.message);
    }

    let newNodeData = nodeData;
    newNodeData.userData = userDataObj;
    //如果是监课，不告诉其他人
    if (nodeData.role == ApeConsts.NR_INVISIBLE && GlobalConfig.userRole != ApeConsts.invisible) {
      loger.log("监课进入或更新数据");
      return;
    }
    if (nodeData.role == ApeConsts.NR_ASSISTANT && GlobalConfig.userRole != ApeConsts.invisible && GlobalConfig.userRole != ApeConsts.assistant) {
      loger.log("助教进入或更新数据");
      return;
    }

    if (!rosterExists) {
      //this.rosterLen = Object.keys(this.rosters).length;
      //GlobalConfig.rosterNum = this.rosterLen;//记录当前的总人数
      //newNodeData.rosterLen = this.rosterLen;
      newNodeData.rosterLen=GlobalConfig.rosterNum
      if(GlobalConfig.classType!= ApeConsts.CLASS_TYPE_ZHIBO){
        loger.log("人员加入->", newNodeData);
      }

      if(!GlobalConfig.isH5){
        this._emit(MessageTypes.CLASS_INSERT_ROSTER, {"nodeId": nodeId, "nodeData": newNodeData});
        this.emitRosterChange();

        //更新webRtc模块的音视频禁用状态
        //{nodeId: uid, video: true, audio: false}
        //消息自己的不处理
        if(nodeId!=GlobalConfig.nodeId&&(newNodeData.openCamera>0||newNodeData.openMicrophones>0)){
          this.receiveChangeUserMediaEnabledStatus({nodeId:nodeId,video:newNodeData.videoEnabled,audio:newNodeData.audioEnabled});
        }

      }
    } else {
      //loger.log("更新人员列表数据,rosterExists已经存在",rosterExists);
      //this.rosterLen = Object.keys(this.rosters).length;
      //GlobalConfig.rosterNum = this.rosterLen;//记录当前的总人数
      newNodeData.rosterLen = GlobalConfig.rosterNum;
      if (nodeId != GlobalConfig.nodeId) {
        if(GlobalConfig.classType!= ApeConsts.CLASS_TYPE_ZHIBO){
          loger.log("人员更新信息->", newNodeData);
        }
      }
      if(!GlobalConfig.isH5){
        this._emit(MessageTypes.CLASS_UPDATE_ROSTER, {"nodeId": nodeId, "nodeData": newNodeData});

        //更新webRtc模块的音视频禁用状态
        //{nodeId: uid, video: true, audio: false}
        //消息自己的不处理
        if(nodeId!=GlobalConfig.nodeId){
          this.receiveChangeUserMediaEnabledStatus({nodeId:nodeId,video:newNodeData.videoEnabled,audio:newNodeData.audioEnabled});
        }
      }
    }
  }

  //踢出用户(_param是新进入的人的信息)
  kickOutRoster(_newUserInfo) {
    /*  {
     userId: nodeData.userId,
     userName: nodeData.name,
     nodeId:nodeData.nodeId,
     userRole:nodeData.userRole,
     deviceType: nodeData.deviceType
     }*/
    this._emit(MessageTypes.MCU_ERROR, {type: MessageTypes.ERR_CLASS_KICK_OUT, data: _newUserInfo});
    this._emit(MessageTypes.CLASS_RUN_EXIT, {'type': 1});
  }

  //视频模块发生更新，人员状态需要更新
  updaterRosterStatus(_param) {
    //loger.log("媒体模块发生更新，人员状态需要更新,fromNodeId->",_param);
    //如果视频消息中channel的占用人 fromNodeId在人员列表中不存在，需要释放这channel,因为这个有可能是之前没释放成功的
    if (_param && _param.status == ApeConsts.CHANNEL_STATUS_OPENING) {
      //如果推流的人员已经不存在,并且当前课堂内人员大于0；
      // 如果不判断当前的人数，会出现把正常的视频消息释放的情况；
      // 因为会出现先收到视频消息后收到人员加入和更新的消息
      if(this.rosters[_param.fromNodeId] == null&&GlobalConfig.rosterNum>0){
        //H5不做释放处理
        if(GlobalConfig.deviceType==GlobalConfig.deviceH5){
          loger.warn("H5不做媒体模块的频道释放->当前总人数->"+GlobalConfig.rosterNum, _param);
          return ;
        }
        loger.warn("媒体模块被占用->占有人已经不存在课堂中->释放->当前总人数->"+GlobalConfig.rosterNum, _param);
        this._emit(MessageTypes.CLASS_NONENTITY_ROSTER, {"nodeId": _param.fromNodeId});
      }
    }
  }

  /*
  * 设备状态更新
  * */
  updaterUserDeviecStatusChange(_data) {
    loger.log("音视频设备状态更新->", _data);
    this.updateUserInfo();
  }
  /*
   * 媒体开启或禁用
   * */
  sendMediaEnabledChange(_data){
    if(!_data){
      return;
    }

    try{
      loger.log("发送->媒体开启或禁用",_data);
      this.sendConferMsg({"to": 0, "message":JSON.stringify(_data), "actionType": ApeConsts.MEDIA_ENABLED_CHANGE});
    }catch (err){
      loger.warn("发送->媒体开启或禁用->失败",_data,err.message);
    }
  }

  /*
   * 同步用户的媒体禁用状态
   * */
  sendUpdateUserMediaMutedStatus(_data){
    if(!_data){
      return;
    }
    loger.log('发送同步用户的媒体禁用状态->', _data);
    GlobalConfig.videoEnabled =Boolean(_data.video);
    GlobalConfig.audioEnabled =Boolean(_data.audio);
    this.updateUserInfo();
  }
  /*
   * 收到媒体开启或禁用控制消息或同步消息
   * */
  receiveChangeUserMediaEnabledStatus(_data){
    this._emit(MessageTypes.RECEIVE_MEDIA_ENABLED_CHANGE,_data);
  }

  //删除用户
  rosterDelHandler(nodeId) {
    if (GlobalConfig.nodeId == nodeId) {
      if(GlobalConfig.classExit==false||this.isLeave==false){
        this.isLeave=true;
        loger.log("自己离开课堂","classExit:"+GlobalConfig.classExit);
        // 自己退出
        this._emit(MessageTypes.CLASS_RUN_EXIT, {'type': 0});
      }
      GlobalConfig.classExit=true;
      LogManager.IS_OPEN_SEND_LOG=false;
    } else {
      let user = this.rosters[nodeId];
      if (user) {
        if(GlobalConfig.classType!= ApeConsts.CLASS_TYPE_ZHIBO){
          loger.log(nodeId, "->离开课堂->身份->", user.userRole);
        }
      }
      delete this.rosters[nodeId];
      GlobalConfig.rosters = this.rosters;

      if(!GlobalConfig.isH5) {
        this.emitRosterChange();
        this._emit(MessageTypes.CLASS_DELETE_ROSTER, {"nodeId": nodeId, "rosterLen": GlobalConfig.rosterNum});

        //当前人员列表中抽一个人来检查离开人员是否占用频道
        for (let key in this.rosters) {
          let randNodeId = parseInt(key);
          //判断是否是自己就处理以下操作
          if (randNodeId == GlobalConfig.nodeId) {
            loger.log("检查离开的人员是否占用channel");
            this._emit(MessageTypes.CLASS_NONENTITY_ROSTER, {"nodeId": nodeId, "rosterLen": GlobalConfig.rosterNum});
            //如果离开的人员是老师，需要暂停当前的课堂
            if (user && user.role == ApeConsts.NR_HOST) {
              this.pauseClass();
            }
          }
          return;
        }
      }
    }
  }

  //广播当前的人数
  emitRosterChange() {
    //if(!GlobalConfig.isH5){
      this._emit(MessageTypes.CLASS_UPDATE_ROSTER_NUM,{rosterLen:GlobalConfig.rosterNum});
    //}
  }

  ///////数据的封包和解包/////////////////////////////////////////
  packPdu(_param, _itemIdx) {
    //loger.log("课堂===packPdu ");
    //验证坐标点集合数组是否合法
    if (_param == null || _itemIdx == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }
    let classStatusInfo = new pdu['RCClassStatusInfoPdu'];
    classStatusInfo.nodeId = GlobalConfig.nodeId; //mcu中的唯一ID
    classStatusInfo.userId = GlobalConfig.userId;
    classStatusInfo.userName = GlobalConfig.userName;
    classStatusInfo.siteId = GlobalConfig.siteId; //站点号
    classStatusInfo.classId = GlobalConfig.classId;
    classStatusInfo.className = GlobalConfig.className;
    classStatusInfo.classType = GlobalConfig.classType; //课堂类型
    classStatusInfo.classStatus = GlobalConfig.classStatus; //课堂的状态
    classStatusInfo.classStartTime = GlobalConfig.classStartTime; //课堂点击开始时间
    classStatusInfo.classStopTime = GlobalConfig.classStopTime; //最后一次停止的时间(点暂停或结束)，每次发送数据都获取当前时间戳
    classStatusInfo.classTimestamp = GlobalConfig.classTimestamp; //相对于点开始课堂的时间戳
    classStatusInfo.classBeginTime = GlobalConfig.classBeginTime; //课堂创建的时间,这个是Sass返回的
    classStatusInfo.classEndTime = GlobalConfig.classEndTime; //课堂结束的时间，这个是Sass返回的
    classStatusInfo.recordStatus = GlobalConfig.recordStatus; //当前录制状态
    classStatusInfo.recordTimestamp = GlobalConfig.recordTimestamp; //相对于首次开始录制的时间戳
    classStatusInfo.recordFileName = GlobalConfig.recordFileName; //录制的文件名
    classStatusInfo.recordDownloadUrl = GlobalConfig.recordDownloadUrl; //下载地址
    classStatusInfo.serverTimestamp = GlobalConfig.serverTimestamp; //当前的系统时间戳
    classStatusInfo.activeDocId = GlobalConfig.activeDocId; //当前激活的文档id
    classStatusInfo.activeDocCurPage = GlobalConfig.activeDocCurPage; //当前激活的文档的当前页
    classStatusInfo.isStopAllPublishMedia = Boolean(_param.isStopAllPublishMedia) || false;
    classStatusInfo.currentSceneTableId = GlobalConfig.currentSceneTableId;
    classStatusInfo.silence = GlobalConfig.silence;
    classStatusInfo.silenceUsers = JSON.stringify(GlobalConfig.silenceUsers);
    classStatusInfo.isEnableDraw = GlobalConfig.isEnableDraw;
    classStatusInfo.isEnableGift = GlobalConfig.isEnableGift;
    classStatusInfo.videoScale=GlobalConfig.videoScale||1;
    //loger.log("classStatusInfo--->", classStatusInfo);

    /*
     optional uint32 item_idx=1;
     optional uint32 from=2;
     optional uint32 owner=3;
     optional uint32 action_type=4;//状态改变的类型
     optional RCClassStatusInfoPdu class_status_info=5;//当前课堂状态的信息
     */
    //判断type类型，根据type设置不同的参数
    let modelPdu = new pdu['RCClassSendDataModelPdu'];
    modelPdu.itemIdx = _itemIdx;
    modelPdu.from = GlobalConfig.nodeId;
    modelPdu.owner = GlobalConfig.nodeId;
    //modelPdu.actionType  =_param.actionType;
    modelPdu.classStatusInfo = classStatusInfo;
    return modelPdu;
  }

  unPackPdu(owner, itemIdx, itemData) {
    //loger.log("课堂数据->unPackPdu ");
    if (owner == null || itemIdx == null || itemData == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }

    try {
      let modelPdu = pdu['RCClassSendDataModelPdu'].decode(itemData);
      return modelPdu;
    } catch (err) {
      loger.log("课堂收到数据解析错误:" + itemIdx + "  err:" + err.message);
    }
    return null;
  }

  stopApe() {
    this.rosters = {};
    GlobalConfig.rosterNum = 0;
    GlobalConfig.rosters = this.rosters;
    this.isLeave=true;
    this.isSendInsterRoster=false;
  }

}

export default ConferApe;