fcr-ui-scene 3.4.1 → 3.4.3

package/lib/providers/interpreter-provider.js

@@ -1,17 +1,63 @@
 "use strict";
 
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.object.define-properties.js");
 require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.object.keys.js");
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.FcrUIInterpreterProviderImpl = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.iterator.js");
 require("core-js/modules/es.array.join.js");
 require("core-js/modules/es.array.map.js");
-require("core-js/modules/es.object.keys.js");
-require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.for-each.js");
 require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.v2.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.v2.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.v2.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.v2.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.v2.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.v2.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.v2.js");
+require("core-js/modules/esnext.set.union.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.timers.js");
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -20,122 +66,1051 @@ var _logger = require("agora-foundation/lib/logger");
 var _observable = require("agora-foundation/lib/utilities/observable");
 var _base = require("../base");
 var _fcrCore = require("fcr-core");
+var _interpreter = require("../shared-data-source/interpreter");
+var _type = require("../modules/interpreter/type");
+var _imports = require("fcr-core/lib/imports");
+var _type2 = require("agora-rte-sdk/lib/type");
+var _type3 = require("fcr-core/lib/type");
+var _utils = require("../modules/interpreter/utils");
+var _constant = require("../utilities/constant");
+var _enums = require("../modules/action-bar/enums");
+var _i18n = require("agora-ui-foundation/lib/i18n");
+var _lodash = require("lodash");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var getRoomJoinOptions = function getRoomJoinOptions(localUser) {
+  var roomJoinOptions = {
+    userName: localUser.userName,
+    userRole: _type3.FcrUserRole.PARTICIPANT,
+    roomToken: '',
+    streamLatency: _fcrCore.FcrStreamLatencyLevel.ULTRA_LOW,
+    createStreamConfigs: [{
+      videoSourceState: _imports.AgoraRtcMediaSourceState.CLOSE,
+      audioSourceState: _imports.AgoraRtcMediaSourceState.CLOSE,
+      videoSourceId: '',
+      audioSourceId: '',
+      streamName: 'default',
+      streamType: _imports.AgoraRteMediaStreamType.NONE,
+      videoSourceType: _type2.AgoraRteVideoSourceType.CAMERA,
+      audioSourceType: _type2.AgoraRteAudioSourceType.MICROPHONE
+    }]
+  };
+  return roomJoinOptions;
+};
 var FcrUIInterpreterProviderImpl = exports.FcrUIInterpreterProviderImpl = /*#__PURE__*/function () {
-  function FcrUIInterpreterProviderImpl() {
+  function FcrUIInterpreterProviderImpl(params) {
+    var _this = this;
     (0, _classCallCheck2["default"])(this, FcrUIInterpreterProviderImpl);
     // @internal
     (0, _defineProperty2["default"])(this, "logger", (0, _logger.getLogger)());
     (0, _defineProperty2["default"])(this, "_observable", new _observable.AgoraObservable());
+    (0, _defineProperty2["default"])(this, "_languageRoomListByStatus", []);
+    (0, _defineProperty2["default"])(this, "_indicateTimerId", null);
+    (0, _defineProperty2["default"])(this, "_volumeTimerId", null);
+    (0, _defineProperty2["default"])(this, "_hasSubscribedLanguageList", new Set([_interpreter.ORIGIN]));
+    (0, _defineProperty2["default"])(this, "_observerStream", {
+      onStreamVolumeIndicationUpdated: (0, _lodash.throttle)(function (roomId, streamId, volume) {
+        _this._onStreamVolumeIndicationUpdated(roomId, streamId, volume);
+      }, 500)
+    });
+    (0, _defineProperty2["default"])(this, "_observerMicrophoneChanged", {
+      onMicrophoneChanged: function onMicrophoneChanged(microphoneId) {
+        _this._languageRoomListByStatus.forEach(function (room) {
+          if (room.status === _type.UpdateType.JOIN) {
+            _this._bindLocalMicrophoneId(room, microphoneId);
+          }
+        });
+      }
+    });
+    (0, _defineProperty2["default"])(this, "_observerInterpreter", {
+      onInterpreterStateUpdated: function () {
+        var _onInterpreterStateUpdated = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(roomId, state, operatorUser) {
+          var interpreterList, languageList;
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return _this._update();
+              case 2:
+                _this._publishEvent();
+                if (state.enable) {
+                  interpreterList = _this.getInterpreterList();
+                  if (interpreterList) {
+                    _this._observable.notifyObservers('onInterpretationEnabled', interpreterList, operatorUser);
+                  }
+                  languageList = _this.getSubscribeLanguageList();
+                  _this._observable.notifyObservers('onSubscribeLanguageListUpdated', languageList);
+                } else {
+                  _this._observable.notifyObservers('onInterpretationDisabled', operatorUser);
+                }
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        function onInterpreterStateUpdated(_x, _x2, _x3) {
+          return _onInterpreterStateUpdated.apply(this, arguments);
+        }
+        return onInterpreterStateUpdated;
+      }(),
+      onInterpreterUsersUpdated: function () {
+        var _onInterpreterUsersUpdated = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(roomId, users, operatorUser) {
+          var _this$_sharedInterpre, preInterpreterInfo, interpreterInfo, localInterpreterUpdate, outputLanguage, languageList;
+          return _regenerator["default"].wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                _this$_sharedInterpre = _this._sharedInterpreterDataSource, preInterpreterInfo = _this$_sharedInterpre.preInterpreterInfo, interpreterInfo = _this$_sharedInterpre.interpreterInfo;
+                localInterpreterUpdate = preInterpreterInfo && interpreterInfo && (interpreterInfo.sourceLanguage !== preInterpreterInfo.sourceLanguage || interpreterInfo.targetLanguage !== preInterpreterInfo.targetLanguage);
+                if (localInterpreterUpdate && _this._sharedInterpreterDataSource.outputLanguage && (operatorUser === null || operatorUser === void 0 ? void 0 : operatorUser.userId) !== _this._userControl.getLocalUser().userId) {
+                  _this._observable.notifyObservers('onLocalInterpreterWillUpdate', _this._sharedInterpreterDataSource.outputLanguage);
+                }
+                _context2.next = 5;
+                return _this._update();
+              case 5:
+                outputLanguage = _this._sharedInterpreterDataSource.outputLanguage;
+                if (interpreterInfo && localInterpreterUpdate && outputLanguage) {
+                  _this._observable.notifyObservers('onLocalInterpreterUpdated', [interpreterInfo.sourceLanguage, interpreterInfo.targetLanguage], outputLanguage);
+                }
+                _this._publishEvent();
+                if (users && operatorUser) {
+                  _this._observable.notifyObservers('onInterpreterListUpdated', users, operatorUser);
+                }
+                languageList = _this.getSubscribeLanguageList();
+                _this._observable.notifyObservers('onSubscribeLanguageListUpdated', languageList);
+                if (preInterpreterInfo && !interpreterInfo) {
+                  _this._observable.notifyObservers('onLocalNotInterpreter');
+                }
+              case 12:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }));
+        function onInterpreterUsersUpdated(_x4, _x5, _x6) {
+          return _onInterpreterUsersUpdated.apply(this, arguments);
+        }
+        return onInterpreterUsersUpdated;
+      }()
+    });
+    (0, _defineProperty2["default"])(this, "_retryTask", {
+      timerId: null,
+      isAllowRetry: true
+    });
+    var privilegeProvider = params.privilegeProvider,
+      interpreterControl = params.interpreterControl,
+      userControl = params.userControl,
+      sharedInterpreterDataSource = params.sharedInterpreterDataSource,
+      eventProvider = params.eventProvider,
+      streamControl = params.streamControl,
+      deviceProvider = params.deviceProvider,
+      devicePrivilegeProvider = params.devicePrivilegeProvider;
+    this._privilegeProvider = privilegeProvider;
+    this._interpreterControl = interpreterControl;
+    this._userControl = userControl;
+    this._sharedInterpreterDataSource = sharedInterpreterDataSource;
+    this._eventProvider = eventProvider;
+    this._mainStreamControl = streamControl;
+    this._deviceProvider = deviceProvider;
+    this._devicePrivilegeProvider = devicePrivilegeProvider;
+    this._deviceProvider.addObserver(this._observerMicrophoneChanged);
+    this._interpreterControl.addObserver(this._observerInterpreter);
+    this._mount();
   }
   return (0, _createClass2["default"])(FcrUIInterpreterProviderImpl, [{
-    key: "joinInterpreterRoom",
-    value: // 加入语言房间
-    function () {
-      var _joinInterpreterRoom = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(param) {
-        var control, roomJoinOptions;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
+    key: "_publishEvent",
+    value: function _publishEvent() {
+      var _this$_sharedInterpre2 = this._sharedInterpreterDataSource,
+        preInterpreterInfo = _this$_sharedInterpre2.preInterpreterInfo,
+        interpreterInfo = _this$_sharedInterpre2.interpreterInfo,
+        outputLanguage = _this$_sharedInterpre2.outputLanguage;
+      if (interpreterInfo) {
+        if (!preInterpreterInfo) {
+          var _supportedLanguages = [interpreterInfo.sourceLanguage, interpreterInfo.targetLanguage];
+          this._observable.notifyObservers('onLocalBecomeInterpreter', _supportedLanguages, outputLanguage || interpreterInfo.targetLanguage);
+        }
+      }
+    }
+  }, {
+    key: "_triggerDvicePrivilege",
+    value: function _triggerDvicePrivilege() {
+      var interpreterInfo = this._sharedInterpreterDataSource.interpreterInfo;
+      if (interpreterInfo) {
+        this._devicePrivilegeProvider.setAlwaysHasMicrophonePrivilege(true);
+        this._devicePrivilegeProvider.setAutoUpdateAudioStreamPrivilege(false);
+      } else {
+        this._devicePrivilegeProvider.setAlwaysHasMicrophonePrivilege(false);
+        this._devicePrivilegeProvider.setAutoUpdateAudioStreamPrivilege(true);
+      }
+    }
+  }, {
+    key: "_mount",
+    value: function () {
+      var _mount2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var _this2 = this;
+        var initLanguageRoomListByStatus, interpreterInfo, targetLanguage, sourceLanguage;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              control = param.control, roomJoinOptions = param.roomJoinOptions;
-              _context.prev = 1;
-              this._observable.notifyObservers('onJoinInterpretingRoom', param);
-              _context.next = 5;
-              return control.join(roomJoinOptions);
-            case 5:
-              this.logger.info("interpreterLog-joinInterpreterRoom succeed", param.language);
-              this._observable.notifyObservers('onJoinInterpretingRoomSuccess', param);
-              _context.next = 13;
-              break;
+              initLanguageRoomListByStatus = function initLanguageRoomListByStatus() {
+                if (_this2._interpreterControl) {
+                  var rooms = _this2._interpreterControl.getInterpreterRoomList(); //语言房间列表
+                  if (rooms) {
+                    var languageRoomLisByStatus = rooms.map(function (ele) {
+                      return _objectSpread(_objectSpread({}, ele), {}, {
+                        status: _type.UpdateType.LEFT,
+                        control: _this2._interpreterControl.createRoomControl(ele.roomId)
+                      });
+                    });
+                    _this2._updateLanguageRoomListByStatus(languageRoomLisByStatus);
+                  }
+                }
+              };
+              this._triggerDvicePrivilege();
+              interpreterInfo = this._sharedInterpreterDataSource.interpreterInfo;
+              initLanguageRoomListByStatus();
+              _context3.next = 6;
+              return this._updateOutputLanguage((interpreterInfo === null || interpreterInfo === void 0 ? void 0 : interpreterInfo.targetLanguage) || null);
+            case 6:
+              _context3.next = 8;
+              return this._updateSubscribeLanguage([_interpreter.ORIGIN]);
+            case 8:
+              if (interpreterInfo) {
+                targetLanguage = interpreterInfo.targetLanguage, sourceLanguage = interpreterInfo.sourceLanguage;
+                this._observable.notifyObservers('onLocalBecameInterpreter', [targetLanguage, sourceLanguage], targetLanguage);
+              }
             case 9:
-              _context.prev = 9;
-              _context.t0 = _context["catch"](1);
-              this.logger.info("interpreterLog-joinInterpreterRoom fail", param.language);
-              this._observable.notifyObservers('onJoinInterpretingRoomFailed', param);
-            case 13:
             case "end":
-              return _context.stop();
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function _mount() {
+        return _mount2.apply(this, arguments);
+      }
+      return _mount;
+    }()
+  }, {
+    key: "_update",
+    value: function () {
+      var _update2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var _this3 = this;
+        var _this$_sharedInterpre3, interpreterInfo, subscribeLanguageList, outputLanguage, subscribeLanguageOptionList, rooms, copyLanguageRoomListByStatus, outputLanguageList, language, languageList;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              this._triggerDvicePrivilege();
+              _this$_sharedInterpre3 = this._sharedInterpreterDataSource, interpreterInfo = _this$_sharedInterpre3.interpreterInfo, subscribeLanguageList = _this$_sharedInterpre3.subscribeLanguageList, outputLanguage = _this$_sharedInterpre3.outputLanguage, subscribeLanguageOptionList = _this$_sharedInterpre3.subscribeLanguageOptionList;
+              rooms = this._interpreterControl.getInterpreterRoomList(); //语言房间列表
+              if (rooms) {
+                copyLanguageRoomListByStatus = (0, _toConsumableArray2["default"])(this._languageRoomListByStatus);
+                rooms.forEach(function (ele) {
+                  var languageRomm = copyLanguageRoomListByStatus.find(function (item) {
+                    return item.language === ele.language;
+                  });
+                  if (languageRomm) {
+                    return;
+                  } else {
+                    copyLanguageRoomListByStatus.push(_objectSpread(_objectSpread({}, ele), {}, {
+                      status: _type.UpdateType.LEFT,
+                      control: _this3._interpreterControl.createRoomControl(ele.roomId)
+                    }));
+                  }
+                });
+                this._languageRoomListByStatus = copyLanguageRoomListByStatus;
+              }
+              outputLanguageList = [];
+              if (interpreterInfo) {
+                outputLanguageList.push(interpreterInfo.sourceLanguage, interpreterInfo.targetLanguage);
+              }
+              language = outputLanguageList.includes(outputLanguage) ? outputLanguage : (interpreterInfo === null || interpreterInfo === void 0 ? void 0 : interpreterInfo.targetLanguage) || null;
+              _context4.next = 9;
+              return this._updateOutputLanguage(language);
+            case 9:
+              languageList = subscribeLanguageList.filter(function (ele) {
+                return subscribeLanguageOptionList.includes(ele);
+              });
+              _context4.next = 12;
+              return this._updateSubscribeLanguage(languageList);
+            case 12:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function _update() {
+        return _update2.apply(this, arguments);
+      }
+      return _update;
+    }()
+  }, {
+    key: "_unload",
+    value: function _unload() {}
+  }, {
+    key: "_clearTimer",
+    value: function _clearTimer() {
+      if (this._indicateTimerId) {
+        clearTimeout(this._indicateTimerId);
+        this._indicateTimerId = null;
+      }
+      if (this._volumeTimerId) {
+        clearInterval(this._volumeTimerId);
+        this._volumeTimerId = null;
+      }
+    }
+  }, {
+    key: "_onStreamVolumeIndicationUpdated",
+    value: function _onStreamVolumeIndicationUpdated(roomId, streamId, volume) {
+      var _this4 = this;
+      var setMainRoomVolume = function setMainRoomVolume(volume) {
+        _this4._mainStreamControl.getStreamList().forEach(function (stream) {
+          var needSetVolume = [_imports.AgoraRteMediaStreamType.AUDIO, _imports.AgoraRteMediaStreamType.BOTH].includes(stream.streamType);
+          if (needSetVolume) _this4._mainStreamControl.adjustRemoteAudioStreamVolume(stream.streamId, volume);
+        });
+      };
+      var restoreVolumeByMainRoom = function restoreVolumeByMainRoom() {
+        if (_this4._volumeTimerId) return;
+        var startValue = 25; // 主房间初始音量
+        var endValue = 100; // 最大音量
+        var duration = 2000; // 在 2 秒内逐渐放大
+        var interval = 50; // 更新间隔为 50ms
+
+        var volume = startValue;
+        var steps = (endValue - startValue) / (duration / interval);
+        _this4._volumeTimerId = setInterval(function () {
+          volume += steps;
+          if (volume >= endValue) {
+            volume = endValue;
+            _this4._clearTimer();
+          }
+          setMainRoomVolume(volume);
+        }, interval);
+      };
+
+      // HLD: 判断 volume > 10 ，避免波动， 则认为是在说话
+      var isSpeaking = Math.floor(volume / 255 * 100) > 10;
+      if (isSpeaking) {
+        // HLD: 主房输出音量设置为25，语言房间设置输出音频为100
+        this._observable.notifyObservers('onSubscribeLanguageVolumePrioritized', isSpeaking);
+        setMainRoomVolume(25);
+        this._clearTimer();
+      } else {
+        // PRD: 参会人听到的是译员的声音及轻微的原始音频声音。当语言频道内 6 秒内没有译员发言，原始音频的音量将在接下来的 2 秒内逐渐放大到正常音量。
+        this._indicateTimerId = setTimeout(function () {
+          _this4._observable.notifyObservers('onSubscribeLanguageVolumePrioritized', isSpeaking);
+          restoreVolumeByMainRoom();
+        }, 6000);
+      }
+    }
+  }, {
+    key: "_updateLanguageRoomListByStatus",
+    value: function _updateLanguageRoomListByStatus(executeRoomList) {
+      this._languageRoomListByStatus = (0, _utils.mergeArrays)(this._languageRoomListByStatus, executeRoomList, 'language');
+    }
+  }, {
+    key: "_clearRetryTaskTimer",
+    value: function _clearRetryTaskTimer() {
+      this._retryTask.isAllowRetry = false;
+      if (this._retryTask.timerId) {
+        clearTimeout(this._retryTask.timerId);
+        this._retryTask.timerId = null;
+      }
+    }
+  }, {
+    key: "_getRoomInfo",
+    value: function _getRoomInfo(language) {
+      var room = this._languageRoomListByStatus.find(function (languageRoom) {
+        return languageRoom.language === language;
+      });
+      return room;
+    }
+  }, {
+    key: "_bindLocalMicrophoneId",
+    value: function _bindLocalMicrophoneId(room, _microphoneId) {
+      var microphoneId = _microphoneId || this._deviceProvider.currentDeviceId.microphoneDeviceId;
+      if (microphoneId) {
+        var streamList = room.control.getStreamControl().getStreamsByUserId(room.control.getUserControl().getLocalUser().userId);
+        var micStream = streamList.find(function (stream) {
+          return stream.audioSourceType === _fcrCore.FcrAudioSourceType.MICROPHONE;
+        });
+        if (micStream && micStream.audioSourceId !== microphoneId) {
+          var _room$control$getRoom;
+          this.logger.info("bind local microphone id to stream: [".concat(micStream.streamId, "], room: ").concat((_room$control$getRoom = room.control.getRoomInfo()) === null || _room$control$getRoom === void 0 ? void 0 : _room$control$getRoom.roomId));
+          room.control.getStreamControl().bindLocalStreams([{
+            streamId: micStream.streamId,
+            audioSourceId: microphoneId
+          }]);
+        }
+      }
+    }
+  }, {
+    key: "_joinInterpreterRoom",
+    value: function () {
+      var _joinInterpreterRoom2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(_ref) {
+        var language, _ref$isToggleInterper, isToggleInterperterRemoteAudio, room, roomJoinOptions, _params;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              language = _ref.language, _ref$isToggleInterper = _ref.isToggleInterperterRemoteAudio, isToggleInterperterRemoteAudio = _ref$isToggleInterper === void 0 ? true : _ref$isToggleInterper;
+              room = this._getRoomInfo(language);
+              if (!(room && room.status !== _type.UpdateType.JOIN)) {
+                _context5.next = 17;
+                break;
+              }
+              roomJoinOptions = getRoomJoinOptions(this._userControl.getLocalUser());
+              _params = _objectSpread(_objectSpread({}, room), {}, {
+                isToggleInterperterRemoteAudio: isToggleInterperterRemoteAudio,
+                roomJoinOptions: roomJoinOptions
+              });
+              _context5.prev = 5;
+              this._observable.notifyObservers('onJoinInterpretingRoom', _params);
+              _context5.next = 9;
+              return room.control.join(roomJoinOptions);
+            case 9:
+              this._observable.notifyObservers('onJoinInterpretingRoomSuccess', _params);
+
+              //TODO 更新房间状态
+              this._updateLanguageRoomListByStatus([_objectSpread(_objectSpread({}, room), {}, {
+                status: _type.UpdateType.JOIN
+              })]);
+              //TODO 绑定本地麦克风
+              this._bindLocalMicrophoneId(room);
+              _context5.next = 17;
+              break;
+            case 14:
+              _context5.prev = 14;
+              _context5.t0 = _context5["catch"](5);
+              this._observable.notifyObservers('onJoinInterpretingRoomFailed', _params);
+            case 17:
+            case "end":
+              return _context5.stop();
           }
-        }, _callee, this, [[1, 9]]);
+        }, _callee5, this, [[5, 14]]);
       }));
