fcr-ui-scene 3.8.1 → 3.9.0-alpha

package/lib-es/electron/process-manager/index.js

@@ -0,0 +1,879 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.object.define-properties.js";
+import "core-js/modules/es.object.define-property.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.reflect.construct.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.date.to-json.js";
+import "core-js/modules/es.json.stringify.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/esnext.json.parse.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.timers.js";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(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; })(); }
+import { app, BrowserWindow, ipcMain } from 'electron';
+import os from 'os';
+import { EventEmitter } from 'events';
+import { getLogger } from '../logger';
+import { StateManager, IPCConnectionState } from './state-manager';
+import { EventManager } from './event-manager';
+import { IPCClient } from '../ipc/ipc';
+import { IPCMessageCMD } from '../ipc/type';
+import { AppExitCode } from '../exit-codes';
+import { DisplayState, FcrUISceneLaunchState as LaunchState, FcrUISceneLaunchEndReason } from '../struct';
+import { closeWindowBeforeLaunchSuccessErrorCode, crashedErrorCode, hangDetectionErrorCode, meetingLaunchProcessingErrorCode, windowHideErrorCode } from '../until';
+import { DEFAULT_TIMEOUT } from './constants';
+import { canShowMainWindow } from '../plugins/main-window-display';
+
+/**
+ * ProcessManager 配置
+ */
+
+/**
+ * 默认配置
+ */
+var DEFAULT_CONFIG = {
+  port: 50000,
+  isDev: false
+};
+
+/**
+ * ProcessManager 负责协调整个进程的生命周期
+ * - 管理 IPC 通信
+ * - 内部管理 stateManager 和 eventManager
+ * - 处理窗口事件
+ * - 处理 IPC 消息
+ * - 提供完整的初始化和清理流程
+ */
+export var ProcessManager = /*#__PURE__*/function (_EventEmitter) {
+  function ProcessManager() {
+    var _this;
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, ProcessManager);
+    _this = _callSuper(this, ProcessManager);
+
+    // 合并配置和默认值
+    _defineProperty(_this, "logger", getLogger());
+    // process manager 初始化状态
+    _defineProperty(_this, "isInitialized", false);
+    // process manager 释放状态
+    _defineProperty(_this, "isReleased", false);
+    _this.config = _objectSpread(_objectSpread({}, DEFAULT_CONFIG), config);
+
+    // 验证配置
+    _this._validateConfig();
+
+    // 初始化状态管理器和事件管理器
+    _this.stateManager = new StateManager();
+    _this.eventManager = new EventManager();
+
+    // 初始化 IPC 客户端
+    _this.ipcClient = new IPCClient({
+      port: _this.config.port
+    });
+    _this._setupIPCClient();
+    _this.logger.info("ProcessManager created with config: ".concat(JSON.stringify(_this.config)));
+    return _this;
+  }
+
+  /**
+   * 验证配置参数
+   */
+  _inherits(ProcessManager, _EventEmitter);
+  return _createClass(ProcessManager, [{
+    key: "_validateConfig",
+    value: function _validateConfig() {
+      if (this.config.port < 1 || this.config.port > 65535) {
+        throw new Error("Invalid port number: ".concat(this.config.port, ". Port must be between 1 and 65535."));
+      }
+      if (typeof this.config.isDev !== 'boolean') {
+        throw new Error("Invalid isDev value: ".concat(this.config.isDev, ". Musth be a boolean."));
+      }
+    }
+
+    // ==================== IPC 客户端设置 ====================
+
+    /**
+     * 设置 IPC 客户端的事件监听
+     */
+  }, {
+    key: "_setupIPCClient",
+    value: function _setupIPCClient() {
+      var _this2 = this;
+      this.ipcClient.addObserver({
+        onConnected: function onConnected() {
+          return _this2._handleIPCConnected();
+        },
+        onDisconnected: function onDisconnected() {
+          return _this2._handleIPCDisconnected();
+        },
+        onMessageReceived: function onMessageReceived(message) {
+          return _this2._handleIPCMessage(message);
+        },
+        onError: function onError(error) {
+          return _this2._handleIPCError(error);
+        }
+      });
+    }
+
+    /**
+     * IPC 连接成功处理
+     */
+  }, {
+    key: "_handleIPCConnected",
+    value: function _handleIPCConnected() {
+      this.logger.info('IPC client connected to server');
+      this.stateManager.setIPCConnectionState(IPCConnectionState.CONNECTED);
+
+      // 如果主窗口已准备就绪，通知服务器
+      if (this.stateManager.mainWindowReady) {
+        this._sendMainWindowLoaded();
+      }
+    }
+
+    /**
+     * IPC 断开连接处理
+     */
+  }, {
+    key: "_handleIPCDisconnected",
+    value: function _handleIPCDisconnected() {
+      this.logger.info('IPC client disconnected from server, closing all windows');
+      this.stateManager.setIPCConnectionState(IPCConnectionState.DISCONNECTED);
+
+      // 关闭所有窗口并退出应用
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        if (!window.isDestroyed()) {
+          window.close();
+        }
+      });
+      app.exit(AppExitCode.NORMAL_EXIT);
+    }
+
+    /**
+     * IPC 消息接收处理
+     */
+  }, {
+    key: "_handleIPCMessage",
+    value: function _handleIPCMessage(message) {
+      switch (message.cmd) {
+        case IPCMessageCMD.LaunchMeeting:
+          this._handleLaunchMeeting(message.data);
+          break;
+        case IPCMessageCMD.InitCreator:
+          this._handleInitCreator(message.data);
+          break;
+        case IPCMessageCMD.OpenSetting:
+          this._handleOpenSetting(message.data);
+          break;
+        case IPCMessageCMD.CloseSetting:
+          this._handleCloseSetting(message.data);
+          break;
+        case IPCMessageCMD.SetParameters:
+          this._handleSetParameters(message.data);
+          break;
+        case IPCMessageCMD.RenewUserToken:
+          this._handleRenewUserToken(message.data);
+          break;
+        case IPCMessageCMD.ExitUiScene:
+          this._handleExitUiScene(message.data);
+          break;
+        case IPCMessageCMD.GetDependencyVersions:
+          this._handleGetDependencyVersions(message.data);
+          break;
+        case IPCMessageCMD.ShowMainWindow:
+          this._handleShowMainWindow(message.data);
+          break;
+        default:
+          this.logger.info("CPP EVENT: Unknown command: ".concat(message.cmd));
+          break;
+      }
+    }
+
+    /**
+     * IPC 错误处理
+     */
+  }, {
+    key: "_handleIPCError",
+    value: function _handleIPCError(error) {
+      this.logger.error("IPC Error: ".concat(error));
+      this.stateManager.setIPCConnectionState(IPCConnectionState.ERROR);
+    }
+
+    // ==================== IPC 消息处理器 ====================
+
+    /**
+     * 处理启动会议消息
+     */
+  }, {
+    key: "_handleLaunchMeeting",
+    value: function _handleLaunchMeeting(data) {
+      var roomId = '';
+      // 参数是客户传递，最好是校验一下
+      if (data && typeof data.roomId === 'string') {
+        roomId = data.roomId;
+      }
+      if (!roomId) {
+        this.logger.error('roomId is required');
+        return;
+      }
+
+      // 检查当前launch状态，如果正在处理中则拒绝新的launch请求
+      if (!this.eventManager.canLaunchMeeting()) {
+        this.logger.warn("CPP EVENT: Launch request rejected: already in PROCESSING state. Current state: ".concat(LaunchState[this.eventManager.launchState]));
+
+        // 发送失败消息给客户端
+        this.ipcClient.sendMessage({
+          cmd: IPCMessageCMD.LaunchFailure,
+          data: {
+            roomId: roomId,
+            errorCode: meetingLaunchProcessingErrorCode
+          }
+        });
+        return;
+      }
+      this.eventManager.startMeetingProcess(roomId);
+      this.logger.info("CPP EVENT: LaunchMeeting: ".concat(JSON.stringify(data), ", has mainWindow ").concat(this.stateManager.isMainWindowAvailable(), ", state changed to ").concat(LaunchState[this.eventManager.launchState]));
+
+      // 显示并聚焦主窗口
+      var mainWindow = this.stateManager.mainWindow;
+      if (mainWindow) {
+        // 发送 LaunchMeeting 消息，包含当前数据和上次的初始化参数
+        mainWindow.webContents.send(IPCMessageCMD.LaunchMeeting, {
+          data: data,
+          lastInitParams: this.stateManager.lastInitParams
+        });
+        if (mainWindow.isMinimized()) {
+          this.stateManager.setRestoringFromMinimize(true);
+          mainWindow.restore();
+          return;
+        }
+
+        // Windows 平台特殊处理
+        var platform = os.platform();
+        if (platform === 'win32') {
+          this.logger.info('windows_index setAlwaysOnTop in process-manager');
+          this.stateManager.showAndFocusWithAlwaysOnTop();
+        } else {
+          this.stateManager.showAndFocusMainWindow();
+        }
+      }
+    }
+
+    /**
+     * 处理初始化创建者消息
+     */
+  }, {
+    key: "_handleInitCreator",
+    value: function _handleInitCreator(data) {
+      this.logger.info("InitCreator: ".concat(JSON.stringify(data)));
+
+      // 保存初始化参数，用于后续 LaunchMeeting 时传递
+      this.stateManager.setLastInitParams(JSON.stringify(data));
+
+      // 检查调用顺序：如果是 init -> launch 但 launch 在 PROCESSING 阶段，需要报错
+      if (this.eventManager.launchState === LaunchState.PROCESSING) {
+        this.logger.error("CPP EVENT: InitCreator call rejected: Launch is already in PROCESSING state. Please complete the current launch cycle first.");
+        return;
+      }
+      this.logger.info("InitCreator: Initialization completed");
+      try {
+        var parsedData = data;
+        if (typeof data === 'string') {
+          parsedData = JSON.parse(data);
+        }
+        if (parsedData['appUserModelId']) {
+          app.setAppUserModelId(parsedData['appUserModelId']);
+        }
+      } catch (e) {
+        this.logger.error("InitCreator: ".concat(e));
+      }
+      this._forwardMessageToRenderer(IPCMessageCMD.InitCreator, data);
+    }
+
+    /**
+     * 处理打开设置消息
+     */
+  }, {
+    key: "_handleOpenSetting",
+    value: function _handleOpenSetting(data) {
+      this.logger.info("CPP EVENT: OpenSetting: ".concat(JSON.stringify(data)));
+      this._forwardMessageToRenderer(IPCMessageCMD.OpenSetting, data);
+    }
+
+    /**
+     * 处理关闭设置消息
+     */
+  }, {
+    key: "_handleCloseSetting",
+    value: function _handleCloseSetting(data) {
+      this.logger.info("CPP EVENT: CloseSetting: ".concat(JSON.stringify(data)));
+      this._forwardMessageToRenderer(IPCMessageCMD.CloseSetting, data);
+    }
+
+    /**
+     * 处理设置参数消息
+     */
+  }, {
+    key: "_handleSetParameters",
+    value: function _handleSetParameters(data) {
+      this.logger.info("CPP EVENT: SetParameters: ".concat(JSON.stringify(data)));
+      this._forwardMessageToRenderer(IPCMessageCMD.SetParameters, data);
+    }
+
+    /**
+     * 处理更新用户令牌消息
+     */
+  }, {
+    key: "_handleRenewUserToken",
+    value: function _handleRenewUserToken(data) {
+      this.logger.info("CPP EVENT: RenewUserToken: ".concat(JSON.stringify(data)));
+      this._forwardMessageToRenderer(IPCMessageCMD.RenewUserToken, data);
+    }
+
+    /**
+     * 处理退出 UI 场景消息
+     */
+  }, {
+    key: "_handleExitUiScene",
+    value: function _handleExitUiScene(data) {
+      this.logger.info("CPP EVENT: ExitUiScene: ".concat(JSON.stringify(data)));
+      this._forwardMessageToRenderer(IPCMessageCMD.ExitUiScene, data);
+    }
+
+    /**
+     * 处理获取依赖版本消息
+     */
+  }, {
+    key: "_handleGetDependencyVersions",
+    value: function _handleGetDependencyVersions(data) {
+      this.logger.info("CPP EVENT: GetDependencyVersions: ".concat(JSON.stringify(data)));
+      this._forwardMessageToRenderer(IPCMessageCMD.GetDependencyVersions, data);
+    }
+  }, {
+    key: "_handleShowMainWindow",
+    value: function _handleShowMainWindow(data) {
+      this.logger.info("CPP EVENT: ShowMeetingWindow: ".concat(JSON.stringify(data)));
+      var mainWindow = this.stateManager.mainWindow;
+      if (!mainWindow) {
+        this.logger.error('main window not found,Or it has been destroyed and cannot handle the window closing event.');
+        return;
+      }
+      if (!canShowMainWindow) {
+        this.logger.info('main window display support is not supported, ignore this event');
+        return;
+      }
+      var platform = os.platform();
+      if (platform === 'win32') {
+        this.stateManager.showAndFocusWithAlwaysOnTop();
+      } else {
+        this.stateManager.onlyShowMainWindow();
+      }
+    }
+
+    /**
+     * 转发消息到渲染进程
+     */
+  }, {
+    key: "_forwardMessageToRenderer",
+    value: function _forwardMessageToRenderer(cmd, data) {
+      var mainWindow = this.stateManager.mainWindow;
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        this.logger.info("forwardMessageToRenderer: ".concat(cmd, ", ").concat(JSON.stringify(data)));
+        mainWindow.webContents.send(cmd, data);
+      }
+    }
+
+    // ==================== 窗口事件设置 ====================
+
+    /**
+     * 设置主窗口的事件监听
+     */
+  }, {
+    key: "setupMainWindowListeners",
+    value: function setupMainWindowListeners(mainWindow) {
+      var _this3 = this;
+      // 窗口状态事件
+      mainWindow.addListener('minimize', function () {
+        return _this3._handleWindowMinimize();
+      });
+      mainWindow.addListener('show', function () {
+        return _this3._handleWindowShow();
+      });
+      mainWindow.addListener('hide', function () {
+        return _this3._handleWindowHide();
+      });
+      mainWindow.addListener('close', function (e) {
+        return _this3._handleWindowClose(e);
+      });
+      mainWindow.addListener('closed', function () {
+        return _this3._handleWindowClosed();
+      });
+
+      // 渲染进程崩溃事件
+      mainWindow.webContents.addListener('render-process-gone', function () {
+        return _this3._handleRenderProcessGone();
+      });
+
+      // 页面加载完成事件
+      mainWindow.webContents.addListener('did-finish-load', function () {
+        return _this3._handleDidFinishLoad();
+      });
+
+      // Windows 特定事件
+      mainWindow.addListener('always-on-top-changed', function (event, alwaysOnTop) {
+        _this3.logger.info("windows_index main window always-on-top-changed: ".concat(alwaysOnTop));
+      });
+      this.logger.info('Main window listeners setup completed');
+    }
+
+    /**
+     * 处理窗口最小化事件
+     */
+  }, {
+    key: "_handleWindowMinimize",
+    value: function _handleWindowMinimize() {
+      this.logger.info('windows_release main window minimized');
+      this.stateManager.setMainWindowDisplayState(DisplayState.MINIMIZE);
+      this.stateManager.setUserMinimize(true);
+    }
+
+    /**
+     * 处理窗口显示事件
+     */
+  }, {
+    key: "_handleWindowShow",
+    value: function _handleWindowShow() {
+      this.logger.info('windows_release main window show');
+      this.stateManager.setMainWindowDisplayState(DisplayState.SHOW);
+      this.stateManager.setUserMinimize(false);
+
+      // 如果是从最小化恢复触发的show事件，不执行focus避免动画期间闪烁
+      if (this.stateManager.isRestoringFromMinimize) {
+        this.logger.info('windows_release main window show: skip focus during restore animation');
+        this.stateManager.setRestoringFromMinimize(false);
+        return;
+      }
+      this.stateManager.setRestoringFromMinimize(false);
+      this.stateManager.focusMainWindow();
+    }
+
+    /**
+     * 处理窗口隐藏事件
+     */
+  }, {
+    key: "_handleWindowHide",
+    value: function _handleWindowHide() {
+      this.logger.info("windows_release main window hidden, current launch state: ".concat(LaunchState[this.eventManager.launchState]));
+      this.logger.info("windows_release the main window is hide, all window State: ".concat(BrowserWindow.getAllWindows().map(function (windowItem) {
+        return "the window id ".concat(windowItem.id, " ").concat(windowItem.getTitle(), " ").concat(windowItem.isVisible());
+      })));
+      this.stateManager.setMainWindowDisplayState(DisplayState.HIDE);
+
+      // 如果是用户主动最小化，忽略此事件
+      if (this.stateManager.userMinimize) {
+        this.logger.info('windows_release main window hidden, but user minimize, ignore this event');
+        return;
+      }
+
+      // 只在 PROCESSING 状态下处理窗口隐藏事件
+      if (this.eventManager.launchState !== LaunchState.PROCESSING) {
+        return;
+      }
+      try {
+        var _this$stateManager$ma;
+        // 再会议启动过程中，窗口被其他窗口遮挡也会触发hide事件，实际窗口在后面运行，所以需要判断窗口是否可见
+        if ((_this$stateManager$ma = this.stateManager.mainWindow) !== null && _this$stateManager$ma !== void 0 && _this$stateManager$ma.isVisible()) {
+          getLogger().info('windows_release main window hidden, but window is visible, ignore this event');
+          return;
+        }
+      } catch (error) {
+        getLogger().error("windows_release main window hide, get main window visible error");
+      }
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.ExitedMeeting,
+        data: {
+          roomId: this.eventManager.roomId,
+          reason: windowHideErrorCode
+        }
+      });
+      this.eventManager.onExitedMeeting(this.eventManager.roomId, 'window hidden');
+    }
+
+    /**
+     * 处理窗口关闭事件
+     */
+  }, {
+    key: "_handleWindowClose",
+    value: function _handleWindowClose(e) {
+      var _this4 = this;
+      this.stateManager.setMainWindowDisplayState(DisplayState.HIDE);
+      var mainWindow = this.stateManager.mainWindow;
+      if (!mainWindow) {
+        this.logger.error('main window not found,Or it has been destroyed and cannot handle the window closing event.');
+        return;
+      }
+      var closeListenerCount = mainWindow.listenerCount('close');
+      this.logger.info("windows_release main window close listener count: ".concat(closeListenerCount, ", currentMeetingState: ").concat(this.stateManager.currentMeetingState));
+
+      // 只有在会议启动中才处理窗口关闭事件，其他状态走默认的会中逻辑
+      if (this.stateManager.currentMeetingState === 0) {
+        if (this.eventManager.launchState === LaunchState.PROCESSING) {
+          this.eventManager.onCloseWindow();
+        }
+        e.preventDefault();
+        this.logger.info('windows_release main window close event prevented');
+        this.logger.info("windows_release main window close event prevented send close-window-before-launch-success, listener count: ".concat(mainWindow.listenerCount('close-window-before-launch-success')));
+        mainWindow.webContents.send('close-window-before-launch-success');
+        this.ipcClient.sendMessage({
+          cmd: IPCMessageCMD.ExitedMeeting,
+          data: {
+            roomId: this.eventManager.roomId,
+            reason: closeWindowBeforeLaunchSuccessErrorCode
+          }
+        });
+        this.logger.info('main window close event prevented');
+        setTimeout(function () {
+          if (_this4.stateManager.isMainWindowAvailable()) {
+            _this4.stateManager.hideMainWindow();
+          }
+        }, DEFAULT_TIMEOUT);
+      }
+    }
+
+    /**
+     * 处理窗口已关闭事件
+     */
+  }, {
+    key: "_handleWindowClosed",
+    value: function _handleWindowClosed() {
+      this.logger.info('windows_release main window closed');
+      app.exit(AppExitCode.NORMAL_EXIT);
+    }
+
+    /**
+     * 处理窗口无响应事件
+     */
+  }, {
+    key: "handleWindowUnresponsive",
+    value: function handleWindowUnresponsive() {
+      this.logger.warn("main window unresponsive");
+      this.logger.error('Window hang detected, forcing exit');
+      this.eventManager.onExitedMeeting(this.eventManager.roomId, FcrUISceneLaunchEndReason.HANG_DETECTION);
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.Error,
+        data: {
+          errorCode: hangDetectionErrorCode,
+          message: 'Window hang detected, forcing exit'
+        }
+      });
+      app.exit(AppExitCode.HANG_DETECTION_EXIT);
+    }
+
+    /**
+     * 处理渲染进程崩溃事件
+     */
+  }, {
+    key: "_handleRenderProcessGone",
+    value: function _handleRenderProcessGone() {
+      var roomId = this.eventManager.roomId;
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.ExitedMeeting,
+        data: {
+          roomId: roomId,
+          reason: crashedErrorCode
+        }
+      });
+      this.eventManager.onExitedMeeting(roomId, FcrUISceneLaunchEndReason.CRASHED);
+    }
+
+    /**
+     * 处理页面加载完成事件
+     */
+  }, {
+    key: "_handleDidFinishLoad",
+    value: function _handleDidFinishLoad() {
+      this.stateManager.setMainWindowReady(true);
+      this._sendMainWindowLoaded();
+    }
+
+    // ==================== IPC Main 事件设置 ====================
+
+    /**
+     * 设置 IPC Main 事件监听
+     */
+  }, {
+    key: "setupIPCMainListeners",
+    value: function setupIPCMainListeners() {
+      var _this5 = this;
+      ipcMain.addListener('launch-success', function (_, roomId) {
+        return _this5._handleLaunchSuccess(roomId);
+      });
+      ipcMain.addListener('launch-failure', function (_, roomId, errorCode) {
+        return _this5._handleLaunchFailure(roomId, errorCode);
+      });
+      ipcMain.addListener('exited-meeting', function (_, roomId, reason) {
+        return _this5._handleExitedMeeting(roomId, reason);
+      });
+      ipcMain.addListener('widget-clicked', function (_, widgetId) {
+        return _this5._handleWidgetClicked(widgetId);
+      });
+      ipcMain.addListener('user-token-will-expire', function () {
+        return _this5._handleUserTokenWillExpire();
+      });
+      ipcMain.addListener('current-dependency-versions', function (_, dependencyVersions) {
+        return _this5._handleCurrentDependencyVersionResponse(dependencyVersions);
+      });
+      this.logger.info('IPC Main listeners setup completed');
+    }
+
+    /**
+     * 处理启动成功事件
+     */
+  }, {
+    key: "_handleLaunchSuccess",
+    value: function _handleLaunchSuccess(roomId) {
+      if (this.eventManager.launchState !== LaunchState.PROCESSING) {
+        this.logger.warn("launch-success: ".concat(roomId, ", but launch state is not PROCESSING, current state is ").concat(LaunchState[this.eventManager.launchState]));
+        return;
+      }
+      this.eventManager.onLaunchSuccess(roomId);
+      this.logger.info("launch-success: ".concat(roomId));
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.LaunchSuccess,
+        data: {
+          roomId: roomId
+        }
+      });
+    }
+
+    /**
+     * 处理启动失败事件
+     */
+  }, {
+    key: "_handleLaunchFailure",
+    value: function _handleLaunchFailure(roomId, errorCode) {
+      if (this.eventManager.launchState !== LaunchState.PROCESSING) {
+        this.logger.warn("launch-failure: ".concat(roomId, ", but launch state is not PROCESSING, current state is ").concat(LaunchState[this.eventManager.launchState]));
+        return;
+      }
+      if (!roomId || typeof roomId !== 'string') {
+        this.logger.error("Invalid roomId: ".concat(roomId));
+        return;
+      }
+      this.eventManager.onLaunchFailure(roomId, errorCode);
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.LaunchFailure,
+        data: {
+          roomId: roomId,
+          errorCode: errorCode
+        }
+      });
+    }
+
+    /**
+     * 处理退出会议事件
+     */
+  }, {
+    key: "_handleExitedMeeting",
+    value: function _handleExitedMeeting(roomId, reason) {
+      if (this.eventManager.launchState === LaunchState.END && this.eventManager.endReason === FcrUISceneLaunchEndReason.CLOSE_WINDOW) {
+        this.logger.warn("exited-meeting: ".concat(roomId, ", but launch state is END with closeWindow reason, ignore this event"));
+        return;
+      }
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.ExitedMeeting,
+        data: {
+          roomId: roomId,
+          reason: reason
+        }
+      });
+      this.eventManager.onExitedMeeting(roomId, 'exited-meeting');
+    }
+
+    /**
+     * 处理小部件点击事件
+     */
+  }, {
+    key: "_handleWidgetClicked",
+    value: function _handleWidgetClicked(widgetId) {
+      this.logger.info("widget-clicked: ".concat(widgetId));
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.WidgetClicked,
+        data: {
+          widgetId: widgetId
+        }
+      });
+    }
+
+    /**
+     * 处理用户令牌即将过期事件
+     */
+  }, {
+    key: "_handleUserTokenWillExpire",
+    value: function _handleUserTokenWillExpire() {
+      this.logger.info("user-token-will-expire");
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.TokenWillExpire,
+        data: {}
+      });
+    }
+  }, {
+    key: "_handleCurrentDependencyVersionResponse",
+    value: function _handleCurrentDependencyVersionResponse(dependencyVersions) {
+      this.logger.info("current-dependency-versions in bootstrap-sdk: ".concat(JSON.stringify(dependencyVersions)));
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.CurrentDependencyVersions,
+        data: {
+          dependencyVersions: dependencyVersions
+        }
+      });
+    }
+
+    // ==================== 辅助方法 ====================
+
+    /**
+     * 发送主窗口已加载消息
+     */
+  }, {
+    key: "_sendMainWindowLoaded",
+    value: function _sendMainWindowLoaded() {
+      this.ipcClient.sendMessage({
+        cmd: IPCMessageCMD.ElectronMainWindowLoaded,
+        data: {}
+      });
+    }
+
+    /**
+     * 获取进程状态描述
+     */
+  }, {
+    key: "getProcessDescription",
+    value: function getProcessDescription() {
+      return "ProcessManager: {\n      initialized: ".concat(this.isInitialized, ",\n      released: ").concat(this.isReleased, ",\n      config: ").concat(JSON.stringify(this.config), ",\n      ").concat(this.stateManager.getStateDescription(), ",\n      ").concat(this.eventManager.getStateDescription(), "\n    }");
+    }
+
+    // ==================== 公共接口 ====================
+
+    /**
+     * 初始化 ProcessManager
+     * @param window 主窗口实例
+     */
+  }, {
+    key: "init",
+    value: function init(window) {
+      if (this.isReleased) {
+        this.logger.error('Cannot initialize ProcessManager: already released');
+        return;
+      }
+      if (this.isInitialized) {
+        this.logger.warn('ProcessManager already initialized, skipping...');
+        return;
+      }
+      this.logger.info('ProcessManager initializing...');
+      try {
+        // 验证窗口实例
+        if (!window || window.isDestroyed()) {
+          this.logger.error('Invalid window instance provided to ProcessManager.init()');
+          return;
+        }
+        this.setMainWindow(window);
+        this.setupMainWindowListeners(window);
+        this.setupIPCMainListeners();
+        this.isInitialized = true;
+        this.logger.info('ProcessManager initialized successfully');
+      } catch (error) {
+        this.logger.error("ProcessManager initialization failed: ".concat(error));
+      }
+    }
+
+    /**
+     * 检查是否已初始化
+     */
+  }, {
+    key: "initialized",
+    get: function get() {
+      return this.isInitialized && !this.isReleased;
+    }
+
+    /**
+     * 获取配置信息
+     */
+  }, {
+    key: "getConfig",
+    value: function getConfig() {
+      return _objectSpread({}, this.config);
+    }
+
+    /**
+     * 设置主窗口
+     * 供外部调用，将主窗口设置到 StateManager
+     */
+  }, {
+    key: "setMainWindow",
+    value: function setMainWindow(window) {
+      if (this.isReleased) {
+        this.logger.error('Cannot set main window: ProcessManager already released');
+        return;
+      }
+      this.stateManager.setMainWindow(window);
+      this.logger.info('Main window set to ProcessManager');
+    }
+
+    // ==================== 清理 ====================
+
+    /**
+     * 清理所有资源
+     * 包括 stateManager、eventManager 和 processManager 自身
+     */
+  }, {
+    key: "release",
+    value: function release() {
+      if (this.isReleased) {
+        this.logger.warn('ProcessManager already released, skipping...');
+        return;
+      }
+      this.logger.info('ProcessManager releasing resources...');
+      try {
+        // 清理状态管理器
+        this.stateManager.release();
+        this.logger.info('StateManager released');
+
+        // 清理事件管理器
+        this.eventManager.release();
+        this.logger.info('EventManager released');
+
+        // 清理自身
+        // this.removeAllListeners();
+
+        // 标记为已释放
+        this.isReleased = true;
+        this.isInitialized = false;
+        this.logger.info('ProcessManager released successfully');
+      } catch (error) {
+        this.logger.error("ProcessManager release failed: ".concat(error));
+        throw error;
+      }
+    }
+  }]);
+}(EventEmitter);