//*
// WebRtc
// */
import Emiter from 'Emiter';
import Loger from "Loger";
import $ from "jquery";
import GlobalConfig from 'GlobalConfig';
import ApeConsts from './ApeConsts';
import EngineUtils from 'EngineUtils';
import MessageTypes from 'MessageTypes';
var AgoraRTC = require('../AgoraRTCSDK-1.14.0');
let loger = Loger.getLoger('WebRtcApe');
const SIZE_480=480;
const SIZE_360=360;
const SIZE_320=320;
const SIZE_240=240;
const SIZE_160=160;
const SIZE_120=120;
class WebRtcApe extends Emiter {
  constructor() {
    super();
    this.nameDisplay = "block";//默认显示名字
    this.appId = '';
    this.appCertificate = "";
    this.appRecordingKey = "";

    this.setConfigTimestamp=0;//设置旁路地址的时间戳
    this.configPublisherUrl = "";//旁路地址；
    this.m3u8Url="";//旁路拉流地址
    this.rtmpUrl="";//旁路拉流地址

    this.channelKey = null;
    this.channelId = "";
    this.uid = 0;
    this.info = ""

    this.reAddRemoteStreamDelay = 0;//重连远程视频的计时器
    this.rePublishDelay = 0;//重新推流的间隔

    this.mode = "interop";
    this.client = null;
    this.localStream = null;
    this.cameras = [];
    this.microphones = [];
    this.curCameraId = "";
    this.curMicrophoneId = "";

    this.remoteVideoList = {};//记录远程视频流

    this.pWidth=SIZE_480;
    this.pHeight=SIZE_360;
    this.pFrameRate=30;
    this.pBitrate=500;

    //120P	0	160x120	15	65
    //240P	20	320x240	15	200
    //360P_8	37	480x360	30	490
    this.videoResolution = "240P";
    this.isOpenVideo = true;

    this.firstPublishSuccess=false;//记录加入频道成功之后是否推流成功过，离开频道之后需要设置为false

    this.isPublish = false;//当前是否正在推流
    this.videoScale=1;//视图的缩放比例，默认为1；


    this.normalRemoteViewId = "";
    this.normalRemoteStyle = "";
    this.normalRemoteVideoWidth = SIZE_480;
    this.normalRemoteVideoHeight = SIZE_360;

    this.localViewId = "";
    this.localStyle = "";
    this.localVideoWidth = SIZE_480;
    this.localVideoHeight = SIZE_360;

    this.hostRemoteViewId = "";
    this.hostRemoteStyle = "";
    this.hostRemoteVideoWidth = SIZE_480;
    this.hostRemoteVideoHeight = SIZE_360;

    this.invisibleViewId = "";
    this.invisibleStyle = "";
    this.invisibleVideoWidth = SIZE_480;
    this.invisibleVideoHeight = SIZE_360;
    this.xdyRemote = "xdy_remote";

    this.localWebRtcVideoClass='localWebRtcVideoClass';//本地视图统一的class名称
    this.invisibleWebRtcVideoClass='invisibleWebRtcVideoClass';
    this.normalWebRtcVideoClass='normalWebRtcVideoClass';
    this.hostWebRtcVideoClass='hostWebRtcVideoClass';

    //webRtc sdk
    this.client = AgoraRTC.createClient({mode: this.mode});

    this.getDevices(null, (devices)=> {
      if (this.cameras && this.cameras.length > 0) {
        this.curCameraId = this.cameras[0].deviceId || "";
        GlobalConfig.curCamera = this.cameras[0].label || "";
      }
      if (this.microphones && this.microphones.length > 0) {
        this.curMicrophoneId = this.microphones[0].deviceId || "";
        GlobalConfig.curMicrophone = this.microphones[0].label || "";
      }
    });
  }

  initApp(_params, _callback) {
    loger.log("初始化WebRtc");
    if (_params) {
      this.appId = _params.appId;
    }
    if (this.client) {
      this.client.init(this.appId, () => {
        loger.log("初始化WebRtc->成功");
        if (_callback) {
          _callback({isSuccess: true});
        }
      }, (err)=> {
        loger.error("初始化WebRtc->失败", err);
        if (_callback) {
          _callback({isSuccess: false, error: err});
        }
      });
      this.addEvent();
    }
  }