-      function joinInterpreterRoom(_x) {
-        return _joinInterpreterRoom.apply(this, arguments);
+      function _joinInterpreterRoom(_x7) {
+        return _joinInterpreterRoom2.apply(this, arguments);
       }
-      return joinInterpreterRoom;
-    }() // 离开语言房间
+      return _joinInterpreterRoom;
+    }()
   }, {
-    key: "leaveInterpreterRoom",
+    key: "_leaveInterpreterRoom",
     value: function () {
-      var _leaveInterpreterRoom = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(param) {
-        var control;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
+      var _leaveInterpreterRoom2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6(_ref2) {
+        var language, room, control;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
-              control = param.control;
-              _context2.prev = 1;
-              this._observable.notifyObservers('onLeaveInterpretingRoom', param);
-              _context2.next = 5;
+              language = _ref2.language;
+              room = this._getRoomInfo(language);
+              if (!(room && room.status === _type.UpdateType.JOIN)) {
+                _context6.next = 15;
+                break;
+              }
+              control = room.control;
+              _context6.prev = 4;
+              this._observable.notifyObservers('onLeaveInterpretingRoom', room);
+              _context6.next = 8;
               return control.leave();
-            case 5:
-              this.logger.info("interpreterLog-leaveInterpreterRoom  succeed", param.language);
-              this._observable.notifyObservers('onLeaveInterpretingRoomSuccess', param);
-              _context2.next = 13;
+            case 8:
+              this._observable.notifyObservers('onLeaveInterpretingRoomSuccess', room);
+              _context6.next = 14;
               break;
-            case 9:
-              _context2.prev = 9;
-              _context2.t0 = _context2["catch"](1);
-              this.logger.info("interpreterLog-leaveInterpreterRoom fail", param.language);
-              this._observable.notifyObservers('onLeaveInterpretingRoomFailed', param);
+            case 11:
+              _context6.prev = 11;
+              _context6.t0 = _context6["catch"](4);
+              this._observable.notifyObservers('onLeaveInterpretingRoomFailed', room);
+            case 14:
+              this._updateLanguageRoomListByStatus([_objectSpread(_objectSpread({}, room), {}, {
+                status: _type.UpdateType.LEFT
+              })]);
+            case 15:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[4, 11]]);
+      }));
+      function _leaveInterpreterRoom(_x8) {
+        return _leaveInterpreterRoom2.apply(this, arguments);
+      }
+      return _leaveInterpreterRoom;
+    }()
+  }, {
+    key: "_setMainRoomStream",
+    value: function () {
+      var _setMainRoomStream2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7(open) {
+        var _this5 = this;
+        var localStreamList, micStreams, streamId, streamInfo, hasAudioPublishPrivilege, streamsConfig;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              localStreamList = this._mainStreamControl.getStreamsByUserId(this._userControl.getLocalUser().userId);
+              micStreams = localStreamList.filter(function (ele) {
+                return ele.audioSourceType === _type2.AgoraRteAudioSourceType.MICROPHONE;
+              });
+              streamId = !!micStreams.length ? micStreams[0].streamId : null;
+              if (!streamId) {
+                _context7.next = 10;
+                break;
+              }
+              streamInfo = this._mainStreamControl.getStreamByStreamId(streamId);
+              hasAudioPublishPrivilege = streamInfo && (streamInfo.streamType === _fcrCore.FcrStreamType.BOTH || streamInfo.streamType === _fcrCore.FcrStreamType.AUDIO);
+              if (!hasAudioPublishPrivilege) {
+                _context7.next = 10;
+                break;
+              }
+              streamsConfig = (0, _defineProperty2["default"])({}, streamId, {
+                audioPrivilege: open ? _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE : _fcrCore.FcrStreamPrivilegeOperation.NOPRIVILEGE,
+                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+              });
+              _context7.next = 10;
+              return (0, _utils.retryTask)(function () {
+                return _this5._mainStreamControl.updatePublishPrivilegeOfStreams(streamsConfig);
+              }, this._retryTask);
+            case 10:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function _setMainRoomStream(_x9) {
+        return _setMainRoomStream2.apply(this, arguments);
+      }
+      return _setMainRoomStream;
+    }()
+  }, {
+    key: "_updateOutputLanguage",
+    value: function () {
+      var _updateOutputLanguage2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee10(language, isLocalOperation) {
+        var _this6 = this;
+        var setUiOutputLanguage, setInterpreterRoomStreams, _this$_sharedInterpre4, outputLanguage, preInterpreterInfo, interpreterInfo, subscribeLanguageList, isToggleInterperterRemoteAudio, outputLanguageList, preOutputLanguageList, closeOutputLanguageList, index, languageRoom;
+        return _regenerator["default"].wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              setUiOutputLanguage = /*#__PURE__*/function () {
+                var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8(language) {
+                  var interpreterLangCode;
+                  return _regenerator["default"].wrap(function _callee8$(_context8) {
+                    while (1) switch (_context8.prev = _context8.next) {
+                      case 0:
+                        _this6._sharedInterpreterDataSource.outputLanguage = language;
+                        _context8.prev = 1;
+                        interpreterLangCode = _this6._userControl.getUserPropertiesByKeyPath('interpreterLangCode', _this6._userControl.getLocalUser().userId);
+                        if (!(!language && !interpreterLangCode)) {
+                          _context8.next = 5;
+                          break;
+                        }
+                        return _context8.abrupt("return");
+                      case 5:
+                        _context8.next = 7;
+                        return _this6._userControl.updateUserProperties({
+                          interpreterLangCode: language
+                        }, {}, _this6._userControl.getLocalUser().userId);
+                      case 7:
+                        _this6.logger.info("interpreterLog- _updateUserProperties  interpreterLangCode:".concat(language, " succeed"));
+                        _context8.next = 13;
+                        break;
+                      case 10:
+                        _context8.prev = 10;
+                        _context8.t0 = _context8["catch"](1);
+                        _this6.logger.info("interpreterLog- _updateUserProperties  interpreterLangCode:".concat(language, " fail"));
+                      case 13:
+                      case "end":
+                        return _context8.stop();
+                    }
+                  }, _callee8, null, [[1, 10]]);
+                }));
+                return function setUiOutputLanguage(_x12) {
+                  return _ref3.apply(this, arguments);
+                };
+              }();
+              setInterpreterRoomStreams = /*#__PURE__*/function () {
+                var _ref4 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9(language, open) {
+                  var room, control, streamControl, streamList, stream;
+                  return _regenerator["default"].wrap(function _callee9$(_context9) {
+                    while (1) switch (_context9.prev = _context9.next) {
+                      case 0:
+                        room = _this6._getRoomInfo(language);
+                        if (!(room && room.status === _type.UpdateType.JOIN)) {
+                          _context9.next = 9;
+                          break;
+                        }
+                        control = room.control;
+                        streamControl = control.getStreamControl();
+                        streamList = streamControl.getStreamsByUserId(_this6._userControl.getLocalUser().userId);
+                        if (!(streamList.length > 0)) {
+                          _context9.next = 9;
+                          break;
+                        }
+                        stream = streamList[0];
+                        _context9.next = 9;
+                        return streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, stream.streamId, {
+                          videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION,
+                          audioPrivilege: open ? _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE : _fcrCore.FcrStreamPrivilegeOperation.NOPRIVILEGE
+                        }));
+                      case 9:
+                      case "end":
+                        return _context9.stop();
+                    }
+                  }, _callee9);
+                }));
+                return function setInterpreterRoomStreams(_x13, _x14) {
+                  return _ref4.apply(this, arguments);
+                };
+              }();
+              this._clearRetryTaskTimer(); // 清除当前重试任务
+              _this$_sharedInterpre4 = this._sharedInterpreterDataSource, outputLanguage = _this$_sharedInterpre4.outputLanguage, preInterpreterInfo = _this$_sharedInterpre4.preInterpreterInfo, interpreterInfo = _this$_sharedInterpre4.interpreterInfo, subscribeLanguageList = _this$_sharedInterpre4.subscribeLanguageList;
+              _context10.next = 6;
+              return this._setMainRoomStream(language ? false : true);
+            case 6:
+              isToggleInterperterRemoteAudio = false; //  开启
+              if (!language) {
+                _context10.next = 19;
+                break;
+              }
+              if (!outputLanguage) {
+                _context10.next = 15;
+                break;
+              }
+              _context10.next = 11;
+              return this._joinInterpreterRoom({
+                language: language,
+                isToggleInterperterRemoteAudio: isToggleInterperterRemoteAudio
+              });
+            case 11:
+              _context10.next = 13;
+              return setInterpreterRoomStreams(language, true);
             case 13:
