fcr-ui-scene 3.7.5 → 3.7.7

package/lib/providers/dialog/provider.electron.js

@@ -57,8 +57,10 @@ var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _type = require("./type");
 var _provider = require("./provider.base");
+var _constant = require("../../utilities/constant");
 var _decorator = require("agora-foundation/lib/decorator");
 var _isBoolean = _interopRequireDefault(require("lodash/isBoolean"));
+var _imports = require("fcr-core/lib/imports");
 var _FcrUIElectronDialogProviderImpl;
 var _initProto;
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
@@ -71,11 +73,14 @@ function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side
 var FcrUIElectronDialogProviderImpl = exports.FcrUIElectronDialogProviderImpl = /*#__PURE__*/function (_FcrUIDialogProviderB) {
   function FcrUIElectronDialogProviderImpl(_ref) {
     var _this;
-    var windowProvider = _ref.windowProvider;
+    var windowProvider = _ref.windowProvider,
+      renderer = _ref.renderer;
     (0, _classCallCheck2["default"])(this, FcrUIElectronDialogProviderImpl);
     _this = _callSuper(this, FcrUIElectronDialogProviderImpl);
     (0, _defineProperty2["default"])(_this, "_windowProvider", void _initProto(_this));
+    (0, _defineProperty2["default"])(_this, "_sharingDisplayBounds", null);
     _this._windowProvider = windowProvider;
+    _this._renderer = renderer;
     return _this;
   }
   (0, _inherits2["default"])(FcrUIElectronDialogProviderImpl, _FcrUIDialogProviderB);
@@ -121,6 +126,9 @@ var FcrUIElectronDialogProviderImpl = exports.FcrUIElectronDialogProviderImpl =
         this.logger.warn("dialog ".concat(dialogKey, "(").concat(dialogId, ") is already opened"));
         var _window = this._windowProvider.getWindowById(dialogKey, dialogId);
         _window.show(showOptions);
+        if (params !== null && params !== void 0 && params.alwaysOnTop) {
+          _window.setAlwaysOnTop(true, 'pop-up-menu');
+        }
         return;
       }
       var dialogIds = this.dialogKeyMap.get(dialogKey);