  addEvent() {
    loger.log("监听webRtc消息");
    if (!this.client) {
      loger.log("addEvent error:client is null");
      return;
    }
    this.channelKey = "";
    this.client.on('error', (err) => {
      loger.log("WebRtc异常:", err);
      if (err.reason === 'DYNAMIC_KEY_TIMEOUT') {
        this.client.renewChannelKey(this.channelKey, ()=> {
          loger.log("Renew channel key successfully");
        }, (err)=> {
          loger.log("Renew channel key failed: ", err);
        });
      }
    });
    this.client.on('stream-published', (evt)=> {
      loger.log("webRtc->推流成功->", new Date().getTime());
      this.isPublish = true;
      this.firstPublishSuccess=true;
      GlobalConfig.openCamera = EngineUtils.creatTimestamp();
      GlobalConfig.openMicrophones = GlobalConfig.openCamera;
      this._emit(MessageTypes.USER_DEVICE_STATUS_CHAANGE, {
        nodeId: GlobalConfig.nodeId,
        userRole: GlobalConfig.userRole,
        userName: GlobalConfig.userName,
        userId: GlobalConfig.userId,
        openCamera: GlobalConfig.openCamera,
        openMicrophones: GlobalConfig.openMicrophones
      });
      this.changePublishStatusAndServerRecord(WebRtcApe.RECORD_STATUS_1);
    });
    this.client.on('stream-added', (evt)=> {
      let stream = evt.stream;
      /* loger.log("添加一个远程视频流: " + stream.getId(),new Date().getTime());
       this.client.subscribe(stream, (err)=> {
       loger.log("添加一个远程视频流->failed", err);
       });*/
      this.reAddRemoteStream(stream);
    });
    this.client.on('stream-subscribed', (evt)=> {
      let stream = evt.stream;
      this.addRemoetStreamView(stream);
    });
    this.client.on('stream-removed', (evt)=> {
      let stream = evt.stream;
      if (stream) {
        stream.stop();
        $('#' + this.xdyRemote + stream.getId()).remove();
        loger.log("远程视频流已经断开:" + stream.getId());
      }

    });

    this.client.on('peer-leave', (evt)=> {
      let stream = evt.stream;
      if (stream) {
        stream.stop();
        $('#' + this.xdyRemote + stream.getId()).remove();
        loger.log(evt.uid + " ->离开视频通话频道");
      }
    });
    this.client.on("active-speaker", (evt)=> {
      let uid = evt.uid;
      loger.log("当前正在讲话的uid:" + uid);
    });

  }

