fcr-ui-scene 3.7.6 → 3.7.7

package/lib/modules/video-window/popover-watcher.d.ts

@@ -4,6 +4,9 @@
  */
 export declare function usePopoverWatcher({ rootDom, setVideoWindowSize, resetVideoWindowSize, }: {
     rootDom: HTMLElement | null;
-    setVideoWindowSize: (width: number, height: number) => void;
+    setVideoWindowSize: (width: number, height: number) => {
+        width: number;
+        height: number;
+    };
     resetVideoWindowSize: () => void;
 }): void;

package/lib/modules/video-window/popover-watcher.js

@@ -27,12 +27,14 @@ function usePopoverWatcher(_ref) {
     var dialogWrapper = rootDom;
     var body = dialogWrapper.ownerDocument.body;
     var popoverClassName = 'fcr-popover';
+    var isPopoverOpened = false;
     var observer = new MutationObserver(function (mutationsList) {
       var popover = body.querySelector(".".concat(popoverClassName));
       mutationsList.forEach(function (mutation) {
         if (mutation.type === 'childList') {
           mutation.removedNodes.forEach(function (node) {
             if (node.nodeType === Node.ELEMENT_NODE && node.classList.contains(popoverClassName)) {
+              isPopoverOpened = false;
               resetVideoWindowSize();
             }
           });
@@ -40,10 +42,21 @@ function usePopoverWatcher(_ref) {
             return;
           }
           mutation.addedNodes.forEach(function (node) {
-            if (node.nodeType === Node.ELEMENT_NODE && node.contains(popover)) {
+            if (node.nodeType === Node.ELEMENT_NODE && node.contains(popover) && !isPopoverOpened) {
+              isPopoverOpened = true;
               var width = popover.offsetWidth + dialogWrapper.offsetWidth - WIDTH_RIGHT_OFFSET;
               var height = Math.max(popover.offsetHeight + HEAD_HEIGHT_OFFSET, dialogWrapper.offsetHeight);
-              setVideoWindowSize(width, height);
+              var _setVideoWindowSize = setVideoWindowSize(width, height),
+                videoWidth = _setVideoWindowSize.width;
+              if (videoWidth < width) {
+                // 说明右侧的宽度不够放下 popover，此时 popover 会自动翻转到左侧。
+                // 需要把手动调整左侧的距离，使其贴靠在窗口的最右侧。
+
+                // popover 会自动计算并设置 style 的 left 值，此处如果直接设置 left 会被 popover 内覆盖。
+                // 所以通过设置 css 变量的方式传递给 fcr-video-window-diaolog-wrapper_popover-align-right 使用。
+                popover.style.setProperty('--video-window-popover-left', "".concat(videoWidth - popover.offsetWidth, "px"));
+                popover.id = 'fcr-video-window-diaolog-wrapper_popover-align-right';
+              }
             }
           });
         }

package/lib/modules/video-window/store.d.ts

@@ -62,8 +62,25 @@ export default class VideoWindowStore {
         width: number;
         height: number;
     }): void;
-    setVideoWindowSize(width: number, height: number): void;
+    /**
+     * @description 如果传入的宽度超过了允许的最大宽度, 则使用允许的最大宽度设置窗口宽度，以避免窗口超出显示器的边缘。
+     * @param width 期望设置的视频窗宽度
+     * @param height 视频窗高度
+     * @returns 实际设置的视频窗尺寸
+     */
+    setVideoWindowSize(width: number, height: number): {
+        width: number;
+        height: number;
+    };
     resetVideoWindowSize(): void;
+    /**
+     * 计算 video-window 窗口允许设置的最大宽度，窗口左上角距离屏幕右侧边缘的距离和当前的窗口内容宽度中，选择最大值作为允许的最大宽度（不能超过窗口最大化的宽度）
+     * @param videoWindowX 视频窗左上角 x 坐标
+     * @param videoWindowStyleWidth 视频窗内容的宽度
+     * @returns 允许设置的最大宽度
+     */
+    private _computedMaxAllowedWidth;
+    private _setVideoWindowDialogSize;
     private _onAudioVolumeUpdated;
     private _handleDialogOpen;
     private _handleDialogClose;

package/lib/modules/video-window/store.js

@@ -136,7 +136,7 @@ var VideoWindowStore = exports["default"] = /*#__PURE__*/function () {
       return _this.videoWindowPreviewType;
     }, function () {
       var size = _this.videoWindowStyleSize;
-      _this.setVideoWindowSize(size.width, size.height);
+      _this._setVideoWindowDialogSize(size.width, size.height);
     }), (0, _mobx.reaction)(function () {
       return _this.filterFoldList.length;
     }, function (length, prevLength) {
@@ -151,7 +151,7 @@ var VideoWindowStore = exports["default"] = /*#__PURE__*/function () {
         var videoWindow = _this._windowProvider.getWindowById(_constant.FcrUIDialogKey.VIDEO_WINDOW);
         var bounds = videoWindow.getBounds();
         var width = Math.max(bounds.width, size.width);
-        _this.setVideoWindowSize(width, size.height);
+        _this._setVideoWindowDialogSize(width, size.height);
       }
     }));
     this._streamControl.addObserver({
@@ -410,21 +410,69 @@ var VideoWindowStore = exports["default"] = /*#__PURE__*/function () {
         this._videoWindowSmallTypeStyleSize = size;
       }
     }
+    /**
+     * @description 如果传入的宽度超过了允许的最大宽度, 则使用允许的最大宽度设置窗口宽度，以避免窗口超出显示器的边缘。
+     * @param width 期望设置的视频窗宽度
+     * @param height 视频窗高度
+     * @returns 实际设置的视频窗尺寸
+     */
   }, {
     key: "setVideoWindowSize",
     value: function setVideoWindowSize(width, height) {
       var videoWindow = this._windowProvider.getWindowById(_constant.FcrUIDialogKey.VIDEO_WINDOW);
-      this._isWindowApiResize = true;
-      (0, _videoWindow.setVideoWindowDialogSize)(videoWindow, {
-        width: width,
+      var _videoWindow$getBound = videoWindow.getBounds(),
+        videoWindowX = _videoWindow$getBound.x;
+      var videoWindowStyleWidth = this.videoWindowStyleSize.width;
+      var maxAllowedWidth = this._computedMaxAllowedWidth(videoWindowX, videoWindowStyleWidth);
+
+      // 在最大宽度限制内，使用期望的宽度
+      // 超出最大宽度限制，使用允许的最大宽度
+      var finalWidth = Math.min(maxAllowedWidth, width);
+      this._setVideoWindowDialogSize(finalWidth, height, videoWindow);
+      return {
+        width: finalWidth,
         height: height
-      });
+      };
     }
   }, {
     key: "resetVideoWindowSize",
     value: function resetVideoWindowSize() {
       var size = this.videoWindowStyleSize;
-      this.setVideoWindowSize(size.width, size.height);
+      this._setVideoWindowDialogSize(size.width, size.height);
+    }
+
+    /**
+     * 计算 video-window 窗口允许设置的最大宽度，窗口左上角距离屏幕右侧边缘的距离和当前的窗口内容宽度中，选择最大值作为允许的最大宽度（不能超过窗口最大化的宽度）
+     * @param videoWindowX 视频窗左上角 x 坐标
+     * @param videoWindowStyleWidth 视频窗内容的宽度
+     * @returns 允许设置的最大宽度
+     */
+  }, {
+    key: "_computedMaxAllowedWidth",
+    value: function _computedMaxAllowedWidth(videoWindowX, videoWindowStyleWidth) {
+      var sharingDisplayBounds = this._screenShareProvider.sharingDisplayBounds;
+      var displayX = sharingDisplayBounds.x,
+        displayWidth = sharingDisplayBounds.width;
+      var displayRightEdge = displayX + displayWidth;
+      var distanceToRightEdge = displayRightEdge - videoWindowX;
+
+      // 如果窗口左上角距离屏幕边缘的距离小于当前的窗口内容宽度，则使用当前窗口内容宽度作为允许的最大宽度，避免窗口收窄导致内容显示异常
+      var maxAllowedWidth = Math.max(distanceToRightEdge, videoWindowStyleWidth);
+
+      // 如果最大允许宽度超出了窗口最大化的宽度，则使用窗口最大化的宽度作为允许设置的宽度
+      return Math.min(maxAllowedWidth, _type.VideoWindowZoomMaxWidth);
+    }
+  }, {
+    key: "_setVideoWindowDialogSize",
+    value: function _setVideoWindowDialogSize(width, height, videoWindow) {
+      if (!videoWindow) {
+        videoWindow = this._windowProvider.getWindowById(_constant.FcrUIDialogKey.VIDEO_WINDOW);
+      }
+      this._isWindowApiResize = true;
+      (0, _videoWindow.setVideoWindowDialogSize)(videoWindow, {
+        width: width,
+        height: height
+      });
     }
   }, {
     key: "_onAudioVolumeUpdated",

package/lib/modules/whiteboard/components/progress/electron.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/modules/whiteboard/components/progress/electron.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _mobxReact = require("mobx-react");
+var _store = require("../../../dialog/store");
+var _react = require("react");
+var _reactDom = require("react-dom");
+var _jsxRuntime = require("react/jsx-runtime");
+var ProgressElectronDialog = (0, _mobxReact.observer)(function (_ref) {
+  var children = _ref.children;
+  var store = (0, _react.useContext)(_store.StoreContext);
+  (0, _react.useEffect)(function () {
+    var node;
+    window.runtime.openRendererWindow('progress-dialog', function (dom) {
+      node = dom;
+      (0, _reactDom.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_store.StoreContext.Provider, {
+        value: store,
+        children: children
+      }), dom);
+    }, {
+      frame: false,
+      fullscreen: false,
+      maximizable: false,
+      width: 290,
+      height: 60,
+      transparent: true
+    });
+    return function () {
+      (0, _reactDom.unmountComponentAtNode)(node);
+      window.runtime.closeRendererWindow('progress-dialog');
+    };
+  }, []);
+  return null;
+});

package/lib/modules/whiteboard/store.js

@@ -231,10 +231,27 @@ var WhitebaordStoreBase = exports["default"] = /*#__PURE__*/function () {
     key: "setBoardContainerDom",
     value: function setBoardContainerDom(boardDom) {
       if (boardDom) {
-        this.logger.info("set board container dom: ".concat(boardDom));
+        if (this.boardContainer === boardDom) {
+          this.logger.warn("set board container dom: container is the same, ignore");
+          return;
+        }
+        this.logger.info("set board container dom: container is mounted");
         this.boardContainer = boardDom;
+        if (this._isMounted) {
+          this.logger.error("set board container dom: container is already mounted");
+          return;
+        }
+
+        // 切换布局和 pin 时，白板会在 Carousel 和 Gallery 两个组件内切换显示
+        // 原先的白板容器会被销毁，新的白板容器会重新创建
+        // 这里需要重新挂载白板视图到新的容器内
+        if (this._boardView) {
+          this._mount(this._boardView);
+        }
       } else {
-        this.logger.warn("set board container dom is not ready");
+        this.logger.info("set board container dom: container is unmounted");
+        this._isMounted = false;
+        this.boardContainer = undefined;
       }
     }
   }, {
@@ -361,6 +378,7 @@ var WhitebaordStoreBase = exports["default"] = /*#__PURE__*/function () {
       var reason = data.reason,
         operatorUser = data.operatorUser;
       this._unmount();
+      this._boardView = null;
       var stopByOther = reason === _struct.FcrUIBoardShareStopReason.STOPPED_BY_OTHER;
       var normalStop = reason === _struct.FcrUIBoardShareStopReason.NORMAL_STOP;
       var operatorIsNotMe = (operatorUser === null || operatorUser === void 0 ? void 0 : operatorUser.userId) !== this.localUser.userId;

package/lib/modules/widget/store.d.ts

@@ -0,0 +1,14 @@
+import { FcrUIWidgetProvider } from '../../providers/widget-provider';
+import { FcrUIWebWidgetConfig } from '../../type';
+export default class WebWidgetStore {
+    private _widgetProvider;
+    constructor({ widgetProvider }: {
+        widgetProvider: FcrUIWidgetProvider;
+    });
+    get openedWidgets(): Map<string, import("./type").FcrUIWebWidget>;
+    release(): void;
+}
+export declare const StoreContext: import("react").Context<{
+    widgetConfig: FcrUIWebWidgetConfig;
+    store: WebWidgetStore;
+}>;

package/lib/modules/widget/store.js

@@ -0,0 +1,28 @@
+"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["default"] = exports.StoreContext = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _react = require("react");
+var WebWidgetStore = exports["default"] = /*#__PURE__*/function () {
+  function WebWidgetStore(_ref) {
+    var widgetProvider = _ref.widgetProvider;
+    (0, _classCallCheck2["default"])(this, WebWidgetStore);
+    this._widgetProvider = widgetProvider;
+  }
+  return (0, _createClass2["default"])(WebWidgetStore, [{
+    key: "openedWidgets",
+    get: function get() {
+      return this._widgetProvider.openedWidgets;
+    }
+  }, {
+    key: "release",
+    value: function release() {}
+  }]);
+}(); // #endregion
+var StoreContext = exports.StoreContext = /*#__PURE__*/(0, _react.createContext)(null);

package/lib/object-manager.d.ts

@@ -44,7 +44,6 @@ export declare enum FcrUIObjectKeys {
     P_MULTI_DISPLAY_PROVIDER = "multiDisplayProvider",
     P_WAITING_ROOM_CONTROL_PROVIDER = "waitingRoomControlProvider",
     P_CURRENT_ROOM_CONTROL_PROVIDER = "currentRoomControlProvider",
-    P_CONNECTION_PROVIDER = "connectionProvider",
     P_SESSION_PROVIDER = "sessionProvider",
     P_PHONE_AUDIO_CONNECTOR_PROVIDER = "phoneAudioConnectorProvider",
     P_ANNOTATION_PROVIDER = "annotationProvider",

package/lib/object-manager.js

@@ -160,7 +160,6 @@ var FcrUIObjectKeys = exports.FcrUIObjectKeys = /*#__PURE__*/function (FcrUIObje
   FcrUIObjectKeys["P_MULTI_DISPLAY_PROVIDER"] = "multiDisplayProvider";
   FcrUIObjectKeys["P_WAITING_ROOM_CONTROL_PROVIDER"] = "waitingRoomControlProvider";
   FcrUIObjectKeys["P_CURRENT_ROOM_CONTROL_PROVIDER"] = "currentRoomControlProvider";
-  FcrUIObjectKeys["P_CONNECTION_PROVIDER"] = "connectionProvider";
   FcrUIObjectKeys["P_SESSION_PROVIDER"] = "sessionProvider";
   FcrUIObjectKeys["P_PHONE_AUDIO_CONNECTOR_PROVIDER"] = "phoneAudioConnectorProvider";
   FcrUIObjectKeys["P_ANNOTATION_PROVIDER"] = "annotationProvider";

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

@@ -0,0 +1,124 @@
+import { FcrAnnotationControl } from 'fcr-core/lib/room-control/whiteboard-control-v2/annotation-control/type';
+import { FcrUIDialogProvider } from './dialog-provider';
+import { CurrentShareScreenTypes } from '../modules/share-screen/types';
+import { FcrUIVideoWindowDataSource } from '../shared-data-source/video-window';
+import { FcrUIVideoWindowData } from '../type';
+import { FcrUIPrivilegeProvider } from './privilege-provider';
+import { FcrUIScreenShareSharedDataSource } from '../shared-data-source/screen-share-data';
+export interface FcrUIAnnotationProvider {
+    /**
+     * 接收端属性，用于获取当前标注窗口的缩放比例
+     */
+    get scalcValue(): number;
+    /**
+     * 接收端方法，用于获取标注功能的 Control 对象
+     */
+    get annotationControl(): FcrAnnotationControl | undefined;
+    /**
+     * 接收端属性，用于获取当前共享窗口数据
+     */
+    get screenShareWindowData(): FcrUIVideoWindowData | undefined;
+    /**
+     * 接收端属性，用于获取当前标注启动状态
+     */
+    get annotationHasStart(): boolean;
+    /**
+     * 安全中是否允许书写
+     */
+    get allowAnnotationWrite(): boolean;
+    /**
+     * 当前用户是否允许书写
+     */
+    get allowAnnotationSelfWrite(): boolean;
+    /**
+     * 发起端状态，用于获取当前是否正在标注
+     */
+    get annotating(): boolean;
+    /**
+     * 发起端数据，当前共享屏幕信息
+     */
+    get currentShareInfo(): CurrentShareScreenTypes;
+    /**
+     * 是否展示toolbar
+     */
+    get isShowToolbar(): boolean;
+    /**
+     * 设置是否展示toolbar
+     */
+    setIsShowToolbar(isShow: boolean): void;
+    /**
+     * 发起端方法，用于打开关闭标注，由用户触发，此操切换标注工具栏打开状态合窗口的鼠标穿透模式
+     */
+    toggleAnnotation(): void;
+    /**
+     * 发起端方法，启动/初始化标注窗口，在主窗口启动时调用
+     */
+    initAnnotationWindow(): void;
+    /**
+     * 发起端方法，打开标注窗口
+     */
+    openAnnotationWindow(): void;
+    /**
+     * 发起端方法，展示标注窗口
+     */
+    showAnnotationWindow(): void;
+    /**
+     * 发起端方法，用于隐藏标注窗口，不是关闭
+     */
+    hideAnnotationWindow(): void;
+    /**
+     * 发起端方法，用于关闭标注窗口
+     */
+    closeAnnotationWindow(): void;
+    /**
+     * 发起端方法，用于设置当前共享屏幕信息
+     */
+    setCurrentShareInfo(info: CurrentShareScreenTypes): void;
+    /**
+     * 发起端方法，用通知标注窗口更新当前共享屏幕信息
+     */
+    setBoundsToAnnotationWindow(info?: CurrentShareScreenTypes): void;
+    /**
+     * 发起端方法，更新标注白板的viewport
+     */
+    updateWindowSize(width: number, height: number): void;
+}
+export declare enum FcrAnnotationState {
+    START = "start",
+    END = "end"
+}
+export declare class FcrUIAnnotationProviderImpl implements FcrUIAnnotationProvider {
+    private _dialogProvider;
+    private _videoWindowDataSource;
+    private _privilegeProvider;
+    private _sharedScreenShareSharedDataSource;
+    private _annotationDialogId;
+    private _annotationToolDialogId;
+    private _disposers;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _annotationControl;
+    accessor annotationState: FcrAnnotationState;
+    accessor annotating: boolean;
+    accessor isShowToolbar: boolean;
+    accessor currentShareInfo: CurrentShareScreenTypes;
+    get allowAnnotationSelfWrite(): boolean;
+    get screenShareWindowData(): import("../shared-data-source/video-window").FcrUIVideoWindowDataImpl | undefined;
+    get scalcValue(): number;
+    get annotationControl(): FcrAnnotationControl | undefined;
+    get annotationHasStart(): boolean;
+    get allowAnnotationWrite(): boolean;
+    constructor(_dialogProvider: FcrUIDialogProvider, _videoWindowDataSource: FcrUIVideoWindowDataSource, _privilegeProvider: FcrUIPrivilegeProvider, _sharedScreenShareSharedDataSource: FcrUIScreenShareSharedDataSource);
+    updateWindowSize(width: number, height: number): void;
+    toggleAnnotation(): Promise<void>;
+    setIsShowToolbar(isShow: boolean): void;
+    initAnnotationWindow(): void;
+    openAnnotationWindow(): void;
+    showAnnotationWindow(): void;
+    hideAnnotationWindow(): void;
+    setCurrentShareInfo(info: CurrentShareScreenTypes): void;
+    setBoundsToAnnotationWindow(info?: CurrentShareScreenTypes): Promise<void>;
+    closeAnnotationWindow(): void;
+    release(): void;
+    private _openToolbar;
+    private _closeToolbar;
+}