require('es6-promise').polyfill();
require('whatwg-fetch');
require('jquery-touchswipe');
require('string.fromcodepoint');

import Emiter from './Emiter';
import Sass from 'Sass';
import IpManager from 'IpManager';
import RecordPlayBackParse from 'RecordPlayBackParse';
import MD5 from "md5";
import Mcu from 'mcu';
import MessageTypes from 'MessageTypes';
import Loger from 'Loger';
import ConferApe from 'apes/ConferApe';
import ChatApe from 'apes/ChatApe';
import VideoApe from 'apes/VideoApe';
import AudioApe from 'apes/AudioApe';
import DocApe from 'apes/DocApe';
import WhiteBoardApe from 'apes/WhiteBoardApe';
import EngineUtils from "EngineUtils";
import GlobalConfig from 'GlobalConfig';
import ApeConsts from 'apes/ApeConsts';
import Base64 from 'base64-js';
import ArrayBufferUtil from 'libs/ArrayBufferUtil';
import Server from "config/Server";

import UTF8 from 'utf-8';

let loger = Loger.getLoger('McuClient');
let _sdkInfo = {"version": "v1.9.15.20170420", "author": "www.3mang.com"};

//APE
let _sass;
let _ipManager;
let _mcu;
let _confer_ape;
let _chat_ape;
let _video_ape;
let _audio_ape;
let _doc_ape;
let _whiteboard_ape;
let _recordPlayback;

//MCUClient 外部实例化主类
export default class MessageEntrance extends Emiter {
    constructor() {
        super();
        //sdk 信息
        this.sdkInfo = _sdkInfo;
        loger.log(this.sdkInfo);

        //初始化状态
        this.isGetUserIpCallback = false;//是否获取IP信息返回
        this.isGetFastestMcuCallback = false;//是否MCU选点结束
        this.isGetFastestMsCallback = false;//是否MS选点结束

        GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_0);

        //全局的Error处理
        this.on(MessageTypes.MCU_ERROR, this._mcuErrorHandler.bind(this));

        // Sass平台层
        _sass = Sass;
        _sass.on('*', (type, data) => this._emit(type, data));
        _sass.on(_sass.SUCCESS, this._sassJoinSuccessHandler.bind(this));//通过SASS平台验证(密码和MD5)
        _sass.on(_sass.CLASS_INIT_SUCCESS, this._sassInitSuccessHandler.bind(this));//获取课堂初始化信息
        //_sass.on(_sass.CLASS_GET_CLASS_DETAIL, this._sassGetClassDetailSuccessHandler.bind(this));//获取课堂的基本信息
        _sass.on(_sass.CLASS_GET_CLASS_PARAM, this._sassGetClassParamSuccessHandler.bind(this));//获取课堂的最全信息和历史保存的数据

        _sass.on(_sass.CLASS_SAVE_STATUS_INFO_SUCCESS, this._sassSaveClassStatusInfoSuccessHandler.bind(this));//保存课堂状态信息
        _sass.on(_sass.CLASS_SAVE_RECORD_INFO_SUCCESS, this._sassSaveClassRecordInfoSuccessHandler.bind(this));//保存课堂录制信息
        _sass.on(_sass.DELETE_DOCUMENT_SUCCESS, this._sassDeleteDocumentSuccess.bind(this));//sass删除文档成功

        //选点模块
        _ipManager = new IpManager();

        // 底层MCU消息层
        _mcu = Mcu;
        _mcu.on('*', (type, data) => this._emit(type, data));
        _mcu.on(MessageTypes.CLASS_JOIN_MCU_SUCCESS, this._mcuJoinMCUClassSuccessHandler.bind(this));//加入MCU课堂完成
        _mcu.on(MessageTypes.SWITCH_MCU_IP, this._switchMcuIpHandler.bind(this));//切换MCU，重新选点

        //录制回放
        _recordPlayback = RecordPlayBackParse;
        _recordPlayback.on('*', (type, data) => this._emit(type, data));
        _recordPlayback.on(RecordPlayBackParse.CLASS_JOIN_RECORD_PLAYBACK_SUCCESS, this._joinRecordPlaybackSuccessHandler.bind(this));//加入录制回放完成
        _recordPlayback.on(RecordPlayBackParse.RECORD_PLAYBACK_CLEAR_DATA, this._recordPlaybackClearDataHandler.bind(this));//录制回放状态更新


        // 注册所有应用Ape
        _confer_ape = new ConferApe();
        _confer_ape.on('*', (type, data) => this._emit(type, data));
        _confer_ape.on(MessageTypes.CLASS_EXIT, this._doClassExit.bind(this));//监听自己的关闭事件
        _confer_ape.on(MessageTypes.CLASS_STATUS_INFO_CHANGE, this._onClassStatusInfoChange.bind(this));//当前课堂状态信息发生改变
        _confer_ape.on(MessageTypes.CLASS_DELETE_ROSTER, this._onClassDeleteRoster.bind(this));//当前课堂人员离开
        _confer_ape.on(MessageTypes.CLASS_NONENTITY_ROSTER, this._onClassNonentityRoster.bind(this));//当前课堂中视频或音频占用channel的nodeId ，在人员列表中不存在
        _confer_ape.on(MessageTypes.CLASS_RECORD_START, this._onClassRecordStart.bind(this));//课堂开始录制
        _confer_ape.on(MessageTypes.CLASS_RECORD_SUCCESS, this._onClassRecordSuccess.bind(this));//课堂开启录制成功
        _confer_ape.on(MessageTypes.SWITCH_MS_IP, this._switchMsIpHandler.bind(this));//MS动态选点


        _chat_ape = new ChatApe();
        _chat_ape.on('*', (type, data) => this._emit(type, data));

        _video_ape = new VideoApe();
        _video_ape.on('*', (type, data) => this._emit(type, data));
        _video_ape.on(MessageTypes.VIDEO_UPDATE, this.videoUpdate.bind(this));//这个监听事件不能删除，需要通知课堂模块，检查channel占用


        _audio_ape = new AudioApe();
        _audio_ape.on('*', (type, data) => this._emit(type, data));
        _audio_ape.on(MessageTypes.AUDIO_UPDATE, this.audioUpdate.bind(this));//这个监听事件不能删除，需要通知课堂模块，检查channel占用

        _whiteboard_ape = new WhiteBoardApe();
        _whiteboard_ape.on('*', (type, data) => this._emit(type, data));
        //_whiteboard_ape.on(MessageTypes.WHITEBOARD_ANNOTATION_UPDATE, this.annoUpdateHandler.bind(this));