  addRemoetStreamView(stream) {
    if (stream) {
      let uid = stream.getId();
      let user = GlobalConfig.getUserInfoFromeNodeId(uid);
      let userName = "";
      let userRole = ""
      if (user) {
        userName = user.name || "unknow";
        userRole = user.userRole;
      }

      //添加之前先删除之前存在的重复视图
      let len=$("#"+this.xdyRemote + uid+" #player_" + uid).length;
      if(len<1){
        loger.log("添加之前先删除之前存在的重复视图",uid);
        $("#"+this.xdyRemote + uid).remove();
      }

      if (userRole == ApeConsts.invisible) {
        let nameDiv = `<div style=${this.invisibleVideoWidth}px;height:20px; position: absolute;bottom: 0; z-index: 1;overflow:hidden;font-size: 14px;text-align: right; color: #cccccc;display:${this.nameDisplay}">${userName}</div>`;
        //把远程视频添加到监课列表
        loger.log("获取远程视频流成功->监课:" + userName + "->" + uid, new Date().getTime());
        let viewDiv = `<div id="${this.xdyRemote + uid}" class="${this.invisibleWebRtcVideoClass}" style="width:${this.invisibleVideoWidth*this.videoScale}px;height:${this.invisibleVideoHeight*this.videoScale}px;float: left;margin-right: 1px;pointer-events: none;">${nameDiv}</div>`;
        $(this.invisibleViewId).append(viewDiv);
      } else if (userRole == ApeConsts.host||userRole == ApeConsts.assistant||userRole == ApeConsts.presenter) {
        let nameDiv = `<div style="width:${this.hostRemoteVideoWidth}px;height:20px; position: absolute;bottom: 0; z-index: 1;overflow:hidden;font-size: 14px;text-align: right; color: #cccccc;display:${this.nameDisplay}">${userName}</div>`;
        //把远程视图添加到老师列表
        loger.log("获取远程视频流成功->userRole:"+userRole+":" + userName + "->" + uid, new Date().getTime());
        let viewDiv = `<div id="${this.xdyRemote + uid}" class="${this.hostWebRtcVideoClass}" style="width:${this.hostRemoteVideoWidth*this.videoScale}px;height:${this.hostRemoteVideoHeight*this.videoScale}px;float: left;margin-right: 1px;pointer-events: none;">${nameDiv}</div>`;
        $(this.hostRemoteViewId).prepend(viewDiv);
      } else {
        let nameDiv = `<div style="width:${this.normalRemoteVideoWidth}px;height:20px; position: absolute;bottom: 0; z-index: 1;overflow:hidden;font-size: 14px;text-align: right; color: #cccccc;display:${this.nameDisplay}">${userName}</div>`;
        //把视图添加到学生列表
        loger.log("获取远程视频流成功->学生:" + userName + "->" + uid, new Date().getTime());
        let viewDiv = `<div id="${this.xdyRemote + uid}" class="${this.normalWebRtcVideoClass}" style="width:${this.normalRemoteVideoWidth*this.videoScale}px;height:${this.normalRemoteVideoHeight*this.videoScale}px;float: left;margin-right: 1px;pointer-events: none;">${nameDiv}</div>`;
        $(this.normalRemoteViewId).append(viewDiv);
      }
      //播放视频,隐藏控制条
      try {
        $("bar_" + stream.getId()).hide();
        stream.play(this.xdyRemote + stream.getId());
      } catch (err) {
        //添加之前先删除之前存在的重复视图
        let len=$("#"+this.xdyRemote + uid+" #player_" + uid).length;
        if(len<1){
          lloger.log("流播放失败->删除视图",uid);
          $("#"+this.xdyRemote + uid).remove();
        }
      }
      if (user && (user.deviceType == GlobalConfig.deviceIOS || user.deviceType == GlobalConfig.deviceAndroid)) {
        this.remoteVideoList[user.nodeId] = stream;
      }
    }

    this.clearInvalidVideoView();
  }
  //清除无效的视图
  clearInvalidVideoView(){
    let normalList=document.getElementsByClassName(this.normalWebRtcVideoClass);
    let hostList=document.getElementsByClassName(this.hostWebRtcVideoClass);
    let localList=document.getElementsByClassName(this.localWebRtcVideoClass);

    let divItem=null;
    if(normalList){
      for (let i=normalList.length-1;i>=0;i--){
        divItem=normalList[i];
        if(divItem&&divItem.children.length<2){
          console.log("删除无效的学生视图");
          divItem.remove();
        }
      }
    }
    divItem=null;
    if(hostList){
      for (let i=hostList.length-1;i>=0;i--){
        divItem=hostList[i];
        if(divItem&&divItem.children.length<2){
          console.log("删除无效的老师视图");
          divItem.remove();
        }
      }
    }
    divItem=null;
    if(localList){
      for (let i=localList.length-1;i>=0;i--){
        divItem=localList[i];
        if(divItem&&divItem.children.length<2){
          console.log("删除无效的本地视图");
          divItem.remove();
        }
      }
    }
    divItem=null;
  }


  //重新添加远程视频
  reAddRemoteStream(_stream) {
    if (!_stream) {
      return;
    }
    let user = GlobalConfig.getUserRoleFromeNodeId(_stream.getId());
    if (user.openCamera <= 0) {
      loger.log("远程流已经停止，不需要再连接: " + _stream.getId(), new Date().getTime());
      return;
    }
    loger.log("添加一个远程视频流: " + _stream.getId(), new Date().getTime());
    this.client.subscribe(_stream, (err)=> {
      //clearTimeout(this.reAddRemoteStreamDelay);
      if (err == "INVALID_REMOTE_STREAM") {
        //流已经无效，不需要再重连
        loger.warn("流已经无效->不需要再重连", err);
        return;
      }
      if (err == "PEERCONNECTION_FAILED") {
        setTimeout(()=> {
          loger.warn("连接远程的流失败->尝试重新连接", err);
          this.reAddRemoteStream(_stream);
        }, 1200);
      } else {
        loger.warn("添加一个远程视频流->失败", err);
      }
    });
  }

  //尝试添加远程的移动设备视频流
  tryAddMobileStream(nodeId) {
    let stream = this.remoteVideoList[nodeId];
    if (!stream) {
      return;
    }
    let remoteView = document.getElementById(this.xdyRemote + nodeId);
    //console.log("remoteView->", remoteView)
    if (remoteView) {
      let player = document.getElementById("player_" + nodeId);
      let len=$("#"+this.xdyRemote + nodeId+" #player_" + nodeId).length;
      if (len>0) {
        loger.log(nodeId + " 流已经添加显示，不需要再处理");
        return;
      } else {
        loger.log(nodeId + " 删除无效的视图->创建新的视图remoteView");
        remoteView.remove();
      }
    }
    if (stream) {
      loger.log("收到移动端推流的消息,主动添加一个远程视频流");
      this.addRemoetStreamView(stream);
    }
  }

