fcr-ui-scene 3.7.9-alpha → 3.8.0-alpha

package/lib/electron/process-manager/state-manager.d.ts

@@ -0,0 +1,135 @@
+import { BrowserWindow } from 'electron';
+import { EventEmitter } from 'events';
+import { DisplayState } from '../struct';
+/**
+ * 窗口状态变更事件
+ */
+export interface WindowStateChangeEvent {
+    previousState: DisplayState;
+    currentState: DisplayState;
+    timestamp: number;
+}
+/**
+ * IPC 连接状态
+ */
+export declare enum IPCConnectionState {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+/**
+ * IPC 连接状态变更事件
+ */
+export interface IPCConnectionStateChangeEvent {
+    previousState: IPCConnectionState;
+    currentState: IPCConnectionState;
+    timestamp: number;
+}
+/**
+ * StateManager 负责管理应用的各种状态
+ * - 窗口状态（显示/隐藏/最小化）
+ * - IPC 连接状态
+ * - 主窗口准备状态
+ * - 用户交互状态
+ */
+export declare class StateManager extends EventEmitter {
+    private readonly logger;
+    private _mainWindow;
+    private _mainWindowDisplayState;
+    private _mainWindowReady;
+    private _userMinimize;
+    private _ipcConnectionState;
+    private _lastInitParams;
+    get currentMeetingState(): 0 | 1;
+    constructor();
+    /**
+     * 获取主窗口实例
+     */
+    get mainWindow(): BrowserWindow | null;
+    /**
+     * 获取主窗口显示状态
+     */
+    get mainWindowDisplayState(): DisplayState;
+    /**
+     * 获取主窗口是否准备就绪
+     */
+    get mainWindowReady(): boolean;
+    /**
+     * 获取是否用户主动最小化
+     */
+    get userMinimize(): boolean;
+    /**
+     * 获取 IPC 连接状态
+     */
+    get ipcConnectionState(): IPCConnectionState;
+    /**
+     * 获取最后一次初始化参数
+     */
+    get lastInitParams(): string;
+    /**
+     * 设置主窗口实例
+     */
+    setMainWindow(window: BrowserWindow | null): void;
+    /**
+     * 设置主窗口显示状态
+     */
+    setMainWindowDisplayState(state: DisplayState): void;
+    /**
+     * 设置主窗口准备状态
+     */
+    setMainWindowReady(ready: boolean): void;
+    /**
+     * 设置用户最小化状态
+     */
+    setUserMinimize(minimize: boolean): void;
+    /**
+     * 设置 IPC 连接状态
+     */
+    setIPCConnectionState(state: IPCConnectionState): void;
+    /**
+     * 设置最后一次初始化参数
+     */
+    setLastInitParams(params: string): void;
+    /**
+     * 显示并聚焦主窗口
+     */
+    showAndFocusMainWindow(): void;
+    /**
+     * 隐藏主窗口
+     */
+    hideMainWindow(): void;
+    /**
+     * 最小化主窗口
+     */
+    minimizeMainWindow(): void;
+    /**
+     * Windows 平台特殊处理：显示并置顶窗口
+     * 用于 Windows 平台的会议启动逻辑
+     */
+    showAndFocusWithAlwaysOnTop(): void;
+    /**
+     * 聚焦主窗口
+     */
+    focusMainWindow(): void;
+    /**
+     * 检查主窗口是否可用
+     */
+    isMainWindowAvailable(): boolean;
+    /**
+     * 检查主窗口是否可见
+     */
+    isMainWindowVisible(): boolean;
+    /**
+     * 获取状态描述
+     */
+    getStateDescription(): string;
+    /**
+     * 重置所有状态
+     */
+    reset(): void;
+    /**
+     * 清理资源
+     */
+    release(): void;
+}

package/lib/electron/process-manager/state-manager.js

@@ -0,0 +1,358 @@
+"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.StateManager = exports.IPCConnectionState = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.date.now.js");
+require("core-js/modules/web.timers.js");
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _events = require("events");
+var _logger = require("../logger");
+var _struct = require("../struct");
+var _constants = require("./constants");
+var _meetingState = require("../plugins/meeting-state");
+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; })(); }
+/**
+ * 窗口状态变更事件
+ */
+/**
+ * IPC 连接状态
+ */
+var IPCConnectionState = exports.IPCConnectionState = /*#__PURE__*/function (IPCConnectionState) {
+  IPCConnectionState["DISCONNECTED"] = "disconnected";
+  IPCConnectionState["CONNECTING"] = "connecting";
+  IPCConnectionState["CONNECTED"] = "connected";
+  IPCConnectionState["ERROR"] = "error";
+  return IPCConnectionState;
+}({});
+/**
+ * IPC 连接状态变更事件
+ */
+/**
+ * StateManager 负责管理应用的各种状态
+ * - 窗口状态（显示/隐藏/最小化）
+ * - IPC 连接状态
+ * - 主窗口准备状态
+ * - 用户交互状态
+ */
+var StateManager = exports.StateManager = /*#__PURE__*/function (_EventEmitter) {
+  function StateManager() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, StateManager);
+    _this = _callSuper(this, StateManager);
+    (0, _defineProperty2["default"])(_this, "logger", (0, _logger.getLogger)());
+    // 窗口相关状态
+    (0, _defineProperty2["default"])(_this, "_mainWindow", null);
+    (0, _defineProperty2["default"])(_this, "_mainWindowDisplayState", _struct.DisplayState.HIDE);
+    (0, _defineProperty2["default"])(_this, "_mainWindowReady", false);
+    (0, _defineProperty2["default"])(_this, "_userMinimize", false);
+    // IPC 连接状态
+    (0, _defineProperty2["default"])(_this, "_ipcConnectionState", IPCConnectionState.DISCONNECTED);
+    // 初始化参数缓存
+    (0, _defineProperty2["default"])(_this, "_lastInitParams", '');
+    _this.logger.info('StateManager initialized');
+    return _this;
+  }
+
+  // ==================== Getters ====================
+
+  /**
+   * 获取主窗口实例
+   */
+  (0, _inherits2["default"])(StateManager, _EventEmitter);
+  return (0, _createClass2["default"])(StateManager, [{
+    key: "currentMeetingState",
+    get: function get() {
+      return _meetingState.isInMeeting;
+    }
+  }, {
+    key: "mainWindow",
+    get: function get() {
+      return this._mainWindow;
+    }
+
+    /**
+     * 获取主窗口显示状态
+     */
+  }, {
+    key: "mainWindowDisplayState",
+    get: function get() {
+      return this._mainWindowDisplayState;
+    }
+
+    /**
+     * 获取主窗口是否准备就绪
+     */
+  }, {
+    key: "mainWindowReady",
+    get: function get() {
+      return this._mainWindowReady;
+    }
+
+    /**
+     * 获取是否用户主动最小化
+     */
+  }, {
+    key: "userMinimize",
+    get: function get() {
+      return this._userMinimize;
+    }
+
+    /**
+     * 获取 IPC 连接状态
+     */
+  }, {
+    key: "ipcConnectionState",
+    get: function get() {
+      return this._ipcConnectionState;
+    }
+
+    /**
+     * 获取最后一次初始化参数
+     */
+  }, {
+    key: "lastInitParams",
+    get: function get() {
+      return this._lastInitParams;
+    }
+
+    // ==================== Setters ====================
+
+    /**
+     * 设置主窗口实例
+     */
+  }, {
+    key: "setMainWindow",
+    value: function setMainWindow(window) {
+      this._mainWindow = window;
+      this.logger.info("Main window ".concat(window ? 'set' : 'cleared'));
+    }
+
+    /**
+     * 设置主窗口显示状态
+     */
+  }, {
+    key: "setMainWindowDisplayState",
+    value: function setMainWindowDisplayState(state) {
+      var previousState = this._mainWindowDisplayState;
+      this._mainWindowDisplayState = state;
+      var event = {
+        previousState: previousState,
+        currentState: state,
+        timestamp: Date.now()
+      };
+      this.logger.info("Window display state changed: ".concat(previousState, " -> ").concat(state));
+      this.emit('windowStateChange', event);
+    }
+
+    /**
+     * 设置主窗口准备状态
+     */
+  }, {
+    key: "setMainWindowReady",
+    value: function setMainWindowReady(ready) {
+      this._mainWindowReady = ready;
+      this.logger.info("Main window ready state: ".concat(ready));
+      if (ready) {
+        this.emit('mainWindowReady');
+      }
+    }
+
+    /**
+     * 设置用户最小化状态
+     */
+  }, {
+    key: "setUserMinimize",
+    value: function setUserMinimize(minimize) {
+      this._userMinimize = minimize;
+      this.logger.info("User minimize state: ".concat(minimize));
+    }
+
+    /**
+     * 设置 IPC 连接状态
+     */
+  }, {
+    key: "setIPCConnectionState",
+    value: function setIPCConnectionState(state) {
+      var previousState = this._ipcConnectionState;
+      this._ipcConnectionState = state;
+      var event = {
+        previousState: previousState,
+        currentState: state,
+        timestamp: Date.now()
+      };
+      this.logger.info("IPC connection state changed: ".concat(previousState, " -> ").concat(state));
+      this.emit('ipcConnectionStateChange', event);
+    }
+
+    /**
+     * 设置最后一次初始化参数
+     */
+  }, {
+    key: "setLastInitParams",
+    value: function setLastInitParams(params) {
+      this._lastInitParams = params;
+      this.logger.info('Last init params updated');
+    }
+
+    // ==================== 窗口操作方法 ====================
+
+    /**
+     * 显示并聚焦主窗口
+     */
+  }, {
+    key: "showAndFocusMainWindow",
+    value: function showAndFocusMainWindow() {
+      if (!this._mainWindow || this._mainWindow.isDestroyed()) {
+        this.logger.warn('Cannot show main window: window not available');
+        return;
+      }
+      this._mainWindow.show();
+      this._mainWindow.focus();
+      this._mainWindow.moveTop();
+      this.setMainWindowDisplayState(_struct.DisplayState.SHOW);
+    }
+
+    /**
+     * 隐藏主窗口
+     */
+  }, {
+    key: "hideMainWindow",
+    value: function hideMainWindow() {
+      if (!this._mainWindow || this._mainWindow.isDestroyed()) {
+        this.logger.warn('Cannot hide main window: window not available');
+        return;
+      }
+      this._mainWindow.hide();
+      this.setMainWindowDisplayState(_struct.DisplayState.HIDE);
+    }
+
+    /**
+     * 最小化主窗口
+     */
+  }, {
+    key: "minimizeMainWindow",
+    value: function minimizeMainWindow() {
+      if (!this._mainWindow || this._mainWindow.isDestroyed()) {
+        this.logger.warn('Cannot minimize main window: window not available');
+        return;
+      }
+      this._mainWindow.minimize();
+      this.setMainWindowDisplayState(_struct.DisplayState.MINIMIZE);
+    }
+
+    /**
+     * Windows 平台特殊处理：显示并置顶窗口
+     * 用于 Windows 平台的会议启动逻辑
+     */
+  }, {
+    key: "showAndFocusWithAlwaysOnTop",
+    value: function showAndFocusWithAlwaysOnTop() {
+      var _this2 = this;
+      if (!this._mainWindow || this._mainWindow.isDestroyed()) {
+        this.logger.warn('Cannot show main window: window not available');
+        return;
+      }
+      this._mainWindow.show();
+      this._mainWindow.focus();
+      this._mainWindow.moveTop();
+      this._mainWindow.setAlwaysOnTop(true, 'pop-up-menu');
+
+      // 300ms 后再次确认窗口状态
+      setTimeout(function () {
+        if (!_this2._mainWindow || _this2._mainWindow.isDestroyed()) {
+          return;
+        }
+        if (_this2._mainWindowDisplayState === _struct.DisplayState.SHOW) {
+          _this2._mainWindow.moveTop();
+          _this2._mainWindow.show();
+          _this2._mainWindow.focus();
+        }
+      }, _constants.DEFAULT_TIMEOUT);
+      this._mainWindow.setAlwaysOnTop(false, 'pop-up-menu');
+      this.setMainWindowDisplayState(_struct.DisplayState.SHOW);
+    }
+
+    /**
+     * 聚焦主窗口
+     */
+  }, {
+    key: "focusMainWindow",
+    value: function focusMainWindow() {
+      if (!this._mainWindow || this._mainWindow.isDestroyed()) {
+        this.logger.warn('Cannot focus main window: window not available');
+        return;
+      }
+      this._mainWindow.focus();
+    }
+
+    // ==================== 状态查询 ====================
+
+    /**
+     * 检查主窗口是否可用
+     */
+  }, {
+    key: "isMainWindowAvailable",
+    value: function isMainWindowAvailable() {
+      return this._mainWindow !== null && !this._mainWindow.isDestroyed();
+    }
+
+    /**
+     * 检查主窗口是否可见
+     */
+  }, {
+    key: "isMainWindowVisible",
+    value: function isMainWindowVisible() {
+      return this.isMainWindowAvailable() && this._mainWindow.isVisible() && this._mainWindowDisplayState === _struct.DisplayState.SHOW;
+    }
+
+    /**
+     * 获取状态描述
+     */
+  }, {
+    key: "getStateDescription",
+    value: function getStateDescription() {
+      return "StateManager: {\n      windowState: ".concat(this._mainWindowDisplayState, ",\n      windowReady: ").concat(this._mainWindowReady, ",\n      userMinimize: ").concat(this._userMinimize, ",\n      ipcState: ").concat(this._ipcConnectionState, ",\n      windowAvailable: ").concat(this.isMainWindowAvailable(), "\n    }");
+    }
+
+    // ==================== 清理 ====================
+
+    /**
+     * 重置所有状态
+     */
+  }, {
+    key: "reset",
+    value: function reset() {
+      this._mainWindowDisplayState = _struct.DisplayState.HIDE;
+      this._mainWindowReady = false;
+      this._userMinimize = false;
+      this._lastInitParams = '';
+      this.logger.info('StateManager reset');
+      this.emit('reset', {
+        timestamp: Date.now()
+      });
+    }
+
+    /**
+     * 清理资源
+     */
+  }, {
+    key: "release",
+    value: function release() {
+      this.removeAllListeners();
+      this._mainWindow = null;
+      this.logger.info('StateManager released');
+    }
+  }]);
+}(_events.EventEmitter);