        _doc_ape = new DocApe();
        _doc_ape.on('*', (type, data) => this._emit(type, data));
        _doc_ape.on(MessageTypes.DOC_UPDATE, this.docUpdateHandler.bind(this));
        _doc_ape.on(MessageTypes.DOC_DELETE, this.docDeleteHandler.bind(this));
        _doc_ape.on(DocApe.DOC_JOIN_CHANNEL_SUCCESS, this.docJoinChannelSuccess.bind(this));

        //公开外部调用的方法
        //class
        this.init = this._init.bind(this);
        this.joinClass = this._joinClass.bind(this);
        this.leaveClass = this._leaveClass.bind(this);
        this.getMcuClientStatus = this._getMcuClientStatus.bind(this);
        //this.getClassDetail = this._getClassDetail;//停用
        this.getClassStatusInfo = this._getClassStatusInfo.bind(this);
        this.sendStartClass = this._sendStartClass.bind(this);
        this.sendPauseClass = this._sendPauseClass.bind(this);
        this.sendCloseClass = this._sendCloseClass.bind(this);

        //录制回放
        this.initRecordPlayback = this._initRecordPlayback.bind(this);
        this.startRecordPlayback = this._startRecordPlayback.bind(this);
        this.stopRecordPlayback = this._stopRecordPlayback.bind(this);
        this.pauseRecordPlayback = this._pauseRecordPlayback.bind(this);
        this.seekRecordPlayback = this._seekRecordPlayback.bind(this);

        //chatApe
        this.sendChatMsg = this._sendChatMsg.bind(this);

        //videoApe
        //this.getVideoPlayPath = this._getVideoPlayPath.bind(this);
        this.getVideoPublishPath = this._getVideoPublishPath.bind(this);
        this.getVideoAllChannelInfo = this._getVideoAllChannelInfo.bind(this);
        this.publishVideo = this._publishVideo.bind(this);
        this.stopPublishVideo = this.unPublishVideo = this._stopPublishVideo.bind(this);
        this.sendVideoBroadcastMsg = this._sendVideoBroadcastMsg.bind(this);

        //audioApe
        //this.getAudioPlayPath = this._getPlayAudioPath.bind(this);
        this.getAudioPublishPath = this._getPublishAudioPath.bind(this);
        this.getAudioAllChannelInfo = this._getAudioAllChannelInfo.bind(this);
        this.publishAudio = this._publishAudio.bind(this);
        this.stopPublishAudio = this.unPublishAudio = this._stopPublishAudio.bind(this);
        this.sendAudioBroadcastMsg = this.sendAudioCommandMsg.bind(this);

        //whiteBoradApe
        this.sendInsertAnnotaion = this._sendInsertAnnotaion.bind(this);
        this.sendDeleteAllAnnotation = this._sendDeleteAllAnnotation.bind(this);
        this.sendDeleteCurPageAnnotation = this._sendDeleteCurPageAnnotation.bind(this);
        this.sendGotoPrev = this._sendGotoPrev.bind(this);

        //DocApe
        this.sendDocumentUpload = this._sendDocumentUpload.bind(this);//上传文档
        this.sendDocumentSwitchDoc = this._sendDocumentSwitchDoc.bind(this); //切换文档
        this.sendDocumentSwitchPage = this._sendDocumentSwitchPage.bind(this);//翻页
        this.sendDocumentDelete = this._sassDeleteDocument.bind(this);
        this.sendDocBroadcastMsg = this._sendDocBroadcastMsg.bind(this);
        //删除文档,先通过Sass删除,sass删除成功之后再同步mcu
        //this.sendDocumentDeleteAll= this._documentDeleteAll;//删除所有文档
        this.sendDocumentCommand = this._sendDocumentCommand.bind(this);
        //操作文档(翻页、缩放、滚动...)
        this.getDocImageFullPath = this._getDocImageFullPath.bind(this);
        //获取文档图片的完整路径
        this.getDocPDFFullPath = this._getDocPDFFullPath.bind(this);//获取文档的完整路径
        this.getDocFullAddress = this._getDocFullAddress.bind(this);//获取文档资源地址


        //this.setDebuger = this._setDebuger.bind(this);//debug
        this.setMessageDelay = this._setMessageDelay.bind(this);//设置是否延迟消息
        this.switchServer = this._switchMcuIpHandler.bind(this);//切换mcu服务器
        this.switchMediaServer = this._switchMsIpHandler.bind(this);//切换ms服务器
    }

    _setDebuger(_data) {
        GlobalConfig.isDebuger = _data.isDebuger || true;
    }

    _setMessageDelay(_data) {
        loger.warn("延迟消息-->", _data);
        if (_data) {
            GlobalConfig.messageDelay = Boolean(_data.messageDelay);
        }
    }

    //mcu异常监听
    _mcuErrorHandler(_data, _option) {
        let option = _option || "";
        let errorMessage = {"code": _data, "reson": MessageTypes.ErrorReson[_data] + " " + option};
        this._emit(MessageTypes.ERROR_EVENT, errorMessage);
        loger.error("MCU_ERROR", errorMessage);
    }

    //获取当前的状态
    _getMcuClientStatus() {
        return GlobalConfig.getCurrentStatus();
    }