  joinChannel(_params) {
    if (!this.client) {
      loger.warn("入视频通话频道->失败->未初始化对象");
      return;
    }
    this.channelId = _params.channelId || "";
    this.uid = parseInt(_params.uid) || 0;
    this.info = _params.info || "";
    this.channelKey = _params.channelKey || null;

    //记录加入频道成功之后是否立即推流,默认false
    //一般只有在刷新重进频道的时候会用到
    this.immediatePublish=_params.immediatePublish||false;

    //根据不同身份设置不同的分辨率
    if(GlobalConfig.isTeachOrAssistant){
      if(GlobalConfig.maxMediaChannels==1){
        //直播时使用标清最高档
        this.videoResolution="360P_8";
      }else {
        this.videoResolution="240P";
      }
    }else if(GlobalConfig.isInvisible){
      this.videoResolution="120P";
    }else {
      //学生在两路视频的时候使用240P 其他多人课堂的时候使用低清的
      if(GlobalConfig.maxMediaChannels==2||GlobalConfig.maxMediaChannels>3){
        this.videoResolution="240P"
      }else {
        //180P_4	13	240x180	15	120
        this.videoResolution="180P_4"
      }
    }

    loger.log("开始加入视频通话频道->channelId:" + this.channelId, "uid:" + this.uid,"videoResolution:"+this.videoResolution);
    this.client.join(this.channelKey, "" + this.channelId, this.uid, (uid)=> {
      this.uid = uid;
      loger.log("加入视频通话频道->成功->channelId:" + this.channelId, "uid:" + this.uid);
      this._emit(MessageTypes.WEB_RTC_JOIN_SUCCESS);
      this.openLoaclStream();

      //加入频道成功之后需要判断是否立即开启推流
      if(this.immediatePublish==true){
        loger.log("加入音视频频道成功->立刻开始推流->"+this.immediatePublish);
        clearTimeout(this.rePublishDelay);
        this.rePublishDelay=setTimeout(()=>{
          this.publish();
        },200);
      }
    }, (err)=> {
      loger.error("加入视频通话频道->失败->", err);
      this._emit(MessageTypes.WEB_RTC_JOIN_FAILED);
    });
  }

  //重新获取摄像头和麦克风并重新推流
  reGetLoaclStream() {
    if (this.isPublish) {
      loger.log("重新获取摄像头和麦克风并重新推流");
      //this.changePublishStatusAndServerRecord(WebRtcApe.RECORD_STATUS_0);
      this.unpublish();
      this.openLoaclStream();
      //切换设备后自动重推流
      this.rePublishDelay = setTimeout(()=> {
        this.publish();
      }, 1200);
      //this.publish();
    } else {
      this.openLoaclStream();
    }
  }

  openLoaclStream() {
    /* if(this.localStream){
     this.localStream.close();
     this.localStream=null;
     }*/
    this.localStream = AgoraRTC.createStream({
      streamID: this.uid,
      audio: true,
      microphoneId: this.curMicrophoneId,
      cameraId: this.curCameraId,
      video: this.isOpenVideo,
      screen: false
    });

    if (this.isOpenVideo) {
      //设置分辨率
      this.localStream.setVideoProfile(this.videoResolution);
    }
  }

  leaveChannel() {
    loger.log("调用离开视频通话频道->isPublish"+this.isPublish);
    if (!this.client) {
      return;
    }
    this.firstPublishSuccess=false;
    this.unpublish();
    this.client.leave(() => {
      loger.log("离开视频通话频道->成功");
    }, (err)=> {
      loger.log("离开视频通话频道->失败");
    });
  }

  closeRemoteVideoView(_data) {
    if (!_data) {
      return;
    }
    //根据nodeId查找视频
    try {
      //loger.log("立即删除停止推流人员的视图");
      $('#' + this.xdyRemote + _data.nodeId).remove();
    } catch (err) {

    }

  }

