fcr-ui-scene 1.0.40 → 3.1.0-2

package/lib/creator.d.ts

@@ -0,0 +1,8 @@
+import { FcrUISceneCancelCallback, FcrUISceneConfig, FcrUISceneCreatorConfig, FcrUISceneFailureCallback, FcrUISceneSuccessCallback } from './type';
+import { FcrUIDefaultScene } from './ui-scene';
+export declare class FcrUISceneCreator {
+    private _config;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    constructor(_config: FcrUISceneCreatorConfig);
+    launch(config: FcrUISceneConfig, onCancel: FcrUISceneCancelCallback, onSuccess: FcrUISceneSuccessCallback, onFailure: FcrUISceneFailureCallback, dom: HTMLElement): FcrUIDefaultScene;
+}

package/lib/creator.js

@@ -0,0 +1,37 @@
+"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.FcrUISceneCreator = 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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _logger = require("agora-foundation/lib/logger");
+var _uiScene = require("./ui-scene");
+var FcrUISceneCreator = exports.FcrUISceneCreator = /*#__PURE__*/function () {
+  function FcrUISceneCreator(_config) {
+    (0, _classCallCheck2["default"])(this, FcrUISceneCreator);
+    (0, _defineProperty2["default"])(this, "logger", (0, _logger.getLogger)());
+    this._config = _config;
+    this.logger.info("[FcrUISceneCreator] creator config: ".concat(JSON.stringify(_config)));
+  }
+  return (0, _createClass2["default"])(FcrUISceneCreator, [{
+    key: "launch",
+    value: function launch(config, onCancel, onSuccess, onFailure, dom) {
+      this.logger.info("[FcrUISceneCreator] scene config: ".concat(JSON.stringify(config)));
+      var scene = new _uiScene.FcrUIDefaultScene(config, this._config, dom);
+      scene.addObserver({
+        onLaunchSuccess: onSuccess,
+        onLaunchFailure: onFailure,
+        onLaunchCancel: onCancel
+      });
+      scene.launch();
+      return scene;
+    }
+  }]);
+}();

package/lib/electron/app.d.ts

@@ -0,0 +1 @@
+export declare const hookApp: (app: Electron.App) => void;

package/lib/electron/app.js

