fcr-ui-scene 3.7.4 → 3.7.5

package/lib/electron/sdk-helper.js

@@ -0,0 +1,238 @@
+"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.getBundleType = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.date.to-json.js");
+require("core-js/modules/es.date.to-string.js");
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/esnext.json.parse.js");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _renderer = require("electron/renderer");
+var _type = require("./ipc/type");
+// Numeric exit reason enum
+var FcrNumericExitReason = /*#__PURE__*/function (FcrNumericExitReason) {
+  FcrNumericExitReason[FcrNumericExitReason["LEAVE_ROOM"] = 1] = "LEAVE_ROOM";
+  // 自己离开而退出
+  FcrNumericExitReason[FcrNumericExitReason["CLOSE_ROOM"] = 2] = "CLOSE_ROOM";
+  // 房间关闭而退出
+  FcrNumericExitReason[FcrNumericExitReason["KICKED_OUT"] = 3] = "KICKED_OUT";
+  // 被踢出房间而退出
+  FcrNumericExitReason[FcrNumericExitReason["ABORTED"] = 4] = "ABORTED"; // 其他原因退出
+  return FcrNumericExitReason;
+}(FcrNumericExitReason || {}); // // Mapping from FcrUIExitReason to FcrNumericExitReason
+var exitReasonMap = {
+  LEAVE_ROOM: FcrNumericExitReason.LEAVE_ROOM,
+  CLOSE_ROOM: FcrNumericExitReason.CLOSE_ROOM,
+  KICKED_OUT: FcrNumericExitReason.KICKED_OUT,
+  ABORTED: FcrNumericExitReason.ABORTED
+};
+var getLaunchOptions = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", _renderer.ipcRenderer.invoke('get-launch-options'));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getLaunchOptions() {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getBundleType = exports.getBundleType = function getBundleType() {
+  return _renderer.ipcRenderer.invoke('getBundleType');
+};
+var launch = function launch(options) {
+  _renderer.ipcRenderer.invoke('launch', options);
+};
+var setInMeetingState = function setInMeetingState(state) {
+  _renderer.ipcRenderer.send('set-in-meeting-state', state);
+};
+var initSDK = function initSDK(options) {
+  _renderer.ipcRenderer.invoke('initSDK', options);
+};
+var openSetting = function openSetting() {
+  _renderer.ipcRenderer.invoke('openSetting');
+};
+var getIsSDKReady = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    return _regenerator["default"].wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 1;
+          return _renderer.ipcRenderer.invoke('getIsSDKReady');
+        case 1:
+          return _context2.abrupt("return", _context2.sent);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function getIsSDKReady() {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var launchSuccess = function launchSuccess(roomId) {
+  _renderer.ipcRenderer.send('launch-success', roomId);
+};
+var exitedMeeting = function exitedMeeting(roomId, reason) {
+  var numericReason = exitReasonMap[reason];
+  _renderer.ipcRenderer.send('exited-meeting', roomId, numericReason);
+};
+var launchFailure = function launchFailure(roomId, errorCode) {
+  _renderer.ipcRenderer.send('launch-failure', roomId, errorCode);
+};
+var setParameters = function setParameters(parameters) {
+  _renderer.ipcRenderer.send('set-parameters', parameters);
+};
+var getIsMeetingLaunched = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+    return _regenerator["default"].wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 1;
+          return _renderer.ipcRenderer.invoke('getIsMeetingLaunched');
+        case 1:
+          return _context3.abrupt("return", _context3.sent);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function getIsMeetingLaunched() {
+    return _ref3.apply(this, arguments);
+  };
+}();
+var refreshUserToken = function refreshUserToken(token) {
+  _renderer.ipcRenderer.send('refresh-user-token', token);
+};
+var cppSdkHelper = {
+  getLaunchOptions: getLaunchOptions,
+  getBundleType: getBundleType,
+  launch: launch,
+  setInMeetingState: setInMeetingState,
+  initSDK: initSDK,
+  openSetting: openSetting,
+  getIsSDKReady: getIsSDKReady,
+  launchSuccess: launchSuccess,
+  launchFailure: launchFailure,
+  setParameters: setParameters,
+  getIsMeetingLaunched: getIsMeetingLaunched,
+  refreshUserToken: refreshUserToken,
+  exitedMeeting: exitedMeeting
+};
+// @ts-ignore
+window.cppSdkHelper = cppSdkHelper;
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.InitCreator, function (_event, value) {
+  if (cppSdkHelper.onCreatorInit) {
+    var data = value;
+    try {
+      if (typeof value == 'string') {
+        data = JSON.parse(value);
+      }
+    } catch (e) {
+      console.error('Failed to parse init options:', e);
+    }
+    cppSdkHelper.onCreatorInit(data);
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.OpenSetting, function (_event, value) {
+  if (cppSdkHelper.onSettingOpen) {
+    cppSdkHelper.onSettingOpen();
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.CloseSetting, function (_event, value) {
+  if (cppSdkHelper.onSettingClose) {
+    cppSdkHelper.onSettingClose();
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.SetParameters, function (_event, value) {
+  if (cppSdkHelper.onSetParameters) {
+    cppSdkHelper.onSetParameters(value);
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.LaunchMeeting, function (_event, value) {
+  console.log('LaunchMeeting in sdk-helper', value);
+  if (cppSdkHelper.onLaunchMeeting) {
+    var data = value;
+    try {
+      if (typeof value == 'string') {
+        data = JSON.parse(value);
+      }
+    } catch (e) {
+      console.error("windows_release Failed to parse launch options:, ".concat(JSON.stringify(e), ", typeof value: ").concat((0, _typeof2["default"])(value), ", value: ").concat(value));
+    }
+    cppSdkHelper.onLaunchMeeting(data);
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.RenewUserToken, function (_event, value) {
+  if (cppSdkHelper.onRenewUserToken) {
+    cppSdkHelper.onRenewUserToken(value);
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.ExitUiScene, function (_event, value) {
+  if (cppSdkHelper.exitUiScene) {
+    cppSdkHelper.exitUiScene();
+  }
+});
+_renderer.ipcRenderer.on('sdk-ready', function () {
+  if (cppSdkHelper.onSDKReady) {
+    cppSdkHelper.onSDKReady();
+  }
+});
+_renderer.ipcRenderer.on('launch-failure', function (_event, roomId, errorCode) {
+  if (cppSdkHelper.onLaunchFailure) {
+    cppSdkHelper.onLaunchFailure(roomId, errorCode);
+  }
+});
+_renderer.ipcRenderer.on('close-window-before-launch-success', function () {
+  console.log('windows_release Received close-window-before-launch-success event', new Date().toLocaleTimeString());
+  if (cppSdkHelper.exitUiScene) {
+    cppSdkHelper.exitUiScene();
+  }
+});
+_renderer.ipcRenderer.on('exited-meeting', function (_event, roomId, reason) {
+  if (cppSdkHelper.onExitedMeeting) {
+    cppSdkHelper.onExitedMeeting(roomId, reason);
+  }
+});
+_renderer.ipcRenderer.on('refresh-user-token', function () {
+  if (cppSdkHelper.onRefreshUserToken) {
+    cppSdkHelper.onRefreshUserToken();
+  }
+});
+_renderer.ipcRenderer.on('launch-success', function (_event, roomId) {
+  if (cppSdkHelper.onLaunchSuccess) {
+    cppSdkHelper.onLaunchSuccess(roomId);
+  }
+});
+
+// 添加其他可能需要的 IPC 监听器
+_renderer.ipcRenderer.on('widget-clicked', function (_event, widgetId) {
+  if (cppSdkHelper.onWidgetClicked) {
+    cppSdkHelper.onWidgetClicked(widgetId);
+  }
+});
+_renderer.ipcRenderer.on('user-token-will-expire', function () {
+  if (cppSdkHelper.onUserTokenWillExpire) {
+    cppSdkHelper.onUserTokenWillExpire();
+  }
+});
+_renderer.ipcRenderer.on('exit-ui-scene', function () {
+  if (cppSdkHelper.onExitUiScene) {
+    cppSdkHelper.onExitUiScene();
+  }
+});

package/lib/electron/struct.d.ts

@@ -0,0 +1,12 @@
+export declare enum FcrUISceneLaunchState {
+    DEFAULT = 0,
+    PROCESSING = 1,
+    END = 2
+}
+export declare enum FcrUISceneLaunchEndReason {
+    LAUNCH_SUCCESS = "launchSuccess",
+    LAUNCH_FAILURE = "launchFailure",
+    CLOSE_WINDOW = "closeWindow",
+    EXITED = "exited",
+    CRASHED = "crashed"
+}

package/lib/electron/struct.js

@@ -0,0 +1,21 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUISceneLaunchState = exports.FcrUISceneLaunchEndReason = void 0;
+var FcrUISceneLaunchState = exports.FcrUISceneLaunchState = /*#__PURE__*/function (FcrUISceneLaunchState) {
+  FcrUISceneLaunchState[FcrUISceneLaunchState["DEFAULT"] = 0] = "DEFAULT";
+  FcrUISceneLaunchState[FcrUISceneLaunchState["PROCESSING"] = 1] = "PROCESSING";
+  FcrUISceneLaunchState[FcrUISceneLaunchState["END"] = 2] = "END";
+  return FcrUISceneLaunchState;
+}({});
+var FcrUISceneLaunchEndReason = exports.FcrUISceneLaunchEndReason = /*#__PURE__*/function (FcrUISceneLaunchEndReason) {
+  FcrUISceneLaunchEndReason["LAUNCH_SUCCESS"] = "launchSuccess";
+  FcrUISceneLaunchEndReason["LAUNCH_FAILURE"] = "launchFailure";
+  FcrUISceneLaunchEndReason["CLOSE_WINDOW"] = "closeWindow";
+  FcrUISceneLaunchEndReason["EXITED"] = "exited";
+  FcrUISceneLaunchEndReason["CRASHED"] = "crashed";
+  return FcrUISceneLaunchEndReason;
+}({});

package/lib/electron/until.d.ts

@@ -0,0 +1,28 @@
+declare enum ServiceErrorCode {
+    FcrUIScene = 800
+}
+declare enum UISceneErrorCode {
+    Creator = 10,
+    ProcessManager = 11
+}
+declare enum DetailErrorCode {
+    unknown = 1,
+    invalidParams = 10,
+    jsonParseError = 11,
+    localHttpRequestFailed = 12,
+    notLoggedIn = 13,
+    notJoinedRoom = 14,
+    expired = 15,
+    systemNotAuthorized = 16,
+    deviceNotAuthorized = 17,
+    apDetectionFailed = 51,
+    processLaunchFailed = 81,
+    mainWindowHidden = 82,
+    closeWindowBeforeLaunchSuccess = 83,
+    meetingLaunchProcessing = 84
+}
+export declare const generaErrorCode: (serviceCode: ServiceErrorCode, uiSceneCode: UISceneErrorCode, detailCode: DetailErrorCode) => number;
+export declare const windowHideErrorCode: number;
+export declare const closeWindowBeforeLaunchSuccessErrorCode: number;
+export declare const meetingLaunchProcessingErrorCode: number;
+export {};

package/lib/electron/until.js

@@ -0,0 +1,54 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.windowHideErrorCode = exports.meetingLaunchProcessingErrorCode = exports.generaErrorCode = exports.closeWindowBeforeLaunchSuccessErrorCode = void 0;
+// 错误代码枚举定义
+var ServiceErrorCode = /*#__PURE__*/function (ServiceErrorCode) {
+  ServiceErrorCode[ServiceErrorCode["FcrUIScene"] = 800] = "FcrUIScene";
+  return ServiceErrorCode;
+}(ServiceErrorCode || {});
+var UISceneErrorCode = /*#__PURE__*/function (UISceneErrorCode) {
+  UISceneErrorCode[UISceneErrorCode["Creator"] = 10] = "Creator";
+  UISceneErrorCode[UISceneErrorCode["ProcessManager"] = 11] = "ProcessManager";
+  return UISceneErrorCode;
+}(UISceneErrorCode || {});
+var DetailErrorCode = /*#__PURE__*/function (DetailErrorCode) {
+  // 未定义错误
+  DetailErrorCode[DetailErrorCode["unknown"] = 1] = "unknown";
+  // 参数错误
+  DetailErrorCode[DetailErrorCode["invalidParams"] = 10] = "invalidParams";
+  // Json解析错误
+  DetailErrorCode[DetailErrorCode["jsonParseError"] = 11] = "jsonParseError";
+  // 本地Http请求失败（包括超时、DNS解析失败，未连接网络等本地异常）
+  DetailErrorCode[DetailErrorCode["localHttpRequestFailed"] = 12] = "localHttpRequestFailed";
+  // 未登录
+  DetailErrorCode[DetailErrorCode["notLoggedIn"] = 13] = "notLoggedIn";
+  // 未加入房间
+  DetailErrorCode[DetailErrorCode["notJoinedRoom"] = 14] = "notJoinedRoom";
+  // 过期
+  DetailErrorCode[DetailErrorCode["expired"] = 15] = "expired";
+  // 系统未授权
+  DetailErrorCode[DetailErrorCode["systemNotAuthorized"] = 16] = "systemNotAuthorized";
+  // 设备、系统没有授权
+  DetailErrorCode[DetailErrorCode["deviceNotAuthorized"] = 17] = "deviceNotAuthorized";
+  // AP探测失败
+  DetailErrorCode[DetailErrorCode["apDetectionFailed"] = 51] = "apDetectionFailed";
+  // 进程启动失败
+  DetailErrorCode[DetailErrorCode["processLaunchFailed"] = 81] = "processLaunchFailed";
+  // 窗口隐藏
+  DetailErrorCode[DetailErrorCode["mainWindowHidden"] = 82] = "mainWindowHidden";
+  // 窗口在会议启动前关闭
+  DetailErrorCode[DetailErrorCode["closeWindowBeforeLaunchSuccess"] = 83] = "closeWindowBeforeLaunchSuccess";
+  // 会议启动中
+  DetailErrorCode[DetailErrorCode["meetingLaunchProcessing"] = 84] = "meetingLaunchProcessing";
+  return DetailErrorCode;
+}(DetailErrorCode || {}); // 格式：ServiceErrorCode(3位) + UISceneErrorCode(3位) + DetailErrorCode(3位)
+var generaErrorCode = exports.generaErrorCode = function generaErrorCode(serviceCode, uiSceneCode, detailCode) {
+  return serviceCode * 1000000 + uiSceneCode * 1000 + detailCode;
+};
+var windowHideErrorCode = exports.windowHideErrorCode = generaErrorCode(ServiceErrorCode.FcrUIScene, UISceneErrorCode.Creator, DetailErrorCode.mainWindowHidden);
+var closeWindowBeforeLaunchSuccessErrorCode = exports.closeWindowBeforeLaunchSuccessErrorCode = generaErrorCode(ServiceErrorCode.FcrUIScene, UISceneErrorCode.Creator, DetailErrorCode.closeWindowBeforeLaunchSuccess);
+var meetingLaunchProcessingErrorCode = exports.meetingLaunchProcessingErrorCode = generaErrorCode(ServiceErrorCode.FcrUIScene, UISceneErrorCode.Creator, DetailErrorCode.meetingLaunchProcessing);

package/lib/electron/window-proxy/browser-window-proxy.d.ts

@@ -0,0 +1,63 @@
+import { BrowserWindowProxy } from '../../runtime';
+/**
+ * BrowserWindow 代理类
+ * 通过 IPC 通信与主进程中的 BrowserWindow 进行交互
+ */
+export declare class BrowserWindowProxyImpl implements BrowserWindowProxy {
+    private _windowId;
+    private _eventListeners;
+    private _isDestroyed;
+    private _runtimeEventListener;
+    constructor(windowId: string);
+    get windowId(): string;
+    /**
+     * 检查窗口是否已销毁
+     */
+    isDestroyed(): boolean;
+    moveTop(): Promise<void>;
+    setPosition(x: number, y: number): Promise<void>;
+    getPosition(): Promise<[number, number]>;
+    close(): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    focus(): Promise<void>;
+    maximize(): Promise<void>;
+    unmaximize(): Promise<void>;
+    isVisible(): Promise<boolean>;
+    isMaximized(): Promise<boolean>;
+    isFullScreen(): Promise<boolean>;
+    getTitle(): Promise<string>;
+    getBounds(): Promise<Electron.Rectangle>;
+    /**
+     * 窗口设置方法
+     */
+    setBounds(bounds: Electron.Rectangle): Promise<void>;
+    setFullScreen(fullscreen: boolean): Promise<void>;
+    setIgnoreMouseEvents(ignore: boolean, options?: {
+        forward: boolean;
+    }): Promise<void>;
+    setAlwaysOnTop(flag: boolean, level?: 'normal' | 'floating' | 'torn-off-menu' | 'modal-panel' | 'main-menu' | 'status' | 'pop-up-menu' | 'screen-saver', relativeLevel?: number): Promise<void>;
+    setPreventClose(prevent: boolean): Promise<void>;
+    /**
+     * 事件监听方法
+     */
+    addListener(event: string, listener: Function): void;
+    removeListener(event: string, listener: Function): void;
+    removeAllListeners(event?: string): void;
+    /**
+     * 销毁代理对象
+     */
+    destroy(): void;
+    /**
+     * 私有方法
+     */
+    private _sendIpcRequest;
+    private _registerEventListener;
+    private _unregisterEventListener;
+    private _setupEventListener;
+    private _removeEventListener;
+    private _handleWindowEvent;
+    private _mapEventActionToName;
+    private _addBrowserWindowEventListener;
+    private _removeBrowserWindowEventListener;
+}