  /*
   * 设置旁录地址
   * */
  setConfigPublisherUrl(_publishUrl){
    this.firstPublishSuccess=false;
    this.setConfigTimestamp=new Date().getTime()/1000;
    this.configPublisherUrl=_publishUrl;
    if(this.client&& this.configPublisherUrl){
      let configObj={width: parseInt(this.pWidth), height: parseInt(this.pHeight), framerate: parseInt(this.pFrameRate), bitrate: parseInt(this.pBitrate), publishUrl:""+this.configPublisherUrl};
      //let configObj={width: 480, height:360, framerate:30, bitrate:500, publishUrl:_publishUrl};
      //let configObj={width: 480, height:360, framerate:30, bitrate:500, publishUrl:'rtmp://txlivepush.xuedianyun.com/live/markettest_395312484_T8440_983041_1507888360?bizid=11220&txSecret=15cc50d93f86f9e1a2a76a10db2b09a8&txTime=59e135a8&record=hls|flv&record_interval=5400'};
      loger.warn("设置旁路地址->",configObj);
      this.client.configPublisher(configObj);
    }else {
      loger.warn("设置旁路地址->失败->为初始化或旁路地址无效",_publishUrl);
    }
  }
  /*
   * 设置旁录拉流地址
   * */
  setRtmpM3u8Path(_param){
    //_webRtc.setRtmpM3u8Path({m3u8Url:m3u8Stream,rtmpUrl:rtmpStream});
    loger.log("设置旁录拉流地址",_param);
    if(_param){
      this.m3u8Url=_param.m3u8Url||"";
      this.rtmpUrl=_param.rtmpUrl||"";
    }
  }
  publish(_params) {
    if (!this.client || !this.localStream) {
      loger.warn("推流失败->未加入频道!");
      return;
    }
    if (!this.localStream) {
      loger.warn("推流失败->本地流获取失败!");
      return;
    }
    //老师-助教-主讲人-->设置旁路大于30秒没有推流，推流服务会停止，需要重设旁录和重加频道；
    if(this.setConfigTimestamp>0&&GlobalConfig.isTeachOrAssistant){
      //如果间隔大于28秒并且没有推过流需要重新加入频道，推成功一次之后就不需要
      let interval=parseInt(new Date().getTime()/1000-this.setConfigTimestamp);
      loger.log("设置旁路的时间和推流时间的间隔->"+interval+"秒 firstPublishSuccess:"+ this.firstPublishSuccess);
      if(interval>=28&&!this.firstPublishSuccess){
        loger.warn("设置旁路大于30秒没有推流，推流服务会停止，需要重设旁录和重加频道");
        this._emit(WebRtcApe.RE_JOIN_CHANNEL,{publish:true});
        return;
      }
    }

    this.localStream.init(()=> {
      this.clearLocalView();
      let viewName = 'localVideoBox_' + this.uid;
      let videoBox = document.createElement("div");
      videoBox.id = viewName;
      videoBox.className=this.localWebRtcVideoClass;
      videoBox.style.width = (this.localVideoWidth*this.videoScale) + 'px';
      videoBox.style.height = (this.localVideoHeight*this.videoScale) + 'px';
      videoBox.style.float = 'left';
      videoBox.style.marginRight = "1px";
      videoBox.style.pointerEvents = 'none';
      //自己的视图往前添加
      $(this.localViewId).prepend(videoBox);
      $("#" + viewName).css("transform", 'rotateY(180deg)');

      //显示自己的名字
      let user = GlobalConfig.getUserInfoFromeNodeId(this.uid);
      let userName = "";
      if (user) {
        userName = user.name || "";
      }
      let nameDiv = `<div id="${"videoOwnerName_" + this.uid}"  class="localVideoOwnerName" style="width:${this.localVideoWidth}px;height:20px; position: absolute;bottom: 0; z-index: 1;overflow:hidden;font-size: 14px;text-align: right; color: #cccccc;display:${this.nameDisplay}">${userName}</div>`;
      $(this.localViewId).prepend(nameDiv);

      loger.log("webRtc->推流->", viewName, new Date().getTime());
      this.localStream.play(viewName);
      this.client.publish(this.localStream, (err)=> {
        loger.log("webRtc->推流失败: " + err);
        GlobalConfig.openCamera = 0;
        GlobalConfig.openMicrophones = 0;
        this.isPublish = false;
        this.unpublish();
      });
    }, (err)=> {
      loger.warn("webRtc->推流->本地流开启失败", err);
      this.isPublish = false;
      this.clearLocalView();
      this._emit(MessageTypes.WEB_RTC_PUBLISH_FAILED, err);
      if(err) {
        switch (err.msg) {
          case "DEVICES_NOT_FOUND":
            this.curCameraId="";
            this.curMicrophoneId="";
            this.unpublish();
            break;
          case "NOT_SUPPORTED":
            this.curCameraId="";
            this.curMicrophoneId="";
            this.unpublish();
            break;
          case "PERMISSION_DENIED":
            this.curCameraId="";
            this.curMicrophoneId="";
            this.unpublish();
            break;
          case "CONSTRAINT_NOT_SATISFIED":
            this.curCameraId="";
            this.curMicrophoneId="";
            this.unpublish();
            break;
          case "STREAM_ALREADY_INITIALIZED":
            this.curCameraId="";
            this.curMicrophoneId="";
            this.unpublish();
            break;
          default:
            break
        }
      }
    });
  }