+              _context10.next = 19;
+              break;
+            case 15:
+              _context10.next = 17;
+              return (0, _utils.retryTask)(function () {
+                return _this6._joinInterpreterRoom({
+                  language: language,
+                  isToggleInterperterRemoteAudio: isToggleInterperterRemoteAudio
+                });
+              }, this._retryTask);
+            case 17:
+              _context10.next = 19;
+              return (0, _utils.retryTask)(function () {
+                return setInterpreterRoomStreams(language, true);
+              }, this._retryTask);
+            case 19:
+              // 关闭
+              outputLanguageList = [];
+              preOutputLanguageList = [];
+              if (interpreterInfo) {
+                outputLanguageList.push(interpreterInfo.sourceLanguage, interpreterInfo.targetLanguage);
+              }
+              if (preInterpreterInfo) {
+                preOutputLanguageList.push(preInterpreterInfo.sourceLanguage, preInterpreterInfo.targetLanguage);
+              }
+              closeOutputLanguageList = [].concat((0, _toConsumableArray2["default"])(outputLanguageList.filter(function (ele) {
+                return ele !== language;
+              })), (0, _toConsumableArray2["default"])(preOutputLanguageList.filter(function (ele) {
+                return ele !== language;
+              })));
+              closeOutputLanguageList = Array.from(new Set(closeOutputLanguageList));
+              index = 0;
+            case 26:
+              if (!(index < closeOutputLanguageList.length)) {
+                _context10.next = 38;
+                break;
+              }
+              languageRoom = closeOutputLanguageList[index];
+              if (!(outputLanguageList.includes(languageRoom) || subscribeLanguageList.includes(languageRoom))) {
+                _context10.next = 33;
+                break;
+              }
+              _context10.next = 31;
+              return setInterpreterRoomStreams(languageRoom, false);
+            case 31:
+              _context10.next = 35;
+              break;
+            case 33:
+              _context10.next = 35;
+              return this._leaveInterpreterRoom({
+                language: languageRoom
+              });
+            case 35:
+              index++;
+              _context10.next = 26;
+              break;
+            case 38:
+              setUiOutputLanguage(language);
+
+              // if (localInterpreterUpdate) {
+              //   this._observable.notifyObservers(
+              //     'onLocalInterpreterUpdated',
+              //     [interpreterInfo.sourceLanguage, interpreterInfo.targetLanguage],
+              //     language,
+              //   );
+              // }
+            case 39:
             case "end":