@@ -136,6 +144,82 @@ var FcrUIElectronDialogProviderImpl = exports.FcrUIElectronDialogProviderImpl =
       }
       var window = this._windowProvider.getWindowById(dialogKey, dialogId);
       var windowObserver = {
+        onReady: function onReady() {
+          _this2.logger.info("sharing display bounds: ".concat((0, _imports.jsonstring)(_this2._sharingDisplayBounds)));
+          if ([_constant.FcrUIDialogKey.SUB_WINDOW].includes(dialogKey)) {
+            return;
+          }
+          // 获取主屏幕的宽高
+          var bounds = _this2._windowProvider.getCurrentWindow().getBounds();
+          var _this2$_renderer$getD = _this2._renderer.getDisplayMatching(bounds).bounds,
+            mw = _this2$_renderer$getD.width,
+            mh = _this2$_renderer$getD.height,
+            mx = _this2$_renderer$getD.x,
+            my = _this2$_renderer$getD.y;
+          var shareScreenDialogs = [_constant.FcrUIDialogKey.SHARE_SCREEN_CONTROL_BAR, _constant.FcrUIDialogKey.VIDEO_WINDOW];
+          var fullScreenDialogs = [_constant.FcrUIDialogKey.TOAST, _constant.FcrUIDialogKey.CONFIRM];
+          var _window$getBounds = window.getBounds(),
+            ww = _window$getBounds.width,
+            wh = _window$getBounds.height;
+          if (shareScreenDialogs.includes(dialogKey)) {
+            return;
+          }
+
+          // 分享主应用所在显示器
+          var x = mx + mw / 2 - ww / 2;
+          var y = my + mh / 2 - wh / 2;
+          if (_this2._sharingDisplayBounds) {
+            var _this2$_sharingDispla = _this2._sharingDisplayBounds,
+              sx = _this2$_sharingDispla.x,
+              sy = _this2$_sharingDispla.y,
+              sw = _this2$_sharingDispla.width,
+              sh = _this2$_sharingDispla.height;
+            if (fullScreenDialogs.includes(dialogKey)) {
+              window.setBounds(_this2._sharingDisplayBounds);
+            } else {
+              // 分享的显示器在左侧
+              if (sx < 0 && Math.abs(sx) >= sw) {
+                x = sx / 2 - ww / 2;
+                y = sh / 2 - wh / 2 + sy;
+                _this2.logger.info("sharing display in the left");
+              }
+
+              // 分享的显示器在右侧
+              else if (sx > 0 && Math.abs(sx) >= mw) {
+                x = sw / 2 - ww / 2 + sx;
+                y = sh / 2 - wh / 2 + sy;
+                _this2.logger.info("sharing display in the right");
+              }
+
+              // 分享的显示器在上面
+              else if (sy < 0 && Math.abs(sy) >= sh) {
+                x = sw / 2 - ww / 2 + sx;
+                y = sy / 2 - wh / 2;
+                _this2.logger.info("sharing display in the top");
+              }
+
+              // 分享的显示器在下面
+              else if (sy > 0 && Math.abs(sy) >= mh) {
+                x = sw / 2 - ww / 2 + sx;
+                y = sy + sh / 2 - wh / 2;
+                _this2.logger.info("sharing display in the bottom");
+              }
+              x = Math.floor(x);
+              y = Math.floor(y);
+              window.setBounds({
+                x: x,
+                y: y
+              });
+            }
+          } else {
+            x = Math.floor(x);
+            y = Math.floor(y);
+            window.setBounds({
+              x: x,
+              y: y
+            });
+          }
+        },
         onClosed: function onClosed() {
           window.removeObserver(windowObserver);
           _this2.dialogKeyMap["delete"](dialogKey);
@@ -157,6 +241,9 @@ var FcrUIElectronDialogProviderImpl = exports.FcrUIElectronDialogProviderImpl =
       window.addObserver(windowObserver);
       window.setPreventClose(true);
       window.show(showOptions);
+      if (params !== null && params !== void 0 && params.alwaysOnTop) {
+        window.setAlwaysOnTop(true, 'pop-up-menu');
+      }
       this.observable.notifyObservers('onDialogOpen', dialogKey, dialogId, params);
     }
   }, {
@@ -168,10 +255,15 @@ var FcrUIElectronDialogProviderImpl = exports.FcrUIElectronDialogProviderImpl =
         window.close();
       }
     }
+  }, {
+    key: "setSharingDisplayBounds",
+    value: function setSharingDisplayBounds(bounds) {
+      this._sharingDisplayBounds = bounds;
+    }
   }]);
 }(_provider.FcrUIDialogProviderBase);
 _FcrUIElectronDialogProviderImpl = FcrUIElectronDialogProviderImpl;
-var _applyDecs$e = _applyDecs(_FcrUIElectronDialogProviderImpl, [[_decorator.trace, 2, "openDialog"], [_decorator.trace, 2, "openDialogWithId"], [_decorator.trace, 2, "closeDialog"], [_decorator.trace, 2, "closeDialogById"]], [], 0, void 0, _provider.FcrUIDialogProviderBase).e;
+var _applyDecs$e = _applyDecs(_FcrUIElectronDialogProviderImpl, [[_decorator.trace, 2, "openDialog"], [_decorator.trace, 2, "openDialogWithId"], [_decorator.trace, 2, "closeDialog"], [_decorator.trace, 2, "closeDialogById"], [_decorator.trace, 2, "setSharingDisplayBounds"]], [], 0, void 0, _provider.FcrUIDialogProviderBase).e;
 var _applyDecs$e2 = (0, _slicedToArray2["default"])(_applyDecs$e, 1);
 _initProto = _applyDecs$e2[0];
 _applyDecs$e;