  unpublish() {
    clearTimeout(this.rePublishDelay);
    loger.log("webRtc->停止推流 ", new Date().getTime());
    if (!this.client || !this.localStream) {
      return;
    }
    this.client.unpublish(this.localStream, (err)=> {
      loger.log("webRtc->停止推流->失败" + err);
    });
    this.localStream.close();
    this.clearLocalView();
    this.isPublish = false;
    GlobalConfig.openCamera = 0;
    GlobalConfig.openMicrophones = 0;
    this._emit(MessageTypes.USER_DEVICE_STATUS_CHAANGE, {
      nodeId: GlobalConfig.nodeId,
      userRole: GlobalConfig.userRole,
      userName: GlobalConfig.userName,
      userId: GlobalConfig.userId,
      openCamera: GlobalConfig.openCamera,
      openMicrophones: GlobalConfig.openMicrophones
    });
  }

  //清除本地视图
  clearLocalView() {
    loger.log("清除本地视图");
    $('#localVideoBox_' + this.uid).remove();
    $("#videoOwnerName_" + this.uid).remove();
    $(".localVideoOwnerName").remove();
    $("."+this.localWebRtcVideoClass).remove();
  }

  /*
   * 更新所有视频的尺寸大小
   * */
  updateAllVideoSize(){
    $("."+this.localWebRtcVideoClass).css("width",this.localVideoWidth*this.videoScale);
    $("."+this.localWebRtcVideoClass).css("height",this.localVideoHeight*this.videoScale);

    $("."+this.hostWebRtcVideoClass).css("width",this.hostRemoteVideoWidth*this.videoScale);
    $("."+this.hostWebRtcVideoClass).css("height",this.hostRemoteVideoHeight*this.videoScale);

    $("."+this.normalWebRtcVideoClass).css("width",this.normalRemoteVideoWidth*this.videoScale);
    $("."+this.normalWebRtcVideoClass).css("height",this.normalRemoteVideoHeight*this.videoScale);

  }

  /*
  * 设置rtc视频的属性
  * */
  changeRtcVideoConfig(_params){
    //{videoScale:1}
    if(!_params){
      return;
    }
    let scale=parseInt(_params.videoScale)||1;//最小值只能为1，这个是按倍数缩放视频
    if(this.videoScale==scale){
      return;
    }
    this.videoScale=scale;
    loger.log("更新视频视图大小->videoScale:"+this.videoScale);
    this.updateAllVideoSize();
  }

  /*
   * 设置本地回显视图
   * */
  setLoaclView(_params) {
    loger.log("设置自己本地回显视图");
    this.localViewId = _params.divId || "";
    this.localStyle = _params.styleStr || "";
    this.localVideoWidth = parseInt(_params.width) || SIZE_480;
    this.localVideoHeight = parseInt(_params.height) || SIZE_360;
    this.nameDisplay = _params.nameDisplay || "block";

    this.localVideoWidth=this.localVideoWidth;
    this.localVideoHeight=this.localVideoHeight;
  }

  /*
   * 设置其他人的video视图容器
   * */
  setHostRemoteMediaView(_params) {
    loger.log("设置老师视图容器");
    this.hostRemoteViewId = _params.divId || "";
    this.hostRemoteStyle = _params.styleStr || "";
    this.hostRemoteVideoWidth = parseInt(_params.width) || SIZE_480;
    this.hostRemoteVideoHeight = parseInt(_params.height) || SIZE_360;
    this.hostRemoteVideoWidth=this.hostRemoteVideoWidth;
    this.hostRemoteVideoHeight=this.hostRemoteVideoHeight;
  }