@@ -0,0 +1,140 @@
+"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.hookApp = void 0;
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.join.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.starts-with.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.timers.js");
+var _window = require("./window");
+var _electron = require("electron");
+var _path = _interopRequireDefault(require("path"));
+var hookApp = exports.hookApp = function hookApp(app) {
+  var isWindowDestroyed = function isWindowDestroyed(window) {
+    return window.isDestroyed();
+  };
+  app.addListener('browser-window-created', function (_, window) {
+    var windowId = window.id;
+    window.addListener('close', function () {
+      _electron.BrowserWindow.getAllWindows().forEach(function (window) {
+        if (!isWindowDestroyed(window)) {
+          window.webContents.send('custom-event', {
+            action: 'FRAGMENT_CLOSED',
+            payload: (0, _window.getWindowKeyById)(windowId)
+          });
+        }
+      });
+    });
+    window.webContents.addListener('render-process-gone', function (event, arg) {
+      console.log('render-process-gone', arg);
+    });
+    window.webContents.addListener('did-finish-load', function () {
+      setTimeout(function () {
+        _electron.BrowserWindow.getAllWindows().forEach(function (window) {
+          if (!isWindowDestroyed(window)) {
+            window.webContents.send('custom-event', {
+              action: 'FRAGMENT_LOADED',
+              payload: (0, _window.getWindowKeyById)(windowId)
+            });
+          }
+        });
+      });
+    });
+  });
+  app.addListener('ready', function () {
+    _electron.powerMonitor.addListener('suspend', function () {
+      _electron.BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_SUSPEND'
+        });
+      });
+    });
+    _electron.powerMonitor.addListener('resume', function () {
+      _electron.BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_RESUME'
+        });
+      });
+    });
+    _electron.powerMonitor.addListener('lock-screen', function () {
+      _electron.BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_LOCK_SCREEN'
+        });
+      });
+    });
+    _electron.powerMonitor.addListener('unlock-screen', function () {
+      _electron.BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_UNLOCK_SCREEN'
+        });
+      });
+    });
+    _electron.powerMonitor.addListener('shutdown', function () {
+      _electron.BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_SHUTDOWN'
+        });
+      });
+    });
+    _electron.ipcMain.handle('get-launch-options', function () {
+      var launchOptions = process.argv.find(function (arg) {
+        return arg.startsWith('--launch-options=');
+      });
+      if (!launchOptions) {
+        console.error('No launch options found');
+        return {};
+      }
+      var jsonStr = launchOptions.substring('--launch-options='.length);
+      try {
+        return launchOptions = JSON.parse(jsonStr);
+      } catch (e) {
+        console.error('Invalid JSON argument:', jsonStr);
+      }
+    });
+    _electron.ipcMain.handle('launch', function (_e, launchOptions) {
+      if (process.platform === 'darwin') {
+        var ext = require(_path["default"].join(process.resourcesPath, 'Frameworks', 'FcrUISceneLauncher.node'));
+        var res = ext.launch(launchOptions);
+        if (res !== 0) {
+          console.error('Failed to launch FcrUISceneLauncher');
+        }
+      } else {
+        var _ext = require(_path["default"].join(process.resourcesPath, 'Libs', 'FcrUISceneLauncher.node'));
+        var _res = _ext.launch(launchOptions);
+        if (_res !== 0) {
+          console.error('Failed to launch FcrUISceneLauncher');
+        }
+      }
+    });
+    _electron.ipcMain.handle('getBrowserWindowId', function (_, frameName) {
+      var _getRendererWindow;
+      return (_getRendererWindow = (0, _window.getRendererWindow)(frameName)) === null || _getRendererWindow === void 0 ? void 0 : _getRendererWindow.id;
+    });
+    _electron.ipcMain.addListener('open', function (_, entryPath, dialogId) {
+      (0, _window.open)(entryPath, dialogId);
+    });
+    _electron.ipcMain.addListener('close', function (_, entryPath, dialogId) {
+      (0, _window.close)(entryPath, dialogId);
+    });
+    _electron.ipcMain.addListener('setFragmentBaseUrl', function (_, isDev, baseUrl) {
+      (0, _window.setFragmentBaseUrl)(isDev, baseUrl);
+    });
+    _electron.ipcMain.addListener('setFragmentOptions', function (_, entryPath, windowOptions, webPreferences) {
+      _window.windowOptionsMap[entryPath] = windowOptions;
+      _window.webPreferencesMap[entryPath] = webPreferences;
+    });
+    _electron.ipcMain.addListener('closeAllSubWindows', function () {
+      (0, _window.closeAllWindows)();
+      (0, _window.clearAllRendererWindows)();
+    });
+  });
+};

package/lib/electron/default-options.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultWindowOptions: Electron.BrowserWindowConstructorOptions;
+export declare const defaultWebPreferences: Electron.WebPreferences;

package/lib/electron/default-options.js

@@ -0,0 +1,25 @@
+"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.defaultWindowOptions = exports.defaultWebPreferences = void 0;
+var _path = _interopRequireDefault(require("path"));
+var defaultWindowOptions = exports.defaultWindowOptions = {
+  height: 850,
+  width: 1340,
+  minWidth: 825,
+  // 这个值会影响主窗口的最小宽度，如需改变，记得同步 /fcr-ui-scene-desktop/src/modules/state-bar/store.ts 中的 GALLERY_MIN_SIZE
+  minHeight: 600
+};
+var defaultWebPreferences = exports.defaultWebPreferences = {
+  nodeIntegration: true,
+  nodeIntegrationInWorker: true,
+  contextIsolation: false,
+  webSecurity: false,
+  webviewTag: true,
+  backgroundThrottling: false,
+  preload: _path["default"].resolve(__dirname, "preload.js")
+};

package/lib/electron/env.d.ts

@@ -0,0 +1,5 @@
+export declare let isDev: boolean;
+export declare let devPageUrl: string;
+export declare let distPathPrefix: string;
+export declare let distIndexFileName: string;
+export declare let ipcPrefix: string;

package/lib/electron/env.js

