// //////////////////////////////////////////////////////////////////////////////
//
//  伴音共享模块
// //////////////////////////////////////////////////////////////////////////////

import Ape from './Ape';
import ApeConsts from './ApeConsts';
import pdu from 'pdus';
import Loger from 'Loger';
import MessageTypes from 'MessageTypes';
import GlobalConfig from 'GlobalConfig';
import EngineUtils from 'EngineUtils';

let loger = Loger.getLoger('MusicSharedApe');

class MusicSharedApe extends Ape {
  constructor() {
    super(
      ApeConsts.MUSIC_SESSION_ID,
      ApeConsts.MUSIC_SESSION_NAME,
      ApeConsts.MUSIC_SESSION_TAG
    );
    this.lastActiveData=null;
    this.musicSharedList = {}; //记录伴音数据

    // Ape Models
    this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer);
    this.registerObj(pdu.RCPDU_REG_REGISTER_TABLE, ApeConsts.MUSIC_OBJ_TABLE_ID, ApeConsts.MUSIC_OBJ_TABLE_NAME, ApeConsts.MUSIC_OBJ_TABLE_TAG, 0, new ArrayBuffer);
  }

  /////////////发送数据操作//////////////////////////////////////////////////////
  //上传伴音文件
  musicSharedUpload(paramInfo) {
    if (paramInfo == null || EngineUtils.isEmptyObject(paramInfo)) {
      loger.warn('上传伴音文件->失败->参数错误->', paramInfo);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }
    //判断伴音文件是否已经存在，每个伴音文件都有唯一的fileId,如果已经同步的伴音文件中存在相同的fileId就不需要再同步
    if (this.checkMusicSharedId(paramInfo.fileId)) {
      //伴音文件已经存在相同的fileId，不需要同步上传
      loger.warn('上传伴音文件->失败->伴音文件档的fileId无效或已经存在相同的fileId不需要上传');
      return;
    }

    let itemIdx = parseInt(EngineUtils.creatRandomNum(3));//生成唯一的标识 int32
    let pduDataModel = this.packPdu(paramInfo, itemIdx);
    if (pduDataModel == null) {
      loger.log('上传伴音文件->失败->数据无效');
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    let tableItemPdu = new pdu['RCRegistryTableItemPdu'];
    tableItemPdu.itemIdx = itemIdx; //直接用时间戳作为id
    tableItemPdu.registerObjId = ApeConsts.MUSIC_OBJ_TABLE_ID;
    tableItemPdu.owner = 0; //收到flash的是这个值，不清楚先写固定
    tableItemPdu.itemData = pduDataModel.toArrayBuffer();

    //insert
    let tableInsertItemPdu = new pdu['RCRegistryTableInsertItemPdu'];
    //optional RCPduType_E type = 1 [default = RCPDU_REG_TABLE_UPDATE_PDU];
    //repeated RCRegistryTableItemPdu items = 2;
    tableInsertItemPdu.type = pdu.RCPDU_REG_TABLE_INSERT_PDU; //
    tableInsertItemPdu.items.push(tableItemPdu);

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.MUSIC_OBJ_TABLE_ID;
    updateObjPdu.subType = tableInsertItemPdu.type;
    updateObjPdu.userData = tableInsertItemPdu.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("上传伴音文件->发送->itemIdx=" + tableItemPdu.itemIdx);
    this.sendUniform(adapterPdu, true);
  }

  //删除伴音文件
  musicSharedDelete(paramInfo) {
    let tableDeleteItemPdu = new pdu['RCRegistryTableDeleteItemPdu'];
    tableDeleteItemPdu.type = pdu.RCPDU_REG_TABLE_DELETE_PDU; //
    tableDeleteItemPdu.itemIdx = parseInt(paramInfo.itemIdx); //这里需要设置要删除的数据的itemIdx，每条数据的这个id都不一样

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.MUSIC_OBJ_TABLE_ID;
    updateObjPdu.subType = tableDeleteItemPdu.type;
    updateObjPdu.userData = tableDeleteItemPdu.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("MUSIC文件发送删除数据=============>" + tableDeleteItemPdu.itemIdx);
    this.sendUniform(adapterPdu, true);
  }

  //更新
  updaterMusicShared(_pduDataModel, _itemIdx) {
    //验证坐标点集合数组是否合法
    if (_pduDataModel == null || _itemIdx == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }
    //本地已经存储的数据
    let localDataItem=this.musicSharedList[_itemIdx];
    if(localDataItem){
      //把总时间取出来，外部更新的时候不传这个值
      _pduDataModel.duration=localDataItem.duration||0;
    }
   // loger.log("发送伴音文件->更新 ", _pduDataModel);

    let pduDataModel = this.packPdu(_pduDataModel, _itemIdx);
    let tableItemPdu = new pdu['RCRegistryTableItemPdu'];
    tableItemPdu.itemIdx = _itemIdx; //直接用时间戳作为id
    tableItemPdu.owner = 0; //收到flash的是这个值，不清楚先写固定
    tableItemPdu.itemData = pduDataModel.toArrayBuffer();

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

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.MUSIC_OBJ_TABLE_ID;
    updateObjPdu.subType = tableInsertItemPdu.type;
    updateObjPdu.userData = tableInsertItemPdu.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("发送更新伴音文件.itemIdx=" + tableItemPdu.itemIdx);
    this.sendUniform(adapterPdu, true);
  }

  //组织完整的伴音文件信息，包含上传时的信息和转换后的完整地址信息
  _musicSharedPackFullInfo(_itemDataInfo) {
    let itemDataInfo = _itemDataInfo;
    if (!itemDataInfo.seek) {
      itemDataInfo.seek = 1;
    }
    //loger.log('musicPackFullInfo->', itemDataInfo);
    return itemDataInfo;
  }

  //更新伴音文件模块的录制信息，每次开启录制的时候需要把当前伴音文件的信息更新一次
  updaterRecordApeStatus(_param) {
      loger.warn("录制状态发送改变->更新当前的伴音文件数据->fileId:", GlobalConfig.activeMusicId, 'page:', GlobalConfig.activeMusicSeek);
      this.musicSharedSeek({
        "itemIdx": GlobalConfig.activeMusicId,
        "seek": GlobalConfig.activeMusicSeek
      });
    }
    //清除当前伴音文件模块的数据
  clearData() {
    loger.log("clearData->")
    this.lastActiveData=null;
    this.musicSharedList = {};
    GlobalConfig.activeMusicId = 0;
    GlobalConfig.activeMusicSeek = 1;

  }

  //更新伴音文件（播放，暂停，停止，seek）
  musicSharedUpdate(_param) {
    if (_param == null || _param.itemIdx == null) {
      loger.warn('伴音文件更新失败->参数错误', _param);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    //获取已经存在的数据
    let pduDataModel = this.musicSharedList[_param.itemIdx];
    if (pduDataModel == null) {
      loger.warn('更新伴音文件->伴音文件不存在', _param);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    //更新当前选择的伴音文件数据的字段
    pduDataModel.status = parseInt(_param.status) || 0; //默认是0
    pduDataModel.seek = parseInt(_param.seek) || 1;
    pduDataModel.musicVolume = parseInt(_param.musicVolume) || 0;
    //更新当前选择的伴音文件
    this.updaterMusicShared(pduDataModel, pduDataModel.itemIdx);
  }

  //播放伴音文件
  musicSharedPlay(paramInfo) {
    loger.log('切换伴音文件->', paramInfo);
    if (GlobalConfig.isRecordPlayBack) {
      loger.warn('录制回放状态不允许切换伴音文件');
      return;
    }

    if (paramInfo == null || paramInfo.itemIdx == null) {
      loger.warn('切换伴音文件失败,参数错误', paramInfo);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    /* if (paramInfo.itemIdx == GlobalConfig.activeMusicId && GlobalConfig.activeMusicId != 0) {
         loger.warn('伴音文件已经显示', paramInfo.itemIdx, GlobalConfig.activeMusicId);
         return;
     }*/

    //更新切换之前的伴音文件的数据,要显示当前切换的伴音文件,上一个伴音文件需要隐藏
    let oldPduDataModel;
    if (GlobalConfig.activeMusicId != 0) {
      oldPduDataModel = this.musicSharedList[GlobalConfig.activeMusicId];
      if (oldPduDataModel) {
        oldPduDataModel.status = 0; //停止状态
        //oldPduDataModel.seek=0;
      }
    }

    //获取已经存在的数据
    let pduDataModel = this.musicSharedList[paramInfo.itemIdx];
    if (pduDataModel == null) {
      loger.warn('切换伴音文件失败,伴音文件不存在', paramInfo);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    //更新当前选择的伴音文件数据的字段
    pduDataModel.status = paramInfo.status || 0; //默认是0
    pduDataModel.seek = paramInfo.seek || 1;
    pduDataModel.musicVolume = parseInt(paramInfo.musicVolume) || 0;
    //loger.log('切换伴音文件，当前伴音文件和上一个显示的伴音文件都需要更新状态');
    loger.log({ "oldDoc": oldPduDataModel, "nowDoc": pduDataModel });
    //更新当前选择的伴音文件
    this.updaterMusicShared(pduDataModel, pduDataModel.itemIdx);

    //更新上一个伴音文件 隐藏
    if (oldPduDataModel && oldPduDataModel.itemIdx != pduDataModel.itemIdx) {
      this.updaterMusicShared(oldPduDataModel, oldPduDataModel.itemIdx);
    }
  }

  //停止伴音文件
  musicSharedStop(paramInfo) {
    loger.log('停止伴音文件->', paramInfo);
    if (GlobalConfig.isRecordPlayBack) {
      loger.warn('录制回放状态不允许停止伴音文件');
      return;
    }

    if (paramInfo == null || paramInfo.itemIdx == null) {
      loger.warn('停止伴音文件,参数错误', paramInfo);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    //获取已经存在的数据
    let pduDataModel = this.musicSharedList[paramInfo.itemIdx];
    if (pduDataModel == null) {
      loger.warn('停止伴音文件,伴音文件不存在', paramInfo);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    //更新当前选择的伴音文件数据的字段
    pduDataModel.status = 0; //默认是0
    pduDataModel.seek = 0;
    //pduDataModel.musicVolume = 60;
    //更新当前选择的伴音文件
    this.updaterMusicShared(pduDataModel, pduDataModel.itemIdx);
  }

  //暂停伴音文件
  musicSharedPause(paramInfo) {
    loger.log('暂停伴音文件->', paramInfo);
    if (GlobalConfig.isRecordPlayBack) {
      loger.warn('录制回放-》暂停伴音文件');
      return;
    }

    if (paramInfo == null || paramInfo.itemIdx == null) {
      loger.warn('暂停伴音文件,参数错误', paramInfo);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    //获取已经存在的数据
    let pduDataModel = this.musicSharedList[paramInfo.itemIdx];
    if (pduDataModel == null) {
      loger.warn('暂停伴音文件,伴音文件不存在', paramInfo);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }

    //更新当前选择的伴音文件数据的字段
    pduDataModel.status = 2; //默认是0
    //更新当前选择的伴音文件
    this.updaterMusicShared(pduDataModel, pduDataModel.itemIdx);
  }

  //伴音文件SEEK
  musicSharedSeek(paramInfo) {
    loger.log('伴音文件SEEK->', paramInfo);
    //获取已经存在的数据
    let pduDataModel = this.musicSharedList[paramInfo.itemIdx];
    if (pduDataModel == null) {
      loger.warn('伴音文件SEEK->伴音文件不存在', paramInfo);
      //this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return;
    }
    //更新数据的字段
    pduDataModel.seek = parseInt(paramInfo.seek) || 1;
    if (pduDataModel.seek < 1) {
      pduDataModel.seek = 1; //默认值最小是1
    }
    this.updaterMusicShared(pduDataModel, pduDataModel.itemIdx);
  }

  /////收到消息处理/////////////////////////////////////////////////////////////////////////////////
  tableInsertHandler(owner, itemIdx, itemData) {

  }

  //添加伴音文件
  tableInsertApeHandler(_tableUpdateItems, _seekTime) {
    let tableInsertItems = _tableUpdateItems;
    let tableInsertItemsLen = tableInsertItems.length;
    loger.log('添加伴音文件->_seekTime:' + _seekTime, "activeMusicId->", GlobalConfig.activeMusicId, "tableUpdateItemsLen->", tableInsertItemsLen);
    for (let i = 0; i < tableInsertItemsLen; ++i) {
      let insertItem = tableInsertItems[i];
      //this.tableInsertHandler(insertItem.owner, insertItem.itemIdx, insertItem.itemData);
      let itemDataInfo = this.unPackPdu(insertItem.owner, insertItem.itemIdx, insertItem.itemData);
      if (itemDataInfo) {
        itemDataInfo.seek = itemDataInfo.seek + parseInt(_seekTime); //seek是伴音文件自己的，_seekTime是录制回放时进度条换算的
        this.musicSharedList[insertItem.itemIdx] = itemDataInfo;
        if (itemDataInfo.status == 1) {
          GlobalConfig.activeMusicId = itemDataInfo.itemIdx; //当前激活的伴音文件ID
          GlobalConfig.activeMusicSeek = itemDataInfo.seek;
          loger.log('添加伴音文件->设置当前激活的伴音文件id');
        }
        let getMusicPackFullInfo = this._musicSharedPackFullInfo(itemDataInfo);
        this._emit(MessageTypes.MUSIC_SHARED_UPDATE, getMusicPackFullInfo);
      }
    }
    //伴音文件数据更新完毕，如果当前没有显示的伴音文件，默认选择一个显示
    this._showDefaultMeida();
  }
  tableDeleteHandler(object_id, tableDeleteData) {
    loger.log('删除伴音文件数据->', object_id, tableDeleteData); //["tableDeleteHandler",1179649,{"type":231,"itemIdx":[1486301768]}]
    if (tableDeleteData && tableDeleteData.itemIdx) {
      let len = tableDeleteData.itemIdx.length;
      let itemIdxs = tableDeleteData.itemIdx;
      for (let i = 0; i < len; i++) {
        if (this.musicSharedList[itemIdxs[i]]) {
          loger.log("删除伴音文件数据:", itemIdxs[i]);
          let itemDataInfo = this.musicSharedList[itemIdxs[i]];
          if (itemDataInfo && itemDataInfo.status == 1) {
            GlobalConfig.activeMusicId = 0; //当前激活的伴音文件ID
            GlobalConfig.activeMusicSeek = 1; //当前激活的伴音文件的当前页
            loger.log('删除伴音文件数据->清除当前显示的伴音文件');
          }
          this._emit(MessageTypes.MUSIC_SHARED_DELETE, { "itemIdx": itemIdxs[i] });
          delete this.musicSharedList[itemIdxs[i]];
        }
      }
    }
  }

  tableUpdateHandler(owner, itemIdx, itemData) {

  }

  tableUpdateApeHandler(_tableUpdateItems, _seekTime) {
    let tableUpdateItemsLen = _tableUpdateItems.length;
    loger.log('更新伴音文件->_seekTime:' + _seekTime, "activeDocId->", GlobalConfig.activeMusicId, "更新的数量->", tableUpdateItemsLen);
    for (let i = 0; i < tableUpdateItemsLen; ++i) {
      let tableItem = _tableUpdateItems[i];
      let itemDataInfo = this.unPackPdu(tableItem.owner, tableItem.itemIdx, tableItem.itemData);
      if (itemDataInfo != null) {
        itemDataInfo.seek = itemDataInfo.seek + parseInt(_seekTime);
        this.musicSharedList[tableItem.itemIdx] = itemDataInfo;
        if (itemDataInfo && itemDataInfo.status == 1) {
          GlobalConfig.activeMusicId = itemDataInfo.itemIdx; //当前激活的伴音文件ID
          GlobalConfig.activeMusicSeek = itemDataInfo.seek;
          //loger.log('更新伴音文件->设置当前激活的伴音文件id->', GlobalConfig.activeMusicId, "curPageNum->", GlobalConfig.activeMusicSeek);
        }
        let getMusicPackFullInfo = this._musicSharedPackFullInfo(itemDataInfo);

      /* if(this.lastActiveData&&this.lastActiveData.status==1){
          if(getMusicPackFullInfo&&
            getMusicPackFullInfo.status==1&&
            getMusicPackFullInfo.musicVolume==this.lastActiveData.musicVolume){

            let timeDistance=Math.abs(new Date().getTime()-parseInt(this.lastActiveData.time))/1000;
            let seek2seek=Math.abs(getMusicPackFullInfo.seek-this.lastActiveData.seek)
            let seekDistance=seek2seek-timeDistance;
            seekDistance=parseInt(Math.abs(seekDistance));
            loger.warn("timeDistance:"+timeDistance+"   seek2seek:"+seek2seek+"   seekDistance:"+seekDistance);

            if(seekDistance<=5){
              //记录最后一次的数据
              loger.warn("伴音更新数据->数据只有SEEK发生改变，低于5秒不需要再更新->");
              //记录最后一次激活的数据
              this.lastActiveData=getMusicPackFullInfo;
              this.lastActiveData.time=new Date().getTime();
              return;
            }
          }
        }*/

        this._emit(MessageTypes.MUSIC_SHARED_UPDATE, getMusicPackFullInfo);

     /*   if(getMusicPackFullInfo.status==1){
          this.lastActiveData=getMusicPackFullInfo;
          this.lastActiveData.time=new Date().getTime();
        }else{
          //如果状态发生改变就清除最后一次的记录
          if( this.lastActiveData&& this.lastActiveData.itemIdx==getMusicPackFullInfo.itemIdx){
            this.lastActiveData=null;
          }
        }*/
      } else {
        loger.log('更新伴音文件-> 数据无效--> itemIdx', itemIdx);
      }
    }
    this._showDefaultMeida();
  }

  //果当前没有显示的伴音文件，默认选择一个显示伴音文件
  _showDefaultMeida() {
    //显示默认伴音文件条件->1.非录制回放状态下 2.只有host有权限操作 3.当前激活的伴音文件id不为0
    if (GlobalConfig.isRecordPlayBack || !GlobalConfig.isHost || GlobalConfig.activeMusicId > 0) {
      return;
    }
    /*
    let tempDocItemIdx;//临时记录伴音文件数据，用于显示默认伴音文件
    for (let key in this.musicSharedList) {
        tempDocItemIdx= this.musicSharedList[key];
        if (tempDocItemIdx) {
            loger.log("选择一个伴音文件作为默认伴音文件显示->", tempDocItemIdx);
            let paramInfo = {
                "itemIdx": tempDocItemIdx.itemIdx,
                "status": 1
            };
            this.musicSharedPlay(paramInfo);
            //选择完成就跳出循环
          return;
        }
    }*/
  }

  onJoinChannelHandlerSuccess() {
    //loger.log(this._session_name + ' 伴音模块共享加入频道成功');
    if (this._apeDelayed) {
      setTimeout(() => {
        this._emit(MusicSharedApe.MUSICSHARED_JOIN_CHANNEL_SUCCESS);
      }, (GlobalConfig.mcuDelay + GlobalConfig.docDelay) || 12000 + GlobalConfig.docDelay);
    } else {
      setTimeout(() => {
        this._emit(MusicSharedApe.MUSICSHARED_JOIN_CHANNEL_SUCCESS);
      }, GlobalConfig.docDelay);
    }
  }

  //检查伴音文件是否已经存在，如果存在 返回true,否则返回false
  checkMusicSharedId(_fileId) {
    if (_fileId == null) {
      loger.warn('查找伴音伴音文件->失败->参数为null');
      return true;
    }
    //遍历查找
    for (let key in this.musicSharedList) {
      let item = this.musicSharedList[key];
      if (item && item.fileId == _fileId) {
        //loger.log('查找伴音伴音文件->已经存在->', _fileId);
        return true;
      }
    }
    loger.log('查找伴音文件->没有查找到伴音文件->', _fileId);
    //储存的数据中没有查找到
    return false;
  }

  ///////数据的封包和解包/////////////////////////////////////////
  packPdu(_param, _itemIdx) {
    //loger.log("伴音伴音文件->packPdu");
    //验证坐标点集合数组是否合法
    if (_param == null || _itemIdx == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }
    /* optional uint32 item_idx=1;//唯一标识
     optional uint32 owner=2;
     optional uint32 from=3;
     optional string file_type=4;
     optional string creat_user_id=5;//创建文件userid
     optional string url  =6;//文件地址
     optional uint32 status=7;//状态0停止  1播放 2暂停
     optional string fileId=8;//文件在服务器数据库中的唯一id
     optional string file_name=9;//文件的名字
     optional uint32 seek=10;//seek*/

    //判断type类型，根据type设置不同的参数
    let pduDataModel = new pdu['RCMusicSharedSendDataModelPdu'];
    pduDataModel.itemIdx = _itemIdx;
    pduDataModel.owner = GlobalConfig.nodeId;
    pduDataModel.from = GlobalConfig.nodeId;
    pduDataModel.fileType = _param.fileType || "";
    pduDataModel.creatUserId = _param.creatUserId || "0";
    pduDataModel.url = _param.url || "";
    pduDataModel.status = _param.status || 0;
    pduDataModel.fileId = _param.fileId || ""; //伴音文件在服务器数据库中的唯一id,必须有
    pduDataModel.fileName = _param.fileName || "music_" + _itemIdx; //伴音文件的名字
    pduDataModel.seek = parseInt(_param.seek) || 1;
    pduDataModel.musicVolume = parseInt(_param.musicVolume)||0;
    pduDataModel.duration=parseInt(_param.duration)||0
    return pduDataModel;
  }

  unPackPdu(owner, itemIdx, itemData) {
    if (owner == null || itemIdx == null || itemData == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }
    try {
      let pduDataModel = pdu['RCMusicSharedSendDataModelPdu'].decode(itemData);
     // loger.log("伴音文件===>unPackPdu");
      if(pduDataModel.url&&pduDataModel.url.indexOf("/DocSharing/")<0){
        loger.log("替换文件路径地址",pduDataModel.url);
        pduDataModel.url=pduDataModel.url.replace("/data/","/DocSharing/data/");
      }
      return pduDataModel;
    } catch (err) {
      loger.log("伴音文件===>unPackPdu->Pdu解析错误->itemIdx=" + itemIdx + "->err:" + err.message);
    }
    return null;
  }

}
MusicSharedApe.prototype.MUSICSHARED_JOIN_CHANNEL_SUCCESS = MusicSharedApe.MUSICSHARED_JOIN_CHANNEL_SUCCESS = 'musicShared_join_channel_success';
export default MusicSharedApe;