import ByteBuffer  from 'libs/bytebuffer.min';
import Emiter from 'Emiter';
import MessageTypes from 'MessageTypes';
import Loger from 'Loger';

import pdu from 'pdus/index';
import PduType from 'pdus/PduType';
import PduConsts from 'pdus/PduConsts';
import ApeConsts from 'apes/ApeConsts';
import MediaModule from "apes/MediaModule";

import ArrayBufferUtil from 'libs/ArrayBufferUtil';
import Base64 from 'base64-js';
import GlobalConfig from 'GlobalConfig';
import EngineUtils from 'EngineUtils';
import TimerCounter from "TimerCounter";
import RecordInfoMatch from "RecordInfoMatch";

let parseBuffer;
// 日志对象
const loger = Loger.getLoger('RecordPlayBackParse');
const Default = 0;//未开始
const PLAY = 1;//播放中
const PAUSE = 2;//暂停
const SEEK = 3;//seek
const STOP = 4;//停止

class RecordPlayBackParse extends Emiter {
  constructor() {
    super();
    //loger.log("RecordPlayBackParse");
    parseBuffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
    parseBuffer.clear();
    this._recordPlaybackTimestamp = 0;//回放的时间
    this._recordPlaybackMaxTime = 0;//录制回放的总时间
    this._isReady = false;//录制回放是否已经准备完成
    this.isLoadTxRecordInfo = false;//是否已经加载TXY的录制数据
    this.isLoadAgoRecordInfo = false;//是否已经加载AGO的录制数据
    this.isgetRecordFileURLFromAgo = false;//是否已经加载AGO的录制文件地址数据

    this._apes = {};
    this.videoPublishMessages=[];//记录推流控制的消息
    this._videoApeBroadcastMssages = {};//视频模块的广播消息
    this.mediaChannleList = {};
    this._conferApeMssages = {};//会议数据
    this._chatApeMssages = {};//聊天数据
    this._videoApeMssages = {};//视频数据
    this._audioApeMssages = {};//音频数据
    this._docApeMssages = {};//文档数据
    this._whiteApeMssages = {};//白板数据
    this._mediaShareApeMssages = {};//媒体共享
    this._musicShareApeMssages = {};//伴音媒体共享
    this._timerCounter = new TimerCounter();//计时器
    this._timerCounter.addTimerCallBack(this._timerCounterUptate.bind(this), 1);

    this.agoTiemstampMessages = {};//ago推流时间戳消息数据集合
    this.agoAllMedias = {};//ago录制的文件集合

    this.allStreams = {};//记录课堂内所有的流id
    this.recordInfoMatch = RecordInfoMatch;
    this.recordInfoMatch.on(RecordInfoMatch.RECORD_INFO_MATCH_COMPLETE, this.onRecordInfoMatchComplete.bind(this));
  }

  //method--------------------内部---------------------------------------------
  // 注册Ape
  registerApe(ape) {
    this._apes[ape._session_id] = ape;
  }

  initReplay() {
    this._stopTimerCounter();
    this._recordPlaybackTimestamp = 0;//回放的时间
    this._recordPlaybackMaxTime = 0;//录制回放的总时间
    this._isReady = false;//录制回放是否已经准备完成

    this._conferApeMssages = {};//会议数据
    this._chatApeMssages = {};//聊天数据
    this._videoApeMssages = {};//视频数据
    this._audioApeMssages = {};//音频数据
    this.mediaChannleList = {};
    this._docApeMssages = {};//文档数据
    this._whiteApeMssages = {};//白板数据
  }

