fcr-ui-scene 3.3.1 → 3.4.1

package/lib/providers/event-provider.js

@@ -0,0 +1,288 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.push.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");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/esnext.async-iterator.filter.js");
+require("core-js/modules/esnext.async-iterator.for-each.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIEventProviderImpl = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.date.now.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _observable = require("agora-foundation/lib/utilities/observable");
+var _constant = require("../utilities/constant");
+var _logger = require("agora-foundation/lib/logger");
+var _chat = require("../modules/chat");
+var _base = require("../base");
+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 FcrUIEventProviderImpl = exports.FcrUIEventProviderImpl = /*#__PURE__*/function () {
+  function FcrUIEventProviderImpl() {
+    (0, _classCallCheck2["default"])(this, FcrUIEventProviderImpl);
+    (0, _defineProperty2["default"])(this, "logger", (0, _logger.getLogger)());
+    (0, _defineProperty2["default"])(this, "_observable", new _observable.AgoraObservable());
+  }
+  return (0, _createClass2["default"])(FcrUIEventProviderImpl, [{
+    key: "sendEvent",
+    value: function sendEvent(action, payload) {
+      var start = Date.now();
+      try {
+        this._observable.notifyObservers('onEvent', action, payload);
+      } finally {
+        var end = Date.now();
+        var time = end - start;
+        if (time >= 10) {
+          this.logger.warn("[FcrUIEventStore] sendEvent ".concat(_constant.FcrUIAction[action], ", payload: ").concat(payload, ", handlers took: ").concat(end - start, "ms"));
+        }
+      }
+    }
+  }, {
+    key: "showToast",
+    value: function showToast(params) {
+      this.sendEvent(_constant.FcrUIAction.OPEN_DIALOG, {
+        dialogKey: _constant.FcrUIDialogKey.SHOW_TOAST,
+        dialogId: "".concat(_constant.FcrUIDialogKey.SHOW_TOAST, "_").concat(Date.now()),
+        params: params
+      });
+    }
+  }, {
+    key: "showNotification",
+    value: function showNotification(params) {
+      this.sendEvent(_constant.FcrUIAction.SHOW_NOTIFICATION, params);
+    }
+  }, {
+    key: "closeNotification",
+    value: function closeNotification(key) {
+      this.sendEvent(_constant.FcrUIAction.COLSE_NOTIFICATION, key);
+    }
+  }, {
+    key: "showChatToast",
+    value: function showChatToast(params) {
+      this.sendEvent(_constant.FcrUIAction.SHOW_TOAST, _objectSpread(_objectSpread({}, params), {}, {
+        customRootClass: _chat.CHAT_WRAPPER_CLASS
+      }));
+    }
+
+    /**
+     * 默认同一个 title 或 content 的 confirm 窗口只打开一个实例
+     * @param key 可以通过 key 区分相同 title 或 content 的 confirm 窗口
+     * @param duration 可以通过 duration 配置自动关闭时间
+     * @mulitple 可以通过 mulitple 配置打开多个实例（忽略 key）
+     * */
+  }, {
+    key: "openConfirmDialog",
+    value: function openConfirmDialog(params, mulitple) {
+      var dialogKey = _constant.FcrUIDialogKey.CONFIRM;
+      var dialogId = mulitple ? "".concat(dialogKey, "_").concat(Date.now()) : "".concat(dialogKey, "_").concat(params.key || params.title || params.content);
+      this.sendEvent(_constant.FcrUIAction.OPEN_DIALOG, {
+        dialogKey: dialogKey,
+        dialogId: dialogId,
+        params: params
+      });
+      return dialogId;
+    }
+  }, {
+    key: "openDialog",
+    value: function openDialog(dialogKey, instanceId, params) {
+      var dialogId = "".concat(dialogKey, "_").concat(instanceId || dialogKey);
+      this.sendEvent(_constant.FcrUIAction.OPEN_DIALOG, {
+        dialogKey: dialogKey,
+        dialogId: dialogId,
+        params: params
+      });
+      return dialogId;
+    }
+  }, {
+    key: "closeDialog",
+    value: function closeDialog(dialogId) {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_DIALOG, {
+        dialogId: dialogId
+      });
+    }
+  }, {
+    key: "closeConfirm",
+    value: function closeConfirm(dialogId) {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_DIALOG, {
+        dialogId: dialogId,
+        dialogKey: _constant.FcrUIDialogKey.CONFIRM
+      });
+    }
+  }, {
+    key: "startShareScreen",
+    value: function startShareScreen() {
+      this.sendEvent(_constant.FcrUIAction.START_SHARE_SCREEN);
+    }
+  }, {
+    key: "stopShareScreen",
+    value: function stopShareScreen() {
+      this.sendEvent(_constant.FcrUIAction.STOP_SHARE_SCREEN);
+    }
+  }, {
+    key: "updateAside",
+    value: function updateAside(params) {
+      this.sendEvent(_constant.FcrUIAction.UPDATE_ASIDE, params);
+    }
+  }, {
+    key: "receiveNewChatMessages",
+    value: function receiveNewChatMessages(params) {
+      this.sendEvent(_constant.FcrUIAction.RECEIVE_NEW_CHAT_MESSAGES, params);
+    }
+  }, {
+    key: "toggleLayout",
+    value: function toggleLayout(params) {
+      this.sendEvent(_constant.FcrUIAction.TOGGLE_LAYOUT, params);
+    }
+  }, {
+    key: "notifyLayoutChanged",
+    value: function notifyLayoutChanged(params) {
+      this.sendEvent(_constant.FcrUIAction.LAYOUT_CHANGED, params);
+    }
+  }, {
+    key: "toggleLayoutSize",
+    value: function toggleLayoutSize(params) {
+      this.sendEvent(_constant.FcrUIAction.TOGGLE_LAYOUT_SIZE, params);
+    }
+  }, {
+    key: "notifyLayoutSizeChanged",
+    value: function notifyLayoutSizeChanged(params) {
+      this.sendEvent(_constant.FcrUIAction.LAYOUT_SIZE_CHANGED, params);
+    }
+  }, {
+    key: "setMainSpeaker",
+    value: function setMainSpeaker(params) {
+      this.sendEvent(_constant.FcrUIAction.SET_MAIN_SPEAKER, params);
+    }
+  }, {
+    key: "setUserPinState",
+    value: function setUserPinState(userId) {
+      this.sendEvent(_constant.FcrUIAction.SET_USER_PIN_STATE, {
+        userId: userId
+      });
+    }
+  }, {
+    key: "updateShareState",
+    value: function updateShareState(isOpen) {
+      this.sendEvent(_constant.FcrUIAction.UPDATE_SHARE_STATE, {
+        isOpen: isOpen
+      });
+    }
+  }, {
+    key: "openDeviceSettingDialog",
+    value: function openDeviceSettingDialog() {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var dialogId = this.openDialog(_constant.FcrUIDialogKey.DEVICE_SETTINGS);
+      this.sendEvent(_constant.FcrUIAction.OPEN_DEVICE_SETTING_DIALOG, _objectSpread({
+        dialogId: dialogId
+      }, config));
+    }
+  }, {
+    key: "closeDeviceSettingDialog",
+    value: function closeDeviceSettingDialog() {
+      this.closeDialog(_constant.FcrUIDialogKey.DEVICE_SETTINGS);
+    }
+  }, {
+    key: "openLiveStreamingDialog",
+    value: function openLiveStreamingDialog() {
+      this.sendEvent(_constant.FcrUIAction.OPEN_LIVE_STEAMING_DIALOG);
+    }
+  }, {
+    key: "closeLiveStreamingDialog",
+    value: function closeLiveStreamingDialog() {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_LIVE_STEAMING_DIALOG);
+    }
+  }, {
+    key: "stopLiveStreaming",
+    value: function stopLiveStreaming() {
+      this.sendEvent(_constant.FcrUIAction.STOP_LIVE_STREAMING);
+    }
+  }, {
+    key: "openInviteDialog",
+    value: function openInviteDialog() {
+      this.sendEvent(_constant.FcrUIAction.OPEN_INVITE_DIALOG);
+    }
+  }, {
+    key: "closeInviteDialog",
+    value: function closeInviteDialog() {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_INVITE_DIALOG);
+    }
+  }, {
+    key: "closeWaitingRoomDialog",
+    value: function closeWaitingRoomDialog() {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_WAITING_ROOM_DIALOG);
+    }
+  }, {
+    key: "closeRemoveAdmitWaitingRoomDialog",
+    value: function closeRemoveAdmitWaitingRoomDialog(dialogKey) {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_REMOVE_ADMIT_WAITING_ROOM_DIALOG, dialogKey);
+    }
+  }, {
+    key: "exitRoom",
+    value: function exitRoom(reason, roomType) {
+      this.sendEvent(_constant.FcrUIAction.EXIT_ROOM, {
+        reason: reason,
+        roomType: roomType
+      });
+    }
+  }, {
+    key: "cloudRecording",
+    value: function cloudRecording(action) {
+      this.sendEvent(_constant.FcrUIAction.CLOUD_RECORDING, {
+        action: action
+      });
+    }
+  }, {
+    key: "notifySpotlightStreamChanged",
+    value: function notifySpotlightStreamChanged(params) {
+      this.sendEvent(_constant.FcrUIAction.SPOTLIGHT_STREAM_CHANGED, params);
+    }
+  }, {
+    key: "notifyCustomSettingsChanged",
+    value: function notifyCustomSettingsChanged(settings) {
+      this.sendEvent(_constant.FcrUIAction.CUSTOM_SETTINGS_CHANGED, settings);
+    }
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._observable.removeObserver(observer);
+    }
+  }, {
+    key: "notifyChatUpdateTarget",
+    value: function notifyChatUpdateTarget(user, roomType) {
+      this.sendEvent(_constant.FcrUIAction.CHAT_UPDATE_TARGET, {
+        user: user,
+        roomType: roomType
+      });
+    }
+  }, {
+    key: "notifyChatResetTarget",
+    value: function notifyChatResetTarget() {
+      this.sendEvent(_constant.FcrUIAction.CHAT_RESET_TARGET);
+    }
+  }, {
+    key: "release",
+    value: function release() {}
+  }]);
+}();
+(0, _base.registerDependency)('eventProvider');