-              return _context2.stop();
+              return _context10.stop();
           }
-        }, _callee2, this, [[1, 9]]);
+        }, _callee10, this);
       }));
-      function leaveInterpreterRoom(_x2) {
-        return _leaveInterpreterRoom.apply(this, arguments);
+      function _updateOutputLanguage(_x10, _x11) {
+        return _updateOutputLanguage2.apply(this, arguments);
       }
-      return leaveInterpreterRoom;
-    }() // 控制翻译房间输出流权限
+      return _updateOutputLanguage;
+    }()
   }, {
-    key: "updateInterpreterRoomStreams",
+    key: "_updateSubscribeLanguage",
     value: function () {
-      var _updateInterpreterRoomStreams = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(roomControl, open) {
-        var streamControl, streamMap, streamList, stream;
-        return _regenerator["default"].wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
+      var _updateSubscribeLanguage2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee12(languageList) {
+        var _this7 = this;
+        var handlesubscribeLanguage, updateLanguageList, index, languageRoom, subscribeLanguageList, closeSubscribeLanguageList, _index, _languageRoom;
+        return _regenerator["default"].wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
             case 0:
-              if (!roomControl) {
-                _context3.next = 9;
+              handlesubscribeLanguage = /*#__PURE__*/function () {
+                var _ref6 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee11(_ref5) {
+                  var language, event, room, interpreterInfo;
+                  return _regenerator["default"].wrap(function _callee11$(_context11) {
+                    while (1) switch (_context11.prev = _context11.next) {
+                      case 0:
+                        language = _ref5.language, event = _ref5.event;
+                        room = _this7._getRoomInfo(language);
+                        interpreterInfo = _this7._sharedInterpreterDataSource.interpreterInfo;
+                        if (!room) {
+                          _context11.next = 21;
+                          break;
+                        }
+                        if (!(room.status === _type.UpdateType.JOIN)) {
+                          _context11.next = 8;
+                          break;
+                        }
+                        _this7._eventProvider.sendEvent(_constant.FcrUIAction.TOGGLE_INTERPRETER_REMOTE_AUDIO, {
+                          roomControl: room.control,
+                          event: event
+                        });
+                        _context11.next = 21;
+                        break;
+                      case 8:
+                        if (!(event === _enums.EventType.STOP)) {
+                          _context11.next = 18;
+                          break;
+                        }
+                        if (!((interpreterInfo === null || interpreterInfo === void 0 ? void 0 : interpreterInfo.sourceLanguage) === language || (interpreterInfo === null || interpreterInfo === void 0 ? void 0 : interpreterInfo.targetLanguage) === language)) {
+                          _context11.next = 13;
+                          break;
+                        }
+                        _this7._eventProvider.sendEvent(_constant.FcrUIAction.TOGGLE_INTERPRETER_REMOTE_AUDIO, {
+                          roomControl: room.control,
+                          event: event
+                        });
+                        _context11.next = 15;
+                        break;
+                      case 13:
+                        _context11.next = 15;
+                        return (0, _utils.retryTask)(function () {
+                          return _this7._leaveInterpreterRoom({
+                            language: language
+                          });
+                        }, _this7._retryTask);
+                      case 15:
+                        // TODO  移除监听音量变化
+                        room.control.getStreamControl().removeObserver(_this7._observerStream);
+                        _context11.next = 21;
+                        break;
+                      case 18:
+                        _context11.next = 20;
+                        return (0, _utils.retryTask)(function () {
+                          return _this7._joinInterpreterRoom({
+                            language: language
+                          });
+                        }, _this7._retryTask);
+                      case 20:
+                        // TODO  设置监听音量变化
+                        room.control.getStreamControl().addObserver(_this7._observerStream);
+                      case 21:
+                      case "end":
+                        return _context11.stop();
+                    }
+                  }, _callee11);
+                }));
+                return function handlesubscribeLanguage(_x16) {
+                  return _ref6.apply(this, arguments);
+                };
+              }();
+              this._clearRetryTaskTimer();
+              updateLanguageList = languageList.length === 0 ? [_interpreter.ORIGIN] : languageList;
+              index = 0;
+            case 4:
+              if (!(index < languageList.length)) {
+                _context12.next = 15;
+                break;
+              }
+              languageRoom = languageList[index];
+              if (!(languageRoom === _interpreter.ORIGIN)) {
+                _context12.next = 10;
                 break;
               }
-              streamControl = roomControl.getStreamControl();
-              streamMap = streamControl.getStreams();
-              streamList = Object.keys(streamMap).map(function (key) {
-                return streamMap[key];
+              this._eventProvider.sendEvent(_constant.FcrUIAction.TOGGLE_MAINROOM_REMOTE_AUDIO, {
+                event: _enums.EventType.START
               });
-              if (!(streamList.length > 0)) {
-                _context3.next = 9;
+              _context12.next = 12;
+              break;
+            case 10:
+              _context12.next = 12;
+              return handlesubscribeLanguage({
+                language: languageRoom,
+                event: _enums.EventType.START
+              });
+            case 12:
+              index++;
+              _context12.next = 4;
+              break;
+            case 15:
+              subscribeLanguageList = this._sharedInterpreterDataSource.subscribeLanguageList;
+              closeSubscribeLanguageList = subscribeLanguageList.filter(function (ele) {
+                return !languageList.includes(ele);
+              });
+              _index = 0;
+            case 18:
+              if (!(_index < closeSubscribeLanguageList.length)) {
+                _context12.next = 29;
                 break;
               }
-              stream = streamList[0][0];
-              _context3.next = 8;
-              return streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, stream.streamId, {
-                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION,
-                audioPrivilege: open ? _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE : _fcrCore.FcrStreamPrivilegeOperation.NOPRIVILEGE
-              }));
-            case 8:
-              this.logger.info("interpreterLog- ".concat(open ? 'ON' : 'OFF', " interpreterRoom input streams"), stream.streamId);
+              _languageRoom = closeSubscribeLanguageList[_index];
+              if (!(_languageRoom === _interpreter.ORIGIN)) {
+                _context12.next = 24;
+                break;
+              }
+              this._eventProvider.sendEvent(_constant.FcrUIAction.TOGGLE_MAINROOM_REMOTE_AUDIO, {
+                event: _enums.EventType.STOP
+              });
+              _context12.next = 26;
+              break;
+            case 24:
+              _context12.next = 26;
+              return handlesubscribeLanguage({
+                language: _languageRoom,
+                event: _enums.EventType.STOP
+              });
+            case 26:
+              _index++;
+              _context12.next = 18;
+              break;
+            case 29:
+              this._sharedInterpreterDataSource.preSubscribeLanguageList = subscribeLanguageList;
+              this._sharedInterpreterDataSource.subscribeLanguageList = updateLanguageList;
+            case 31:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function _updateSubscribeLanguage(_x15) {
+        return _updateSubscribeLanguage2.apply(this, arguments);
+      }
+      return _updateSubscribeLanguage;
+    }()
+  }, {
+    key: "setOutputLanguage",
+    value: function () {
+      var _setOutputLanguage = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee13(language, successCallback, failureCallback) {
+        var _this$_sharedInterpre5, interpreterInfo, outputLanguage;
+        return _regenerator["default"].wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              _this$_sharedInterpre5 = this._sharedInterpreterDataSource, interpreterInfo = _this$_sharedInterpre5.interpreterInfo, outputLanguage = _this$_sharedInterpre5.outputLanguage;
+              _context13.prev = 1;
+              if (!interpreterInfo) {
+                _context13.next = 7;
+                break;
+              }
+              _context13.next = 5;
+              return this._updateOutputLanguage(language, true);
+            case 5:
+              successCallback && successCallback();
+
+              // TODO 触发麦克风关闭提示
+              if (!this._deviceProvider.microphoneEnabled) {
+                this._eventProvider.showToast({
+                  type: 'info',
+                  message: (0, _i18n.transI18n)('fmt_interpretation_interpreter_toast_label_open_micro')
+                });
+              }
+            case 7:
+              _context13.next = 12;
+              break;
             case 9:
+              _context13.prev = 9;
+              _context13.t0 = _context13["catch"](1);
+              failureCallback && failureCallback(_context13.t0);
+            case 12:
+              return _context13.abrupt("return", !!interpreterInfo);
+            case 13:
             case "end":
-              return _context3.stop();
+              return _context13.stop();
           }
-        }, _callee3, this);
+        }, _callee13, this, [[1, 9]]);
+      }));
+      function setOutputLanguage(_x17, _x18, _x19) {
+        return _setOutputLanguage.apply(this, arguments);
+      }
+      return setOutputLanguage;
+    }()
+  }, {
+    key: "subscribeLanguage",
+    value: function () {
+      var _subscribeLanguage = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee14(language, successCallback, failureCallback) {
+        var subscribeLanguageList, languageList, removeLanguage;
+        return _regenerator["default"].wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              _context14.prev = 0;
+              subscribeLanguageList = this._sharedInterpreterDataSource.subscribeLanguageList;
+              languageList = [];
+              if (subscribeLanguageList.length === 2 && language !== _interpreter.ORIGIN) {
+                languageList = [_interpreter.ORIGIN];
+              }
+              _context14.next = 6;
+              return this._updateSubscribeLanguage([].concat((0, _toConsumableArray2["default"])(languageList), [language]));
+            case 6:
+              successCallback && successCallback();
+
+              // TODO
+              // 该方法会使`该方法会使` 时只有一种语言， 之前有的语言移除
+              if (this._hasSubscribedLanguageList.size === 1) {
+                this._hasSubscribedLanguageList.clear();
+                this._hasSubscribedLanguageList.add(language);
+              }
+              removeLanguage = subscribeLanguageList.find(function (ele) {
+                return ele !== _interpreter.ORIGIN && ele !== language;
+              });
+              if (removeLanguage) {
+                this._observable.notifyObservers('onLanguageUnsubscribed', removeLanguage);
+              }
+              this._observable.notifyObservers('onLanguageSubscribed', language);
+              _context14.next = 16;
+              break;
+            case 13:
+              _context14.prev = 13;
+              _context14.t0 = _context14["catch"](0);
+              failureCallback && failureCallback(_context14.t0);
+            case 16:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this, [[0, 13]]);
       }));