package/lib/electron/process-manager/types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * ProcessManager 模块的类型定义
+ */
+import { BrowserWindow } from 'electron';
+/**
+ * ProcessManager 配置接口
+ */
+export interface ProcessManagerConfig {
+    /** IPC 服务器端口号，默认 50000 */
+    port?: number;
+    /** 是否为开发环境，默认 false */
+    isDev?: boolean;
+}
+/**
+ * ProcessManager 初始化状态
+ */
+export declare enum ProcessManagerState {
+    /** 未初始化 */
+    UNINITIALIZED = "uninitialized",
+    /** 已初始化 */
+    INITIALIZED = "initialized",
+    /** 已释放 */
+    RELEASED = "released"
+}
+/**
+ * ProcessManager 事件类型
+ */
+export interface ProcessManagerEvents {
+    /** 初始化完成 */
+    initialized: () => void;
+    /** 资源释放完成 */
+    released: () => void;
+    /** 发生错误 */
+    error: (error: Error) => void;
+}
+/**
+ * 窗口初始化参数
+ */
+export interface WindowInitParams {
+    /** 主窗口实例 */
+    window: BrowserWindow;
+    /** 是否强制重新初始化 */
+    force?: boolean;
+}
+/**
+ * ProcessManager 状态信息
+ */
+export interface ProcessManagerStatus {
+    /** 是否已初始化 */
+    initialized: boolean;
+    /** 是否已释放 */
+    released: boolean;
+    /** 配置信息 */
+    config: Required<ProcessManagerConfig>;
+    /** 状态描述 */
+    description: string;
+}
+/**
+ * 错误类型枚举
+ */
+export declare enum ProcessManagerErrorType {
+    /** 配置错误 */
+    CONFIG_ERROR = "CONFIG_ERROR",
+    /** 初始化错误 */
+    INIT_ERROR = "INIT_ERROR",
+    /** 窗口错误 */
+    WINDOW_ERROR = "WINDOW_ERROR",
+    /** IPC 错误 */
+    IPC_ERROR = "IPC_ERROR",
+    /** 状态错误 */
+    STATE_ERROR = "STATE_ERROR"
+}
+/**
+ * ProcessManager 自定义错误类
+ */
+export declare class ProcessManagerError extends Error {
+    type: ProcessManagerErrorType;
+    originalError?: Error | undefined;
+    constructor(type: ProcessManagerErrorType, message: string, originalError?: Error | undefined);
+}