package/lib/providers/dialog/type.d.ts

@@ -2,6 +2,7 @@ import { ConfirmContentProps } from 'agora-ui-foundation/lib/components/confirm-
 import { FcrUIDialogKey } from '../../utilities/constant';
 import { FcrUIWindowProvider } from '../window/type';
 import { FcrUIDialogInfo } from '../../modules/dialog/type';
+import { FcrUIRendererWrapper } from '../../utilities/renderer';
 export type FcrUIDialogDescriptor = {
     dialogKey: FcrUIDialogKey;
     dialogId: string;
@@ -139,6 +140,11 @@ export interface FcrUIDialogProvider {
      * @param observer - 要移除的观察者对象，类型为 FcrUIDialogObserver。
      */
     removeObserver(observer: FcrUIDialogObserver): void;
+    /**
+     * 设置屏幕共享的 bounds
+     * @param bounds - 屏幕共享的 bounds
+     */
+    setSharingDisplayBounds(bounds: FcrUI.FcrUIRectangle | null): void;
     /**
      * 新增弹窗拦截器
      * @param key - 弹窗拦截器的唯一标识符
@@ -158,4 +164,5 @@ export interface FcrUIDialogProvider {
 }
 export type FcrUIElectronProviderConstructor = {
     windowProvider: FcrUIWindowProvider;
+    renderer: FcrUIRendererWrapper;
 };

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

@@ -0,0 +1,137 @@
+import { FcrUIAction, FcrUIDialogKey } from '../utilities/constant';
+import { DeviceSettingDialogConfig } from '../modules/setting/store';
+import { ConfirmContentProps } from 'agora-ui-foundation/lib/components/confirm-content';
+export interface FcrUIDialogObserver {
+    onEvent?(action: FcrUIAction, payload?: unknown): void;
+    onDialogOpened?(dialogKey: FcrUIDialogKey, dialogId: string, params?: unknown): void;
+    onDialogClosed?(dialogId: string): void;
+    onOpenSettingDialog?(): void;
+}
+export declare enum FcrDialogInterceptorEventName {
+    ON_CLOSE = "onClose"
+}
+/**
+ * FcrUIDialogProvider 接口定义了一系列用于管理和操作对话框的方法。
+ * 这些方法涵盖了打开、关闭各种类型对话框的功能，以及对对话框事件观察者的管理。
+ */
+export interface FcrUIDialogProvider {
+    /**
+     * 打开指定类型的对话框。
+     *
+     * @param dialogKey - 对话框的唯一标识键，用于指定要打开的对话框类型。
+     * @param instanceId - 可选参数，对话框实例的唯一标识符，用于区分同一类型的不同对话框实例。
+     * @param params - 可选参数，传递给对话框的额外参数，类型为 unknown 表示可以是任意类型。
+     * @returns 返回打开对话框的唯一标识符，可用于后续关闭操作。
+     */
+    openDialog(dialogKey: FcrUIDialogKey, instanceId?: string, params?: unknown): string;
+    /**
+     * 关闭指定标识符的对话框。
+     *
+     * @param dialogId - 要关闭对话框的唯一标识符，该标识符通常由 openDialog 方法返回。
+     */
+    closeDialog(dialogId: string): void;
+    /**
+     * 打开确认对话框。
+     *
+     * @param params - 确认对话框的配置参数，包含确认内容的属性以及可选的对话框唯一键和显示时长。
+     * @param mulitple - 可选参数，布尔值，指示是否允许多个确认对话框同时存在。
+     * @returns 返回打开确认对话框的唯一标识符，可用于后续关闭操作。
+     */
+    openConfirmDialog(params: ConfirmContentProps & {
+        key?: string;
+        duration?: number;
+    }, mulitple?: boolean): string;
+    /**
+     * 关闭指定标识符的确认对话框。
+     *
+     * @param dialogId - 要关闭确认对话框的唯一标识符，该标识符通常由 openConfirmDialog 方法返回。
+     */
+    closeConfirm(dialogId: string): void;
+    /**
+     * 打开设备设置对话框。
+     *
+     * @param config - 设备设置对话框的配置参数，为 DeviceSettingDialogConfig 类型的部分属性对象。
+     */
+    openDeviceSettingDialog(config: Partial<DeviceSettingDialogConfig>): void;
+    /**
+     * 关闭设备设置对话框。
+     */
+    closeDeviceSettingDialog(): void;
+    /**
+     * 打开直播流对话框。
+     */
+    openLiveStreamingDialog(): void;
+    /**
+     * 关闭直播流对话框。
+     */
+    closeLiveStreamingDialog(): void;
+    /**
+     * 打开邀请对话框。
+     */
+    openInviteDialog(): void;
+    /**
+     * 关闭邀请对话框。
+     */
+    closeInviteDialog(): void;
+    /**
+     * 关闭等待室对话框。
+     */
+    closeWaitingRoomDialog(): void;
+    /**
+     * 关闭移除准入等待室对话框。
+     *
+     * @param dialogKey - 要关闭的移除准入等待室对话框的唯一标识键。
+     */
+    closeRemoveAdmitWaitingRoomDialog(dialogKey: FcrUIDialogKey): void;
+    /**
+     * 添加对话框事件观察者。
+     * 观察者可以监听对话框的各种事件，如打开、关闭等。
+     *
+     * @param observer - 要添加的观察者对象，类型为 FcrUIDialogObserver。
+     */
+    addObserver(observer: FcrUIDialogObserver): void;
+    /**
+     * 移除对话框事件观察者。
+     * 移除后，该观察者将不再接收对话框的事件通知。
+     *
+     * @param observer - 要移除的观察者对象，类型为 FcrUIDialogObserver。
+     */
+    removeObserver(observer: FcrUIDialogObserver): void;
+    /**
+     * 新增弹窗拦截器
+     * @param key - 弹窗拦截器的唯一标识符
+     * @param interceptor - 弹窗拦截器函数，返回值为 boolean，true 表示拦截弹窗，false 表示不拦截弹窗
+     */
+    addInterceptor(key: FcrDialogInterceptorEventName, interceptor: (dialogKey: FcrUIDialogKey) => boolean): void;
+    /**
+     * 执行弹窗拦截器
+     * @param key - 弹窗拦截器的唯一标识符
+     * @param dialogKey - 弹窗的唯一标识符
+     */
+    emitIntercepter(key: FcrDialogInterceptorEventName, dialogKey: FcrUIDialogKey): boolean;
+}
+export declare class FcrUIDialogProviderImpl implements FcrUIDialogProvider {
+    openConfirmDialog(params: ConfirmContentProps & {
+        key?: string;
+        duration?: number;
+    }, mulitple?: boolean): string;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _observable;
+    private _interceptor;
+    addInterceptor(key: FcrDialogInterceptorEventName, interceptor: (dialogKey: FcrUIDialogKey) => boolean): void;
+    emitIntercepter(key: FcrDialogInterceptorEventName, dialogKey: FcrUIDialogKey): boolean;
+    sendEvent(action: FcrUIAction, payload?: unknown): void;
+    openInviteDialog(): void;
+    closeInviteDialog(): void;
+    closeWaitingRoomDialog(): void;
+    closeRemoveAdmitWaitingRoomDialog(dialogKey: FcrUIDialogKey): void;
+    openDeviceSettingDialog(config: Partial<DeviceSettingDialogConfig>): void;
+    closeDeviceSettingDialog(): void;
+    openLiveStreamingDialog(): void;
+    closeLiveStreamingDialog(): void;
+    openDialog(dialogKey: FcrUIDialogKey, instanceId?: string, params?: unknown): string;
+    closeDialog(dialogId: string): void;
+    closeConfirm(dialogId: string): void;
+    addObserver(observer: FcrUIDialogObserver): void;
+    removeObserver(observer: FcrUIDialogObserver): void;
+}

package/lib/providers/dialog-provider.js

@@ -0,0 +1,194 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.is-array.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.date.to-string.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.test.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIDialogProviderImpl = exports.FcrDialogInterceptorEventName = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.push.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 _base = require("../base");
+var _constant = require("../utilities/constant");
+var _imports = require("fcr-core/lib/imports");
+var _logger = require("../utilities/logger");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var FcrDialogInterceptorEventName = exports.FcrDialogInterceptorEventName = /*#__PURE__*/function (FcrDialogInterceptorEventName) {
+  FcrDialogInterceptorEventName["ON_CLOSE"] = "onClose";
+  return FcrDialogInterceptorEventName;
+}({});
+/**
+ * FcrUIDialogProvider 接口定义了一系列用于管理和操作对话框的方法。
+ * 这些方法涵盖了打开、关闭各种类型对话框的功能，以及对对话框事件观察者的管理。
+ */
+var FcrUIDialogProviderImpl = exports.FcrUIDialogProviderImpl = /*#__PURE__*/function () {
+  function FcrUIDialogProviderImpl() {
+    (0, _classCallCheck2["default"])(this, FcrUIDialogProviderImpl);
+    (0, _defineProperty2["default"])(this, "logger", (0, _logger.createLogger)({
+      prefix: 'FcrUIDialogProviderImpl'
+    }));
+    (0, _defineProperty2["default"])(this, "_observable", new _imports.AgoraObservable());
+    (0, _defineProperty2["default"])(this, "_interceptor", {});
+  }
+  return (0, _createClass2["default"])(FcrUIDialogProviderImpl, [{
+    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: "addInterceptor",
+    value: function addInterceptor(key, interceptor) {
+      if (this._interceptor[key]) {
+        this._interceptor[key].push(interceptor);
+      } else {
+        this._interceptor[key] = [interceptor];
+      }
+    }
+  }, {
+    key: "emitIntercepter",
+    value: function emitIntercepter(key, dialogKey) {
+      var interceptors = this._interceptor[key];
+      if (interceptors) {
+        var _iterator = _createForOfIteratorHelper(interceptors),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _interceptor = _step.value;
+            return _interceptor(dialogKey);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      return false;
+    }
+  }, {
+    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("[FcrUIDialogProviderImpl] sendEvent ".concat(_constant.FcrUIAction[action], ", payload: ").concat(payload, ", handlers took: ").concat(end - start, "ms"));
+        }
+      }
+    }
+  }, {
+    key: "openInviteDialog",
+    value: function openInviteDialog() {
+      this.openDialog(_constant.FcrUIDialogKey.INVITE);
+    }
+  }, {
+    key: "closeInviteDialog",
+    value: function closeInviteDialog() {
+      this.closeDialog(_constant.FcrUIDialogKey.INVITE);
+    }
+  }, {
+    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: "openDeviceSettingDialog",
+    value: function openDeviceSettingDialog(config) {
+      //this.openDialog(FcrUIDialogKey.DEVICE_SETTINGS); // openDialog 方法会统一处理 dialog 窗口的逻辑，如果移除，会在二次点击时无法 focus
+      // this.sendEvent(FcrUIAction.OPEN_DEVICE_SETTING_DIALOG, { dialogId, ...config });
+      this.sendEvent(_constant.FcrUIAction.OPEN_DEVICE_SETTING_DIALOG, config);
+      this._observable.notifyObservers('onOpenSettingDialog');
+    }
+  }, {
+    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: "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
+      });
+      this._observable.notifyObservers('onDialogOpened', dialogKey, dialogId, params);
+      return dialogId;
+    }
+  }, {
+    key: "closeDialog",
+    value: function closeDialog(dialogId) {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_DIALOG, {
+        dialogId: dialogId
+      });
+      this._observable.notifyObservers('onDialogClosed', dialogId);
+    }
+  }, {
+    key: "closeConfirm",
+    value: function closeConfirm(dialogId) {
+      this.sendEvent(_constant.FcrUIAction.CLOSE_DIALOG, {
+        dialogId: dialogId,
+        dialogKey: _constant.FcrUIDialogKey.CONFIRM
+      });
+    }
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._observable.removeObserver(observer);
+    }
+  }]);
+}();
+(0, _base.registerDependency)('dialogProvider');

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