  /*
   * 设置其他人的video视图容器
   * */
  setNormalRemoteMediaView(_params) {
    loger.log("设置学生视图容器");
    this.normalRemoteViewId = _params.divId || "";
    this.normalRemoteStyle = _params.styleStr || "";
    this.normalRemoteVideoWidth = parseInt(_params.width) || SIZE_480;
    this.normalRemoteVideoHeight = parseInt(_params.height) || SIZE_360;

    this.normalRemoteVideoWidth=this.normalRemoteVideoWidth;
    this.normalRemoteVideoHeight=this.normalRemoteVideoHeight;
  }

  /*
   * 设置隐藏用户的video视图容器
   * */
  setInvisibleMediaView(_params) {
    loger.log("设置监课视图容器");
    this.invisibleViewId = _params.divId || "";
    this.invisibleStyle = _params.styleStr || "";
    this.invisibleVideoWidth = parseInt(_params.width) || SIZE_480;
    this.invisibleVideoHeight = parseInt(_params.height) || SIZE_360;
  }

  /*
   * 设置旁录推流的参数
   * */
  setConfigPublisher(_params){
    loger.log("设置旁录推流的参数",_params);
    this.pWidth=_params.width||SIZE_480;
    this.pHeight=_params.height||SIZE_360;
    this.pFrameRate=_params.frameRate||30;
    this.pBitrate=_params.bitrate||500;
  }

  /*
   * 切换当前使用的设备
   * */
  changeDevices(_params) {
    loger.log("切换设备->", _params);
    if (!_params) {
      return;
    }
    //设置摄像头
    if (_params.curCamera) {
      for (let k in this.cameras) {
        let item = this.cameras[k];
        if (item && item.label == _params.curCamera) {
          this.curCameraId = item.deviceId;
          GlobalConfig.curCamera = _params.curCamera;
          break;
        }
      }
    }
    //设置麦克风
    if (_params.curMicrophone) {
      for (let k in this.microphones) {
        let item = this.microphones[k];
        if (item && item.label == _params.curMicrophone) {
          this.curMicrophoneId = item.deviceId;
          GlobalConfig.curMicrophone = _params.curMicrophone;
          break;
        }
      }
    }
    //分辨率
    if (_params.videoResolution) {
      this.videoResolution = _params.videoResolution || this.videoResolution;//默认是240P 	20	320x240	15	200
    }

    clearTimeout(this.changeDevicesDelay);
    this.changeDevicesDelay = setTimeout(()=> {
      this.changePublishStatusAndServerRecord(WebRtcApe.RECORD_STATUS_0);
      //重新获取本地视图流
      this.reGetLoaclStream();
    }, 1400);
  }

  /*
   * 获取设备信息
   * */
  getDevices(_params, _callback) {
    AgoraRTC.getDevices((devices)=> {
      //下面的数组存的是对象
      this.microphones = [];
      this.cameras = [];

      //选的数组存的是设备名称
      GlobalConfig.cameras = [];
      GlobalConfig.microphones = [];

      loger.log("devices", devices)
      for (let i = 0; i < devices.length; i++) {
        let device = devices[i];
        //{"deviceId":"default","kind":"audiooutput","label":"默认","groupId":"cf49a03ca26700235629fc13d3e6630bd34407c66438d157056a34dd3ae03ef5"}
        if(device){
          if (device.kind == 'audioinput') {
            this.microphones.push(device);
            GlobalConfig.microphones.push(device.label);
          } else if (device.kind == 'videoinput') {
            this.cameras.push(device);
            GlobalConfig.cameras.push(device.label);
          } else {
            loger.warn('其他设备: ', device);
          }
        }
      }
      let _deviceData = {cameras: GlobalConfig.cameras, microphones: GlobalConfig.microphones};
      if (_callback) {
        _callback(_deviceData);
      }
      this._emit(MessageTypes.GET_DEVICES_SUCCESS, _deviceData);
    });
  }

