// //////////////////////////////////////////////////////////////////////////////
//会议控制APE
// //////////////////////////////////////////////////////////////////////////////

import Ape from './Ape';
import ApeConsts from './ApeConsts';
import MessageTypes from 'MessageTypes';
import pdu from 'pdus';
import { Zlib } from 'zlibjs/bin/zlib.min';
import UTF8 from 'utf-8';
import Loger from 'Loger';
import GlobalConfig from 'GlobalConfig';
import EngineUtils from 'EngineUtils';


let loger = Loger.getLoger('ConferApe');
let itemIdx=0;//table插入新数据的计数id,目前用时间戳
let timerCounter;

//const ACTION_TYPE_0=0;
//const ACTION_TYPE_1=1;
//const ACTION_TYPE_2=2;
//const ACTION_TYPE_3=3;
//const ACTION_TYPE_4=4;
class ConferApe extends Ape {
  constructor() {
    super(
      ApeConsts.CONFERENCE_SESSION_ID,
      ApeConsts.CONFERENCE_SESSION_NAME,
      ApeConsts.CONFERENCE_SESSION_TAG
    );

    // Attribures
    this.hostNodeId = -1;//主持人的nodeId
                          //    用户的身份，5种类型:
                          //    host（主持人/老师）
                          //    presenter(主讲人)
                          //    assistant(助教)
                          //    normal(普通角色/学生)
                          //    record（暂时没用.
                          //    默认值: normal
    this.hostUserId = '';//主持人的 第三方userId
    this.rosters = {};//用户列表

    // 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_CONFERENCE_SEND_DATA_REQUEST, this.conferMsgComingHandler.bind(this));//这个是会议消息类型，flash里在使用这里不再使用，各个模块的消息由模块自己来处理
  }


  //加入会议
  _joinSessionHandler(_data) {
    let nodeInfoRecordPdu = this.mcu.mcuClassInfo.self;
    loger.log("_joinSessionHandler nodeInfoRecordPdu=",nodeInfoRecordPdu);
    let userDataPdu = new pdu['RCNodeInfoUserDataPdu'];
    userDataPdu.qq = '';
    userDataPdu.skype = '';
    userDataPdu.mobile = '';

    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 ;
    }