@@ -0,0 +1,13 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDev = exports.ipcPrefix = exports.distPathPrefix = exports.distIndexFileName = exports.devPageUrl = void 0;
+var _process$env$ELECTRON, _process$env$DIST_PAT, _process$env$DIST_IND, _process$env$IPC_PREF;
+var isDev = exports.isDev = process.env.DEV === 'true';
+var devPageUrl = exports.devPageUrl = (_process$env$ELECTRON = process.env.ELECTRON_START_URL) !== null && _process$env$ELECTRON !== void 0 ? _process$env$ELECTRON : "http://localhost:3000";
+var distPathPrefix = exports.distPathPrefix = (_process$env$DIST_PAT = process.env.DIST_PATH_PREFIX) !== null && _process$env$DIST_PAT !== void 0 ? _process$env$DIST_PAT : 'dist';
+var distIndexFileName = exports.distIndexFileName = (_process$env$DIST_IND = process.env.DIST_INDEX_FILE_NAME) !== null && _process$env$DIST_IND !== void 0 ? _process$env$DIST_IND : 'index.html';
+var ipcPrefix = exports.ipcPrefix = (_process$env$IPC_PREF = process.env.IPC_PREFIX) !== null && _process$env$IPC_PREF !== void 0 ? _process$env$IPC_PREF : 'fcr-';

package/lib/electron/index.d.ts

@@ -0,0 +1,2 @@
+export { hookApp } from './app';
+export { hookWindow } from './main';

package/lib/electron/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "hookApp", {
+  enumerable: true,
+  get: function get() {
+    return _app.hookApp;
+  }
+});
+Object.defineProperty(exports, "hookWindow", {
+  enumerable: true,
+  get: function get() {
+    return _main.hookWindow;
+  }
+});
+var _app = require("./app");
+var _main = require("./main");

package/lib/electron/injections.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { IpcRendererEvent } from 'electron';
+import { BrowserWindowConstructorOptions } from 'electron/renderer';
+import { BrowserWindow } from '@electron/remote';
+import os from 'os';
+export declare const openDirectory: () => Promise<string | undefined>;
+export declare const showItemInFolder: (path: string) => void;
+export declare const sendEvent: (event: RendererCustomEvent) => void;
+export declare const addEventListener: (listener: (ipcEvent: IpcRendererEvent, event: RendererCustomEvent) => void) => void;
+export declare const removeEventListener: (listener: (ipcEvent: IpcRendererEvent, event: RendererCustomEvent) => void) => void;
+export declare const setFragmentOptions: (entryPath: string, windowOptions: Electron.BrowserWindowConstructorOptions, webPreferences: Electron.WebPreferences) => void;
+export declare const getLaunchOptions: () => Promise<any>;
+export declare const openLinkInDefaultBrowser: (url: string) => void;
+export declare const getBrowserWindowById: (id: number) => Electron.BrowserWindow | undefined;
+export declare const browserWindow: Electron.CrossProcessExports.BrowserWindow;
+export declare const screen: Electron.Screen;
+export declare const open: (entryPath: string, dialogId?: string | undefined) => void;
+export declare const close: (entryPath: string, dialogId?: string) => void;
+export declare const setFragmentBaseUrl: (isDev: boolean, baseUrl: string) => void;
+export declare const registerListenerReady: () => void;
+export declare const captureScreen: (options?: {
+    hideWindow?: boolean;
+}) => void;
+export declare const openRendererWindow: (frameName: string, renderFn: (dom: Element, browserWindow: Electron.BrowserWindow) => void, windowOptions: BrowserWindowConstructorOptions) => Promise<void>;
+export declare const closeRendererWindow: (frameName: string) => Promise<void>;
+export declare const launch: (options: any) => Promise<any>;
+export declare const setAlwaysOnTop: () => void;
+export declare const quitApp: () => void;
+export declare const getSystemMemorySize: () => number;
+export declare const getSystemCpuInfo: () => os.CpuInfo[];
+export declare const getNetworkType: () => Promise<NetworkType>;
+export declare const getAssetUrl: (path: string) => string;
+export declare const getRendererProcessUsage: () => Promise<{
+    memoryUsage: number;
+    cpuUsage: number;
+    totalMemoryUsage: number;
+    totalCpuUsage: number;
+}>;
+export declare const getVirtualBgResource: (url: string, md5Url: string, type: 'image' | 'video') => Promise<string[]>;
+export declare const fileToBase64: (file: string, type: 'image' | 'video') => string;
+export declare const releaseSubAllWindowRefs: () => void;
+export declare const getMediaSourceIdList: () => {
+    title: string;
+    mediaSourceId: string;
+}[];