fcr-ui-scene 3.6.1 → 3.6.2

package/lib/electron/ipc/ipc.js

@@ -58,6 +58,10 @@ var IPCClient = exports.IPCClient = /*#__PURE__*/function () {
     this._socket.on('end', function () {
       _this._logger.info('disconnected from server');
     });
+    this._socket.on('close', function () {
+      _this._logger.info('disconnected from server');
+      _this._observable.emit('onDisconnected');
+    });
     this._socket.on('data', function (data) {
       // 将新数据追加到现有缓冲区
       _this._buffer = Buffer.concat([_this._buffer, data]);

package/lib/electron/main.js

@@ -17,7 +17,7 @@ var logger = (0, _logger.getLogger)();
 var hookWindow = exports.hookWindow = function hookWindow(mainWindow) {
   mainWindow.webContents.addListener('did-create-window', function (window, details) {
     logger.info("browser window is opened, frameName: ".concat(details.frameName));
-    var builtinFrameNames = ['device-settings', 'chat', 'live-streaming', 'participant', 'share-screen-selection', 'invite', 'video-window', 'confirm', 'connection-gateway', 'whiteboard', 'progress-dialog', 'operation-waiting-room', 'operation-waiting-room', 'interpreter-setting', 'waiting-room-single-remove', 'waiting-room-all-remove', 'waiting-room-all-admit', 'control-bar', 'show-toast', 'system-preference', 'rename', 'leave-meeting'];
+    var builtinFrameNames = ['device-settings', 'chat', 'live-streaming', 'participant', 'share-screen-selection', 'invite', 'video-window', 'confirm', 'connection-gateway', 'whiteboard', 'progress-dialog', 'operation-waiting-room', 'operation-waiting-room', 'interpreter-setting', 'waiting-room-single-remove', 'waiting-room-all-remove', 'waiting-room-all-admit', 'control-bar', 'show-toast', 'system-preference', 'rename', 'annotation-tool', 'leave-meeting'];
     if (!builtinFrameNames.includes(details.frameName) && !details.frameName.startsWith('widget')) {
       logger.info("frameName [".concat(details.frameName, "] is not in builtinFrameNames, ignore it"));
       return;
@@ -36,9 +36,13 @@ var hookWindow = exports.hookWindow = function hookWindow(mainWindow) {
       window.emit('will-close');
     });
     window.addListener('will-resize', function (event, newBounds, details) {
-      logger.info("Window [".concat(window.title, ":").concat(window.id, "] is resized, send 'will-resize' event to that window"));
+      logger.info("Window [".concat(window.title, ":").concat(window.id, "] is resized, send 'custom-resize' event to that window"));
       window.emit('custom-resize', event, newBounds, details);
     });
+    window.addListener('move', function () {
+      logger.info("Window [".concat(window.title, ":").concat(window.id, "] is move, send 'custom-move' event to that window"));
+      window.emit('custom-move');
+    });
 
     // screen?.addListener('display-metrics-changed', (event, display, changedMetrics) => {
     //   logger.info(

package/lib/electron/plugins/screenshot.js

@@ -12,10 +12,11 @@ var _electronScreenshots = _interopRequireDefault(require("electron-screenshots"
 var listenScreenshot = exports.listenScreenshot = function listenScreenshot(window) {
   var shortcutCapture = new _electronScreenshots["default"]();
   var isCapturing = false,
-    module = '';
+    module = '',
+    alwaysHide = false;
   var timer = null;
   var stopScreen = function stopScreen() {
-    window.setOpacity(1);
+    !alwaysHide && window.setOpacity(1);
     isCapturing = false;
     timer && clearTimeout(timer);
   };
@@ -42,6 +43,7 @@ var listenScreenshot = exports.listenScreenshot = function listenScreenshot(wind
       var hideWindow = false;
       hideWindow = payload.hideWindow;
       module = payload.module;
+      alwaysHide = !!(payload !== null && payload !== void 0 && payload.alwaysHide);
       hideWindow && window.setOpacity(0);
       if (!shortcutCapture) {
         shortcutCapture = new _electronScreenshots["default"]();

package/lib/electron/preload.js

@@ -40,6 +40,8 @@ window.runtime = {
   openSystemPreferences: _injections.openSystemPreferences,
   getUserSettingData: _injections.getUserSettingData,
   setUserSettingData: _injections.setUserSettingData,
+  getActiveWindow: _injections.getActiveWindow,
+  getWindows: _injections.getWindows,
   initSDK: _injections.initSDK,
   getIsSDKReady: _injections.getIsSDKReady,
   openSetting: _injections.openSetting,
@@ -47,13 +49,16 @@ window.runtime = {
   launchSuccess: _injections.launchSuccess,
   launchFailure: _injections.launchFailure,
   setParameters: _injections.setParameters,
-  exitedMeeting: _injections.exitedMeeting
+  exitedMeeting: _injections.exitedMeeting,
+  getIsMeetingLaunched: _injections.getIsMeetingLaunched
 };
 _renderer.ipcRenderer.on(_type.IPCMessageCMD.InitCreator, function (_event, value) {
   if (window.runtime.onCreatorInit) {
     var data = value;
     try {
-      data = JSON.parse(value);
+      if (typeof value == 'string') {
+        data = JSON.parse(value);
+      }
     } catch (e) {
       console.error('Failed to parse init options:', e);
     }

package/lib/electron/window.js

@@ -48,6 +48,7 @@ var baseUrl = env.devPageUrl;
 var logger = (0, _logger.getLogger)();
 var loadFragment = function loadFragment(browserWindow, path) {
   var url = isDev ? "".concat(baseUrl, "/").concat(path, ".html") : "dist/".concat(path, ".html");
+  logger.info("[loadFragment] url: ".concat(url, ", baseUrl: ").concat(baseUrl, ", path: ").concat(path));
   if (isDev) {
     return browserWindow.loadURL(url);
   } else {
@@ -100,15 +101,15 @@ var closeAllWindows = exports.closeAllWindows = function closeAllWindows() {
   windowKeyById = {};
 };
 var putRendererWindow = exports.putRendererWindow = function putRendererWindow(entryPath, browserWindow) {
-  logger.info('[RendererWindow] putRendererWindow', entryPath);
+  logger.info("[RendererWindow] putRendererWindow', ".concat(entryPath, ", '<-test'"));
   rendererWindows[entryPath] = browserWindow;
 };
 var deleteRendererWindow = exports.deleteRendererWindow = function deleteRendererWindow(entryPath) {
-  logger.info('[RendererWindow] deleteRendererWindow', entryPath);
+  logger.info("[RendererWindow] deleteRendererWindow', ".concat(entryPath));
   delete rendererWindows[entryPath];
 };
 var getRendererWindow = exports.getRendererWindow = function getRendererWindow(entryPath) {
-  logger.info('[RendererWindow] getRendererWindow', entryPath, Object.keys(rendererWindows));
+  logger.info("[RendererWindow] getRendererWindow',\n    ".concat(entryPath, ",\n    ").concat(String(Object.keys(rendererWindows)), ",\n    ").concat(String(rendererWindows[entryPath])));
   return rendererWindows[entryPath];
 };
 var clearAllRendererWindows = exports.clearAllRendererWindows = function clearAllRendererWindows() {

package/lib/fragments/annotation/index.d.ts

@@ -0,0 +1,10 @@
+import { BaseFragment } from '../base';
+export declare class Annotation extends BaseFragment {
+    get name(): string;
+    get component(): import("react/jsx-runtime").JSX.Element;
+    constructor(runtime: Runtime);
+    protected onEvent(event: RendererCustomEvent): void;
+}
+export declare const windowOptions: Electron.BrowserWindowConstructorOptions;
+export declare const title = "Annotation";
+export declare const webPreferences: Electron.WebPreferences;

package/lib/fragments/annotation/index.js

@@ -0,0 +1,106 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.windowOptions = exports.webPreferences = exports.title = exports.Annotation = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _reactDom = _interopRequireDefault(require("react-dom"));
+var _base = require("../base");
+var _root = require("react-hot-loader/root");
+var _jsxRuntime = require("react/jsx-runtime");
+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)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var Annotation = exports.Annotation = /*#__PURE__*/function (_BaseFragment) {
+  function Annotation(runtime) {
+    (0, _classCallCheck2["default"])(this, Annotation);
+    return _callSuper(this, Annotation, [runtime]); // this._store = new AnnotationStore();
+    // window.addEventListener('keydown', (event) => {
+    //   if ((event.ctrlKey || event.metaKey) && event.key === 'w') {
+    //     event.preventDefault();
+    //   }
+    // });
+  }
+  (0, _inherits2["default"])(Annotation, _BaseFragment);
+  return (0, _createClass2["default"])(Annotation, [{
+    key: "name",
+    get:
+    // private _store: AnnotationStore;
+
+    function get() {
+      return 'annotation';
+    }
+  }, {
+    key: "component",
+    get: function get() {
+      // return (
+      //   <AnnotationStoreContext.Provider value={this._store}>
+      //     <View />
+      //   </AnnotationStoreContext.Provider>
+      // );
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {});
+    }
+  }, {
+    key: "onEvent",
+    value: function onEvent(event) {
+      // switch (event.action) {
+      //   case FcrUIRendererEventAction.SET_ANNOTATION_TO_SHOW:
+      //     if (event.payload) {
+      //       console.log('show annotation');
+      //       this._store.open();
+      //     } else {
+      //       console.log('hide annotation');
+      //       this._store.close();
+      //     }
+      //     break;
+      //   case FcrUIRendererEventAction.SET_CURRENT_SHARE_SCREEN_BOUNDS:
+      //     this._store.setBounds(event.payload as Electron.Rectangle);
+      //     break;
+      //   case FcrUIRendererEventAction.SET_ANNOTATION_IGNORE:
+      //     this._store.setIgnore(event.payload as boolean);
+      //     break;
+      //   default:
+      //     this._store.toolChanged(event);
+      //     break;
+      // }
+    }
+  }]);
+}(_base.BaseFragment);
+var windowOptions = exports.windowOptions = {
+  width: 800,
+  height: 600,
+  minHeight: 100,
+  minWidth: 100,
+  webPreferences: {
+    nodeIntegration: true
+  },
+  show: false,
+  frame: false,
+  alwaysOnTop: true,
+  transparent: true,
+  backgroundColor: 'rgba(0, 0, 0, 0)',
+  resizable: false,
+  enableLargerThanScreen: true,
+  hasShadow: false,
+  x: 0,
+  y: 0
+};
+var title = exports.title = 'Annotation';
+var webPreferences = exports.webPreferences = {
+  nodeIntegration: true
+};
+var $$fragment = new Annotation(window.runtime);
+var App = (0, _root.hot)(function () {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_react["default"].Fragment, {
+    children: $$fragment.component
+  });
+});
+_reactDom["default"].render(/*#__PURE__*/(0, _jsxRuntime.jsx)(App, {}), document.getElementById('root'));

package/lib/fragments/annotation/libs.d.ts

@@ -0,0 +1,55 @@
+import { WhiteboardToolType } from '@netless/forge-whiteboard';
+import { FcrBoardToolType } from 'fcr-core/lib/room-control/whiteboard-control/enums';
+export declare function convertTool(type: FcrBoardToolType): WhiteboardToolType;
+export declare const engineRestConfig: {
+    dualCameraVideoStreamConfig: {
+        highVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        lowVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        enableDualStreamMode: boolean;
+    };
+    dualScreenVideoStreamConfig: {
+        highVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        lowVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        enableDualStreamMode: boolean;
+    };
+};

package/lib/fragments/annotation/libs.js

@@ -0,0 +1,93 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertTool = convertTool;
+exports.engineRestConfig = void 0;
+var _enums = require("fcr-core/lib/room-control/whiteboard-control/enums");
+function convertTool(type) {
+  switch (type) {
+    case _enums.FcrBoardToolType.ARROW:
+      return 'arrow';
+    case _enums.FcrBoardToolType.CURVE:
+      return 'curve';
+    case _enums.FcrBoardToolType.ELLIPSE:
+      return 'ellipse';
+    case _enums.FcrBoardToolType.ERASER:
+      return 'eraser';
+    case _enums.FcrBoardToolType.LASER_POINTER:
+      return 'laser';
+    case _enums.FcrBoardToolType.TEXT:
+      return 'text';
+    case _enums.FcrBoardToolType.RECTANGLE:
+      return 'rectangle';
+    case _enums.FcrBoardToolType.TRIANGLE:
+      return 'triangle';
+    case _enums.FcrBoardToolType.SELECTOR:
+      return 'selector';
+    case _enums.FcrBoardToolType.STRAIGHT:
+      return 'line';
+    // case FcrBoardToolType.PENTAGRAM:
+    //   return 'pentagram';
+    // case FcrBoardToolType.RHOMBUS:
+    //   return 'rhombus';
+    case _enums.FcrBoardToolType.HAND:
+      return 'grab';
+    default:
+      return 'curve';
+  }
+}
+var engineRestConfig = exports.engineRestConfig = {
+  dualCameraVideoStreamConfig: {
+    highVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    lowVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    enableDualStreamMode: false
+  },
+  dualScreenVideoStreamConfig: {
+    highVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    lowVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    enableDualStreamMode: false
+  }
+};

package/lib/fragments/annotation/store.d.ts

@@ -0,0 +1,25 @@
+declare class AnnotationStore {
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _engine;
+    private _FORGE_WHITEBOARD_APP_ID;
+    private _boardInstance;
+    private _boardRoom;
+    private _boardView;
+    private _boardDom?;
+    private _config;
+    accessor joined: boolean;
+    accessor bounds: Electron.Rectangle;
+    constructor();
+    open(): Promise<void>;
+    handleBoardDomLoad(dom: HTMLDivElement): void;
+    close(): void;
+    setBounds(bounds: Electron.Rectangle): void;
+    setIgnore(ignore: boolean): void;
+    toolChanged(event: RendererCustomEvent): void;
+    private _setBoardInstance;
+    private _init;
+    private _initBoardRoom;
+    private _initEngine;
+}
+export default AnnotationStore;
+export declare const AnnotationStoreContext: import("react").Context<AnnotationStore>;