package/lib/providers/interpreter-provider.d.ts

@@ -0,0 +1,25 @@
+import { FcrUIJoinInterpreterRoom, FcrUILeaveInterpreterRoom } from '../type';
+import { FcrInterpreterRoomControl } from 'fcr-core/lib/room-control/interpreter-control/types';
+export type FcrUIInterpreterRoomObserver = {
+    onJoinInterpretingRoom?: (param: FcrUIJoinInterpreterRoom) => void;
+    onJoinInterpretingRoomSuccess?: (param: FcrUIJoinInterpreterRoom) => void;
+    onJoinInterpretingRoomFailed?: (param: FcrUIJoinInterpreterRoom) => void;
+    onLeaveInterpretingRoom?: (param: FcrUILeaveInterpreterRoom) => void;
+    onLeaveInterpretingRoomFailed?: (param: FcrUILeaveInterpreterRoom) => void;
+    onLeaveInterpretingRoomSuccess?: (param: FcrUILeaveInterpreterRoom) => void;
+};
+export interface FcrUIInterpreterProvider {
+    joinInterpreterRoom(param: FcrUIJoinInterpreterRoom): Promise<void>;
+    leaveInterpreterRoom(param: FcrUILeaveInterpreterRoom): Promise<void>;
+    updateInterpreterRoomStreams(roomControl: FcrInterpreterRoomControl | null, open: boolean): void;
+    addObserver(observer: FcrUIInterpreterRoomObserver): void;
+    removeObserver(observer: FcrUIInterpreterRoomObserver): void;
+}
+export declare class FcrUIInterpreterProviderImpl implements FcrUIInterpreterProvider {
+    private _observable;
+    joinInterpreterRoom(param: FcrUIJoinInterpreterRoom): Promise<void>;
+    leaveInterpreterRoom(param: FcrUILeaveInterpreterRoom): Promise<void>;
+    updateInterpreterRoomStreams(roomControl: FcrInterpreterRoomControl | null, open: boolean): Promise<void>;
+    addObserver(observer: FcrUIInterpreterRoomObserver): void;
+    removeObserver(observer: FcrUIInterpreterRoomObserver): void;
+}

