fcr-ui-scene 3.8.1 → 3.9.0-alpha

package/lib-es/providers/interpreter-provider.js

@@ -0,0 +1,955 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.object.define-properties.js";
+import "core-js/modules/es.object.define-property.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { AgoraObservable } from 'agora-foundation/lib/utilities/observable';
+import { FcrStreamLatencyLevel, FcrStreamPrivilegeOperation } from 'fcr-core';
+// import { FcrUIPrivilegeProvider } from './privilege-provider';
+
+import { ORIGIN } from '../shared-data/interpreter';
+import { UpdateType } from '../modules/interpreter/type';
+import { FcrMediaSourceState, FcrStreamType, FcrVideoSourceType } from 'fcr-core/lib/type';
+import { FcrAudioSourceType, FcrUserRole } from 'fcr-core/lib/type';
+import { retryTask } from '../modules/interpreter/utils';
+import { FcrUIAction } from '../utilities/constant';
+import { EventType } from '../modules/action-bar/enums';
+import { throttle } from 'lodash';
+import { createLogger } from '../utilities/logger';
+var getRoomJoinOptions = function getRoomJoinOptions(localUser) {
+  var roomJoinOptions = {
+    userName: localUser.userName,
+    userRole: FcrUserRole.PARTICIPANT,
+    roomToken: '',
+    streamLatency: FcrStreamLatencyLevel.ULTRA_LOW,
+    createStreamConfigs: [{
+      videoSourceState: FcrMediaSourceState.CLOSE,
+      audioSourceState: FcrMediaSourceState.CLOSE,
+      videoSourceId: '',
+      audioSourceId: '',
+      streamName: 'default',
+      streamType: FcrStreamType.NONE,
+      videoSourceType: FcrVideoSourceType.CAMERA,
+      audioSourceType: FcrAudioSourceType.MICROPHONE
+    }]
+  };
+  return roomJoinOptions;
+};
+export var FcrUIInterpreterProviderImpl = /*#__PURE__*/function () {
+  function FcrUIInterpreterProviderImpl(params) {
+    var _this = this;
+    _classCallCheck(this, FcrUIInterpreterProviderImpl);
+    // @internal
+    _defineProperty(this, "logger", createLogger({
+      prefix: 'FcrUIInterpreterProviderImpl'
+    }));
+    _defineProperty(this, "_observable", new AgoraObservable());
+    // private _hasSubscribedLanguageList = new Set<FcrUILanguage>([ORIGIN]);
+    _defineProperty(this, "_observerStream", {
+      onStreamVolumeIndicationUpdated: throttle(function (roomId, streamId, volume) {
+        // HLD: 判断 volume > 10 ，避免波动， 则认为是在说话
+        var isSpeaking = Math.floor(volume / 255 * 100) > 10;
+        _this._observable.notifyObservers('onSubscribeLanguageVolumePrioritized', isSpeaking);
+      }, 500)
+    });
+    _defineProperty(this, "_publishEvent", {
+      onLocalBecomeInterpreter: function onLocalBecomeInterpreter() {
+        var _this$_sharedInterpre = _this._sharedInterpreterDataSource,
+          preLocalInterpreterUserInfo = _this$_sharedInterpre.preLocalInterpreterUserInfo,
+          localInterpreterUserInfo = _this$_sharedInterpre.localInterpreterUserInfo,
+          outputLanguage = _this$_sharedInterpre.outputLanguage,
+          supportedLanguages = _this$_sharedInterpre.supportedLanguages;
+        if (localInterpreterUserInfo && !preLocalInterpreterUserInfo && outputLanguage) {
+          _this._observable.notifyObservers('onLocalBecomeInterpreter', supportedLanguages, outputLanguage);
+        }
+      },
+      onSubscribeLanguageListUpdated: function onSubscribeLanguageListUpdated() {
+        var state = _this.getInterpretationState();
+        if (state) {
+          var languageList = _this.getSubscribeLanguageList();
+          _this._observable.notifyObservers('onSubscribeLanguageListUpdated', languageList);
+        }
+      },
+      onInterpretationEnabled: function onInterpretationEnabled(operatorUser) {
+        var interpreterList = _this.getInterpreterList();
+        var state = _this.getInterpretationState();
+        if (state && interpreterList && operatorUser) {
+          _this._observable.notifyObservers('onInterpretationEnabled', interpreterList, operatorUser);
+        }
+      },
+      onInterpretationDisabled: function onInterpretationDisabled(operatorUser) {
+        var state = _this.getInterpretationState();
+        if (!state && operatorUser) {
+          _this._observable.notifyObservers('onInterpretationDisabled', operatorUser);
+        }
+      },
+      onInterpreterListUpdated: function onInterpreterListUpdated(users, operatorUser) {
+        if (users && operatorUser) {
+          _this._observable.notifyObservers('onInterpreterListUpdated', users, operatorUser);
+        }
+      },
+      onLocalNotInterpreter: function onLocalNotInterpreter() {
+        var _this$_sharedInterpre2 = _this._sharedInterpreterDataSource,
+          preLocalInterpreterUserInfo = _this$_sharedInterpre2.preLocalInterpreterUserInfo,
+          localInterpreterUserInfo = _this$_sharedInterpre2.localInterpreterUserInfo;
+        if (preLocalInterpreterUserInfo && !localInterpreterUserInfo) {
+          _this._observable.notifyObservers('onLocalNotInterpreter');
+        }
+      },
+      onLocalBecameInterpreter: function onLocalBecameInterpreter() {
+        var _this$_sharedInterpre3 = _this._sharedInterpreterDataSource,
+          localInterpreterUserInfo = _this$_sharedInterpre3.localInterpreterUserInfo,
+          supportedLanguages = _this$_sharedInterpre3.supportedLanguages;
+        if (localInterpreterUserInfo) {
+          var targetLanguage = localInterpreterUserInfo.targetLanguage;
+          _this._observable.notifyObservers('onLocalBecameInterpreter', supportedLanguages, targetLanguage);
+        }
+      },
+      onLanguageUnsubscribed: function onLanguageUnsubscribed(language) {
+        _this._observable.notifyObservers('onLanguageUnsubscribed', language);
+      },
+      onLanguageSubscribed: function onLanguageSubscribed(language) {
+        _this._observable.notifyObservers('onLanguageSubscribed', language);
+      },
+      onLocalInterpreterWillUpdate: function onLocalInterpreterWillUpdate(language) {
+        var isSupportedLanguagesUpdate = _this._sharedInterpreterDataSource.isSupportedLanguagesUpdate;
+        if (isSupportedLanguagesUpdate) {
+          _this._observable.notifyObservers('onLocalInterpreterWillUpdate', language);
+        }
+      },
+      onLocalInterpreterUpdated: function onLocalInterpreterUpdated() {
+        var _this$_sharedInterpre4 = _this._sharedInterpreterDataSource,
+          isSupportedLanguagesUpdate = _this$_sharedInterpre4.isSupportedLanguagesUpdate,
+          supportedLanguages = _this$_sharedInterpre4.supportedLanguages,
+          outputLanguage = _this$_sharedInterpre4.outputLanguage;
+        if (isSupportedLanguagesUpdate && outputLanguage) {
+          _this._observable.notifyObservers('onLocalInterpreterUpdated', supportedLanguages, outputLanguage);
+        }
+      }
+    });
+    _defineProperty(this, "_observerInterpreter", {
+      onInterpreterStateUpdated: function () {
+        var _onInterpreterStateUpdated = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(roomId, state, operatorUser) {
+          return _regeneratorRuntime.wrap(function (_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 1;
+                return _this._refresh(operatorUser);
+              case 1:
+                _this._publishEvent.onLocalBecomeInterpreter();
+                _this._publishEvent.onInterpretationEnabled(operatorUser);
+                _this._publishEvent.onSubscribeLanguageListUpdated();
+                _this._publishEvent.onInterpretationDisabled(operatorUser);
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        function onInterpreterStateUpdated(_x, _x2, _x3) {
+          return _onInterpreterStateUpdated.apply(this, arguments);
+        }
+        return onInterpreterStateUpdated;
+      }(),
+      onInterpreterUsersUpdated: function () {
+        var _onInterpreterUsersUpdated = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(roomId, users, operatorUser) {
+          return _regeneratorRuntime.wrap(function (_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 1;
+                return _this._refresh(operatorUser);
+              case 1:
+                _this._publishEvent.onLocalBecomeInterpreter();
+                _this._publishEvent.onInterpreterListUpdated(users, operatorUser);
+                _this._publishEvent.onSubscribeLanguageListUpdated();
+                _this._publishEvent.onLocalNotInterpreter();
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }));
+        function onInterpreterUsersUpdated(_x4, _x5, _x6) {
+          return _onInterpreterUsersUpdated.apply(this, arguments);
+        }
+        return onInterpreterUsersUpdated;
+      }()
+    });
+    _defineProperty(this, "_retryTask", {
+      timerId: null,
+      isAllowRetry: true
+    });
+    _defineProperty(this, "_closeOutputLanguageRoom", /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var languageRoomListByStatus;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            languageRoomListByStatus = _this._sharedInterpreterDataSource.languageRoomListByStatus;
+            languageRoomListByStatus.forEach(function (ele) {
+              if (ele.status === UpdateType.JOIN) {
+                _this._leaveInterpreterRoom({
+                  language: ele.language
+                });
+              }
+            });
+            _this._sharedInterpreterDataSource.languageRoomListByStatus.clear();
+          case 1:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+    _defineProperty(this, "_roomProviderObserver", {
+      onLeaveMainRoom: function () {
+        var _onLeaveMainRoom = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+          return _regeneratorRuntime.wrap(function (_context4) {
+            while (1) switch (_context4.prev = _context4.next) {
+              case 0:
+                _this._closeOutputLanguageRoom();
+              case 1:
+              case "end":
+                return _context4.stop();
+            }
+          }, _callee4);
+        }));
+        function onLeaveMainRoom() {
+          return _onLeaveMainRoom.apply(this, arguments);
+        }
+        return onLeaveMainRoom;
+      }(),
+      onExitMeeting: function () {
+        var _onExitMeeting = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+          return _regeneratorRuntime.wrap(function (_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
+              case 0:
+                _this._closeOutputLanguageRoom();
+              case 1:
+              case "end":
+                return _context5.stop();
+            }
+          }, _callee5);
+        }));
+        function onExitMeeting() {
+          return _onExitMeeting.apply(this, arguments);
+        }
+        return onExitMeeting;
+      }()
+    });
+    var privilegeProvider = params.privilegeProvider,
+      interpreterControl = params.interpreterControl,
+      userControl = params.userControl,
+      sharedInterpreterDataSource = params.sharedInterpreterDataSource,
+      eventProvider = params.eventProvider,
+      devicePrivilegeProvider = params.devicePrivilegeProvider,
+      roomProvider = params.roomProvider;
+    this._privilegeProvider = privilegeProvider;
+    this._interpreterControl = interpreterControl;
+    this._userControl = userControl;
+    this._sharedInterpreterDataSource = sharedInterpreterDataSource;
+    this._eventProvider = eventProvider;
+    this._devicePrivilegeProvider = devicePrivilegeProvider;
+    this._roomProvider = roomProvider;
+    this._interpreterControl.addObserver(this._observerInterpreter);
+    this._refresh(this._userControl.getLocalUser());
+    this._publishEvent.onLocalBecameInterpreter();
+    this._roomProvider.addObserver(this._roomProviderObserver);
+  }
+  return _createClass(FcrUIInterpreterProviderImpl, [{
+    key: "_clearRetryTaskTimer",
+    value: function _clearRetryTaskTimer() {
+      this._retryTask.isAllowRetry = false;
+      if (this._retryTask.timerId) {
+        clearTimeout(this._retryTask.timerId);
+        this._retryTask.timerId = null;
+      }
+    }
+  }, {
+    key: "_refresh",
+    value: function () {
+      var _refresh2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(operatorUse) {
+        var _this2 = this;
+        var triggerDvicePrivilege, updateLanguageRoomListByStatus, getOutputLanguage, getSubscribeLanguageList, outputLanguage;
+        return _regeneratorRuntime.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              triggerDvicePrivilege = function triggerDvicePrivilege() {
+                var localInterpreterUserInfo = _this2._sharedInterpreterDataSource.localInterpreterUserInfo;
+                if (localInterpreterUserInfo) {
+                  _this2._devicePrivilegeProvider.setAlwaysHasMicrophonePrivilege(true);
+                  _this2._devicePrivilegeProvider.setAutoUpdateAudioStreamPrivilege(false);
+                } else {
+                  _this2._devicePrivilegeProvider.setAlwaysHasMicrophonePrivilege(false);
+                  _this2._devicePrivilegeProvider.setAutoUpdateAudioStreamPrivilege(true);
+                }
+              };
+              updateLanguageRoomListByStatus = function updateLanguageRoomListByStatus() {
+                var rooms = _this2._interpreterControl.getInterpreterRoomList() || []; //语言房间列表
+                rooms.forEach(function (ele) {
+                  var languageRoom = _this2._sharedInterpreterDataSource.languageRoomListByStatus.get(ele.language);
+                  _this2._sharedInterpreterDataSource.languageRoomListByStatus.set(ele.language, languageRoom ? languageRoom : _objectSpread(_objectSpread({}, ele), {}, {
+                    control: _this2._interpreterControl.createRoomControl(ele.roomId),
+                    status: UpdateType.LEFT
+                  }));
+                });
+              };
+              getOutputLanguage = function getOutputLanguage() {
+                var _this2$_sharedInterpr = _this2._sharedInterpreterDataSource,
+                  localInterpreterUserInfo = _this2$_sharedInterpr.localInterpreterUserInfo,
+                  outputLanguage = _this2$_sharedInterpr.outputLanguage,
+                  supportedLanguages = _this2$_sharedInterpr.supportedLanguages;
+                return outputLanguage && supportedLanguages.includes(outputLanguage) ? outputLanguage : (localInterpreterUserInfo === null || localInterpreterUserInfo === void 0 ? void 0 : localInterpreterUserInfo.targetLanguage) || null;
+              };
+              getSubscribeLanguageList = function getSubscribeLanguageList() {
+                var _this2$_sharedInterpr2 = _this2._sharedInterpreterDataSource,
+                  hasSubscribedLanguageList = _this2$_sharedInterpr2.hasSubscribedLanguageList,
+                  subscribeLanguageOptionList = _this2$_sharedInterpr2.subscribeLanguageOptionList;
+                var updateLanguageList = hasSubscribedLanguageList.filter(function (ele) {
+                  return subscribeLanguageOptionList.includes(ele);
+                });
+                return updateLanguageList.length === 0 ? [ORIGIN] : updateLanguageList;
+              };
+              triggerDvicePrivilege();
+              updateLanguageRoomListByStatus();
+              outputLanguage = getOutputLanguage();
+              if (operatorUse && operatorUse.userId !== this._userControl.getLocalUser().userId && outputLanguage) {
+                this._publishEvent.onLocalInterpreterWillUpdate(outputLanguage);
+              }
+              _context6.next = 1;
+              return this._updateOutputLanguage(outputLanguage);
+            case 1:
+              this._publishEvent.onLocalInterpreterUpdated();
+              _context6.next = 2;
+              return this._updateSubscribeLanguage(getSubscribeLanguageList());
+            case 2:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function _refresh(_x7) {
+        return _refresh2.apply(this, arguments);
+      }
+      return _refresh;
+    }()
+  }, {
+    key: "_joinInterpreterRoom",
+    value: function () {
+      var _joinInterpreterRoom2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(_ref2) {
+        var language, isToggleInterperterRemoteAudio, interpreterRoom, roomJoinOptions, _params, _t;
+        return _regeneratorRuntime.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              language = _ref2.language, isToggleInterperterRemoteAudio = _ref2.isToggleInterperterRemoteAudio;
+              interpreterRoom = this._sharedInterpreterDataSource.languageRoomListByStatus.get(language);
+              if (!(interpreterRoom && interpreterRoom.status !== UpdateType.JOIN)) {
+                _context7.next = 4;
+                break;
+              }
+              roomJoinOptions = getRoomJoinOptions(this._userControl.getLocalUser());
+              _params = _objectSpread(_objectSpread({}, interpreterRoom), {}, {
+                isToggleInterperterRemoteAudio: isToggleInterperterRemoteAudio,
+                roomJoinOptions: roomJoinOptions,
+                control: interpreterRoom.control
+              });
+              _context7.prev = 1;
+              this._observable.notifyObservers('onJoinInterpretingRoom', _params);
+              _context7.next = 2;
+              return interpreterRoom.control.join(roomJoinOptions);
+            case 2:
+              this._observable.notifyObservers('onJoinInterpretingRoomSuccess', _params);
+              this._sharedInterpreterDataSource.languageRoomListByStatus.set(interpreterRoom.language, _objectSpread(_objectSpread({}, interpreterRoom), {}, {
+                status: UpdateType.JOIN
+              }));
+              _context7.next = 4;
+              break;
+            case 3:
+              _context7.prev = 3;
+              _t = _context7["catch"](1);
+              this._observable.notifyObservers('onJoinInterpretingRoomFailed', _params);
+            case 4:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[1, 3]]);
+      }));
+      function _joinInterpreterRoom(_x8) {
+        return _joinInterpreterRoom2.apply(this, arguments);
+      }
+      return _joinInterpreterRoom;
+    }()
+  }, {
+    key: "_leaveInterpreterRoom",
+    value: function () {
+      var _leaveInterpreterRoom2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8(_ref3) {
+        var language, interpreterRoom, param, _t2;
+        return _regeneratorRuntime.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              language = _ref3.language;
+              interpreterRoom = this._sharedInterpreterDataSource.languageRoomListByStatus.get(language);
+              if (!(interpreterRoom && interpreterRoom.status === UpdateType.JOIN)) {
+                _context8.next = 5;
+                break;
+              }
+              param = _objectSpread(_objectSpread({}, interpreterRoom), {}, {
+                control: interpreterRoom.control
+              });
+              _context8.prev = 1;
+              this._observable.notifyObservers('onLeaveInterpretingRoom', param);
+              _context8.next = 2;
+              return interpreterRoom.control.leave();
+            case 2:
+              this._observable.notifyObservers('onLeaveInterpretingRoomSuccess', param);
+              _context8.next = 4;
+              break;
+            case 3:
+              _context8.prev = 3;
+              _t2 = _context8["catch"](1);
+              this._observable.notifyObservers('onLeaveInterpretingRoomFailed', param);
+            case 4:
+              this._sharedInterpreterDataSource.languageRoomListByStatus.set(interpreterRoom.language, _objectSpread(_objectSpread({}, interpreterRoom), {}, {
+                status: UpdateType.LEFT
+              }));
+            case 5:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[1, 3]]);
+      }));
+      function _leaveInterpreterRoom(_x9) {
+        return _leaveInterpreterRoom2.apply(this, arguments);
+      }
+      return _leaveInterpreterRoom;
+    }()
+  }, {
+    key: "_updateOutputLanguage",
+    value: function () {
+      var _updateOutputLanguage2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1(language) {
+        var _this3 = this;
+        var setUiOutputLanguage, setInterpreterRoomStreams, outputLanguage;
+        return _regeneratorRuntime.wrap(function (_context1) {
+          while (1) switch (_context1.prev = _context1.next) {
+            case 0:
+              setUiOutputLanguage = /*#__PURE__*/function () {
+                var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9(language) {
+                  var interpreterLangCode, _t3;
+                  return _regeneratorRuntime.wrap(function (_context9) {
+                    while (1) switch (_context9.prev = _context9.next) {
+                      case 0:
+                        _this3._sharedInterpreterDataSource.outputLanguage = language;
+                        _context9.prev = 1;
+                        interpreterLangCode = _this3._userControl.getUserPropertiesByKeyPath('interpreterLangCode', _this3._userControl.getLocalUser().userId);
+                        if (!(!language && !interpreterLangCode)) {
+                          _context9.next = 2;
+                          break;
+                        }
+                        return _context9.abrupt("return");
+                      case 2:
+                        _context9.next = 3;
+                        return _this3._userControl.updateUserProperties({
+                          interpreterLangCode: language
+                        }, {}, _this3._userControl.getLocalUser().userId);
+                      case 3:
+                        _context9.next = 5;
+                        break;
+                      case 4:
+                        _context9.prev = 4;
+                        _t3 = _context9["catch"](1);
+                        _this3.logger.info("interpreter log update user properties interpreterLangCode:".concat(language, " fail"));
+                      case 5:
+                      case "end":
+                        return _context9.stop();
+                    }
+                  }, _callee9, null, [[1, 4]]);
+                }));
+                return function setUiOutputLanguage(_x1) {
+                  return _ref4.apply(this, arguments);
+                };
+              }();
+              setInterpreterRoomStreams = /*#__PURE__*/function () {
+                var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0(language, open) {
+                  var interpreterRoom, streamControl, streamList, stream;
+                  return _regeneratorRuntime.wrap(function (_context0) {
+                    while (1) switch (_context0.prev = _context0.next) {
+                      case 0:
+                        if (!open) {
+                          _context0.next = 1;
+                          break;
+                        }
+                        _context0.next = 1;
+                        return _this3._joinInterpreterRoom({
+                          language: language,
+                          isToggleInterperterRemoteAudio: false
+                        });
+                      case 1:
+                        interpreterRoom = _this3._sharedInterpreterDataSource.languageRoomListByStatus.get(language);
+                        if (!(interpreterRoom && interpreterRoom.status === UpdateType.JOIN)) {
+                          _context0.next = 2;
+                          break;
+                        }
+                        streamControl = interpreterRoom.control.getStreamControl();
+                        streamList = streamControl.getStreamsByUserId(_this3._userControl.getLocalUser().userId);
+                        if (!(streamList.length > 0)) {
+                          _context0.next = 2;
+                          break;
+                        }
+                        stream = streamList[0];
+                        _context0.next = 2;
+                        return streamControl.updatePublishPrivilegeOfStreams(_defineProperty({}, stream.streamId, {
+                          videoPrivilege: FcrStreamPrivilegeOperation.NOOPERATION,
+                          audioPrivilege: open ? FcrStreamPrivilegeOperation.HAS_PRIVILEGE : FcrStreamPrivilegeOperation.NOPRIVILEGE
+                        }));
+                      case 2:
+                      case "end":
+                        return _context0.stop();
+                    }
+                  }, _callee0);
+                }));
+                return function setInterpreterRoomStreams(_x10, _x11) {
+                  return _ref5.apply(this, arguments);
+                };
+              }();
+              this._clearRetryTaskTimer(); // 清除当前重试任务
+              outputLanguage = this._sharedInterpreterDataSource.outputLanguage; //  开启
+              if (!language) {
+                _context1.next = 3;
+                break;
+              }
+              if (!outputLanguage) {
+                _context1.next = 2;
+                break;
+              }
+              _context1.next = 1;
+              return setInterpreterRoomStreams(language, true);
+            case 1:
+              _context1.next = 3;
+              break;
+            case 2:
+              _context1.next = 3;
+              return retryTask(function () {
+                return setInterpreterRoomStreams(language, true);
+              }, this._retryTask);
+            case 3:
+              if (!(outputLanguage && language !== outputLanguage)) {
+                _context1.next = 4;
+                break;
+              }
+              _context1.next = 4;
+              return setInterpreterRoomStreams(outputLanguage, false);
+            case 4:
+              setUiOutputLanguage(language);
+            case 5:
+            case "end":
+              return _context1.stop();
+          }
+        }, _callee1, this);
+      }));
+      function _updateOutputLanguage(_x0) {
+        return _updateOutputLanguage2.apply(this, arguments);
+      }
+      return _updateOutputLanguage;
+    }()
+  }, {
+    key: "_updateSubscribeLanguage",
+    value: function () {
+      var _updateSubscribeLanguage2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee11(updateLanguageList) {
+        var _this4 = this;
+        var handlesubscribeLanguage, index, languageRoom, hasSubscribedLanguageList, closeSubscribeLanguageList, _index, _languageRoom, _t4;
+        return _regeneratorRuntime.wrap(function (_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.prev = 0;
+              handlesubscribeLanguage = /*#__PURE__*/function () {
+                var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10(_ref6) {
+                  var language, open, interpreterRoom, _supportedLanguages;
+                  return _regeneratorRuntime.wrap(function (_context10) {
+                    while (1) switch (_context10.prev = _context10.next) {
+                      case 0:
+                        language = _ref6.language, open = _ref6.open;
+                        interpreterRoom = _this4._sharedInterpreterDataSource.languageRoomListByStatus.get(language);
+                        if (!interpreterRoom) {
+                          _context10.next = 7;
+                          break;
+                        }
+                        if (!open) {
+                          _context10.next = 4;
+                          break;
+                        }
+                        if (!(interpreterRoom.status !== UpdateType.JOIN)) {
+                          _context10.next = 2;
+                          break;
+                        }
+                        _context10.next = 1;
+                        return _this4._joinInterpreterRoom({
+                          language: language,
+                          isToggleInterperterRemoteAudio: true
+                        });
+                      case 1:
+                        interpreterRoom.control.getStreamControl().addObserver(_this4._observerStream);
+                        _context10.next = 3;
+                        break;
+                      case 2:
+                        _this4._eventProvider.sendEvent(FcrUIAction.TOGGLE_INTERPRETER_REMOTE_AUDIO, {
+                          roomControl: interpreterRoom.control,
+                          event: EventType.START
+                        });
+                        interpreterRoom.control.getStreamControl().addObserver(_this4._observerStream);
+                      case 3:
+                        _context10.next = 7;
+                        break;
+                      case 4:
+                        _supportedLanguages = _this4._sharedInterpreterDataSource.supportedLanguages;
+                        if (!_supportedLanguages.includes(language)) {
+                          _context10.next = 5;
+                          break;
+                        }
+                        if (interpreterRoom.status === UpdateType.JOIN) {
+                          _this4._eventProvider.sendEvent(FcrUIAction.TOGGLE_INTERPRETER_REMOTE_AUDIO, {
+                            roomControl: interpreterRoom.control,
+                            event: EventType.STOP
+                          });
+                        }
+                        _context10.next = 6;
+                        break;
+                      case 5:
+                        _context10.next = 6;
+                        return _this4._leaveInterpreterRoom({
+                          language: language
+                        });
+                      case 6:
+                        interpreterRoom.control.getStreamControl().removeObserver(_this4._observerStream);
+                      case 7:
+                      case "end":
+                        return _context10.stop();
+                    }
+                  }, _callee10);
+                }));
+                return function handlesubscribeLanguage(_x13) {
+                  return _ref7.apply(this, arguments);
+                };
+              }();
+              this._eventProvider.sendEvent(FcrUIAction.TOGGLE_MAINROOM_REMOTE_AUDIO, {
+                event: updateLanguageList.includes(ORIGIN) ? EventType.START : EventType.STOP
+              });
+              index = 0;
+            case 1:
+              if (!(index < updateLanguageList.length)) {
+                _context11.next = 3;
+                break;
+              }
+              languageRoom = updateLanguageList[index];
+              if (!(languageRoom !== ORIGIN)) {
+                _context11.next = 2;
+                break;
+              }
+              _context11.next = 2;
+              return handlesubscribeLanguage({
+                language: languageRoom,
+                open: true
+              });
+            case 2:
+              index++;
+              _context11.next = 1;
+              break;
+            case 3:
+              hasSubscribedLanguageList = this._sharedInterpreterDataSource.hasSubscribedLanguageList;
+              closeSubscribeLanguageList = hasSubscribedLanguageList.filter(function (ele) {
+                return !updateLanguageList.includes(ele);
+              });
+              _index = 0;
+            case 4:
+              if (!(_index < closeSubscribeLanguageList.length)) {
+                _context11.next = 6;
+                break;
+              }
+              _languageRoom = closeSubscribeLanguageList[_index];
+              if (!(_languageRoom !== ORIGIN)) {
+                _context11.next = 5;
+                break;
+              }
+              _context11.next = 5;
+              return handlesubscribeLanguage({
+                language: _languageRoom,
+                open: false
+              });
+            case 5:
+              _index++;
+              _context11.next = 4;
+              break;
+            case 6:
+              this._sharedInterpreterDataSource.preHasSubscribedLanguageList = hasSubscribedLanguageList;
+              this._sharedInterpreterDataSource.hasSubscribedLanguageList = updateLanguageList;
+              _context11.next = 8;
+              break;
+            case 7:
+              _context11.prev = 7;
+              _t4 = _context11["catch"](0);
+              this.logger.info("interpreter log  update subscribe language  fail ".concat(updateLanguageList.join(',')));
+            case 8:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this, [[0, 7]]);
+      }));
+      function _updateSubscribeLanguage(_x12) {
+        return _updateSubscribeLanguage2.apply(this, arguments);
+      }
+      return _updateSubscribeLanguage;
+    }()
+  }, {
+    key: "setOutputLanguage",
+    value: function () {
+      var _setOutputLanguage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12(language, successCallback, failureCallback) {
+        var localInterpreterUserInfo, _t5;
+        return _regeneratorRuntime.wrap(function (_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              localInterpreterUserInfo = this._sharedInterpreterDataSource.localInterpreterUserInfo;
+              if (!localInterpreterUserInfo) {
+                _context12.next = 4;
+                break;
+              }
+              _context12.prev = 1;
+              _context12.next = 2;
+              return this._updateOutputLanguage(language);
+            case 2:
+              successCallback && successCallback();
+              _context12.next = 4;
+              break;
+            case 3:
+              _context12.prev = 3;
+              _t5 = _context12["catch"](1);
+              failureCallback && failureCallback(_t5);
+            case 4:
+              return _context12.abrupt("return", !!localInterpreterUserInfo);
+            case 5:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this, [[1, 3]]);
+      }));
+      function setOutputLanguage(_x14, _x15, _x16) {
+        return _setOutputLanguage.apply(this, arguments);
+      }
+      return setOutputLanguage;
+    }()
+  }, {
+    key: "subscribeLanguage",
+    value: function () {
+      var _subscribeLanguage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee13(language, successCallback, failureCallback) {
+        var hasSubscribedLanguageList, _subscribeLanguage2, isHasOrigin, removeLanguage, _t6;
+        return _regeneratorRuntime.wrap(function (_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              _context13.prev = 0;
+              hasSubscribedLanguageList = this._sharedInterpreterDataSource.hasSubscribedLanguageList;
+              _subscribeLanguage2 = [];
+              if (hasSubscribedLanguageList.length === 2) {
+                if (language === ORIGIN) {
+                  _subscribeLanguage2 = [ORIGIN];
+                } else {
+                  _subscribeLanguage2 = [ORIGIN, language];
+                }
+              } else {
+                isHasOrigin = hasSubscribedLanguageList.includes(ORIGIN);
+                _subscribeLanguage2 = isHasOrigin ? [ORIGIN, language] : [language];
+              }
+              _context13.next = 1;
+              return this._updateSubscribeLanguage(_subscribeLanguage2);
+            case 1:
+              successCallback && successCallback();
+              removeLanguage = hasSubscribedLanguageList.find(function (ele) {
+                return ele !== ORIGIN && ele !== language;
+              });
+              if (removeLanguage) {
+                this._publishEvent.onLanguageUnsubscribed(removeLanguage);
+              }
+              this._publishEvent.onLanguageSubscribed(language);
+              _context13.next = 3;
+              break;
+            case 2:
+              _context13.prev = 2;
+              _t6 = _context13["catch"](0);
+              failureCallback && failureCallback(_t6);
+            case 3:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this, [[0, 2]]);
+      }));
+      function subscribeLanguage(_x17, _x18, _x19) {
+        return _subscribeLanguage.apply(this, arguments);
+      }
+      return subscribeLanguage;
+    }()
+  }, {
+    key: "subscribeExtraOriginLanguage",
+    value: function () {
+      var _subscribeExtraOriginLanguage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee14(subscribe) {
+        var hasSubscribedLanguageList, subscribeLanguageList, isHasOrigin;
+        return _regeneratorRuntime.wrap(function (_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              hasSubscribedLanguageList = this._sharedInterpreterDataSource.hasSubscribedLanguageList;
+              subscribeLanguageList = hasSubscribedLanguageList.filter(function (language) {
+                return language !== ORIGIN;
+              });
+              subscribeLanguageList = subscribe ? [].concat(_toConsumableArray(subscribeLanguageList), [ORIGIN]) : subscribeLanguageList;
+              if (subscribeLanguageList.length === 0) {
+                subscribeLanguageList = [ORIGIN];
+              }
+              _context14.next = 1;
+              return this._updateSubscribeLanguage(subscribeLanguageList);
+            case 1:
+              isHasOrigin = hasSubscribedLanguageList.includes(ORIGIN);
+              if (subscribe && !isHasOrigin) {
+                this._publishEvent.onLanguageSubscribed(ORIGIN);
+              }
+              if (!subscribe && isHasOrigin) {
+                this._publishEvent.onLanguageUnsubscribed(ORIGIN);
+              }
+            case 2:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function subscribeExtraOriginLanguage(_x20) {
+        return _subscribeExtraOriginLanguage.apply(this, arguments);
+      }
+      return subscribeExtraOriginLanguage;
+    }()
+  }, {
+    key: "getHasSubscribedLanguageList",
+    value: function getHasSubscribedLanguageList() {
+      return this._sharedInterpreterDataSource.hasSubscribedLanguageList;
+    }
+  }, {
+    key: "userIsInterpreter",
+    value: function userIsInterpreter(userId) {
+      var interpreterUserList = this._interpreterControl.getInterpreterUserList();
+      return !!(interpreterUserList !== null && interpreterUserList !== void 0 && interpreterUserList.find(function (ele) {
+        return ele.userId === userId;
+      }));
+    }
+  }, {
+    key: "getUserOutputLanguage",
+    value: function getUserOutputLanguage(userId) {
+      var isUserIsInterpreter = this.userIsInterpreter(userId);
+      if (!isUserIsInterpreter) {
+        return 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 interpreterUserList = this._interpreterControl.getInterpreterUserList();
+      var hasSubscribedLanguageList = [ORIGIN];
+      interpreterUserList === null || interpreterUserList === void 0 || interpreterUserList.forEach(function (ele) {
+        hasSubscribedLanguageList.push(ele.sourceLanguage, ele.targetLanguage);
+      });
+      return hasSubscribedLanguageList;
+    }
+  }, {
+    key: "getOutputLanguageOptionList",
+    value: function getOutputLanguageOptionList() {
+      return this._interpreterControl.getInterpreterLanguageList();
+    }
+  }, {
+    key: "setInterpreterUsers",
+    value: function () {
+      var _setInterpreterUsers = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee15(params, successCallback, failureCallback) {
+        var _t7;
+        return _regeneratorRuntime.wrap(function (_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              _context15.prev = 0;
+              _context15.next = 1;
+              return this._interpreterControl.setInterpreterUsers(params);
+            case 1:
+              successCallback && successCallback();
+              _context15.next = 3;
+              break;
+            case 2:
+              _context15.prev = 2;
+              _t7 = _context15["catch"](0);
+              failureCallback && failureCallback(_t7);
+            case 3:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this, [[0, 2]]);
+      }));
+      function setInterpreterUsers(_x21, _x22, _x23) {
+        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) {
+      this._observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    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._interpreterControl.removeObserver(this._observerInterpreter);
+      this._roomProvider.removeObserver(this._roomProviderObserver);
+    }
+  }]);
+}();