  //组织数据，发送给服务器，控制录制和开启录制-推流和停止推流  status:0 停止推流  1：开始推流(同时开启录制),2：停止录制(同时停止推流)
  packMediaInfoData(_status) {
    let curTimestamp = new Date().getTime();
    let data = `appId=${GlobalConfig.appId}&channel=${GlobalConfig.channelId}&channelKey=${GlobalConfig.appCertificate}&uid=${GlobalConfig.userUid}&status=${_status}&userId=${GlobalConfig.userId}&userName=${GlobalConfig.userName}&userRole=${GlobalConfig.userRole}&timestamp=${curTimestamp}&recordTimestamp=${GlobalConfig.recordTimestamp}`;

    //markettest_623790840_T9540_1508207080
    let streamId=GlobalConfig.siteId+"_"+GlobalConfig.classId+"_"+GlobalConfig.userId+"_"+curTimestamp;
    //mcu记录一份数据
    this._emit(MessageTypes.MEDIA_PUBLISH_STATUS_CHANGE, {
      appId: GlobalConfig.appId,
      channel: GlobalConfig.channelId,
      channelKey: GlobalConfig.appCertificate,
      uid: GlobalConfig.userUid,
      status: _status,
      userId: GlobalConfig.userId,
      userName: GlobalConfig.userName,
      userRole: GlobalConfig.userRole,
      timestamp: curTimestamp,
      recordTimestamp: GlobalConfig.recordTimestamp,
      streamId:streamId,
      publishUrl:this.configPublisherUrl,
      m3u8Url:this.m3u8Url,
      rtmpUrl:this.rtmpUrl
    });
    return data;
  }

  //调用服务端接口
  //调用推流/停止推流->并且告诉服务器端开启录制
  //status:0 停止推流  1：开始推流(同时开启录制),2：停止录制(同时停止推流)
  changePublishStatusAndServerRecord(_status) {
    if (!GlobalConfig.recordInterfaces) {
      loger.log("调用服务器端更新视频录制状态->失败->接口地址无效");
      return;
    }
    let url = GlobalConfig.locationProtocol + GlobalConfig.recordInterfaces;
    let data = this.packMediaInfoData(_status);
    loger.log("调用服务器端更新视频录制状态->status",_status);
    fetch(encodeURI(url), {
      method: 'POST',
      headers: {
        "Content-Type": "application/x-www-form-urlencoded"
      },
      body: data,
      timeout: 4000
    })
      .then(ret => {
        if (ret.ok) {
          return ret.json();
        } else {
          loger.error(`调用服务器端更新视频录制状态-网络异常.状态码:${ret.status}`);
          throw '';
        }
      })
      .then(ret => {
        if (ret) {
          loger.log('调用服务器端更新视频录制状态', ret);
        } else {
          loger.warn('调用服务器端更新视频录制状态 失败.', ret);
        }
      })
      .catch(err => {
        loger.error(`调用服务器端更新视频录制状态.状态码:${err}`);
      });
  }

  /*
  * 切换音视频的录制状态
  * */
  changeMediaRecordStatus(_params) {
    if (!GlobalConfig.recordInterfaces||!_params) {
      loger.warn("切换音视频的录制状态->失败->接口地址无效",_params);
      return;
    }
    loger.warn("切换音视频的录制状态->"+_params);
    let url = GlobalConfig.locationProtocol + GlobalConfig.recordInterfaces;
    let curTimestamp = new Date().getTime();
    let data = `appId=${GlobalConfig.appId}&channel=${GlobalConfig.channelId}&channelKey=${GlobalConfig.appCertificate}&uid=${GlobalConfig.userUid}&status=${_params.status}&userId=${GlobalConfig.userId}&userName=${GlobalConfig.userName}&userRole=${GlobalConfig.userRole}&timestamp=${curTimestamp}&recordTimestamp=${GlobalConfig.recordTimestamp}`;
    fetch(encodeURI(url), {
      method: 'POST',
      headers: {
        "Content-Type": "application/x-www-form-urlencoded"
      },
      body: data,
      timeout: 4000
    })
      .then(ret => {
        if (ret.ok) {
          return ret.json();
        } else {
          loger.error(`切换音视频的录制状态-网络异常.状态码:${ret.status}`);
          throw '';
        }
      })
      .then(ret => {
        if (ret) {
          loger.log('切换音视频的录制状态->完成', ret);
        } else {
          loger.warn('切换音视频的录制状态 失败.', ret);
        }
      })
      .catch(err => {
        loger.error(`切换音视频的录制状态.状态码:${err}`);
      });
  }
}
WebRtcApe.prototype.RECORD_STATUS_0 = WebRtcApe.RECORD_STATUS_0 = 0; //停止推流
WebRtcApe.prototype.RECORD_STATUS_1 = WebRtcApe.RECORD_STATUS_1 = 1; //开始推流
WebRtcApe.prototype.RECORD_STATUS_2 = WebRtcApe.RECORD_STATUS_2 = 2; //停止录制
WebRtcApe.prototype.RE_JOIN_CHANNEL = WebRtcApe.RE_JOIN_CHANNEL = "reJoninChanel";//重加入频道

export default new WebRtcApe;