package/lib/providers/interpreter-provider.js

@@ -0,0 +1,151 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.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.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/esnext.iterator.map.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+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 FcrUIInterpreterProviderImpl = exports.FcrUIInterpreterProviderImpl = /*#__PURE__*/function () {
+  function FcrUIInterpreterProviderImpl() {
+    (0, _classCallCheck2["default"])(this, FcrUIInterpreterProviderImpl);
+    // @internal
+    (0, _defineProperty2["default"])(this, "logger", (0, _logger.getLogger)());
+    (0, _defineProperty2["default"])(this, "_observable", new _observable.AgoraObservable());
+  }
+  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) {
+            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;
+            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();
+          }
+        }, _callee, this, [[1, 9]]);
+      }));
+      function joinInterpreterRoom(_x) {
+        return _joinInterpreterRoom.apply(this, arguments);
+      }
+      return joinInterpreterRoom;
+    }() // 离开语言房间
+  }, {
+    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) {
+            case 0:
+              control = param.control;
+              _context2.prev = 1;
+              this._observable.notifyObservers('onLeaveInterpretingRoom', param);
+              _context2.next = 5;
+              return control.leave();
+            case 5:
+              this.logger.info("interpreterLog-leaveInterpreterRoom  succeed", param.language);
+              this._observable.notifyObservers('onLeaveInterpretingRoomSuccess', param);
+              _context2.next = 13;
+              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 13:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[1, 9]]);
+      }));
+      function leaveInterpreterRoom(_x2) {
+        return _leaveInterpreterRoom.apply(this, arguments);
+      }
+      return leaveInterpreterRoom;
+    }() // 控制翻译房间输出流权限
+  }, {
+    key: "updateInterpreterRoomStreams",
+    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) {
+            case 0:
+              if (!roomControl) {
+                _context3.next = 9;
+                break;
+              }
+              streamControl = roomControl.getStreamControl();
+              streamMap = streamControl.getStreams();
+              streamList = Object.keys(streamMap).map(function (key) {
+                return streamMap[key];
+              });
+              if (!(streamList.length > 0)) {
+                _context3.next = 9;
+                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);
+            case 9:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function updateInterpreterRoomStreams(_x3, _x4) {
+        return _updateInterpreterRoomStreams.apply(this, arguments);
+      }
+      return updateInterpreterRoomStreams;
+    }()
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._observable.removeObserver(observer);
+    }
+  }]);
+}();
+(0, _base.registerDependency)('interpreterProvider');