package/lib/electron/process-manager/types.js

@@ -0,0 +1,79 @@
+"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.ProcessManagerState = exports.ProcessManagerErrorType = exports.ProcessManagerError = void 0;
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.function.name.js");
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+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 _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+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; })(); }
+/**
+ * ProcessManager 模块的类型定义
+ */
+/**
+ * ProcessManager 配置接口
+ */
+/**
+ * ProcessManager 初始化状态
+ */
+var ProcessManagerState = exports.ProcessManagerState = /*#__PURE__*/function (ProcessManagerState) {
+  /** 未初始化 */
+  ProcessManagerState["UNINITIALIZED"] = "uninitialized";
+  /** 已初始化 */
+  ProcessManagerState["INITIALIZED"] = "initialized";
+  /** 已释放 */
+  ProcessManagerState["RELEASED"] = "released";
+  return ProcessManagerState;
+}({});
+/**
+ * ProcessManager 事件类型
+ */
+/**
+ * 窗口初始化参数
+ */
+/**
+ * ProcessManager 状态信息
+ */
+/**
+ * 错误类型枚举
+ */
+var ProcessManagerErrorType = exports.ProcessManagerErrorType = /*#__PURE__*/function (ProcessManagerErrorType) {
+  /** 配置错误 */
+  ProcessManagerErrorType["CONFIG_ERROR"] = "CONFIG_ERROR";
+  /** 初始化错误 */
+  ProcessManagerErrorType["INIT_ERROR"] = "INIT_ERROR";
+  /** 窗口错误 */
+  ProcessManagerErrorType["WINDOW_ERROR"] = "WINDOW_ERROR";
+  /** IPC 错误 */
+  ProcessManagerErrorType["IPC_ERROR"] = "IPC_ERROR";
+  /** 状态错误 */
+  ProcessManagerErrorType["STATE_ERROR"] = "STATE_ERROR";
+  return ProcessManagerErrorType;
+}({});
+/**
+ * ProcessManager 自定义错误类
+ */
+var ProcessManagerError = exports.ProcessManagerError = /*#__PURE__*/function (_Error) {
+  function ProcessManagerError(type, message, originalError) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, ProcessManagerError);
+    _this = _callSuper(this, ProcessManagerError, [message]);
+    _this.type = type;
+    _this.originalError = originalError;
+    _this.name = 'ProcessManagerError';
+    return _this;
+  }
+  (0, _inherits2["default"])(ProcessManagerError, _Error);
+  return (0, _createClass2["default"])(ProcessManagerError);
+}(/*#__PURE__*/(0, _wrapNativeSuper2["default"])(Error));

package/lib/electron/sdk-helper.d.ts

@@ -1,4 +1,8 @@
+import type { FcrUIMediaConfig } from '../type';
 export declare const getBundleType: () => Promise<"JS_BUNDLE" | "NATIVE_BUNDLE">;
 export declare const onUserTokenWillExpire: () => void;
 export declare const onWidgetClicked: (widgetId: string) => void;
 export declare const onExitUiScene: () => void;
+export declare const getUIMediaConfig: () => Promise<FcrUIMediaConfig>;
+export declare const setUIMediaConfig: (mediaConfig: Partial<FcrUIMediaConfig>) => void;
+export declare const onDependencyVersionsResponse: (dependencyVersions: Record<string, string>) => void;