//获取课堂信息
    _getClassDetail() {
        return GlobalConfig.getClassDetail();
    }

    //获取当前课堂的状态信息
    _getClassStatusInfo() {
        return GlobalConfig.classStatusInfo;
    }

    //关闭课堂，所有人都退出
    _doClassClose(_param) {
        this._leaveClass();
    }

    //离开课堂，断开连接
    _doClassExit() {
        this._leaveClass();
    }

    //当前的课堂状态信息发生改变,需要保存课堂状态到Sass
    _onClassStatusInfoChange(_param) {
        //如果MCU连接已经断开，不发送
        if (GlobalConfig.getCurrentStatus().code != GlobalConfig.statusCode_2.code) {
            loger.warn("不能保存课堂状态", GlobalConfig.getCurrentStatus());
            return;
        }
        this._sassSaveClassStatusInfo(_param);
    }

    //如果是第一次点击开始上课，需要创建录制时的文件名
    _onClassRecordStart(_param) {
        if (GlobalConfig.getCurrentStatus().code != GlobalConfig.statusCode_2.code) {
            loger.warn("不能保存课堂状态", GlobalConfig.getCurrentStatus());
            return;
        }
        if (_sass) {
            _sass.saveClassRecordContrlInfo(_param);
        }
    }

    //开启录制成功
    _onClassRecordSuccess(_param) {
        if (_doc_ape) {
            _doc_ape.updaterRecordStatus();
        }
        if (_whiteboard_ape) {
            _whiteboard_ape.updaterRecordStatus();
        }
    }

    //有人员离开
    _onClassDeleteRoster(_data) {
    }

    //当前课堂中视频或音频占用channel的nodeId ，在人员列表中不存在，这种情况是占用channel的人员掉线或离开的时候没有释放channel
    //的占用状态导致，对于这种情况，需要释放掉
    _onClassNonentityRoster(_param) {
        if (GlobalConfig.isRecordPlayBack) {
            loger.warn("录制回放中，不处理")
            return;
        }

        if (_param == null || _param.nodeId == null) {
            loger.warn("onClassNonentityRoster.参数错误")
            return;
        }
        let data = {"nodeId": _param.nodeId};
        if (_video_ape) {
            _video_ape.stopPublishVideo(data);
        }
        if (_audio_ape) {
            _audio_ape.stopPublishAudio(data);
        }
    }


    //Sass
    //初始化
    _init(_param) {
        //{"classId":"1653304953","portal":"112.126.80.182:80","userRole":"normal","userId":0}
        //判断传入的参数是否存在
        if (_param == null || EngineUtils.isEmptyObject(_param)) {
            loger.error('初始化课堂失败->参数错误', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_PARAM);
            return;
        }
        //判断必要的参数字段值
        if (_param.classId == null || isNaN(_param.classId) || _param.portal == null || _param.portal == "") {
            loger.error('初始化课堂失败->参数错误', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_PARAM);
            return;
        }
        loger.log('初始化课堂->', _param);

        //保存参数
        GlobalConfig.isRecordPlayBack = false;//设置为非录制回放状态
        GlobalConfig.classId = parseInt(_param.classId);
        GlobalConfig.portal = _param.portal;
        GlobalConfig.userId = _param.userId || "0";
        GlobalConfig.userName = _param.userName || "";

        //设置角色身份
        GlobalConfig.userRole = _param.userRole || ApeConsts.normal;
        if (GlobalConfig.userRole != ApeConsts.host &&
            GlobalConfig.userRole != ApeConsts.presenter &&
            GlobalConfig.userRole != ApeConsts.assistant &&
            GlobalConfig.userRole != ApeConsts.record &&
            GlobalConfig.userRole != ApeConsts.invisible) {
            GlobalConfig.userRole = ApeConsts.normal;
        }

        //客户端决定是否延迟接收消息
        GlobalConfig.messageDelay = _param.messageDelay || false;

        //最长允许录制的时间
        if (_param.allowRecordMaxTime) {
            GlobalConfig.allowRecordMaxTime = parseInt(_param.allowRecordMaxTime);
        }

        //获取课堂校验信息
        if (_sass) {
            _sass.getJoinParams(GlobalConfig.getClassInfo());
        }
    }

    //外部请求加入课堂
    _joinClass(_param) {
        if (_param == null || EngineUtils.isEmptyObject(_param)) {
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_PARAM);
            loger.log('加入课堂失败->参数错误.', _param);
            return;
        }
        //判断userName
        if (_param.userName == null || _param.userName == "") {
            loger.log('加入课堂失败->参数错误->名字不能为空');
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_PARAM);
            return;
        }
        //{"userName":"名字","password":""，"autoLogin":""}
        GlobalConfig.userName = _param.userName || GlobalConfig.userName;//以登陆时的名字为主，登陆之前可以修改名字
        GlobalConfig.autoLogin = _param.autoLogin || "";
        GlobalConfig.password = _param.password || "";
        GlobalConfig.hasCamera = (typeof  _param.hasCamera == "boolean") ? _param.hasCamera : false;
        GlobalConfig.hasMicrophone = (typeof  _param.hasMicrophone == "boolean") ? _param.hasMicrophone : false;

        //loger.log("autoLoginMd5", GlobalConfig.classId, GlobalConfig.userId, GlobalConfig.userRole);
        let autoLoginMd5 = MD5("" + GlobalConfig.classId + GlobalConfig.userId + GlobalConfig.userRole);
        //loger.log("joinClass-GlobalConfig.autoLogin", GlobalConfig.autoLogin, "autoLoginMd5-", autoLoginMd5);
        if (GlobalConfig.autoLogin && autoLoginMd5 == GlobalConfig.autoLogin) {
            // MD5(classId+userId+userRole)==m
            //自动登录，跳过验证流程
            loger.log("自动登录");
            this._sassJoinSuccessHandler();
        } else {
            //不能自动登录，开始校验
            if (_sass) {
                _sass.passwordAndMd5Checking(GlobalConfig.getClassInfo());
            }
        }
    }

    // 用classId向SASS平台获取入会验证信息成功
    _sassInitSuccessHandler(_data) {
        //{"siteId":"h5test","passwordRequired":true,"md5":"de399d5540b3da2fbc1eb0a770d4fd66","code":0,"msType":1}
        //储存数据
        GlobalConfig.md5 = _data.md5 || "";//这个暂时用假数据，后台接口写完就有数据了
        GlobalConfig.msType = _data.msType || 1;
        GlobalConfig.siteId = _data.siteId || "";
        GlobalConfig.classType = _data.meetingType || 0;

        //host默认需要密码，Sass服务器只判断学生是否需要密码，没有判断老师的
        GlobalConfig.passwordRequired = _data.passwordRequired || false;//md5验证的时候需要Sass返回的值,不能更改

        loger.log('初始化课堂验证完成.');

        //设置当前的课堂状态
        GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_1);
        //返回给客户端初始化成功的数据
        let initSuccessCallBackData = {};
        initSuccessCallBackData.siteId = GlobalConfig.siteId;
        initSuccessCallBackData.classId = GlobalConfig.classId;
        initSuccessCallBackData.userRole = GlobalConfig.userRole;
        initSuccessCallBackData.userId = GlobalConfig.userId;
        initSuccessCallBackData.userName = GlobalConfig.userName;
        initSuccessCallBackData.classType = GlobalConfig.classType;

        //host默认需要密码，Sass服务器只判断学生是否需要密码，没有判断老师的
        if (GlobalConfig.userRole == ApeConsts.host) {
            initSuccessCallBackData.passwordRequired = true;
        } else {
            initSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;
        }

        this._emit(MessageTypes.CLASS_INIT_SUCCESS, initSuccessCallBackData);
    }

    // 通过SASS平台验证(密码和MD5)
    _sassJoinSuccessHandler(_data) {
        //获取课堂最完整的数据
        if (_sass) {
            _sass.getClassParam();
        }
    }

    //获取课堂所有参数 api/meeting/detail.do? flash中的接口文件是 getClassParam.do
    _sassGetClassParamSuccessHandler(_data) {
        loger.log('获取课堂课堂信息完成.');
        //包含整个课堂最全的信息,储存数据
        if (_data) {
            GlobalConfig.mcuDelay = _data.h5Delay || 0;//mcu消息延迟的时间间隔，单位(秒)，结合客户端传的messageDelay的值使用
            GlobalConfig.className = _data.meetingName || "";
            GlobalConfig.classBeginTime = _data.beginTime || "";
            GlobalConfig.classEndTime = _data.endTime || "";
            GlobalConfig.userIp = _data.userIp || "";

            GlobalConfig.maxVideoChannels = _data.maxVideoChannels;
            GlobalConfig.maxAudioChannels = _data.maxAudioChannels;

            //视频质量相关设置
            GlobalConfig.fps = _data.fps || 15;
            GlobalConfig.gop = _data.gop || 3;
            GlobalConfig.videoQuality = _data.videoQuality || 2;

            //是否自动开始(身份是host的时候才用到的)
            GlobalConfig.isAutoStartClass = _data.autoRecord || 0;

            GlobalConfig.setDocListPrepare(_data.docListPrepare);  //提前上传的文档列表
            GlobalConfig.setRecordList(_data.recordList);//录制回放地址
            GlobalConfig.setDocList(_data.docList);//文档地址
            GlobalConfig.setMsList(_data.msList);//推流播流服务器地址
            GlobalConfig.setRsList(_data.rsList);//播放m3u8格式的地址
            GlobalConfig.setMcuList(_data.mcuList);//mcu
            GlobalConfig.setMusicList(_data.musicList);//
            GlobalConfig.setMusicListPrepare(_data.musicListPrepare);//提前上传的声音文件列表


            if (_data.mcuList && _data.mcuList.length > 0) {
                /* //MCU地址默认使用第一个
                 GlobalConfig.MCUServerIP = _data.mcuList[0].ip || "";
                 GlobalConfig.MCUServerPort = _data.mcuList[0].port || "";*/
                //随机选择一个
                let index = parseInt(Math.random() * _data.mcuList.length);
                GlobalConfig.MCUServerIP = _data.mcuList[index].ip || "";
                GlobalConfig.MCUServerPort = _data.mcuList[index].port || "";
                loger.log('初始->MCU->.', GlobalConfig.MCUServerIP, GlobalConfig.MCUServerPort);
            }

            //上课中视频推流播流地址
            if (_data.msList && _data.msList.length > 0) {
                //MS地址默认使用第一个
                /* GlobalConfig.MSServerIP = _data.msList[0].ip || "";
                 GlobalConfig.MSServerPort = _data.msList[0].port || "";*/

                let index = parseInt(Math.random() * _data.msList.length);
                GlobalConfig.MSServerIP = _data.msList[index].ip || "";
                GlobalConfig.MSServerPort = _data.msList[index].port || "";
                loger.log('初始->MS->.', GlobalConfig.MSServerIP, GlobalConfig.MSServerPort);
            }

            //录制回放时m3u8播流地址
            if (_data.rsList && _data.rsList.length > 0) {
                //RS地址默认使用第一个
                //GlobalConfig.RSServerIP = _data.rsList[0].ip || "";
                //GlobalConfig.RSServerPort = _data.rsList[0].port || "";

                let index = parseInt(Math.random() * _data.rsList.length);
                GlobalConfig.RSServerIP = _data.rsList[index].ip || "";
                GlobalConfig.RSServerPort = _data.rsList[index].port || "";
                loger.log('初始->RS->.', GlobalConfig.RSServerIP, GlobalConfig.RSServerPort);
            }

            //文档地址
            if (_data.docList && _data.docList.length > 0) {
                //doc上传地址，随机获取一个
                let index = parseInt(Math.random() * _data.docList.length);
                loger.log("docServer->", _data.docList[index]);
                GlobalConfig.DOCServerIP = _data.docList[index].ip || "";
                GlobalConfig.DOCServerPort = _data.docList[index].port || "";
                loger.log('初始->DOC->.', GlobalConfig.DOCServerIP, GlobalConfig.DOCServerPort);
            }

            //record
            if (_data.recordList && _data.recordList.length > 0) {
                //地址默认使用第一个
                //GlobalConfig.RecordServerIP = _data.recordList[0].ip || "";
                //GlobalConfig.RecordServerPort = _data.recordList[0].port || "";

                let index = parseInt(Math.random() * _data.recordList.length);
                GlobalConfig.RecordServerIP = _data.recordList[index].ip || "";
                GlobalConfig.RecordServerPort = _data.recordList[index].port || "";
                loger.log('初始->RECORD->.', GlobalConfig.RecordServerIP, GlobalConfig.RecordServerPort);
            }

        }

        if (_data.currentInfo) {
            //根据从Sass获取的数据信息,同步最后一次保存的课堂状态信息
            loger.log("本地同步最后一次保存过的课堂状态信息");
            try {
                GlobalConfig.setClassStatusInfo(JSON.parse(_data.currentInfo));
            } catch (err) {
                GlobalConfig.setClassStatusInfo(_data.currentInfo);
            }
            loger.log(GlobalConfig.classStatusInfo);
        } else {
            loger.log("还没有保存过课堂状信息");
        }


        //录制回放不需要获取ip信息和选点
        if (GlobalConfig.isRecordPlayBack) {
            if (_recordPlayback) {
                //开启录制回放流程
                loger.log("开启录制回放流程");
                _recordPlayback.readyRecordPlay();
            } else {
                loger.warn("开启录制回放流程失败->还未创建模块");
            }
        } else {
            //根据用户的userIp获取信息,选点
            this.getUserIpInfo();
        }
    }

    //根据UserIp获取ip信息,选点
    getUserIpInfo() {
        if (_ipManager) {
            _ipManager.getUserIpInfo("", GlobalConfig.userIp, this._getUserIpCallbackHandler.bind(this), 1000);
        }
    }

    //获取IP信息完成
    _getUserIpCallbackHandler(_data) {
        //获取IP信息，返回一次就不再处理
        if (this.isGetUserIpCallback) {
            return;
        }
        this.isGetUserIpCallback = true;
        if (_data && _data.ret == "ok") {
            GlobalConfig.country = _data.country;//国家
            GlobalConfig.city = _data.city;//城市
            GlobalConfig.province = _data.province;//服务商
            GlobalConfig.isp = _data.isp;//服务商
        }

        //合并MCU 、MS的列表
        this._mergeMcuAndMsList();

        //开始选点
        let _this = this;
        this._getFastestMsServer(function (_data) {
            loger.log("MS选点结束->", _data);
            if (_data && _data.ip) {
                GlobalConfig.MSServerIP = _data.ip || "";
                GlobalConfig.MSServerPort = _data.port || "";
            }
            loger.log("当前使用的MS->", GlobalConfig.MSServerIP, GlobalConfig.MSServerPort);
            _this.isGetFastestMcuCallback = true;
            _this._startConnectMCU();
        });
        this._getFastestMcuServer(function (_data) {
            loger.log("MCU选点结束->", _data);
            if (_data && _data.ip) {
                GlobalConfig.MCUServerIP = _data.ip || "";
                GlobalConfig.MCUServerPort = _data.port || "";
            }
            loger.log("当前使用的MCU->", GlobalConfig.MCUServerIP, GlobalConfig.MCUServerPort);
            _this.isGetFastestMsCallback = true;
            _this._startConnectMCU();
        });
    }

    //开始连接MCU(MCU和MS都选点结束之后才开始连接)
    _startConnectMCU() {
        if (this.isGetFastestMcuCallback && this.isGetFastestMsCallback) {
            this._joinMCU();
        }
    }

    //合并Sever和Sass的mcu、ms列表
    _mergeMcuAndMsList() {
        if (_ipManager) {
            GlobalConfig.mcuListFromServer = _ipManager.getServerMcuList(
                GlobalConfig.country,
                GlobalConfig.province,
                GlobalConfig.city,
                GlobalConfig.isp,
                Server.serverList);

            GlobalConfig.msListFromServer = _ipManager.getServerMsList(
                GlobalConfig.country,
                GlobalConfig.province,
                GlobalConfig.city,
                GlobalConfig.isp,
                Server.serverList);
        }


        //console.log(" GlobalConfig.mcuListFromServer", GlobalConfig.mcuListFromServer)
        //console.log(" GlobalConfig.msListFromServer", GlobalConfig.msListFromServer)
        //合并所有MCU、MS 列表
        GlobalConfig.mcuListAll.length = 0;
        GlobalConfig.mcuListAll = GlobalConfig.mcuListAll.concat(GlobalConfig.mcuList, GlobalConfig.mcuListFromServer);
        GlobalConfig.msListAll.length = 0;
        GlobalConfig.msListAll = GlobalConfig.msListAll.concat(GlobalConfig.msList, GlobalConfig.msListFromServer);

        //console.log(" GlobalConfig.mcuListAll", GlobalConfig.mcuListAll)
        //console.log(" GlobalConfig.msListAll", GlobalConfig.msListAll)
    }

    //开始MCU选点操作
    _getFastestMcuServer(_callback) {
        if (_ipManager) {
            _ipManager.getFastestMcuServer(GlobalConfig.mcuListAll, _callback);
        } else {
            if (_callback) {
                _callback({'ip': ""});
            }
        }
    }

    // //开始MS选点操作
    _getFastestMsServer(_callback) {
        if (_ipManager) {
            _ipManager.getFastestMsServer(GlobalConfig.msListAll, _callback);
        } else {
            if (_callback) {
                _callback({ip: ""});
            }
        }
    }

    //保存课堂状态信息
    _sassSaveClassStatusInfo(_param) {
        //{isForce:true}   isForce->是否强制提交(true为是）
        //这个是特殊权限
        let isForce = false;
        if (_param && _param.isForce == true) {
            isForce = true;
        }

        if (GlobalConfig.isHost || isForce) {
            //只有加入课堂之后才能保存数据
            if (GlobalConfig.getCurrentStatus().code == GlobalConfig.statusCode_2.code) {
                //POST 保存数据
                _sass.saveClassStatusInfo({"classStatusInfo": GlobalConfig.classStatusInfo});//保存课堂状态信息
            } else {
                loger.error("不能保存课堂数据", GlobalConfig.getCurrentStatus());
            }
        } else {
            loger.log("没有保存课堂状态信息的权限->身份", GlobalConfig.userRole);
        }
    }

    //保存会态信息成功
    _sassSaveClassStatusInfoSuccessHandler(_data) {
        loger.log('保存课堂状态信息成功.');
        loger.log(_data);
    }

    _sassSaveClassRecordInfoSuccessHandler(_data) {
        loger.log('保存课堂录制信息成功.');
        loger.log(_data);
    }

    //Sass校验流程结束之后，开始加入MCU
    _joinMCU() {
        loger.log('加入课堂->.');
        if (_mcu) {
            _mcu.joinMCU(GlobalConfig.getClassInfo());
        }
    }

    _switchMcuIp() {
        loger.log('切换MCU IP->.');
        if (_mcu) {
            _mcu.switchMCUIp(GlobalConfig.getClassInfo());
        }
    }

    // MCU 课堂成功
    _mcuJoinMCUClassSuccessHandler(_data) {
        //loger.log('MCU 课堂成功.');
        GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_2);

        //返回给客户端初始化成功的数据
        let joinClassSuccessCallBackData = {};

        joinClassSuccessCallBackData.isRecordPlayBack = GlobalConfig.isRecordPlayBack;

        joinClassSuccessCallBackData.DOCServerIP = GlobalConfig.DOCServerIP;
        joinClassSuccessCallBackData.DOCServerPort = GlobalConfig.DOCServerPort;

        joinClassSuccessCallBackData.classStatus = GlobalConfig.classStatus;
        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.className = GlobalConfig.className;
        joinClassSuccessCallBackData.h5Module = GlobalConfig.h5Module;
        joinClassSuccessCallBackData.isHost = GlobalConfig.isHost;
        joinClassSuccessCallBackData.maxAudioChannels = GlobalConfig.maxAudioChannels;
        joinClassSuccessCallBackData.maxVideoChannels = GlobalConfig.maxVideoChannels;
        joinClassSuccessCallBackData.mcuDelay = GlobalConfig.mcuDelay;

        joinClassSuccessCallBackData.msType = GlobalConfig.msType;
        joinClassSuccessCallBackData.nodeId = GlobalConfig.nodeId;
        joinClassSuccessCallBackData.password = GlobalConfig.password;
        joinClassSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;//  老师的默认是true
        //GlobalConfig.passwordRequired  老师的默认是true
        //GlobalConfig.portal=_data.portal;
        joinClassSuccessCallBackData.role = GlobalConfig.role;
        joinClassSuccessCallBackData.siteId = GlobalConfig.siteId;
        joinClassSuccessCallBackData.topNodeID = GlobalConfig.topNodeID;
        joinClassSuccessCallBackData.userId = GlobalConfig.userId;
        joinClassSuccessCallBackData.userName = GlobalConfig.userName;
        joinClassSuccessCallBackData.userRole = GlobalConfig.userRole;
        joinClassSuccessCallBackData.userType = GlobalConfig.userType;

        joinClassSuccessCallBackData.siteId = GlobalConfig.siteId;
        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.userRole = GlobalConfig.userRole;
        joinClassSuccessCallBackData.userId = GlobalConfig.userId;
        joinClassSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;
        joinClassSuccessCallBackData.classType = GlobalConfig.classType || ApeConsts.CLASS_TYPE_INTERACT;

        joinClassSuccessCallBackData.country = GlobalConfig.country;//国家
        joinClassSuccessCallBackData.city = GlobalConfig.city;//城市
        joinClassSuccessCallBackData.province = GlobalConfig.province;//服务商
        joinClassSuccessCallBackData.isp = GlobalConfig.isp;//服务商

        joinClassSuccessCallBackData.classTimestamp = GlobalConfig.classTimestamp;//课堂进行的累积时间
        joinClassSuccessCallBackData.recordTimestamp = GlobalConfig.recordTimestamp;//课堂录制的累积时间
        joinClassSuccessCallBackData.recordPlaybackMaxTime = GlobalConfig.recordPlaybackMaxTime;//录制回放的总时间

        joinClassSuccessCallBackData.fps = GlobalConfig.fps;
        joinClassSuccessCallBackData.gop = GlobalConfig.gop;
        joinClassSuccessCallBackData.videoQuality = GlobalConfig.videoQuality;

        loger.log('加入课堂成功->');
        loger.log(joinClassSuccessCallBackData);

        //加入课堂成功，广播消息
        this._emit(MessageTypes.CLASS_JOIN_SUCCESS, joinClassSuccessCallBackData);
    }

    //切换MCU ->_param->{reConnect:false} //reConnect(是否立即替换当前的ip并且重新连接)
    _switchMcuIpHandler(_param) {
        if (GlobalConfig.isRecordPlayBack) {
            loger.log('录制回放->不进行MCU动态选点');
            return;
        }
        loger.log('MCU->动态选点');
        let _this = this;
        this._getFastestMcuServer(function (_data) {
            loger.log("MCU选点结束->", _data);
            //记录当前的IP地址，选点结束后需要判断一下是否是新的IP；
            let oldIp= GlobalConfig.MCUServerIP;

            if (_data && _data.ip) {
                GlobalConfig.MCUServerIP = _data.ip || "";
                GlobalConfig.MCUServerPort = _data.port || "";
            } else {
                //随机选择一个
                if (GlobalConfig.mcuList && GlobalConfig.mcuList.length > 0) {
                    let index = parseInt(Math.random() * GlobalConfig.mcuList.length);
                    GlobalConfig.MCUServerIP = GlobalConfig.mcuList[index].ip || "";
                    GlobalConfig.MCUServerPort = GlobalConfig.mcuList[index].port || "";
                }
            }
            if(oldIp&&oldIp!=GlobalConfig.MCUServerIP){
                loger.log('MCU->最新地址->', GlobalConfig.MCUServerIP, GlobalConfig.MCUServerPort);
                //判断是否需要主动断开当前的连接然后重连新的服务器
                if (_param && _param.reConnect == true) {
                    loger.log('MCU->切换到最新的IP->', GlobalConfig.MCUServerIP, GlobalConfig.MCUServerPort);
                    _this._startConnectMCU();
                }else {
                    //不需要断开当前的连接，更改ip即可
                    _this._switchMcuIp();
                }
            }else {
                //如果选点结束后获得的ip和当前的IP相同，不需要切换
                loger.log('MCU不需要切换->之前的IP->',oldIp,"新的IP->",GlobalConfig.MCUServerIP);
            }
        });
    }

    //切换MS ->_param->{reConnect:false} //reConnect(是否立即替换当前的ip并且重新连接)
    _switchMsIpHandler(_param) {
        if (GlobalConfig.isRecordPlayBack) {
            //录制回放不做操作
            loger.log('录制回放->不进行MS动态选点');
            return;
        }
        loger.log('MS->动态选点');
        let _this = this;
        this._getFastestMsServer(function (_data) {
            loger.log("MS选点结束->", _data);
            //记录当前的IP地址，选点结束后需要判断一下是否是新的IP；
            let oldIp= GlobalConfig.MCUServerIP;

            if (_data && _data.ip) {
                GlobalConfig.MSServerIP = _data.ip || "";
                GlobalConfig.MSServerPort = _data.port || "";
            } else {
                //随机选择一个
                if (GlobalConfig.msList && GlobalConfig.msList.length > 0) {
                    let index = parseInt(Math.random() * GlobalConfig.msList.length);
                    GlobalConfig.MSServerIP = GlobalConfig.msList[index].ip || "";
                    GlobalConfig.MSServerPort = GlobalConfig.msList[index].port || "";
                }
            }


            if(oldIp&&oldIp!=GlobalConfig.MSServerIP){
               /* loger.log('MS->切换地址->', GlobalConfig.MSServerIP, GlobalConfig.MSServerPort);
                //判断是否需要断开当前的连接重连新的服务器
                if (_param && _param.reConnect == true) {
                    loger.log('MS->最新地址->', GlobalConfig.MSServerIP, GlobalConfig.MSServerPort);
                }*/
                loger.log('MS->最新地址->', GlobalConfig.MSServerIP, GlobalConfig.MSServerPort);
            }else {
                //如果选点结束后获得的ip和当前的IP相同，不需要切换
                loger.log('MS不需要切换->IP',GlobalConfig.MSServerIP);
            }

        });
    }


    //Sass删除文档数据
    _sassDeleteDocument(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }

        //判断传入的参数是否存在
        if (_param == null || EngineUtils.isEmptyObject(_param)) {
            loger.error('删除文档失败->参数错误', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_DOC_DELETE_FAILED_PARAM);
            return;
        }
        //判断必要的参数字段值
        if (_param.itemIdx == null || isNaN(_param.itemIdx) || _param.docId == null || _param.docId == "") {
            loger.error('删除文档失败->', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_DOC_DELETE_FAILED_PARAM);
            return;
        }
        loger.log('删除文档->', _param);

        if (_sass) {
            _sass.sassDeleteDocument(_param);
        }
    }

    _sendDocBroadcastMsg(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_doc_ape) {
            _doc_ape.sendDocBroadcastMsg(_param);
        }
    }

    //Sass删除文档成功之后，同步删除MCU数据
    _sassDeleteDocumentSuccess(_param) {
        loger.log('删除文档成功->', _param);
        this._sendDocumentDelete(_param);
    }

    //ConferApe
    //开始上课
    _sendStartClass(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }

        if (_confer_ape) {
            _confer_ape.startClass(_param);
        }
    }

    //暂停上课
    _sendPauseClass(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_confer_ape) {
            _confer_ape.pauseClass(_param);
        }
    }

    //停止上课
    _sendCloseClass(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_confer_ape) {
            _confer_ape.closeClass(_param);
        }
    }

    // 离开课堂
    _leaveClass() {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }

        //停止推流
        if (_video_ape) {
            _video_ape.stopPublishVideo();
        }
        if (_audio_ape) {
            _audio_ape.stopPublishAudio();
        }
        //离开课堂
        if (_confer_ape) {
            _confer_ape.stopRecord();
            _confer_ape.leaveClass();
        }
        //断开MCU连接
        if (_mcu) {
            _mcu.leaveMCU();
            GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_3);
        }
    }


    //ChatApe
    // 发送聊天消息
    _sendChatMsg(_messageInfo) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_messageInfo === null || EngineUtils.isEmptyObject(_messageInfo)) {
            loger.log('发送聊天消息失败->参数错误', _messageInfo);
            return;
        }
        if (_chat_ape) {
            _chat_ape.sendChatMsg(_messageInfo);
        }
    }

    //VidoeApe
    videoUpdate(_data) {
        //视频同步的消息发送改变,需要通知ferApe模块中的用户更新状态
        if (_confer_ape) {
            _confer_ape.updaterRosterStatus(_data);
        }
    }

    _sendVideoBroadcastMsg(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_video_ape) {
            return _video_ape.sendVideoBroadcastMsg(_param);
        }
    }

    _getVideoPlayPath(_param) {
        if (_video_ape) {
            return _video_ape.getPlayVideoPath(_param);
        }
    }

    _getVideoPublishPath(_param) {
        if (_video_ape) {
            return _video_ape.getPublishVideoPath(_param);
        }
    }

    _getVideoAllChannelInfo(_param) {
        if (_video_ape) {
            return _video_ape.getAllChannelInfo(_param);
        }
    }

    _publishVideo(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return {"code": ApeConsts.RETURN_FAILED, "data": ""};
        }
        if (_video_ape) {
            return _video_ape.publishVideo(_param);
        }
    }

    _stopPublishVideo(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return {"code": ApeConsts.RETURN_FAILED, "data": ""};
        }
        if (_video_ape) {
            return _video_ape.stopPublishVideo(_param);
        }
    }

    //AudioApe
    audioUpdate(_data) {
        //音频同步的消息发送改变,需要通知ferApe模块中的用户更新状态
        if (_confer_ape) {
            _confer_ape.updaterRosterStatus(_data);
        }
    }

    sendAudioCommandMsg(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return {"code": ApeConsts.RETURN_FAILED, "data": ""};
        }
        if (_audio_ape) {
            return _audio_ape.sendAudioBroadcastMsg(_param);
        }
    }

    _getPlayAudioPath(_param) {
        if (_audio_ape) {
            return _audio_ape.getAudioPlayPath(_param);
        }
    }

    _getPublishAudioPath(_param) {
        if (_audio_ape) {
            return _audio_ape.getAudioPublishPath(_param);
        }
    }

    _getAudioAllChannelInfo(_param) {
        if (_audio_ape) {
            return _audio_ape.getAllChannelInfo(_param);
        }
    }

    _publishAudio(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return {"code": ApeConsts.RETURN_FAILED, "data": ""};
        }
        if (_audio_ape) {
            return _audio_ape.publishAudio(_param);
        }
    }

    _stopPublishAudio(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return {"code": ApeConsts.RETURN_FAILED, "data": ""};
        }
        if (_audio_ape) {
            return _audio_ape.stopPublishAudio(_param);
        }
    }


    //WhiteBoardApe
    // 添加标注,发送信息
    _sendInsertAnnotaion(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_whiteboard_ape) {
            _whiteboard_ape.sendInsetAnnotaion(_param);
        }
    }

    //删除当前页面上的所有标注
    _sendDeleteCurPageAnnotation(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_whiteboard_ape) {
            _whiteboard_ape.sendDeleteCurPageAnnotation(_param);
        }
    }

    //删除所有标注
    _sendDeleteAllAnnotation(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_whiteboard_ape) {
            _whiteboard_ape.sendDeleteAllAnnotation(_param);
        }
    }

    //返回上一步标注
    _sendGotoPrev(_param) {
        if (_whiteboard_ape) {
            _whiteboard_ape.sendGotoPrev(_param);
        }
    }


    //DocApe
    //获取文档的所有资源地址
    _getDocFullAddress(_param) {
        if (_doc_ape) {
            return _doc_ape.getDocFullAddress(_param);
        } else {
            loger.error("文档模块还没有创建无法获取");
            return {"code": ApeConsts.RETURN_FAILED, "data": "文档模块还没有创建无法获取"};
        }
    }

    //获取文档完整路径
    _getDocImageFullPath(_param) {
        if (_doc_ape) {
            return _doc_ape.getDocImageFullPath(_param);
        } else {
            loger.error("文档模块还没有创建无法获取");
            return [];
        }
    }

    _getDocPDFFullPath(_param) {
        if (_doc_ape) {
            return _doc_ape.getDocPDFFullPath(_param);
        } else {
            loger.error("文档模块还没有创建,无法获取");
            return [];
        }
    }

    //上传文档
    _sendDocumentUpload(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_doc_ape) {
            _doc_ape.documentUpload(_param);
        }
    }

    //切换文档
    _sendDocumentSwitchDoc(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_doc_ape) {
            _doc_ape.documentSwitchDoc(_param);
        }
    }

    //操作文档(翻页)
    _sendDocumentSwitchPage(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_doc_ape) {
            _doc_ape.documentSwitchPage(_param);
        }
    }

    //操作文档(缩放、滚动...)
    _sendDocumentCommand(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_doc_ape) {
            _doc_ape.documentCommand(_param);
        }
    }

    //删除文档
    _sendDocumentDelete(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_doc_ape) {
            _doc_ape.documentDelete(_param);
        }
    }

    //删除所有文档
    _documentDeleteAll(_param) {
        if (!_mcu.connected) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        if (_doc_ape) {
            _doc_ape.documentDeleteAll(_param);
        }
    }

    //// 文档变更，白板也需要做处理
    docUpdateHandler(_data) {
        if (!_mcu.connected && !GlobalConfig.isRecordPlayBack) {
            loger.warn(GlobalConfig.getCurrentStatus());
            return;
        }
        //loger.log('Doc UpdateId ->');
        //loger.log(_data);
        if (_whiteboard_ape) {
            _whiteboard_ape.docUpdateHandler(_data);
        }
    }

    //文档删除，白板也需要做处理
    docDeleteHandler(_data) {
        if (_whiteboard_ape) {
            _whiteboard_ape.docDeleteHandler(_data);
        }
    }

    //文档加入频道成功，同步到MCU服务器上的数据
    docJoinChannelSuccess() {
        loger.log("docJoinChannelSuccess->isHost=", GlobalConfig.isHost, "length=", GlobalConfig.docListPrepare.length);
        //loger.log("docJoinChannelSuccess  docListPrepare=");
        //如果是主持人，那么需要判断一下文档模块同步的数据和从sass获取的文档数据是否相同，如果mcu服务器不存在的，需要上传
        if (GlobalConfig.isHost && GlobalConfig.docListPrepare.length > 0) {
            for (let i = 0; i < GlobalConfig.docListPrepare.length; i++) {
                let value = GlobalConfig.docListPrepare[i];
                if (value) {
                    //loger.log("判断是否需要把提前上传的文档上传到mcu", value);
                    let paramInfo = {
                        "pageNum": value.pdfSize,
                        "fileName": value.name,
                        "fileType": value.type,
                        "relativeUrl": value.relativeLocation,
                        "url": value.absoluteLocation,
                        "creatUserId": value.createUserID,
                        "docId": value.id,
                        "md5": value.MD5,
                        "visible": false
                    };
                    this._sendDocumentUpload(paramInfo);
                }
            }
        }
    }

    //录制回放相关的处理------------------------------------------------
    //录制回放初始化
    _initRecordPlayback(_param) {
        //{"classId":"1653304953","portal":"112.126.80.182:80","userRole":"normal","userId":0}
        if (_param == null) {
            loger.error('录制回放初始化失败->参数错误');
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_INIT_RECORD_PLAY_BACK_FAILED);
            return;
        }
        //判断必要的参数字段值
        if (_param.classId == null || isNaN(_param.classId) || _param.portal == null || _param.portal == "") {
            loger.error('录制回放初始化失败->', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_INIT_RECORD_PLAY_BACK_FAILED);
            return;
        }
        loger.log('录制回放初始化->', _param);

        //保存参数
        GlobalConfig.isRecordPlayBack = true;//设置为录制回放状态
        GlobalConfig.classId = parseInt(_param.classId);
        GlobalConfig.portal = _param.portal;
        GlobalConfig.userRole = ApeConsts.normal;//*************很重要，录制回放的时候，身份模式是普通人********
        GlobalConfig.userId = _param.userId || "0";
        GlobalConfig.userName = _param.userName || "";

        //获取课堂最完整的数据，录制回放需要获取课堂数据
        if (_sass) {
            _sass.getClassParam();
        }
    }

    //开始录制回放
    _startRecordPlayback(_param) {
        if (_recordPlayback) {
            _recordPlayback.startRecordPlayback(_param);
        }
    }

    //停止录制回放
    _stopRecordPlayback(_param) {
        if (_recordPlayback) {
            _recordPlayback.stopRecordPlayback(_param);
        }
    }

    //暂停录制回放
    _pauseRecordPlayback(_param) {
        if (_recordPlayback) {
            _recordPlayback.pauseRecordPlayback(_param);
        }
    }

    //seek录制回放
    _seekRecordPlayback(_param) {
        if (_recordPlayback) {
            _recordPlayback.seekRecordPlayback(_param);
        }
    }

    //录制回放状态更新
    _recordPlaybackClearDataHandler(_param) {
        loger.log("录制回放状态更新->")
        if (_doc_ape) {
            _doc_ape.clearData();
        }
        if (_whiteboard_ape) {
            _whiteboard_ape.clearData();
        }
    }

    //录制回放加入 课堂成功
    _joinRecordPlaybackSuccessHandler(_data) {
        loger.log('加入录制回放成功.');
        GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_2);

        //返回给客户端初始化成功的数据
        let joinClassSuccessCallBackData = {};

        joinClassSuccessCallBackData.isRecordPlayBack = GlobalConfig.isRecordPlayBack;

        joinClassSuccessCallBackData.DOCServerIP = GlobalConfig.DOCServerIP;
        joinClassSuccessCallBackData.DOCServerPort = GlobalConfig.DOCServerPort;

        joinClassSuccessCallBackData.classStatus = GlobalConfig.classStatus;
        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.className = GlobalConfig.className;
        joinClassSuccessCallBackData.h5Module = GlobalConfig.h5Module;
        joinClassSuccessCallBackData.isHost = GlobalConfig.isHost;//
        joinClassSuccessCallBackData.maxAudioChannels = GlobalConfig.maxAudioChannels;
        joinClassSuccessCallBackData.maxVideoChannels = GlobalConfig.maxVideoChannels;
        joinClassSuccessCallBackData.mcuDelay = GlobalConfig.mcuDelay;

        joinClassSuccessCallBackData.msType = GlobalConfig.msType;
        joinClassSuccessCallBackData.nodeId = GlobalConfig.nodeId;
        joinClassSuccessCallBackData.password = GlobalConfig.password;
        joinClassSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;//  老师的默认是true
        //GlobalConfig.passwordRequired  老师的默认是true
        //GlobalConfig.portal=_data.portal;
        joinClassSuccessCallBackData.role = GlobalConfig.role;
        joinClassSuccessCallBackData.siteId = GlobalConfig.siteId;
        joinClassSuccessCallBackData.topNodeID = GlobalConfig.topNodeID;
        joinClassSuccessCallBackData.userId = GlobalConfig.userId;
        joinClassSuccessCallBackData.userName = GlobalConfig.userName;
        joinClassSuccessCallBackData.userRole = GlobalConfig.userRole;
        joinClassSuccessCallBackData.userType = GlobalConfig.userType;

        joinClassSuccessCallBackData.siteId = GlobalConfig.siteId;
        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.userRole = GlobalConfig.userRole;
        joinClassSuccessCallBackData.userId = GlobalConfig.userId;
        joinClassSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;
        joinClassSuccessCallBackData.classType = GlobalConfig.classType || ApeConsts.CLASS_TYPE_INTERACT;

        joinClassSuccessCallBackData.country = GlobalConfig.country;//国家
        joinClassSuccessCallBackData.city = GlobalConfig.city;//城市
        joinClassSuccessCallBackData.province = GlobalConfig.province;//服务商
        joinClassSuccessCallBackData.isp = GlobalConfig.isp;//服务商

        joinClassSuccessCallBackData.classTimestamp = GlobalConfig.classTimestamp;//课堂进行的累积时间
        joinClassSuccessCallBackData.recordTimestamp = GlobalConfig.recordTimestamp;//录制累积的总时间
        joinClassSuccessCallBackData.recordPlaybackMaxTime = GlobalConfig.recordPlaybackMaxTime;//录制回放的总时间

        joinClassSuccessCallBackData.fps = GlobalConfig.fps;
        joinClassSuccessCallBackData.gop = GlobalConfig.gop;
        joinClassSuccessCallBackData.videoQuality = GlobalConfig.videoQuality;

        loger.log(joinClassSuccessCallBackData);
        //和加入课堂成功使用同样的消息处理
        this._emit(MessageTypes.CLASS_JOIN_SUCCESS, joinClassSuccessCallBackData);
    }

}