package/lib/providers/local-storage-provider.d.ts

@@ -0,0 +1,8 @@
+export interface FcrUILocalStorageProvider {
+    write(key: string, value: any): number;
+    read(key: string): string | null;
+}
+export declare class FcrUILocalStorageProviderImpl implements FcrUILocalStorageProvider {
+    write(key: string, value: any): number;
+    read(key: string): string | null;
+}

package/lib/providers/local-storage-provider.js

@@ -0,0 +1,31 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUILocalStorageProviderImpl = void 0;
+require("core-js/modules/es.date.to-json.js");
+require("core-js/modules/es.json.stringify.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _base = require("../base");
+var FcrUILocalStorageProviderImpl = exports.FcrUILocalStorageProviderImpl = /*#__PURE__*/function () {
+  function FcrUILocalStorageProviderImpl() {
+    (0, _classCallCheck2["default"])(this, FcrUILocalStorageProviderImpl);
+  }
+  return (0, _createClass2["default"])(FcrUILocalStorageProviderImpl, [{
+    key: "write",
+    value: function write(key, value) {
+      localStorage.setItem(key, JSON.stringify(value));
+      return 1;
+    }
+  }, {
+    key: "read",
+    value: function read(key) {
+      return localStorage.getItem(key);
+    }
+  }]);
+}();
+(0, _base.registerDependency)('localStorageProvider');

package/lib/providers/monitor-provider.d.ts

@@ -0,0 +1,15 @@
+import { FcrPerformanceInfo } from 'fcr-core/lib/type';
+import { FcrMonitorControl } from 'fcr-core';
+export interface FcrUIMonitorObserver {
+    onPerformanceInfoUpdated?: (status: FcrPerformanceInfo) => void;
+}
+export interface FcrUIMonitorProvider {
+    addObserver(observer: FcrUIMonitorObserver): void;
+    removeObserver(observer: FcrUIMonitorObserver): void;
+}
+export declare class FcrUIMonitorProviderImpl implements FcrUIMonitorProvider {
+    private _monitorControl;
+    constructor(_monitorControl: FcrMonitorControl);
+    addObserver(observer: FcrUIMonitorObserver): void;
+    removeObserver(observer: FcrUIMonitorObserver): void;
+}

package/lib/providers/monitor-provider.js

@@ -0,0 +1,29 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIMonitorProviderImpl = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _base = require("../base");
+var FcrUIMonitorProviderImpl = exports.FcrUIMonitorProviderImpl = /*#__PURE__*/function () {
+  function FcrUIMonitorProviderImpl(_monitorControl) {
+    (0, _classCallCheck2["default"])(this, FcrUIMonitorProviderImpl);
+    this._monitorControl = _monitorControl;
+  }
+  return (0, _createClass2["default"])(FcrUIMonitorProviderImpl, [{
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._monitorControl.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._monitorControl.removeObserver(observer);
+    }
+  }]);
+}();
+(0, _base.registerDependency)('monitorProvider');