@@ -0,0 +1,69 @@
+import { FcrUIToastParams, FcrUINotificationParams, FcrUINotificationContentType } from '../type';
+import { FcrUIAction } from '../utilities/constant';
+interface FcrUIEventObserver {
+    onEvent?(action: FcrUIAction, payload?: unknown): void;
+}
+/**
+ * FcrUIMessageProvider 接口定义了一系列用于管理和操作 UI 消息的方法。
+ * 这些方法涵盖了显示不同类型消息（如 Toast 提示、通知等）、关闭通知以及管理消息事件观察者的功能。
+ */
+export interface FcrUIMessageProvider {
+    /**
+     * 显示一个 Toast 提示消息。
+     * Toast 通常是短暂显示的轻量级消息，用于向用户传达简单的信息。
+     *
+     * @param params - 显示 Toast 提示所需的参数，类型为 FcrUIToastParams，
+     * 该参数包含了 Toast 的内容、显示时长等相关配置信息。
+     */
+    showToast(params: FcrUIToastParams): void;
+    /**
+     * 显示一个通知消息。
+     * 通知通常用于向用户展示更重要、更详细的信息，可能会在界面上停留一段时间。
+     *
+     * @param params - 显示通知所需的参数，类型为 FcrUINotificationParams，
+     * 该参数包含了通知的标题、内容、图标等相关配置信息。
+     */
+    showNotification(params: FcrUINotificationParams): void;
+    /**
+     * 关闭指定类型的通知消息。
+     *
+     * @param key - 要关闭的通知的内容类型标识，类型为 FcrUINotificationContentType，
+     * 通过该标识可以准确地关闭特定类型的通知。
+     */
+    closeNotification(key: FcrUINotificationContentType): void;
+    /**
+     * 在聊天界面显示一个 Toast 提示消息。
+     * 与普通的 showToast 方法不同，此方法专门用于在聊天场景中显示提示。
+     *
+     * @param params - 显示聊天 Toast 提示所需的参数，类型为 FcrUIToastParams，
+     * 同样包含了 Toast 的内容、显示时长等相关配置信息。
+     */
+    showChatToast(params: FcrUIToastParams): void;
+    /**
+     * 添加一个消息事件观察者。
+     * 观察者可以监听 UI 消息的各种事件，如消息显示、关闭等。
+     *
+     * @param observer - 要添加的观察者对象，类型为 FcrUIEventObserver，
+     * 该对象应该实现了相应的事件处理方法。
+     */
+    addObserver(observer: FcrUIEventObserver): void;
+    /**
+     * 移除一个消息事件观察者。
+     * 移除后，该观察者将不再接收 UI 消息的事件通知。
+     *
+     * @param observer - 要移除的观察者对象，类型为 FcrUIEventObserver。
+     */
+    removeObserver(observer: FcrUIEventObserver): void;
+}
+export declare class FcrUIMessageProviderImpl implements FcrUIMessageProvider {
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _observable;
+    sendEvent(action: FcrUIAction, payload?: unknown): void;
+    showToast(params: FcrUIToastParams): void;
+    showNotification(params: FcrUINotificationParams): void;
+    closeNotification(key: FcrUINotificationContentType): void;
+    showChatToast(params: FcrUIToastParams): void;
+    addObserver(observer: FcrUIEventObserver): void;
+    removeObserver(observer: FcrUIEventObserver): void;
+}
+export {};