const imHandler = require('./im_handler.js');
const webim = require('../../../utils/webim_wx');
const CONSTANT = require('./config.js');

Component({
  properties: {
    roomID: {
      type: Number,
      value: 0
    },
    userID: {
      type: String,
      value: ''
    },
    userName: {
      type: String,
      value: ''
    },
    userSig: {
      type: String,
      value: ''
    },
    sdkAppID: {
      type: Number,
      value: 0
    },
    privateMapKey: {
      type: String,
      value: ''
    },
    template: {
      type: String,
      value: '',
      observer: function (newVal, oldVal) {
        this.initLayout(newVal)
      }
    }, //使用的界面模版
    beauty: {
      type: Number,
      value: 5
    }, //美颜程度，取值为0~9

    // 美白指数
    whiteness: {
      type: Number,
      value: 5
    },

    aspect: {
      type: String,
      value: '3:4'
    }, //设置画面比例，取值为'3:4'或者'9:16'
    minBitrate: {
      type: Number,
      value: 200
    }, //设置码率范围为[minBitrate,maxBitrate]，四人建议设置为200~400
    maxBitrate: {
      type: Number,
      value: 400
    },
    muted: {
      type: Boolean,
      value: false
    }, //设置推流是否静音
    debug: {
      type: Boolean,
      value: false
    }, //是否显示log

    enableIM: {
      type: Boolean, //是否启用IM
      value: true
    },

    // 房间的创建者
    roomCreator: {
      type: String,
      value: ''
    },

    useCloud: {
      type: Boolean, //是否使用云上环境
      value: true
    },

    // 进入房间后是否自动播放房间中其他的远程画面
    autoplay: {
      type: Boolean,
      value: false
    },

    enableCamera: {
      type: Boolean,
      value: true
    },

    pureAudioPushMod: {
      type: Number,
      value: 0
    },

    recordId: {
      type: Number,
      value: null
    }
    // frontCamera: {type: Boolean, value: true, observer: function (newVal, oldVal) { this.switchCamera(); }},  //设置前后置摄像头，true表示前置
  },
  data: {
    requestSigFailCount: 0,
    isCaster: false, // 默认是观众
    CONSTANT, // 常量
    pusherContext: '',
    hasPushStarted: false,
    pushURL: '',
    members: [{}, {}, {}],
    presenter: [{}], // presenter 代表主播，audience 代表观众
    audience: [{}, {}],
    maxMembers: 3,
    self: {},
    hasExitRoom: true,
    creator: '',
    // 记录live-player的声音状态， 默认都是打开声音状态(false和undefined)
    playerMutedStatus: {

    },

    // 记录live-player的摄像头状态， 默认都是打开声音状态（true和undefined）
    playerVideoStatus: {

    },

    ERROR_OPEN_CAMERA: -4, //打开摄像头失败
    ERROR_OPEN_MIC: -5, //打开麦克风失败
    ERROR_PUSH_DISCONNECT: -6, //推流连接断开
    ERROR_CAMERA_MIC_PERMISSION: -7, //获取不到摄像头或者麦克风权限
    ERROR_EXCEEDS_THE_MAX_MEMBER: -8, // 超过最大成员数
    ERROR_REQUEST_ROOM_SIG: -9, // 获取房间SIG错误
    ERROR_JOIN_ROOM: -10 // 进房失败
  },

  ready: function () {
    self = this;
    if (!this.data.pusherContext) {
      this.data.pusherContext = wx.createLivePusherContext('rtcpusher');
    }
    this.data.isCaster = this.data.roomCreator === this.data.userID; //是不是主播
    this.setData({
      isCaster: this.data.isCaster,
      creator: this.data.roomCreator
    });
  },

  detached: function () {
    self.exitRoom();
    imHandler.logout();
  },

  methods: {
    /**
     * 初始化布局，当template改变时
     * @param {*} templateName 
     */
    initLayout(templateName) {
      self = this;
      switch (templateName) {
        // 1对1
        case CONSTANT.TEMPLATE_TYPE['1V1']:
          this.setData({
            maxMembers: 1,
            members: [{}],
            presenter: [{}],
            audience: [],
            template: templateName
          });
          break;

        case CONSTANT.TEMPLATE_TYPE['1V3']: // 九宫格1V3
        case CONSTANT.TEMPLATE_TYPE['1U3D']: // 1 up  3 down
        case CONSTANT.TEMPLATE_TYPE['1L3R']: // 1 left 3 right
        default:
          this.setData({
            maxMembers: 3,
            members: [{}, {}, {}],
            presenter: [{}],
            audience: [{}, {}],
            template: templateName
          });
          break;
      }
    },

    /**
     * 初始化IM
     */
    initIm() {
      imHandler.initData({
        'sdkAppID': this.data.sdkAppID, //用户所属应用id,必填
        'appIDAt3rd': this.data.sdkAppID, //用户所属应用id，必填
        'identifier': this.data.userID, //当前用户ID,必须是否字符串类型，选填
        'identifierNick': this.data.userName || this.data.userID, //当前用户昵称，选填
        'userSig': this.data.userSig
      });

      // 初始化Im登录回调
      imHandler.initLoginListeners(this.imLoginListener());

      // 登录IM
      imHandler.loginIm((res) => {
        // 登录成功
        this.fireIMEvent(CONSTANT.IM.LOGIN_EVENT, res.ErrorCode, res);
        // 创建或者加入群
        imHandler.joinGroup(this.data.roomID, (res) => {
          // 创建或者加入群成功
          this.fireIMEvent(CONSTANT.IM.JOIN_GROUP_EVENT, res.ErrorCode, res);
        }, (error) => {
          // 创建或者加入群失败
          this.fireIMEvent(CONSTANT.IM.JOIN_GROUP_EVENT, error.ErrorCode, error);
        });
      }, (error) => {
        // 登录失败
        this.fireIMEvent(CONSTANT.IM.LOGIN_EVENT, error.ErrorCode, error);
      });
    },

    /**
     * 打开或者关闭某一路画面
     * @param {Boolean} enable 
     * @param {String} userid  userid = 0 代表打开或关闭本地的摄像头画面
     */
    enableVideo(enable, userid) {
      if (userid) {
        var playerContext = wx.createLivePlayerContext(userid, this);
        if (playerContext) {
          // 获取用户视频状态，默认是播放用户视频， true 播放   false 不播放
          var videoStatus = this.data.playerVideoStatus[userid];
          // 如果 enable = true（想要打开画面）  
          if (enable) {
            if (videoStatus) {
              // 如果原来是打开状态，则不需要操作了
            } else {
              // 如果原来是关闭状态，则打开
              playerContext.play();
              var playerVideoStatus = this.data.playerVideoStatus;
              playerVideoStatus[userid] = true; // 设置为打开状态
              this.setData({
                playerVideoStatus: playerVideoStatus
              })
            }
          } else { // 想关闭画面
            if (videoStatus) {
              // 原来是打开状态，则关闭
              // playerContext.stop();
              var playerVideoStatus = this.data.playerVideoStatus;
              playerVideoStatus[userid] = false; // 设置为关闭状态
              this.setData({
                playerVideoStatus: playerVideoStatus
              })
            } else {
              // 原来就是关闭的，则不需要操作了
            }
          }

        }
      } else {
        // this.setData({
        //   enableCamera: enable
        // });
      }
    },

    /**
     * 打开或者关闭某一路声音
     * @param {*} enable 
     * @param {*} userid  userid = 0 代表打开或关闭本地的麦克风声音
     */
    enableAudio(enable, userid, params = {}) {
      if (userid) {
        var playerContext = wx.createLivePlayerContext(userid, this);
        if (playerContext) {
          // 获取用户声音的状态，默认false 打开声音  true 关闭声音
          var muted = this.data.playerMutedStatus[userid];

          // 如果 enable = true（想要打开声音）  
          if (enable) {
            // 如果原来是关闭状态，则打开
            if (muted) {
              playerContext.mute(params);
              var playerMutedStatus = this.data.playerMutedStatus;
              playerMutedStatus[userid] = false; // 设置为打开状态
              this.setData({
                playerMutedStatus: playerMutedStatus
              })
            } else {
              // 如果原来是打开状态，则不需要操作了
            }
          } else { // 想关闭声音
            if (muted) {
              // 原来就是关闭的，则不需要操作了
            } else {
              // 原来是打开状态，则关闭
              playerContext.mute(params);
              var playerMutedStatus = this.data.playerMutedStatus;
              playerMutedStatus[userid] = true; // 设置为关闭状态
              this.setData({
                playerMutedStatus: playerMutedStatus
              })
            }
          }
        }
      } else {
        // this.setData({
        //   muted: enable
        // });
      }
    },

    /**
     * 点击切换player的声音事件
     * @param {*} e 
     */
    enableAudioTap(e) {
      var uid = e.currentTarget.dataset.uid;
      var status = this.data.playerMutedStatus[uid];
      if (typeof status === 'undefined') {
        this.data.playerMutedStatus[uid] = false;
        status = false; // 默认是打开audio
      }

      this.enableAudio(status, uid);
    },

    /**
     * 点击切换player的视频事件
     * @param {*} e 
     */
    enableVidoTap(e) {
      var uid = e.currentTarget.dataset.uid;
      var status = this.data.playerVideoStatus[uid];
      if (typeof status === 'undefined') {
        this.data.playerVideoStatus[uid] = !!this.data.autoplay;
        status = !!this.data.autoplay; // 默认是打开audio
      }
      this.enableVideo(!status, uid);
    },

    /**
     * webrtc-room程序的入口
     */
    start: function () {
      self = this;
      self.data.hasExitRoom = false;
      self.requestSigServer(self.data.userSig, self.data.privateMapKey);
      if (this.data.enableIM) {
        this.initIm(); // 初始化IM
      }
    },

    /**
     * 停止
     */
    stop: function () {
      self.data.hasExitRoom = true;
      console.log("组件停止");
      self.exitRoom();
    },

    /**
     * 暂停
     */
    pause: function () {
      if (!self.data.pusherContext) {
        self.data.pusherContext = wx.createLivePusherContext('rtcpusher');
      }
      self.data.pusherContext && self.data.pusherContext.pause();

      self.data.members.forEach(function (val) {
        val.playerContext && val.playerContext.pause();
      });
    },

    resume: function () {
      if (!self.data.pusherContext) {
        self.data.pusherContext = wx.createLivePusherContext('rtcpusher');
      }
      self.data.pusherContext && self.data.pusherContext.resume();

      self.data.members.forEach(function (val) {
        val.playerContext && val.playerContext.resume();
      });
    },

    /**
     * 切换摄像头
     */
    switchCamera: function () {
      if (!self.data.pusherContext) {
        self.data.pusherContext = wx.createLivePusherContext('rtcpusher');
      }
      self.data.pusherContext && self.data.pusherContext.switchCamera({});
    },

    /**
     * 退出房间
     */
    exitRoom: function () {
      if (!self.data.pusherContext) {
        self.data.pusherContext = wx.createLivePusherContext('rtcpusher');
      }
      self.data.pusherContext && self.data.pusherContext.stop && self.data.pusherContext.stop();

      self.data.members.forEach(function (val) {
        val.playerContext && val.playerContext.stop();
      });

      for (var i = 0; i < self.data.maxMembers; i++) {
        self.data.members[i] = {};
      }

      var role = this.filterRole();
      self.setData({
        members: self.data.members,
        presenter: role.presenter,
        audience: role.audience
      });
    },

    postErrorEvent: function (errCode, errMsg) {
      self.postEvent('error', errCode, errMsg);
    },

    postEvent: function (tag, code, detail) {
      self.triggerEvent('RoomEvent', {
        tag: tag,
        code: code,
        detail: detail
      }, {});
    },

    /**
     * 请求SIG服务
     */
    requestSigServer: function (userSig, privMapEncrypt) {
      console.log('获取sig:', this.data);

      var self = this;
      var roomID = this.data.roomID;
      var userID = this.data.userID;
      var sdkAppID = this.data.sdkAppID;

      var url = this.data.useCloud ? 'https://official.opensso.tencent-cloud.com/v4/openim/jsonvideoapp' : 'https://yun.tim.qq.com/v4/openim/jsonvideoapp';
      url += '?sdkappid=' + sdkAppID + "&identifier=" + userID + "&usersig=" + userSig + "&random=9999&contenttype=json";

      var reqHead = {
        "Cmd": 1,
        "SeqNo": 1,
        "BusType": 7,
        "GroupId": roomID
      };
      var reqBody = {
        "PrivMapEncrypt": privMapEncrypt,
        "TerminalType": 1,
        "FromType": 3,
        "SdkVersion": 26280566
      };
      console.log("requestSigServer params:", url, reqHead, reqBody);

      wx.request({
        url: url,
        data: {
          "ReqHead": reqHead,
          "ReqBody": reqBody
        },
        method: "POST",
        success: function (res) {
          console.log("requestSigServer success:", res);
          if (res.data["RspHead"]["ErrorCode"] != 0) {
            console.log(res.data["RspHead"]["ErrorInfo"]);
            wx.showToast({
              icon: 'none',
              title: res.data["RspHead"]["ErrorInfo"],
            })

            self.data.requestSigFailCount++;
            // 重试3次后还是错误，则抛出错误
            if (self.data.requestSigFailCount > 3) {
              self.postErrorEvent(self.data.ERROR_REQUEST_ROOM_SIG, '获取房间SIG错误');
            } else {
              setTimeout(() => {
                console.error('>>>>>>>>', '获取房间sig失败，重试~');
                self.requestSigServer(userSig, privMapEncrypt);
              }, 2000);
            }
            return;
          }

          self.data.requestSigFailCount = 0;

          var roomSig = JSON.stringify(res.data["RspBody"]);
          var pushUrl = "room://cloud.tencent.com?sdkappid=" + sdkAppID + "&roomid=" + roomID + "&userid=" + userID + "&roomsig=" + encodeURIComponent(roomSig);

          // 支持纯音频推流
          if (self.data.pureAudioPushMod) {
            var bizbuf = {
              Str_uc_params: {
                pure_audio_push_mod: self.data.pureAudioPushMod,
                record_id: null
              }
            }
            // 自动录制时业务自定义id
            if (self.data.recordId) {
              bizbuf.Str_uc_params.record_id = self.data.recordId
            }
            pushUrl += '&bizbuf=' + JSON.stringify(bizbuf);
          }

          console.log("roomSigInfo", roomID, userID, roomSig, pushUrl);

          self.setData({
            pushURL: pushUrl,
            userID: userID
          });
        },
        fail: function (res) {
          console.log("requestSigServer fail:", res);
          wx.showToast({
            title: '获取房间签名失败',
          });

          self.data.requestSigFailCount++;
          // 重试3次后还是错误，则抛出错误
          if (self.data.requestSigFailCount > 3) {
            self.postErrorEvent(self.data.ERROR_REQUEST_ROOM_SIG, '获取房间SIG错误');
          } else {
            setTimeout(() => {
              console.error('>>>>>>>>', '获取房间sig失败，重试~');
              self.requestSigServer(userSig, privMapEncrypt);
            }, 2000);
          }
        }
      })
    },

    onWebRTCUserListPush: function (msg) {
      console.log('================= onWebRTCUserListPush method', msg);
      if (!msg) {
        return;
      }

      var jsonDic = JSON.parse(msg);
      if (!jsonDic) {
        return;
      }

      console.log("onWebRTCUserListPush.jsonDict:", jsonDic);
      var newUserList = jsonDic.userlist;
      console.log('=== newUserList: ', JSON.stringify(newUserList));

      if (!newUserList) {
        return;
      }

      var pushers = [];
      newUserList && newUserList.forEach(function (val) {
        var pusher = {
          userID: val.userid,
          accelerateURL: val.playurl
        };
        pushers.push(pusher);
      });

      // 如果超过了最大人数，则检测出不在members里面的成员，并通知他
      if (pushers.length > self.data.maxMembers) {
        self.postErrorEvent(self.data.ERROR_EXCEEDS_THE_MAX_MEMBER, `当前房间超过最大人数${self.data.maxMembers + 1}，请重新进入其他房间体验~`);
      }

      self.onPusherJoin({
        pushers: pushers
      });

      self.onPusherQuit({
        pushers: pushers
      });
    },

    //将在res.pushers中，但不在self.data.members中的流，加入到self.data.members中
    onPusherJoin: function (res) {
      res.pushers.forEach(function (val) {
        var emptyIndex = -1;
        var hasPlay = false;
        for (var i = 0; self.data.members && i < self.data.members.length; i++) {
          if (self.data.members[i].userID && self.data.members[i].userID == val.userID) {
            hasPlay = true;
          } else if (!self.data.members[i].userID && emptyIndex == -1) {
            emptyIndex = i;
          }
        }
        if (!hasPlay && emptyIndex != -1) {
          val.loading = false;
          val.playerContext = wx.createLivePlayerContext(val.userID);
          self.data.members[emptyIndex] = val;
        }

        self.initPlayerStatus(val.userID);
      });

      var role = this.filterRole();
      self.setData({
        members: self.data.members,
        presenter: role.presenter,
        audience: role.audience
      });
    },

    //将在self.data.members中，但不在res.pushers中的流删除
    onPusherQuit: function (res) {
      for (var i = 0; i < self.data.members.length; i++) {
        var needDelete = true;
        for (var j = 0; j < res.pushers.length; j++) {
          if (self.data.members[i].userID == res.pushers[j].userID) {
            needDelete = false;
          }
        }
        if (needDelete) {
          // if(self.data.members[i] && self.data.members[i].userID) {
          //   var player = wx.createLivePlayerContext(self.data.members[i].userID);
          //   player && player.stop();
          // }
          self.data.members[i] = {};
        }
      }

      var role = this.filterRole();
      self.setData({
        members: self.data.members,
        presenter: role.presenter,
        audience: role.audience
      });
    },

    //删除res.pushers
    delPusher: function (pusher) {
      for (var i = 0; i < self.data.members.length; i++) {
        if (self.data.members[i].userID == pusher.userID) {
          var player = wx.createLivePlayerContext(pusher.userID);
          player && player.stop();
          self.data.members[i] = {};
        }
      }
      var role = this.filterRole();
      self.setData({
        members: self.data.members,
        presenter: role.presenter,
        audience: role.audience
      });
    },

    // 推流事件
    onPush: function (e) {
      console.log('============== onPush e userID', this.data.userID);
      if (!self.data.pusherContext) {
        self.data.pusherContext = wx.createLivePusherContext('rtcpusher');
      }
      var code;
      if (e.detail) {
        code = e.detail.code;
      } else {
        code = e;
      }
      console.log('>>>>>>>>>>>> 推流情况：', code);
      var errmessage = '';
      switch (code) {
        case 1002:
          {
            console.log('推流成功');
            break;
          }
        case -1301:
          {
            console.error('打开摄像头失败: ', code);
            self.postErrorEvent(self.data.ERROR_OPEN_CAMERA, '打开摄像头失败');
            self.exitRoom();
            break;
          }
        case -1302:
          {
            console.error('打开麦克风失败: ', code);
            self.postErrorEvent(self.data.ERROR_OPEN_MIC, '打开麦克风失败');
            self.exitRoom();
            break;
          }
        case -1307:
          {
            console.error('推流连接断开: ', code);
            self.postErrorEvent(self.data.ERROR_PUSH_DISCONNECT, '推流连接断开');
            self.exitRoom();
            break;
          }
        case 5000:
          {
            console.log('收到5000: ', code);
            // 收到5000就退房
            self.exitRoom();
            break;
          }
        case 1018:
          {
            console.log('进房成功', code);
            break;
          }
        case 1019:
          {
            console.log('退出房间', code);
            self.postErrorEvent(self.data.ERROR_JOIN_ROOM, '加入房间异常，请重试');
            break;
          }
        case 1020:
          {
            console.log('成员列表', code);
            self.onWebRTCUserListPush(e.detail.message);
            break;
          }
        case 1021:
          {
            console.log('网络类型发生变化，需要重新进房', code);
            //先退出房间
            self.exitRoom();

            //再重新进入房间
            // this.setData({
            //   retryIndex: 5,
            // })

            self.start();

            break;
          }
        case 2007:
          {
            console.log('视频播放loading: ', e.detail.code);
            break;
          };
        case 2004:
          {
            console.log('视频播放开始: ', e.detail.code);
            break;
          };
        default:
          {
            // console.log('推流情况：', code);
          }
      }
    },

    // 标签错误处理
    onError: function (e) {
      console.log('推流错误：', e);
      e.detail.errCode == 10001 ? (e.detail.errMsg = '未获取到摄像头功能权限，请删除小程序后重新打开') : '';
      e.detail.errCode == 10002 ? (e.detail.errMsg = '未获取到录音功能权限，请删除小程序后重新打开') : '';
      self.postErrorEvent(self.data.ERROR_CAMERA_MIC_PERMISSION, e.detail.errMsg || '未获取到摄像头、录音功能权限，请删除小程序后重新打开')
    },

    //播放器live-player回调
    onPlay: function (e) {
      console.log('>>>>>>>>>>>> onPlay code:', e.detail.code);
      self.data.members.forEach(function (val) {
        if (e.currentTarget.id == val.userID) {
          switch (e.detail.code) {
            case 2007:
              {
                console.log('视频播放loading: ', e);
                val.loading = true;
                break;
              }
            case 2004:
              {
                console.log('视频播放开始: ', e);
                val.loading = false;
                break;
              }
            case -2301:
              {
                console.error('网络连接断开，且重新连接亦不能恢复，播放器已停止播放', val);
                self.delPusher(val);
                break;
              }
            default:
              {
                // console.log('拉流情况：', e);
              }
          }
        }
      });

      var role = this.filterRole();
      self.setData({
        members: self.data.members,
        presenter: role.presenter,
        audience: role.audience
      });
    },

    filterRole() {
      var presenter = [];
      var audience = [];
      for (var i = 0; i < self.data.members.length; i++) {
        if (self.data.members[i].userID == this.data.creator) {
          presenter.push(self.data.members[i]);
        } else {
          audience.push(self.data.members[i]);
        }
      }

      if (this.data.isCaster) { // 如果自己是主播

      } else { // 如果自己不是主播
        if (self.data.maxMembers === 3 && audience.length > 2) { // 如果是1pusher 3个player
          audience = audience.slice(0, 2); // 只有2个观众
        }

        if (!presenter.length) { // 如果主播没有, 要保证有一个主播
          presenter = [{}];
        }
      }

      return {
        presenter,
        audience
      }
    },

    // IM登录监听
    imLoginListener() {
      var self = this;
      return {
        // 用于监听用户连接状态变化的函数，选填
        onConnNotify(resp) {
          self.fireIMEvent(CONSTANT.IM.CONNECTION_EVENT, resp.ErrorCode, resp);
        },

        // 监听新消息(直播聊天室)事件，直播场景下必填
        onBigGroupMsgNotify(msgs) {
          if (msgs.length) { // 如果有消息才处理
            self.fireIMEvent(CONSTANT.IM.BIG_GROUP_MSG_NOTIFY, 0, msgs);
          }
        },

        // 监听新消息函数，必填
        onMsgNotify(msgs) {
          if (msgs.length) { // 如果有消息才处理
            self.fireIMEvent(CONSTANT.IM.MSG_NOTIFY, 0, msgs);
          }
        },

        // 系统消息
        onGroupSystemNotifys: {
          "1": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 1, notify);
          }, //申请加群请求（只有管理员会收到）
          "2": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 2, notify);
          }, //申请加群被同意（只有申请人能够收到）
          "3": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 3, notify);
          }, //申请加群被拒绝（只有申请人能够收到）
          "4": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 4, notify);
          }, //被管理员踢出群(只有被踢者接收到)
          "5": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 5, notify);
          }, //群被解散(全员接收)
          "6": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 6, notify);
          }, //创建群(创建者接收)
          "7": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 7, notify);
          }, //邀请加群(被邀请者接收)
          "8": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 8, notify);
          }, //主动退群(主动退出者接收)
          "9": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 9, notify);
          }, //设置管理员(被设置者接收)
          "10": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 10, notify);
          }, //取消管理员(被取消者接收)
          "11": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 11, notify);
          }, //群已被回收(全员接收)
          "255": (notify) => {
            self.fireIMErrorEvent(CONSTANT.IM.GROUP_SYSTEM_NOTIFYS, 255, notify);
          } //用户自定义通知(默认全员接收)
        },

        // 监听群资料变化事件，选填
        onGroupInfoChangeNotify(groupInfo) {
          self.fireIMErrorEvent(CONSTANT.IM.GROUP_INFO_CHANGE_NOTIFY, 0, groupInfo);
        },

        // 被踢下线
        onKickedEventCall() {
          self.fireIMErrorEvent(CONSTANT.IM.KICKED);
        }
      }
    },

    /**
     * 发送C2C文本消息
     * @param {string} receiveUser 
     * @param {string} msg 
     * @param {function} succ 
     * @param {function} fail
     */
    sendC2CTextMsg(receiveUser, msg, succ, fail) {
      imHandler.sendC2CTextMsg(receiveUser, msg, succ, fail);
    },

    /**
     * 发送C2C自定义消息
     * @param {object} msgObj {data: 'xxx', cmd: 'xxxx'}
     * @param {function} succ
     * @param {function} fail
     */
    sendC2CCustomMsg(receiveUser, msgObj, succ, fail) {
      imHandler.sendC2CCustomMsg(receiveUser, msgObj, succ, fail);
    },

    /**
     * 发送群组文本消息
     * @param {string} msg 
     * @param {function} succ 
     * @param {function} fail
     */
    sendGroupTextMsg(msg, succ, fail) {
      imHandler.sendGroupTextMsg(msg, succ, fail);
    },

    /**
     * 发送群组自定义消息
     * @param {object} msgObj {data: 'xxx', cmd: 'xxxx'}
     * @param {function} succ
     * @param {function} fail
     */
    sendGroupCustomMsg(msgObj, succ, fail) {
      imHandler.sendGroupCustomMsg(msgObj, succ, fail);
    },

    /**
     * IM错误信息
     */
    fireIMErrorEvent: function (errCode, errMsg) {
      self.fireIMEvent('error', errCode, errMsg);
    },

    /**
     * 触发IM信息
     */
    fireIMEvent: function (tag, code, detail) {
      self.triggerEvent('IMEvent', {
        tag: tag,
        code: code,
        detail: detail
      });
    },

    // 初始化状态
    initPlayerStatus(uid) {
      var status = this.data.playerVideoStatus[uid];
      if (typeof status === 'undefined') {
        this.data.playerVideoStatus[uid] = !!this.data.autoplay;
        var playerVideoStatus = this.data.playerVideoStatus;
        this.setData({
          playerVideoStatus: playerVideoStatus
        })
      }
    }
  }
})