  //发送数据个各个APE模块处理,data是数据，seekTime是当前数据需要seek的时间长度（针对音视频的seek）
  _everSocketMsgReceivedHandler(data, seekTime) {
    let pduMsg = pdu.decode_pdu(data);
    let pduType = pduMsg.get("type");
    let pduData = pduMsg.get("data");

    //*************非常重要******************
    //客户端发送的所有125消息，MCU收到之后会痛120把消息返回给客户端，
    //所以需要把125消息type转换为120，因为MCU在录制的时候是直接录制客户端发送的消息而不是MCU转换之后的
    if (pduType == PduType.RCPDU_UNIFORM_SEND_DATA_REQUEST) {
      pduMsg.type = PduType.RCPDU_SEND_DATA_REQUEST;
      pduType = PduType.RCPDU_SEND_DATA_REQUEST;
    }
    loger.log('_everSocketMsgReceivedHandler->pduType', pduType, "seekTime->", seekTime);
    switch (pduType) {
      case PduType.RCPDU_CONNECT_PROVIDER_RESPONSE:
        //加入课堂请求返回数据处理
        let joinConfPdu = pdu['RCConferenceJoinResponsePdu'].decode(pduData);
        let pduResultCode = joinConfPdu.result;
        loger.warn('RCPDU_CONNECT_PROVIDER_RESPONSE  ->pduResultCode:' + pduResultCode);
        switch (pduResultCode) {
          case PduConsts.RET_SUCCESS:
            //加入成功
            //this._updateMCUConfInfoDescription(joinConfPdu.classDescription);
            this._emit(MessageTypes.CLASS_JOIN_MCU_SUCCESS, this.classInfo);
            break;
          case PduConsts.RET_FULL_CAPACITY:
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_FULL);
            break;
          default:
            loger.warn('JoinConfPdu-未知类型-等待处理.', pduResultCode);
            break
        }
        break;
      case PduType.RCPDU_SEND_DATA_REQUEST:
        //先判断当前消息属于哪个APE 根据 sessionId来判断
        let ape = this._apes[pduMsg.sessionId];
        let sessionLabel = ApeConsts(pduMsg.sessionId);
        //对方发送消息
        if (ape) {
          let subTypeLabel = pdu.id2type(pduMsg.subType);
          //loger.log('MCU-SecondLayer封装消息', 'sessionId', sessionLabel, pduMsg.sessionId, 'subtype', subTypeLabel, pduMsg.subType);
          //ape广播事件，只要ape中监听就能收到
          ape._emit(pduMsg.subType, pduMsg.data, seekTime);//seekTime是音视频模块seek的时间长度
        } else {
          loger.warn(sessionLabel + '尚未注册');
        }
        break;
      default:
        loger.warn('PDU-未知类型-等待处理.', pduType);
    }
  }

  //解析和储存，录制回放EverSocket底层消息处理  data-数据；timestamp-数据对应的时间戳
  _parseSaveSocketMsgReceivedHandler(data, timestamp) {
    let pduMsg = pdu.decode_pdu(data);
    let pduType = pduMsg.get("type");
    let pduData = pduMsg.get("data");

    //*************非常重要******************
    //客户端发送的所有125消息，MCU收到之后会痛120把消息返回给客户端，
    //所以需要把125消息type转换为120，因为MCU在录制的时候是直接录制客户端发送的消息而不是MCU转换之后的
    if (pduType == PduType.RCPDU_UNIFORM_SEND_DATA_REQUEST) {
      pduMsg.type = PduType.RCPDU_SEND_DATA_REQUEST;
      pduType = PduType.RCPDU_SEND_DATA_REQUEST;
    }
    //loger.log('解析和储存->pduType', pduType);
    switch (pduType) {
      case PduType.RCPDU_CONNECT_PROVIDER_RESPONSE:
        //加入课堂请求返回数据处理
        let joinConfPdu = pdu['RCConferenceJoinResponsePdu'].decode(pduData);
        let pduResultCode = joinConfPdu.result;
        //loger.warn('RCPDU_CONNECT_PROVIDER_RESPONSE  ->pduResultCode:' + pduResultCode);
        switch (pduResultCode) {
          case PduConsts.RET_SUCCESS:
            //加入成功
            //this._updateMCUConfInfoDescription(joinConfPdu.classDescription);
            this._emit(MessageTypes.CLASS_JOIN_MCU_SUCCESS, this.classInfo);
            break;
          case PduConsts.RET_FULL_CAPACITY:
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_FULL);
            break;
          default:
            loger.warn('JoinConfPdu-未知类型-等待处理.', pduResultCode);
            break
        }
        break;
      case PduType.RCPDU_SEND_DATA_REQUEST:
        //先判断当前消息属于哪个APE 根据 sessionId来判断
        let ape = this._apes[pduMsg.sessionId];
        let sessionLabel = ApeConsts(pduMsg.sessionId);
        //只做解析存储，不对外发送
        //loger.log('解析数据-timestamp->', timestamp, 'sessionId->', pduMsg.sessionId, 'sessionLabel->', sessionLabel,"subType:"+pduMsg.subType);
        switch (pduMsg.sessionId) {
          case ApeConsts.CONFERENCE_SESSION_ID:
            this.saveParseData(data, timestamp, this._conferApeMssages);
            break;
          case ApeConsts.CHAT_SESSION_ID:
            this.saveParseData(data, timestamp, this._chatApeMssages);
            break;
          case ApeConsts.DOCSHARING_SESSION_ID:
            this.saveParseData(data, timestamp, this._docApeMssages);
            break;
          case ApeConsts.MEDIA_SESSION_ID:
            this.saveParseData(data, timestamp, this._mediaShareApeMssages);
            break;
          case ApeConsts.MUSIC_SESSION_ID:
            this.saveParseData(data, timestamp, this._musicShareApeMssages);
            break;
          case ApeConsts.WHITEBOARD_SESSION_ID:
            this.saveParseData(data, timestamp, this._whiteApeMssages);
            break;
          case ApeConsts.VIDEO_SESSION_ID:
            this.saveParseData(data, timestamp, this._videoApeMssages);
            this.unpackVideoBroadcastMessage(pduMsg, timestamp, data);
            this.unPackpduRegAdapterHandler(pduMsg.data, timestamp, data, ApeConsts.VIDEO_SESSION_ID, pduMsg.subType)
            break;
          case ApeConsts.AUDIO_SESSION_ID:
            this.saveParseData(data, timestamp, this._audioApeMssages);
            this.unPackpduRegAdapterHandler(pduMsg.data, timestamp, data, ApeConsts.AUDIO_SESSION_ID, pduMsg.subType)
            break;
          default:
            break;
        }

        break;
      default:
        loger.warn('PDU-未知类型-等待处理.', pduType);
        break;
    }
  }

  //消息和录制文件匹配完成
  onRecordInfoMatchComplete(_data) {
    console.log("消息和录制文件匹配完成", _data);
    if (_data) {
      for (let k in _data) {
        //优先使用TXY的，没有的时候再使用AGO
        /*  if(! MediaModule.streams[k]){
         MediaModule.streams[k]=_data[k];
         }else {
         console.log(k+" 已经存在",MediaModule.streams[k]);
         }*/
        MediaModule.streams[k] = _data[k];

      }
    }
    console.warn("最终匹配完成的视频流数据", MediaModule.streams);
    this._emit(RecordPlayBackParse.CLASS_JOIN_RECORD_PLAYBACK_SUCCESS, {"recordPlaybackMaxTime": this._recordPlaybackMaxTime});
    ////解析课堂录制的rec文件
    //this.parseArrayBuf();
  }

  //保存各个模块的MCU原始数据
  saveParseData(data, timestamp, apeMessages) {
    let messageItem = apeMessages[timestamp];
    if (!messageItem) {
      apeMessages[timestamp] = [];//数组存数据，因为有1秒内收到多个消息的情况，timestamp是按秒记录的
      messageItem = apeMessages[timestamp];
    }
    messageItem.push({"timestamp": timestamp, "byteData": data});

  }

  //开启计时器
  _startTimerCounter() {
    if (this._timerCounter) {
      this._timerCounter.startTimer();
    }
  }

  //停止计时器
  _stopTimerCounter() {
    if (this._timerCounter) {
      this._timerCounter.stopTimer();
    }

  }

  _timerCounterUptate() {
    this._recordPlaybackTimestamp = this._recordPlaybackTimestamp + 1;//计时
    //loger.log("录制回放中...", this._recordPlaybackTimestamp);
    this._emit(MessageTypes.CLASS_UPDATE_TIMER, {"classTimestamp": this._recordPlaybackTimestamp});

    if (this._recordPlaybackTimestamp >= this._recordPlaybackMaxTime) {
      loger.log("录制回放结束...当前时间->", this._recordPlaybackTimestamp, " 总时间->", this._recordPlaybackMaxTime);
      //this._stopTimerCounter();
      this.stopRecordPlayback();
      return;
    }

    //各个APE模块根据时间查找消息数据
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._conferApeMssages, "conferApe");
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._chatApeMssages, "chatApe");
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._docApeMssages, "docApe");
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._mediaShareApeMssages, "mediaShareApe");
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._musicShareApeMssages, "musicShareApe");
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._whiteApeMssages, "whiteApe");
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._videoApeMssages, "videoAp");
    this._searchMessageFromTime(this._recordPlaybackTimestamp, this._audioApeMssages, "audioApe");
  }

  //加载录制文件rec
  readyLoadRecordPlayData() {
    this.initReplay();
    loger.log("读取录制回放数据");
    //let url = `http://123.56.73.119:80/h5dev/20170306/1357644520_20170306.rec`;
    //let url = `http://${ GlobalConfig.RecordServerIP}:${ GlobalConfig.RecordServerPort}/${GlobalConfig.recordFileName}`;
    let ipport = GlobalConfig.RecordServerIP;//GlobalConfig.RecordServerPort
    if (GlobalConfig.RecordServerPort) {
      ipport = ipport + ":" + GlobalConfig.RecordServerPort;
    }
    let url = `${GlobalConfig.locationProtocol + ipport}/${GlobalConfig.recordFileName}`;
    loger.log(url);
    fetch(url, {
      timeout: 240000 //加载文件超时时间4分
    })
      .then(ret => {
        if (ret.ok) {
          return ret.arrayBuffer();
        } else {
          loger.error(`读取回放数据-网络异常.状态码:${ret.status}`);
          this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_RECORD_PLAY_BACK_DATA_FAILED);
          throw '';
        }
      })
      .then(ret => {
        if (ret) {
          loger.log('读取回放数据-完成');
          this._loadRecordDataSuccess(ret);
        } else {
          loger.warn('读取回放数据-失败.');
          this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_RECORD_PLAY_BACK_DATA_FAILED);
        }
      })
      .catch(err => {
        loger.error(`读取回放数据.状态码:${err}`);
        this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_RECORD_PLAY_BACK_DATA_FAILED);
      });
  }

  _loadRecordDataSuccess(arrayBuffer) {
    loger.log("获取录制回放数据的长度", arrayBuffer.byteLength);
    if (parseBuffer) {
      parseBuffer.clear();
      parseBuffer.append(arrayBuffer);
      //rec数据加载完成后，继续加载音视频相关的录制数据，然后再解析rec数据

      /*         this.getMediaRecrodInfoFromTx(()=>{
       //解析录制的rec数据
       this.isLoadTxRecordInfo=true;
       if(this.isLoadTxRecordInfo&&this.isLoadAgoRecordInfo&&this.isgetRecordFileURLFromAgo){
       this.matchingVideoUrlFromTime(this.agoTiemstampMessages,this.agoAllMedias);
       this.parseArrayBuf();
       }
       });
       this.getMediaRecrodInfoFromAgora(()=>{
       this.isLoadAgoRecordInfo=true;
       //解析录制的rec数据
       if(this.isLoadTxRecordInfo&&this.isLoadAgoRecordInfo&&this.isgetRecordFileURLFromAgo){
       this.matchingVideoUrlFromTime(this.agoTiemstampMessages,this.agoAllMedias);
       this.parseArrayBuf();
       }
       });
       this.getRecordFileURLFromAgo(()=>{
       this.isgetRecordFileURLFromAgo=true;
       //解析录制的rec数据
       if(this.isLoadTxRecordInfo&&this.isLoadAgoRecordInfo&&this.isgetRecordFileURLFromAgo){
       this.matchingVideoUrlFromTime(this.agoTiemstampMessages,this.agoAllMedias);
       this.parseArrayBuf();
       }
       })*/
      this.getMediaRecrodInfoFromTx(()=> {
        /*//AGO启动录制消息和文件匹配
        this.recordInfoMatch.start();*/
        this.parseArrayBuf();
      });

    }
  }

  //时间戳转换为UTC 时间字符串
  timestampToUTCTime(_timestamp) {
    let date = new Date(_timestamp);
    let y = "" + date.getFullYear();
    let month = "" + (date.getMonth() + 1);
    let d = "" + date.getDate();
    let h = "" + (date.getHours() - 8);//GMT 转UTC 减8
    let minutes = "" + date.getMinutes();
    let s = "" + date.getSeconds();
    if (month.length < 2) {
      month = "0" + month;
    }
    if (d.length < 2) {
      d = "0" + d;
    }
    if (h.length < 2) {
      h = "0" + h;
    }
    if (minutes.length < 2) {
      minutes = "0" + minutes;
    }
    if (s.length < 2) {
      s = "0" + s;
    }
    let tiemStr = y + month + d + h + minutes + s;
    //console.log(_timestamp,tiemStr,date);
    return tiemStr
  }

  //匹配时间戳和录制的视频地址
  matchingVideoUrlFromTime(_tiemstampMessages, _allMedias) {
    if (!_tiemstampMessages || !_allMedias) {
      console.log("没有数据无法解析匹配", _tiemstampMessages, _allMedias)
      return;
    }
    if (Object.keys(_tiemstampMessages).length < 1 || Object.keys(_allMedias).length < 1) {
      console.log("数据没有加载完成->不做匹配");
      return;
    }
    ;

    let finelMediaInfo = {};
    let unknowFiles = {};//记录没有匹配到的，需要再次匹配
    let tItem;
    for (let j in _tiemstampMessages) {
      tItem = _tiemstampMessages[j];
      let videoUrl = "";
      if (_allMedias[tItem.uid + "_" + tItem.createTimeUTC]) {
        videoUrl = _allMedias[tItem.uid + "_" + tItem.createTimeUTC];
        //console.log(tItem.uid+"_"+tItem.createTimeUTC,videoUrl);
      } else {
        let t = parseInt(tItem.createTimeUTC);
        console.log(tItem.uid + "_" + t, "没有数据->查找最近的数据");
        videoUrl = _allMedias[tItem.uid + "_" + (t - 1)];
        if (!videoUrl) {
          videoUrl = _allMedias[tItem.uid + "_" + (t + 1)];
        }
        if (!videoUrl) {
          unknowFiles[tItem.timestamp] = tItem;
        }
      }
      //console.log(tItem.uid+"_"+t+"   "+videoUrl);
      tItem.video_url = videoUrl;
      finelMediaInfo[tItem.timestamp] = tItem;
      // MediaModule.streams[tItem.stream_id]=tItem.video_url;
      MediaModule.streams[tItem.stream_id] = {video_url: tItem.video_url, seek: 0};
    }
    console.log("finelMediaInfo", finelMediaInfo);

    //最后处理没有匹配到的
    //检测没有匹配到数据的消息
    for (let i in unknowFiles) {
      let noItem = unknowFiles[i];
      for (let k in finelMediaInfo) {
        let okItem = finelMediaInfo[k];
        let seek = (parseInt(noItem.timestamp) - parseInt(okItem.timestamp)) / 1000;
        //console.log("seek",seek);
        if (noItem.uid == okItem.uid && seek < 15 && noItem.timestamp != okItem.timestamp) {
          //console.log(noItem,okItem);
          noItem.video_url = okItem.video_url;
          noItem.seek = seek;
          finelMediaInfo [noItem.timestamp] = noItem;
          //MediaModule.streams[noItem.stream_id]=noItem.video_url;
          console.log("根据时间戳查找流", noItem.stream_id, {video_url: noItem.video_url, seek: seek})
          MediaModule.streams[noItem.stream_id] = {video_url: noItem.video_url, seek: seek};
        }
      }
    }
    console.log("服务端所有m3u8文件", _allMedias);
    console.log("所有推流消息", _tiemstampMessages);
    console.log("最终匹配结束的文件", finelMediaInfo);
    console.log("回放中最终使用的视频流数据", MediaModule.streams);
  }

  //获取媒体录制的地址信息-时间戳流名称和文件地址对应
  getRecordFileURLFromAgo(_callback) {
    if (!GlobalConfig.getRecordFileURLAgoInterfaces) {
      loger.log("AGOR-获取媒体录制信息->失败->接口地址无效");
      if (_callback) {
        _callback();
      }
      return;
    }
    let url = `${GlobalConfig.locationProtocol + GlobalConfig.getRecordFileURLAgoInterfaces}`;
    loger.log('AGOR-获取媒体录制信息.', url);
    //接口中用的是GET
    fetch(encodeURI(url), {
      method: 'POST',
      headers: {
        "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
      },
      body: `path=${ GlobalConfig.channelId}`,
      timeout: 15000
    })
      .then(ret => {
        if (ret.ok) {
          return ret.json();
        } else {
          loger.error(`AGOR-获取媒体录制信息-网络异常.状态码:${ret}`);
          if (_callback) {
            _callback();
          }
          throw '';
        }
      })
      .then(ret => {
        loger.log('AGOR-获取媒体录制地址信息-完成');
        /* {"code": 200,
         "returnData":{
         "data":{
         backFile:[],
         fschannefiles:"http://networkschool.xuedianyun.com:8899/20171021/markettest_628050539_053439",
         fschannefiles:[]
         }
         } }*/
        if (ret && ret.code == 200) {
          if (ret.returnData && ret.returnData.data) {
            this.parseAndSavaStreamInfoFromAgor(ret.returnData.data);
          }
        }
        if (_callback) {
          _callback();
        }
      })
      .catch(err => {
        loger.error(`AGOR-获取媒体录制信息-异常.状态码:${err}`);
        if (_callback) {
          _callback();
        }
      });
  }

  //获取媒体录制信息
  getMediaRecrodInfoFromAgora(_callback) {
    //获取课堂录制信息   get  localhost:3000/recordInfo/getRecordInfo/7d72365eb9834353397e3e3f9d460bdda
    //localhost:3000/recordInfo/getRecordInfo/ 后面直接添加课堂号 channel
    if (!GlobalConfig.getRecordInfoInterfaces) {
      loger.log("AG-获取媒体录制信息->失败->接口地址无效");
      if (_callback) {
        _callback();
      }
      return;
    }
    let url = `${GlobalConfig.locationProtocol + GlobalConfig.getRecordInfoInterfaces}/${GlobalConfig.channelId}`;
    loger.log('AG-获取媒体录制信息.', url);
    fetch(url, {
      timeout: 15000
    })
      .then(ret => {
        if (ret.ok) {
          return ret.json();
        } else {
          loger.error(`AG-获取媒体录制信息-网络异常.状态码:${ret}`);
          if (_callback) {
            _callback();
          }
          throw '';
        }
      })
      .then(ret => {
        loger.log('AG-获取媒体录制信息-完成');
        //console.log("getRecordInfo success",ret);
        if (ret && ret.returnData && ret.returnData.data) {
          let dataArr = ret.returnData.data;
          for (let i = 0; i < dataArr.length; i++) {
            let item = dataArr[i];
            if (item.status == 1) {
              //console.log(JSON.stringify(item));
              let time = parseInt(item.createTime);
              item.createTimeUTC = this.timestampToUTCTime(time);
              item.stream_id = item.channel + "_" + item.userId + "_" + item.timestamp;
              this.agoTiemstampMessages[item.timestamp] = item;
            }
          }
        }
        console.log("agoTiemstampMessages", this.agoTiemstampMessages);
        if (_callback) {
          _callback();
        }
      })
      .catch(err => {
        loger.error(`AG-获取媒体录制信息-异常.状态码:${err}`);
        if (_callback) {
          _callback();
        }
      });
  }

  //获取媒体录制信息
  getMediaRecrodInfoFromTx(_callback) {
    if (!GlobalConfig.getTxRecordInfoInterfaces) {
      loger.log("TX-获取媒体录制信息->失败->接口地址无效");
      if (_callback) {
        _callback();
      }
      return;
    }
    let url = `${GlobalConfig.locationProtocol + GlobalConfig.getTxRecordInfoInterfaces}`;
    loger.log('TX-获取媒体录制信息.', url);
    //接口中用的是GET
    fetch(encodeURI(url), {
      method: 'POST',
      headers: {
        "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
      },
      body: `channelId=${ GlobalConfig.channelId}`,
      timeout: 15000
    })
      .then(ret => {
        if (ret.ok) {
          return ret.json();
        } else {
          loger.error(`TX-获取媒体录制信息-网络异常.状态码:${ret}`);
          if (_callback) {
            _callback();
          }
          throw '';
        }
      })
      .then(ret => {
        loger.log('TX-获取媒体录制信息-完成');
        /* {"code": 200,
         "returnData":{
         "data":[
         {
         "id": "0zo9GALQdmkwrJVYxqgaE6xM7j8yvOZN",
         "channelId": "marketflashtest_1966232762",
         "recordInfo": "",
         "createTime": ""
         }]
         }
         }*/
        if (ret && ret.code == 200) {
          if (ret.returnData && ret.returnData.data) {
            this.parseAndSavaStreamInfoFromTx(ret.returnData.data);
          }
        }
        if (_callback) {
          _callback();
        }
      })
      .catch(err => {
        loger.error(`获取媒体录制信息-异常.状态码:${err}`);
        if (_callback) {
          _callback();
        }
      });
  }

  //解析agor录制的视频数据,数组[]
  parseAndSavaStreamInfoFromAgor(_data) {
    //backFile:[
    //  {
    //    "channel": "markettest_628050539",
    //    "uid": "564077803",
    //    "userId": "T6342",
    //    "timestamp": "1508564082837",
    //    "createTime": "1508564083681",
    //    "fileUrl": "http://networkschool.xuedianyun.com:8899/20171021/markettest_628050539_053439/564077803_20171021053443568_av.m3u8"
    //  }
    // ],//根据时间戳匹配好的播放地址
    //fschannefiles:"http://networkschool.xuedianyun.com:8899/20171021/markettest_628050539_053439",//文件目录地址
    //fschannefiles:[] //文件列表
    if (!_data) {
      loger.log("AGOR-外部录制的视频数据无效");
      return;
    }
    /* let backFile=_data.backFile;
     if(!backFile){
     loger.log("AGOR-外部录制的视频数据无效->backFile");
     return;
     }
     let item;
     loger.log("AGOR-外部录制的视频数据-length="+backFile.length);
     for(let i=0;i<backFile.length;i++){
     item=backFile[i];
     if(item&&item.fileUrl){
     let streamId=item.channel+"_"+item.userId+"_"+item.timestamp;
     //if(item.fileUrl.indexOf(".m3u8")>0){
     //   MediaModule.streams[itemJson.stream_id]=itemJson.video_url;
     //}
     if(!MediaModule.streams[streamId]){
     MediaModule.streams[streamId]=item.fileUrl;
     }else {
     loger.log("流数据已经存在->",streamId, MediaModule.streams[streamId],item.fileUrl);
     }
     }
     }
     console.log("AGO MediaModule.streams", MediaModule.streams);*/
    if (!_data.fschannefiles) return;
    let items = _data.fschannefiles;
    //console.log(JSON.stringify(items));
    for (let k = 0; k < items.length; k++) {

      let item = items[k];
//                                    if(item.indexOf(".aac")>=0||item.indexOf(".webm")>=0){
//                                        console.log(item)
//                                    }
      //console.log("item.indexOf ts",item.indexOf(".ts"))
      // if(item.indexOf(".m3u8")>=0&&item.indexOf(".ts")<0&&item.indexOf(".m3u8.swp")<0){
      let indexStr = ".m3u8";
      if (item.lastIndexOf(indexStr) + indexStr.length == item.length) {
        //http://networkschool.xuedianyun.com:8899/20171021/markettest_188409305_030739/555257911_20171021031224730.mp4
        //http://networkschool.xuedianyun.com:8899/20171021/markettest_1785982263_080003/572805001_20171021080041402_av.m3u8
        let itemUrl = _data.channefiles + "/" + item;
        //console.log(item,itemUrl);
        item = item.substr(0, item.length - 11);
        this.agoAllMedias[item] = itemUrl;
      }

    }
    console.log("agoAllMedias", this.agoAllMedias);
  }

  //解析TXY录制的视频数据,数组[]
  parseAndSavaStreamInfoFromTx(_dataArr) {
    /* "id": "0zo9GALQdmkwrJVYxqgaE6xM7j8yvOZN",
     "channelId": "marketflashtest_1966232762",
     "recordInfo":"xxxxx",
     "createTime":"xxxx"*/
    if (!_dataArr) {
      loger.log("TX-外部录制的视频数据无效");
      return;
    }
    let item;
    let itemJson;
    loger.log("TX-外部录制的视频数据-length=" + _dataArr.length)
    for (let i = 0; i < _dataArr.length; i++) {
      item = _dataArr[i];
      if (item) {
        itemJson = item.recordInfo;
        try {
          itemJson = JSON.parse(itemJson);
        } catch (err) {

        }
        if (itemJson && itemJson.video_url) {
          if (itemJson.video_url.indexOf(".m3u8") > 0) {
            //MediaModule.streams[itemJson.stream_id]=itemJson.video_url;
            MediaModule.streams[itemJson.stream_id] = {video_url: itemJson.video_url, seek: 0};
          }
        }
      }
    }
    console.log("TX MediaModule.streams", MediaModule.streams);
  }

  //解析录制的rec数据
  parseArrayBuf() {
    //this._messages = {};
    let byteLength = parseBuffer.offset;
    parseBuffer.byteOffset = 0;
    var position = 0;
    while (position < byteLength) {
      let timestamp = parseBuffer.readUInt32(position);
      position += 4;//4字节
      let byteLen = parseBuffer.readUInt32(position);
      position += 4;//4字节
      let byteData = parseBuffer.buffer.slice(position, (position + byteLen));
      position += byteLen;

      //按时间戳解保存数据
      this._parseSaveSocketMsgReceivedHandler(byteData, timestamp);

      //记录最后一个数据的时间戳作为整个录制回放的总时间戳
      this._recordPlaybackMaxTime = timestamp;
    }
    this._recordPlaybackTimestamp = 0;
    this._isReady = true;
    this._stopTimerCounter();

    //录制回放的总时间长度按课堂最长时间计算，不能按最后一个消息的时间计算
    /*if(this._recordPlaybackMaxTime<GlobalConfig.classTimestamp){
     this._recordPlaybackMaxTime=GlobalConfig.classTimestamp;
     }*/
    if (this._recordPlaybackMaxTime < GlobalConfig.recordTimestamp) {
      this._recordPlaybackMaxTime = GlobalConfig.recordTimestamp;
    }

    GlobalConfig.recordPlaybackMaxTime = this._recordPlaybackMaxTime;
    console.log('课堂模块', this._conferApeMssages);
    console.log('音视频通话模块数据', this.mediaChannleList);
    console.log('媒体共享模块数据', this._mediaShareApeMssages);
    console.log('伴音模块数据', this._musicShareApeMssages);
    console.log('视频数据', this._videoApeMssages);
    console.log('音频数据', this._audioApeMssages);
    console.log('文档数据', this._docApeMssages);
    console.log('白板数据', this._whiteApeMssages);
    console.log('聊天数据', this._chatApeMssages);
    console.log('视频模块广播消息', this._videoApeBroadcastMssages);
    loger.log("录制回放数据解析完成,录制回放的总时间长为->", this._recordPlaybackMaxTime, "recordTimestamp:" + GlobalConfig.recordTimestamp);
    console.log('videoPublishMessages', this.videoPublishMessages);

    //AGO启动录制消息和文件匹配
    this.recordInfoMatch.start(this.videoPublishMessages);

    //this._emit(RecordPlayBackParse.CLASS_JOIN_RECORD_PLAYBACK_SUCCESS, {"recordPlaybackMaxTime": this._recordPlaybackMaxTime});
  }

  //根据时间查找数据
  _searchMessageFromTime(_timestamp, _apeMessages, _ape) {
    let msgDataArr = _apeMessages[_timestamp];
    if (!msgDataArr) {
      //没有数据，需要查找当前时间点属于哪一个时间戳关键帧
    } else {
      //把时间点对应的数据发送,同一秒内有存在多个数据的情况
      loger.log(_ape, "回放数据->length:", msgDataArr.length)
      for (let i = 0; i < msgDataArr.length; i++) {
        this._everSocketMsgReceivedHandler(msgDataArr[i].byteData, 0);
      }
    }
  }

  //method------------外部接口-------------------------------------

  //开始播放
  startRecordPlayback(_param) {
    if (!this._isReady) {
      return {"code": ApeConsts.RETURN_FAILED, "data": "录制回放还未准备完成"};
    }
    loger.log("classStatusInfo", GlobalConfig.classStatusInfo);
    console.log("所有流ID", this.allStreams);
    for (let i in this.allStreams) {
      if (MediaModule.streams[i]) {
        console.log("匹配成功的流:" + i, MediaModule.streams[i]);
      } else {
        console.warn("未匹配成功的流:" + i);
      }
    }
    this._startTimerCounter();
    this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE, {"status": PLAY});
  }

  //停止播放
  stopRecordPlayback(_param) {
    this._stopTimerCounter();
    this._recordPlaybackTimestamp = 0;
    //把记录的文档信息也要清除
    GlobalConfig.activeDocId = 0;
    GlobalConfig.activeDocCurPage = 1;
    this._emit(RecordPlayBackParse.RECORD_PLAYBACK_CLEAR_DATA);
    this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE, {"status": STOP});
  }

  //暂停播放
  pauseRecordPlayback(_param) {
    this._stopTimerCounter();
    this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE, {"status": PAUSE});
  }

  //跳转到指定时间点播放
  seekRecordPlayback(_param) {
    if (!this._isReady) {
      return {"code": ApeConsts.RETURN_FAILED, "data": "录制回放还未准备完成"};
    }
    if (!_param || !_param.time) {
      return {"code": ApeConsts.RETURN_FAILED, "data": "参数不正确"};
    }
    //先暂停，更改进行的时间
    this._stopTimerCounter();
    this._recordPlaybackTimestamp = _param.time || 0;
    //把记录的文档信息也要清除
    GlobalConfig.activeDocId = 0;
    GlobalConfig.activeDocCurPage = 1;
    this._emit(RecordPlayBackParse.RECORD_PLAYBACK_CLEAR_DATA);
    //各个ape模块查找关键帧数据
    this._searchSeekKeyfram();
  }

  //拖动进度条后根据seek时间点查找
  _searchSeekKeyfram() {
    //查找关键帧，找到关键帧后再继续播放
    this._searchApeMessageKeyfram(this._conferApeMssages, ApeConsts.CONFERENCE_SESSION_ID);
    this._searchApeMessageKeyfram(this._docApeMssages, ApeConsts.DOCSHARING_SESSION_ID);

    /*
     //旧的音视频查找关键帧数据，多路音视频的时候存在显示问题，已经废弃
     //this._searchApeMessageKeyfram(this._videoApeMssages, ApeConsts.VIDEO_SESSION_ID);
     //this._searchApeMessageKeyfram(this._audioApeMssages, ApeConsts.AUDIO_SESSION_ID);
     */

    //音视频模块的查找规则和其他模块不一样，音视频按频道查找，如果课堂内存在多个频道，都要查
    this.searchMediaApeMessageKeyfram(this.mediaChannleList);

    //媒体共享模块
    this.searchMediaShareApeMessageKeyfram(this._mediaShareApeMssages);

    //伴音共享模块
    this.searchMusicShareApeMessageKeyfram(this._musicShareApeMssages);

    //聊天模块、白板标注模块的比较特殊，消息是累计的，默认最多30条
    this._searchChatHistoryMessageKeyfram(this._chatApeMssages, ApeConsts.CHAT_SESSION_ID);
    this._searchWhiteboradHistoryMessageKeyfram(this._whiteApeMssages, ApeConsts.WHITEBOARD_SESSION_ID);


    //各个ape模块无论有没有找到关键帧数据，都继续播放
    this._startTimerCounter();
  }

  //查找ape关键帧数据
  _searchApeMessageKeyfram(_apeMessages, _apeId) {
    if (!_apeMessages) {
      return;
    }
    let messageItem;
    let keyFrameSeekTime = 0;
    for (let i = this._recordPlaybackTimestamp; i > 0; i--) {
      messageItem = _apeMessages[i];
      if (messageItem) {
        keyFrameSeekTime = (this._recordPlaybackTimestamp - i)
        loger.log("SEEK->APE", ApeConsts(_apeId), this._recordPlaybackTimestamp, "查找到相连的timestamp->", i, '需要seek->', keyFrameSeekTime, "秒");
        //把时间点对应的数据发送,同一秒内有存在多个数据的情况
        for (let k = 0; k < messageItem.length; k++) {
          this._everSocketMsgReceivedHandler(messageItem[k].byteData, keyFrameSeekTime);
        }
        if (_apeId == ApeConsts.AUDIO_SESSION_ID || _apeId == ApeConsts.VIDEO_SESSION_ID) {
          this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE, {
            "status": SEEK,
            "keyFrameSeekTime": keyFrameSeekTime
          });
        }
        return;
      }
    }
    loger.log("SEEK->APE", ApeConsts(_apeId), this._recordPlaybackTimestamp, "没有查找到相连的数据");
  }

  //音视频模块seek的时候,查找当前seek点的关键帧数据,所有频道的数据都需要查一下,否则多路视频的时候会显示不全
  searchMediaApeMessageKeyfram(_apeMessages) {
    if (!_apeMessages) {
      return;
    }
    console.log('SEEK->查找音视频模块数据', _apeMessages)
    if (_apeMessages) {
      for (let k in _apeMessages) {
        let channelInfos = _apeMessages[k];
        let messageItem;
        let keyFrameSeekTime = 0;
        for (let i = this._recordPlaybackTimestamp; i > 0; i--) {
          messageItem = channelInfos[i];
          if (messageItem) {
            keyFrameSeekTime = (this._recordPlaybackTimestamp - i);
            loger.log("频道:" + k + "->SEEK->查找音视频模块数据->", messageItem, 'keyFrameSeekTime->', keyFrameSeekTime)
            this._everSocketMsgReceivedHandler(messageItem.byteData, keyFrameSeekTime);
            break;
          }
        }
        loger.log("频道:" + k + "—>没有查找到数据")
      }
    }
  }

  //媒体共享模块查找关键帧时间戳的消息
  searchMediaShareApeMessageKeyfram(_apeMessages) {
    if (!_apeMessages) {
      return;
    }
    let messageItem;
    let keyFrameSeekTime = 0;
    for (let i = this._recordPlaybackTimestamp; i > 0; i--) {
      messageItem = _apeMessages[i];
      if (messageItem) {
        keyFrameSeekTime = (this._recordPlaybackTimestamp - i)
        loger.log("SEEK->APE", '媒体共享', this._recordPlaybackTimestamp, "查找到相连的timestamp->", i, '需要seek->', keyFrameSeekTime, "秒");
        //把时间点对应的数据发送,同一秒内有存在多个数据的情况
        for (let k = 0; k < messageItem.length; k++) {
          this._everSocketMsgReceivedHandler(messageItem[k].byteData, keyFrameSeekTime);
        }
        return;
      }
    }
    loger.log("SEEK->APE->媒体共享", this._recordPlaybackTimestamp, "没有查找到相连的数据");
  }

  //伴音共享模块查找关键帧时间戳的消息
  searchMusicShareApeMessageKeyfram(_apeMessages) {
    if (!_apeMessages) {
      return;
    }
    let messageItem;
    let keyFrameSeekTime = 0;
    for (let i = this._recordPlaybackTimestamp; i > 0; i--) {
      messageItem = _apeMessages[i];
      if (messageItem) {
        keyFrameSeekTime = (this._recordPlaybackTimestamp - i)
        loger.log("SEEK->APE", '伴音共享', this._recordPlaybackTimestamp, "查找到相连的timestamp->", i, '需要seek->', keyFrameSeekTime, "秒");
        //把时间点对应的数据发送,同一秒内有存在多个数据的情况
        for (let k = 0; k < messageItem.length; k++) {
          this._everSocketMsgReceivedHandler(messageItem[k].byteData, keyFrameSeekTime);
        }
        return;
      }
    }
    loger.log("SEEK->APE->伴音共享", this._recordPlaybackTimestamp, "没有查找到相连的数据");
  }

  //查找聊天模块ape关键帧数据，聊天模块比较特殊，消息是累积的，当前时间戳之前的都需要显示
  _searchChatHistoryMessageKeyfram(_apeMessages) {
    if (!_apeMessages) {
      return;
    }
    //最多30条数据
    let counter = 0;
    let messageItem;
    let mssageArr = [];
    for (let i = this._recordPlaybackTimestamp; i > 0; i--) {
      messageItem = _apeMessages[i];
      if (messageItem) {
        //把时间点对应的数据发送,同一秒内有存在多个数据的情况
        for (let i = 0; i < messageItem.length; i++) {
          //this._everSocketMsgReceivedHandler(messageItem[i].byteData, 0);
          mssageArr.push(messageItem[i].byteData);
          counter++;
          if (counter > 40) {
            loger.warn("SEEK->最多处理历史消息30条");
            break;
          }
        }
      }
    }
    //mssageArr记录的数据是按时间最大排序的，发消息的时候需要从时间小的开始，倒着发数据
    let len = mssageArr.length;
    if (len > 0) {
      for (let k = len - 1; k >= 0; k--) {
        this._everSocketMsgReceivedHandler(mssageArr[k], 0);
      }
    }
  }

  //查找白板标注模块ape关键帧数据，聊天模块比较特殊，消息是累积的，当前时间戳之前的都需要显示
  _searchWhiteboradHistoryMessageKeyfram(_apeMessages) {
    if (!_apeMessages) {
      return;
    }
    //最多100条数据
    let counter = 0;
    let messageItem;
    for (let i = this._recordPlaybackTimestamp; i > 0; i--) {
      messageItem = _apeMessages[i];
      if (messageItem) {
        //把时间点对应的数据发送,同一秒内有存在多个数据的情况
        for (let i = 0; i < messageItem.length; i++) {
          this._everSocketMsgReceivedHandler(messageItem[i].byteData, 0);
          counter++;
          if (counter > 40) {
            loger.warn("SEEK->最多处理历史消息40条");
            return;
          }
        }
      }
    }
  }

  //解析视频模块的广播消息
  unpackVideoBroadcastMessage(pduMsg, timestamp, data) {
    //console.log("VIDEO_SESSION_ID-pduMsg",pduMsg);
    if (!pduMsg) {
      return;
    }
    if (pduMsg.subType != pdu.RCPDU_SEND_VIDEO_DATA_REQUEST) {
      //视频广播消息，只处理501消息
      return;
    }
    try {
      let videoReceivePdu = pdu['RCVideoSendDataRequestPdu'].decode(pduMsg.data);
      if (videoReceivePdu == null) {
        loger.warn("视频模块广播消息-decode->失败");
        return;
      }
      videoReceivePdu.data = ArrayBufferUtil.uint8ArrayToStr(videoReceivePdu.data, 2);//开头两个字会乱码
      let dataObj = {};
      try {
        dataObj = JSON.parse(videoReceivePdu.data);
      } catch (err) {
        loger.warn('视频模块广播消息->JSON转换失败');
        dataObj = videoReceivePdu.data;
      }
      videoReceivePdu.data = dataObj;
      //actionType:40
      //data :Object
      //fromNodeId :902994631
      //toNodeId : 0
      if (videoReceivePdu.actionType == 40) {
        if (!this._videoApeBroadcastMssages[videoReceivePdu.fromNodeId]) {
          this._videoApeBroadcastMssages[videoReceivePdu.fromNodeId] = {};
        }
        /*
         //结构
         {
         nodeId:{
         时间戳:{数据}
         },
         nodeId:{
         时间戳:{数据}
         },.....
         }*/

        this._videoApeBroadcastMssages[videoReceivePdu.fromNodeId][timestamp] = {
          parseData: videoReceivePdu,
          byteData: data,
          timestamp: timestamp
        };
        //this._videoApeBroadcastMssages[timestamp]={parseData:videoReceivePdu,byteData:data,timestamp: timestamp};
        if(videoReceivePdu&&videoReceivePdu.data){
          videoReceivePdu.data.createTime=videoReceivePdu.data.timestamp;
        }
        this.videoPublishMessages.push(videoReceivePdu.data);
      }

    } catch (err) {
      console.log("视频模块广播消息->解析失败", err.message);
    }
  }

  //音视频的数据需要解析,然后按频道储存数据
  // 解析pdu RCAdapterPdu的数据: regBuffer(RCAdapterPdu数据),timestamp(时间戳),  data(mcu的原始数据) sessionId（类型）
  unPackpduRegAdapterHandler(regBuffer, timestamp, data, sessionId, subType) {
    let regPdu;
    let regItems;
    let regItemSize;
    try {
      //console.log('RCAdapterPdu--->')
      regPdu = pdu['RCAdapterPdu'].decode(regBuffer);
      regItems = regPdu.item;
      regItemSize = regItems.length;

    } catch (err) {
      console.warn('RCAdapterPdu->unpack-error->type类型不对', "subType:" + subType);
      return;
    }

    for (var i = 0; i < regItemSize; ++i) {
      let regItem = regItems[i];
      let regItemType = regItem.type;
      let regItemData = regItem.itemData;

      //根据数据包中的type处理数据是否同步
      if (pdu.RCPDU_REG_UPDATE_OBJ !== regItemType) {
        if (pdu.RCPDU_REG_RESPONSE_OBJ == regItemType) {
          let regResponsePdu = pdu['RCRegistryResponseObjPdu'].decode(regItemData);
          console.log('regResponsePdu', regResponsePdu)
          //this.regResponsePduHandler(regResponsePdu);
        }
        // 只处理两种类型
        continue;
      }

      //具体的数据包
      let regUpdatedItem = pdu['RCRegistryUpdateObjPdu'].decode(regItemData);
      let sub_type = regUpdatedItem.subType;
      let object_id = regUpdatedItem.objId;
      let user_data = regUpdatedItem.userData;

      //console.log('RCRegistryUpdateObjPdu',regUpdatedItem)

      switch (sub_type) {
        case pdu.RCPDU_REG_ROSTER_INSERT_PDU:
          let rosterInsertData = pdu['RCRegistryRosterInsertItemPdu'].decode(user_data);

          let rosterInsertItems = rosterInsertData.items;
          let rosterInsertItemsLen = rosterInsertItems.length;
          for (let i = 0; i < rosterInsertItemsLen; ++i) {
            let record = rosterInsertItems[i];
            let recordId = record.item_id;
            let recordData = pdu['RCNodeInfoRecordPdu'].decode(record.item_data);
          }
          break;
        case pdu.RCPDU_REG_ROSTER_DELETE_PDU:
          let rosterDelData = pdu['RCRegistryRosterDeleteItemPdu'].decode(user_data);
          // console.log('RCRegistryRosterDeleteItemPdu',rosterDelData)
          break;
        case pdu.RCPDU_REG_ROSTER_UPDATE_PDU:
          let rosterUpdateData = pdu['RCRegistryRosterUpdateItemPdu'].decode(user_data);
          let rosterUpdateItems = rosterUpdateData.items;
          let rosterUpdateItemsLen = rosterUpdateItems.length;
          //console.log('RCRegistryRosterUpdateItemPdu',rosterUpdateData)
          for (let i = 0; i < rosterUpdateItemsLen; ++i) {
            let node = rosterUpdateItems[i];
            let nodeId = node.nodeId;
            let nodeData = pdu['RCNodeInfoRecordPdu'].decode(node.nodeData);
            // console.log('RCNodeInfoRecordPdu',nodeData)
          }
          break;
        case pdu.RCPDU_REG_TABLE_INSERT_PDU:
          let tableInsertData = pdu['RCRegistryTableInsertItemPdu'].decode(user_data);
          let tableInsertItems = tableInsertData.items;
          let tableInsertItemsLen = tableInsertItems.length;
          //console.log('RCRegistryTableInsertItemPdu',tableInsertData)
          for (let i = 0; i < tableInsertItemsLen; ++i) {
            let insertItem = tableInsertItems[i];
            //loger.log("insertItem",insertItem);
            //this.tableInsertHandler(insertItem.owner, insertItem.itemIdx, insertItem.itemData);
          }
          break;
        case pdu.RCPDU_REG_TABLE_DELETE_PDU:
          let tableDeleteData = pdu['RCRegistryTableDeleteItemPdu'].decode(user_data);
          //console.log("tableDeleteData",object_id,tableDeleteData);
          break;
        case  pdu.RCPDU_SEND_VIDEO_DATA_REQUEST:
          //视频模块的控制消息
          try {
            let videoReceivePdu = pdu['RCVideoSendDataRequestPdu'].decode(user_data);
            if (videoReceivePdu == null) {
              loger.warn("视频控制消息处理,收到的消息为null,不做处理");
              return;
            }
            videoReceivePdu.data = ArrayBufferUtil.uint8ArrayToStr(videoReceivePdu.data, 2);//开头两个字会乱码
            let dataObj = {};
            try {
              dataObj = JSON.parse(videoReceivePdu.data);
            } catch (err) {
              loger.warn('控制消息->JSON转换失败');
              dataObj = videoReceivePdu.data;
            }
            videoReceivePdu.data = dataObj;
            this._videoApeBroadcastMssages[timestamp] = {
              parseData: videoReceivePdu,
              byteData: data,
              timestamp: timestamp
            };
          } catch (err) {
            loger.warn("RCPDU_SEND_VIDEO_DATA_REQUEST->err", err);
          }
          break;
        case pdu.RCPDU_REG_TABLE_UPDATE_PDU:
          let tableUpdateData = pdu['RCRegistryTableUpdateItemPdu'].decode(user_data);
          let tableUpdateItems = tableUpdateData.items;
          let tableUpdateItemsLen = tableUpdateItems.length;
          for (let i = 0; i < tableUpdateItemsLen; ++i) {
            let tableItem = tableUpdateItems[i];

            //只处理音视频模块的消息
            if (sessionId == ApeConsts.VIDEO_SESSION_ID) {
              try {
                let videoChannelInfo = pdu['RCVideoChannelInfoPdu'].decode(tableItem.itemData);
                //loger.log('RCVideoChannelInfoPdu->timestamp',timestamp,videoChannelInfo);
                //储存音视频模块的数据
                if (!this.mediaChannleList[videoChannelInfo.channelId]) {
                  this.mediaChannleList[videoChannelInfo.channelId] = {};
                }
                let statusStr = "关";
                if (videoChannelInfo && videoChannelInfo.status == 1) {
                  statusStr = "开";
                  this.allStreams[videoChannelInfo.streamId] = videoChannelInfo;
                  console.log("视频流" + videoChannelInfo.streamId);
                }
                this.mediaChannleList[videoChannelInfo.channelId][timestamp] = {
                  parseData: videoChannelInfo,
                  byteData: data,
                  timestamp: timestamp,
                  status: statusStr
                };
              } catch (err) {
                loger.log("RCVideoChannelInfoPdu->unPackPdu->error->" + tableItem.itemIdx + "  err:" + err.message);
              }
            } else if (sessionId == ApeConsts.AUDIO_SESSION_ID) {
              try {
                let audioChannelInfo = pdu['RCAudioChannelInfoPdu'].decode(tableItem.itemData);
                loger.log('RCAudioChannelInfoPdu->timestamp', timestamp, audioChannelInfo);
                //储存音视频模块的数据
                if (!this.mediaChannleList[audioChannelInfo.channelId]) {
                  this.mediaChannleList[audioChannelInfo.channelId] = {};
                }
                let statusStr = "关";
                if (audioChannelInfo && audioChannelInfo.status == 1) {
                  statusStr = "开";
                }
                this.mediaChannleList[audioChannelInfo.channelId][timestamp] = {
                  parseData: audioChannelInfo,
                  byteData: data,
                  timestamp: timestamp,
                  status: statusStr
                };
              } catch (err) {
                loger.log("RCAudioChannelInfoPdu->unPackPdu->error->" + tableItem.itemIdx + "  err:" + err.message);
              }
            }
          }
          break;
        case pdu.RCPDU_REG_QUEUE_UPDATE_PDU:
        case pdu.RCPDU_REG_QUEUE_DELETE_PDU:
        case pdu.RCPDU_REG_QUEUE_INSERT_PDU:
          loger.warn('REG QUEUE ARE IGNORED');
          break;
        default :
          break;
      }
    }
  }
}

RecordPlayBackParse.prototype.CLASS_JOIN_RECORD_PLAYBACK_SUCCESS = RecordPlayBackParse.CLASS_JOIN_RECORD_PLAYBACK_SUCCESS = 'class_join_recordPlayback_success';//加入录制回放成功
RecordPlayBackParse.prototype.RECORD_PLAYBACK_CLEAR_DATA = RecordPlayBackParse.RECORD_PLAYBACK_CLEAR_DATA = 'record_playback_clear_data';//清除录制回放数据

export default new RecordPlayBackParse;