    // to, message
    loger.log('发送会议消息.', _messageInfo);

/*    message RCConferenceSendDataRequestPdu {
      optional uint32 initiator = 1;
      optional uint32 peer = 2;
      required bool is_public = 3;
      required bytes user_data = 4;
    }
    */

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

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

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

    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.classStatus=ApeConsts.CLASS_STATUS_WAIT;
    GlobalConfig.classStopTime=EngineUtils.creatTimestampStr();
    this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
    this.sendUpdaterClassStatusInfo({"actionType":0});
  }

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

    if(GlobalConfig.classStatus==ApeConsts.CLASS_STATUS_WAIT){
      GlobalConfig.classStartTime=timestamp;
    }

    GlobalConfig.classStatus=ApeConsts.CLASS_STATUS_STARTED;
    //_param.actionType=ACTION_TYPE_1;
    this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
    this.sendUpdaterClassStatusInfo({"actionType":1});
  }
  //暂停上课
  pauseClass(_param){
    if(GlobalConfig.classStatus==ApeConsts.CLASS_STATUS_WAIT){
      loger.warn('还没有开始,不能点暂停');
      return;
    }

    GlobalConfig.classStatus=ApeConsts.CLASS_STATUS_PAUSE;
    GlobalConfig.classStopTime=EngineUtils.creatTimestampStr();
    //_param.actionType=ACTION_TYPE_2;
    this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
    this.sendUpdaterClassStatusInfo({"actionType":2});
  }
  //关闭课堂
  closeClass(_param){
    if(GlobalConfig.classStatus==ApeConsts.CLASS_STATUS_WAIT){
      loger.warn('还没有开始,不能点关闭');
      return;
    }

    //把所有人都踢出课堂
    this.sendConferMsg({"to":0,"message":"所有人退出会议","actionType":ApeConsts.CLASS_ACTION_CLOSE_ALL});
  }


  //更新会议信息
  sendUpdaterClassStatusInfo(_param){
    loger.log('sendUpdaterClassStatusInfo---1-------');
    if(_param==null||EngineUtils.isEmptyObject(_param)){
      loger.log('sendUpdaterClassStatusInfo,参数错误');
      this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return ;
    }
    itemIdx=ApeConsts.CONFERENCE_OBJ_TABLE_ID;// itemIdx=_param.itemIdx;
    let modelPdu = this.packPdu(_param,itemIdx);
    loger.log('sendUpdaterClassStatusInfo----2------');
    console.log(modelPdu);

    if(modelPdu==null){
      loger.log('sendUpdaterClassStatusInfo,参数错误');
      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);

    console.log("会议发送更新数据============");
    this.sendUniform(adapterPdu,true);
  }

 /* //更新会议状态
  sendUpdaterClassStatus(_param){
    loger.log('sendUpdaterClassStatus----------');
    if(_param==null||EngineUtils.isEmptyObject(_param)){
      loger.log('sendUpdaterClassStatusInfo,参数错误');
      this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return ;
    }
    itemIdx=_param.itemIdx;
    let modelPdu = this.packPdu(_param,itemIdx);
    console.log(modelPdu);

    if(modelPdu==null){
      loger.log('sendUpdaterClassStatusInfo,参数错误');
      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);

    console.log("会议发送更新数据111============");
    this.sendUniform(adapterPdu,true);
  }*/


  /////收到消息处理/////////////////////////////////////////////////////////////////////////////////
  onJoinChannelHandlerSuccess(){
    loger.log('ConferApe onJoinChannelHandlerSuccess');
    //if(GlobalConfig.isHost){
    //  if(GlobalConfig.classStatus==ApeConsts.CLASS_STATUS_WAIT){
    //    GlobalConfig.classStartTime=EngineUtils.creatTimestampStr();
    //    GlobalConfig.classStopTime=GlobalConfig.classStartTime;
    //  }else{
    //    GlobalConfig.classStopTime=GlobalConfig.creatTimestampStr;
    //  }
    //
    //  GlobalConfig.classStatus=ApeConsts.CLASS_STATUS_STARTED;
    //  //_param.actionType=ACTION_TYPE_1;
    //  this._emit(MessageTypes.CLASS_STATUS_INFO_CHANGE);
    //  this.sendUpdaterClassStatusInfo(_param);
    //}
  }

  tableUpdateHandler(owner, itemIdx, itemData) {
    try {
      let model=this.unPackPdu(owner, itemIdx,itemData);
      loger.log('tableUpdateHandler',model);

      //处理会议更新的信息
      if(model&&model.classStatusInfo){
        GlobalConfig.setClassStatusInfo(model.classStatusInfo);
      }

      switch(GlobalConfig.classStatus){
        case ApeConsts.CLASS_STATUS_WAIT:
              break;
        case ApeConsts.CLASS_STATUS_STARTED:
          break;
        case ApeConsts.CLASS_STATUS_PAUSE:
          break;
        case ApeConsts.CLASS_STATUS_CLOSE:
          break;
        default:
              break;

      }
      //_confer_ape.on(MessageTypes.CLASS_CLOSE, this._doClassClose.bind(this));//会议关闭,所有人都退出
      /*{
        "itemIdx": 720899,
          "from": 161770995,
          "owner": 161770995,
          "actionType": null,
          "classStatusInfo": {
        "nodeId": 161770995,
            "userId": "0",
            "userName": "mcuTest1487161768",
            "siteId": "h5test",
            "classId": 1730033559,
            "className": "mcuClient",
            "classType": 1,
            "classStatus": 0,
            "classStartTime": "2017-2-15-20-30-11",
            "classStopTime": "2017-2-15-20-30-28",
            "classTimestamp": 0,
            "classBeginTime": "2017-02-13 10:00:00",
            "classEndTime": "2017-02-22 12:00:00",
            "recordStatus": false,
            "recordTimestamp": 0,
            "recordFileName": "",
            "recordDownloadUrl": "xxxxxxxxxxxxxxxxxxxxx",
            "serverTimestamp": 161828290,
            "activeDocId": 0,
            "activeDocCurPage": 1
      }
      }*/

    } catch (e) {
      loger.warn('ConferApe table update got exception.   itemIdx',itemIdx);
    }
  }


  conferMsgComingHandler(_data) {
   //flash    RCConferenceSendDataRequestPdu
   //loger.warn('conferMsgComingHandler needs to be handled.');
   //const recordInfo = pdu['RCWhiteboardDataRequestPdu'].decode(pdu);
   //loger.log("conferMsgComingHandler",recordInfo);

    var chatReceivePdu = pdu['RCConferenceSendDataRequestPdu'].decode(_data);

    var chatMsg = {};
    chatMsg.fromNodeID = chatReceivePdu.initiator;
    chatMsg.toNodeID = chatReceivePdu.peer;
    chatMsg.message = this._rCArrayBufferUtil.uint8ArrayToStr(chatReceivePdu.userData, 2);
    chatMsg.actionType=chatReceivePdu.actionType;
   loger.log("conferMsgComingHandler",chatMsg);
    switch (chatMsg.ctionType){
      case ApeConsts.CLASS_ACTION_CLOSE_ALL:
        loger.log(chatMsg.message);
        //会议关闭,所有人都退出
        this._emit(MessageTypes.CLASS_CLOSE);
        break;
      default:
            break;
    }
   }

  rosterInsertHandler(nodeId, nodeData) {
    if(GlobalConfig.nodeId==nodeId){
      loger.log("自己加入 rosterInsertHandler");
    }else {
      loger.log("有人加入 rosterInsertHandler");
      this.rosterUpdateHandler(nodeId, nodeData);
    }
  }

  //更新人员列表数据
  rosterUpdateHandler(nodeId, nodeData) {
    if (nodeData.role === ApeConsts.NR_MASTER ||
      nodeData.role === ApeConsts.NR_SLAVE) {
      this.hostNodeId = nodeData.nodeId;
      this.hostUserId = nodeData.userId;
    }
    if (nodeData.role === ApeConsts.NR_NORMAL &&
      this.hostNodeId === nodeData.nodeId) {
      this.hostNodeId = -1;
      this.hostUserId = '';
    }
    let rosterExists = this.rosters[nodeId];
    this.rosters[nodeId] = nodeData;
    if (!rosterExists) {
      let userDataObj=pdu['RCNodeInfoUserDataPdu'].decode(nodeData.userData);
      let newNodeData=nodeData;
      newNodeData.userData=userDataObj;
      loger.log("更新人员列表数据 rosterUpdateHandler",{"nodeId":nodeId});
      this._emit(MessageTypes.CLASS_INSERT_ROSTER, {"nodeId":nodeId,"nodeData":newNodeData});
      this.emitRosterChange();
    }else {
      //loger.log("更新人员列表数据,rosterExists已经存在",rosterExists);
    }
  }

  //删除用户
  rosterDelHandler(nodeId) {
    if(GlobalConfig.nodeId==nodeId){
      loger.log("自己离开 rosterDelHandler");
      // 自己退出
      this._emit(MessageTypes.CLASS_EXIT);
    }else {
      loger.log("有人离开 rosterDelHandler");
      delete this.rosters[nodeId];
      this._emit(MessageTypes.CLASS_DELETE_ROSTER, {"nodeId":nodeId});
      this.emitRosterChange();
    }
  }

  //广播当前的人数
  emitRosterChange() {
    this._emit(MessageTypes.CLASS_SHOW_ROSTER_NUM, Object.keys(this.rosters).length);
  }

  ///////数据的封包和解包/////////////////////////////////////////
  packPdu(_param,_itemIdx){
    loger.log("会议===packPdu ");
    //验证坐标点集合数组是否合法
    if(_param==null||_itemIdx==null){
      this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }

    /*    message RCClassStatusInfoPdu {
     optional uint32 node_id=1;//mcu中的唯一ID
     optional uint32 user_id=2;
     optional uint32 user_name=3;
     optional uint32 site_id=4;//站点号
     optional uint32 class_id=5;
     optional uint32 class_name=6;
     required uint32 class_type=7;//课堂类型
     required uint32 class_status=9;//课堂的状态
     optional uint32 class_startTime=10;//课堂点击开始时间
     optional uint32 class_stopTime=11;//最后一次停止的时间(点暂停或结束)，每次发送数据都获取当前时间戳
     optional uint32 class_timestamp=12;//相对于点开始课堂的时间戳
     optional uint32 class_beginTime=13;//课堂创建的时间,这个是Sass返回的
     optional uint32 class_endTime=14;//课堂结束的时间，这个是Sass返回的
     optional uint32 record_status=15;//当前录制状态
     optional uint32 record_timestamp=16;//相对于首次开始录制的时间戳
     optional uint32 record_fileName=17;//录制的文件名
     optional uint32 record_downloadUrl=18;//下载地址
     optional uint32 server_timestamp=19;//当前的系统时间戳
     }*/

    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;//当前激活的文档的当前页

    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("会议收到数据 unPackPdu Pdu解析错误，itemIdx="+itemIdx+"  err:"+err.message);
    }
    return null;
  }


}

export default ConferApe;