-      function updateInterpreterRoomStreams(_x3, _x4) {
-        return _updateInterpreterRoomStreams.apply(this, arguments);
+      function subscribeLanguage(_x20, _x21, _x22) {
+        return _subscribeLanguage.apply(this, arguments);
       }
-      return updateInterpreterRoomStreams;
+      return subscribeLanguage;
     }()
+  }, {
+    key: "subscribeExtraOriginLanguage",
+    value: function subscribeExtraOriginLanguage(subscribe) {
+      if (subscribe) {
+        // TODO
+        if (!this._hasSubscribedLanguageList.has(_interpreter.ORIGIN)) {
+          this._hasSubscribedLanguageList.add(_interpreter.ORIGIN);
+          this._observable.notifyObservers('onLanguageSubscribed', _interpreter.ORIGIN);
+        }
+      } else {
+        if (this._hasSubscribedLanguageList.size === 2 && this._hasSubscribedLanguageList.has(_interpreter.ORIGIN)) {
+          this._hasSubscribedLanguageList["delete"](_interpreter.ORIGIN);
+          this._observable.notifyObservers('onLanguageUnsubscribed', _interpreter.ORIGIN);
+        }
+      }
+    }
+  }, {
+    key: "getHasSubscribedLanguageList",
+    value: function getHasSubscribedLanguageList() {
+      this.subscribeExtraOriginLanguage(true);
+      var hasSubscribedLanguageList = [];
+      this._hasSubscribedLanguageList.forEach(function (ele) {
+        hasSubscribedLanguageList.push(ele);
+      });
+      return hasSubscribedLanguageList;
+    }
+  }, {
+    key: "userIsInterpreter",
+    value: function userIsInterpreter(userId) {
+      var interpreterUsers = this._sharedInterpreterDataSource.interpreterUsers;
+      return !!(interpreterUsers !== null && interpreterUsers !== void 0 && interpreterUsers.find(function (ele) {
+        return ele.userId === userId;
+      }));
+    }
+  }, {
+    key: "getUserOutputLanguage",
+    value: function getUserOutputLanguage(userId) {
+      var isUserIsInterpreter = this.userIsInterpreter(userId);
+      if (!isUserIsInterpreter) {
+        return _interpreter.ORIGIN;
+      } else {
+        if (this._userControl.getLocalUser().userId === userId) {
+          return this._sharedInterpreterDataSource.outputLanguage;
+        } else {
+          return this._userControl.getUserPropertiesByKeyPath('interpreterLangCode', userId);
+        }
+      }
+    }
+  }, {
+    key: "getSubscribeLanguageList",
+    value: function getSubscribeLanguageList() {
+      var interpreterUsers = this._interpreterControl.getInterpreterUserList();
+      var subscribeLanguageList = [_interpreter.ORIGIN];
+      interpreterUsers === null || interpreterUsers === void 0 || interpreterUsers.forEach(function (ele) {
+        subscribeLanguageList.push(ele.sourceLanguage, ele.targetLanguage);
+      });
+      return subscribeLanguageList;
+    }
+  }, {
+    key: "getOutputLanguageOptionList",
+    value: function getOutputLanguageOptionList() {
+      return this._interpreterControl.getInterpreterLanguageList();
+    }
+  }, {
+    key: "setInterpreterUsers",
+    value: function () {
+      var _setInterpreterUsers = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee15(params, successCallback, failureCallback) {
+        return _regenerator["default"].wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              _context15.prev = 0;
+              _context15.next = 3;
+              return this._interpreterControl.setInterpreterUsers(params);
+            case 3:
+              successCallback && successCallback();
+              _context15.next = 9;
+              break;
+            case 6:
+              _context15.prev = 6;
+              _context15.t0 = _context15["catch"](0);
+              failureCallback && failureCallback(_context15.t0);
+            case 9:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this, [[0, 6]]);
+      }));
+      function setInterpreterUsers(_x23, _x24, _x25) {
+        return _setInterpreterUsers.apply(this, arguments);
+      }
+      return setInterpreterUsers;
+    }()
+  }, {
+    key: "disableInterpretation",
+    value: function disableInterpretation() {
+      this._interpreterControl.close();
+    }
+  }, {
+    key: "getInterpretationState",
+    value: function getInterpretationState() {
+      return this._interpreterControl.getState().enable;
+    }
+  }, {
+    key: "getInterpreterList",
+    value: function getInterpreterList() {
+      return this._interpreterControl.getInterpreterUserList();
+    }
   }, {
     key: "addObserver",
     value: function addObserver(observer) {
@@ -146,6 +1121,19 @@ var FcrUIInterpreterProviderImpl = exports.FcrUIInterpreterProviderImpl = /*#__P
     value: function removeObserver(observer) {
       this._observable.removeObserver(observer);
     }
+  }, {
+    key: "canEnableInterpretation",
+    value: function canEnableInterpretation() {
+      return this._privilegeProvider.hasEnableInterpreterPermission();
+    }
+  }, {
+    key: "release",
+    value: function release() {
+      this._clearRetryTaskTimer();
+      this._clearTimer();
+      this._deviceProvider.removeObserver(this._observerMicrophoneChanged);
+      this._interpreterControl.removeObserver(this._observerInterpreter);
+    }
   }]);
 }();
 (0, _base.registerDependency)('interpreterProvider');