@plasosdk/plaso-electron-sdk 1.3.16-beta.0 → 1.3.17-beta.0

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+    "printWidth": 130,
+    "tabWidth": 4,
+    "semi": true,
+    "singleQuote": true,
+    "bracketSpacing": true,
+    "arrowParens": "always"
+}

package/README.md

@@ -200,6 +200,7 @@ interface CreateClassWindowPamras {
     onGetExtFileNameFn?: (info: any[], ...args: any[]) => Promise<string>;
     onGetPreParseFileNameFn?: (info: any[], option: { suffix: string }) => Promise<string>;
     onReportIssuesFn?: (Issues: any) => void;
+    browserOptions?: BrowserOptionsType;
 }
 ```
 
@@ -245,6 +246,8 @@ interface ILiveClassOptions {
     residentCamera?: boolean;
     /** 是否启用日志上传。默认启用，进入和退出课堂时自动将日志上传至伯索服务器。 */
     enableUploadLog?: boolean;
+    /** 是否启用课堂内置浏览器工具 */
+    enableBrowser?: boolean;
 }
 
 interface UserInfo {
@@ -274,6 +277,7 @@ interface UserInfo {
 | supportSaveBoard | 否 | boolean | 是否启用保存板书，启用后工具箱中显示`保存当页板书`按钮，需要配合云盘使用。默认不启用。 |
 | residentCamera | 否 | boolean | 是否启用常驻摄像头：只对学生或游客生效。启用后学生进入课堂后摄像头常驻开启，没有开启摄像头权限时也会开启。默认不启用。 |
 | enableUploadLog | 否 | boolean | 是否启用日志自动上传。默认启用，退出课堂时 SDK 会自动将日志文件压缩并上传至伯索日志服务器，便于问题排查。传入 `false` 可关闭。 |
+| enableBrowser | 否 | boolean | 是否启用课堂内置浏览器工具。启用后课堂工具栏将显示浏览器入口，需配合 `browserOptions` 使用以对接外部收藏数据。默认不启用。 |
 
 <a id="query"></a>
 **query属性说明**
@@ -520,6 +524,20 @@ interface Issues {
 type onReportIssuesFn = (info: any) => void;
 ```
 
+##### browserOptions
+
+课堂内置浏览器相关配置，用于对接外部的书签功能。需要同时在 `classOptions` 中传入 `enableBrowser: true` 才能启用内置浏览器。
+
+```ts
+type BrowserOptionsType = {
+    /** 获取自定义分类列表的回调。返回分类数组，每个分类包含名称和该分类下的书签列表 */
+    onFetchCategoriesFn?: () => Promise<
+        | { success: true; data: { name: string; bookmarks: { title: string; url: string; icon: string }[] }[] }
+        | { success: false; message?: string }
+    >;
+};
+```
+
 #### API参考
 
 ##### PlasoElectronSdk.initLogConfig

package/js/macro.js

@@ -37,6 +37,14 @@ const CLASS_WINDOW_MESG_TYPE = {
     GET_PRE_PARSE_FILE_NAME: 'getPreParseFileName',
     /** 上报问题 */
     REPORT_ISSUES: 'reportIssues',
+    /** 浏览器-获取收藏列表 */
+    FETCH_FAVORITES: 'fetchFavorites',
+    /** 浏览器-获取分类列表 */
+    FETCH_CATEGORIES: 'fetchCategories',
+    /** 浏览器-添加收藏 */
+    ADD_FAVORITE: 'addFavorite',
+    /** 浏览器-删除收藏 */
+    REMOVE_FAVORITE: 'removeFavorite',
 
     // >>>>>>> 发送的消息 >>>>>>>
     /** html ready */
@@ -49,10 +57,12 @@ const CLASS_WINDOW_MESG_TYPE = {
     INSERT_BOARD: 'insert_board',
     /** 插入文件 */
     INSERT_OBJECT: 'insertObject',
-    /** 响应getExtFileName */
     RESP_GET_EXT_FILE_NAME: 'respGetExtFileName',
-    /** 响应getPreParseFileName */
     RESP_GET_PRE_PARSE_FILE_NAME: 'respGetPreParseFileName',
+    RESP_FETCH_FAVORITES: 'respFetchFavorites',
+    RESP_FETCH_CATEGORIES: 'respFetchCategories',
+    RESP_ADD_FAVORITE: 'respAddFavorite',
+    RESP_REMOVE_FAVORITE: 'respRemoveFavorite',
 };
 
 const LEVEL = {

package/js/main.js

@@ -1,6 +1,6 @@
 const isElectron = !!process.versions['electron'];
 if (isElectron) {
-    try {        
+    try {
         require('@plasosdk/winproxy');
         require('@plasosdk/screenshot');
     } catch (error) {

package/js/render.d.ts

@@ -0,0 +1,98 @@
+export interface ClassOptionsType {
+    /** 是否开启课堂窗口debug模式 */
+    debug?: boolean;
+    /** 进课堂的必备query */
+    query: string;
+    /** 格式参考：1.53.901 */
+    version?: string;
+    env?: string;
+    appType?: string;
+    classType?: string;
+    topic?: string;
+    loginName?: string;
+    memoryConfigKey?: string;
+    /** 是否启用浏览器工具 */
+    enableBrowser?: boolean;
+    [key: string]: any;
+}
+
+export interface FileParams {
+    /** 备课文件本地地址 */
+    filePath: string[];
+    fileType: 'png' | 'pb' | string;
+}
+
+export interface ClassWindowType {
+    classOptions: ClassOptionsType;
+    /** 自定义electron的窗口参数 */
+    electronWinOptions?: object;
+    /** 课堂窗口打开渲染成功后的回调 */
+    onClassWindowReadyFn?: (winId: number) => void;
+    /** 课堂窗口关闭后的回调 */
+    onClassWindowLeaveFn?: (winId: number) => void;
+    /** 课堂结束后的回调 */
+    onClassFinishedFn?: (meetingId: string) => void;
+    /**
+     * 保存板书，具体的保存逻辑由外部实现。
+     * 取消保存板书时，callback 传 false，否则传 true
+     */
+    onSaveBoardFn?: (params: { fileInfo: FileParams[]; fileName?: string }, callback: (result: boolean) => void) => void;
+    /** 通知外部用户打开自己的资料中心 */
+    onOpenResourceCenterFn?: () => void;
+    /** 通过 insertObject 插入的文件时，从 info 中获取文件可访问地址 */
+    onGetExtFileNameFn?: (info: any, option: any) => Promise<string>;
+    /** 类似 onGetExtFileNameFn，获取的是预解析文件地址 */
+    onGetPreParseFileNameFn?: (info: any, option: { suffix: string }) => Promise<string>;
+    /** 上报问题，具体的上报逻辑由外部实现 */
+    onReportIssuesFn?: (info: { time: string; id: string; name: string; bugDescription: string }) => void;
+    /** 浏览器工具相关配置 */
+    browserOptions?: BrowserOptionsType;
+}
+
+type BrowserOptionsType = {
+    /** 获取自定义分类 */
+    onFetchCategoriesFn?: () => Promise<
+        | { success: true; data: { name: string; bookmarks: { title: string; url: string; icon: string }[] }[] }
+        | { success: false; message?: string }
+    >;
+    // 出于鉴权方面考量，收藏功能暂不对外
+    /** @deprecated 获取"我的收藏"列表 */
+    onFetchFavoritesFn?: () => Promise<
+        { success: true; data: { id: number; title: string; url: string; icon: string }[] } | { success: false; message?: string }
+    >;
+    /** @deprecated 添加收藏 */
+    onAddFavoriteFn?: (value: {
+        url: string;
+        title: string;
+    }) => Promise<
+        { success: true; data: { id: number; title: string; url: string; icon: string } } | { success: false; message?: string }
+    >;
+    /** @deprecated 删除收藏 */
+    onRemoveFavoriteFn?: (ids: number[]) => Promise<{ success: boolean; message?: string }>;
+};
+
+export interface FileDataObj {
+    /** 插入文件的格式，内容参考 FILE_TYPE */
+    type: number;
+    /** 文件名称，传入后会显示在文件窗口标题栏上，建议带上文件后缀名 */
+    title?: string;
+    /** 公开访问权限的文件全地址，建议 https 协议全地址 */
+    url?: string;
+    /** 具体的文件信息，除备课外，内容都由用户自己定义 */
+    info?: any[];
+}
+
+export type BuildReplyingCallback = <TArgs extends any[] = any[], TResult = any>(config: {
+    requestMsgType: string;
+    responseMsgType?: string;
+    /** 返回 false 时跳过后续流程 */
+    beforeCallback?: (...args: TArgs) => boolean | void;
+    /** 不传时跳过后续流程 */
+    callback?: (...args: TArgs) => TResult | Promise<TResult>;
+    /** 返回 false 时跳过后续流程 */
+    afterCallback?: (result: TResult) => boolean | void;
+}) => {
+    requestMsgType: string;
+    responseMsgType: string;
+    handler: (event: any, requestId: string, ...args: TArgs) => Promise<void>;
+};

package/js/render.js

@@ -1,65 +1,23 @@
-const LogFormatter = require('../scripts/logger');
 const path = require('path');
-const { getElectronRemote, parseUrlParams, getEnvironment, getDisplayMatching } = require('./util');
+const { ERROR_CODE, LESSON_TYPE, CLASS_WINDOW_MESG_TYPE, RENDER_TO_MAIN_MESG_TYPE, FILE_TYPE } = require('./macro');
+const getConfig = require('../scripts/getConfig');
+const LogFormatter = require('../scripts/logger');
+const { getElectronRemote, parseUrlParams, getDisplayMatching } = require('./util');
+
 const remote = getElectronRemote();
-const defaultLoggerPath = remote ? path.join(remote.app.getPath('userData'), '/P403FileTemp/') : '';
+const isMac = getConfig().platform === 'darwin';
 
+// logger
+const defaultLoggerPath = remote ? path.join(remote.app.getPath('userData'), '/P403FileTemp/') : '';
 const logger = new LogFormatter(defaultLoggerPath);
 logger.init();
-const getConfig = require('../scripts/getConfig');
-
-const { platform } = getConfig();
-
-const isMac = platform === 'darwin';
-
-const { ERROR_CODE, LESSON_TYPE, CLASS_WINDOW_MESG_TYPE, RENDER_TO_MAIN_MESG_TYPE, FILE_TYPE } = require('./macro');
 
 let currentWinId = null;
-
 let currentWebContentsId = null;
 
 /**
- * @typedef {Object} classOptionsType
- * @property {boolean} [debug] - 是否开启课堂窗口debug模式
- * @property {string} query - 进课堂的必备query
- * @property {string} [version] - 格式参考：1.53.901
- */
-
-/**
- * @typedef {Object} FileParams
- * @property {string[]} filePath - 备课文件本地地址
- * @property {'png' | 'pb' | string} fileType
- */
-
-/**
- * @typedef {Object} classWindowType
- * @property {classOptionsType} classOptions 进课堂参数对象
- * @property {Object} [electronWinOptions] 自定义electron的窗口参数
- * @property {(winId: number)=>void} [onClassWindowReadyFn] 课堂窗口打开渲染成功后的回调
- * @property {(winId: number)=>void} [onClassWindowLeaveFn] 课堂窗口关闭后的回调
- * @property {(meetingId: string)=>void} [onClassFinishedFn] 课堂结束后的回调
- * @property {(
- *   params: {
- *     fileInfo: FileParams[],
- *     fileName?: string
- *   },
- *   callback: (result: boolean) => void
- * ) => void} [onSaveBoardFn] 保存板书，具体的保存逻辑由外部实现，取消保存板书时，callback传false, 不然传true
- * @property {()=>void} [onOpenResourceCenterFn] 通知外部用户打开自己的资料中心，资料中心的具体ui和逻辑由外部用户自己实现
- * @property {(info: any, option: any)=>Promise<string>} [onGetExtFileNameFn] 通过insertObject插入的文件传入 参数 info 时，怎么从info中获取文件的可访问地址的逻辑在用户那，所以需要函数从外部用户获取外部用户传入的文件地址
- * @property {(info: any, option: { suffix: string })=>Promise<string>} [onGetPreParseFileNameFn] 类似onGetExtFileNameFn，只是获取的文件地址是预解析文件地址，通过suffix得到预解析文件路径
- * @property {(info: {
- *   time: string;
- *   id: string;
- *   name: string;
- *   bugDescription: string;
- * })=>void} [onReportIssuesFn] 上报问题，具体的上报逻辑由外部实现
- *
- */
-
-/**
- * @param {classWindowType} classWindowProps
- * @returns
+ * @param {import('./render').ClassWindowType} classWindowProps
+ * @returns {number}
  */
 function createClassWindow(classWindowProps) {
     const {
@@ -75,345 +33,375 @@ function createClassWindow(classWindowProps) {
         onReportIssuesFn,
     } = classWindowProps;
 
-    logger.info(
-        `课堂窗口创建信息: version is ${getVersion()}, classOptions is ${JSON.stringify(classOptions)},electronWinOptions is ${JSON.stringify(
-            electronWinOptions,
-        )}`,
-    );
+    const onFetchFavoritesFn = classWindowProps.browserOptions?.onFetchFavoritesFn;
+    const onFetchCategoriesFn = classWindowProps.browserOptions?.onFetchCategoriesFn;
+    const onAddFavoriteFn = classWindowProps.browserOptions?.onAddFavoriteFn;
+    const onRemoveFavoriteFn = classWindowProps.browserOptions?.onRemoveFavoriteFn;
+
+    logger.info('课堂窗口创建信息', {
+        version: getVersion(),
+        classOptions: classOptions,
+        electronWinOptions: electronWinOptions,
+    });
+
+    /* ----------------------------------- 守卫 ----------------------------------- */
     if (currentWinId) {
         logger.warn('课堂窗口同时仅能存在一个');
         return ERROR_CODE.CLASS_WINODW_GREATER_THAN_ONE;
     }
 
     const isElectron = !!process?.versions?.['electron'];
-    if (isElectron) {
-        try {
-            const appProxy = require('@plasosdk/winproxy');
-            const { ipcRenderer } = window.require('electron');
-            const displayInfo = getDisplayMatching();
+    if (!isElectron) {
+        logger.error('非 Electron 环境');
+        return ERROR_CODE.NO_ELECTRON_ENVIRONMENT;
+    }
 
-            if (remote && displayInfo) {
-                const webContents = remote.getCurrentWebContents();
-                const win = remote.getCurrentWindow();
+    if (!remote) {
+        logger.error('获取 remote 失败');
+        return ERROR_CODE.GET_REMOTE_FAIL;
+    }
 
-                /**----------------------------------------------------课堂入参相关-----------------------------------*/
+    const displayInfo = getDisplayMatching();
+    if (!displayInfo) {
+        logger.error('获取 displayInfo 失败');
+        return ERROR_CODE.GET_DISPLAY_INFO_FAIL;
+    }
 
-                const classInfo = classOptions.query ? parseUrlParams(classOptions.query) : {};
+    /* ---------------------------- 拼凑 globalAppInfo ---------------------------- */
+    const openerId = remote.getCurrentWebContents().id;
+    const queryObj = classOptions.query ? parseUrlParams(classOptions.query) : {};
+    const autoMaximized = true;
+    const env = classOptions.env ? classOptions.env.toLowerCase() : 'www';
+
+    const getHost = () => {
+        let rhost, dhost;
+        switch (env) {
+            case 'local':
+                rhost = 'http://localhost:4399/';
+                dhost = 'https://dev.plaso.cn/';
+                break;
+            case 'dev':
+                rhost = `https://${env}.plaso.cn/static/yxtelectronsdk/`;
+                dhost = `https://${env}.plaso.cn/`;
+                break;
+            case 'test':
+            case 'itest':
+            case 'ftest':
+                rhost = `https://${env}.plaso.cn/static/yxtsdk/`;
+                dhost = `https://${env}.plaso.cn/`;
+                break;
+            default:
+                rhost = `https://wwwr.plaso.cn/static/sdk/styleupime/${classOptions.version ?? '1.60.139'}/`;
+                dhost = 'https://www.plaso.cn/';
+                break;
+        }
+        return { rhost, dhost };
+    };
 
-                const autoMaximized = true;
-                /** 课堂最大化按钮是否是切换全屏模式 */
-                let fullScreenable = false;
-                if (classInfo.userType === 'listener') {
-                    fullScreenable = true;
-                }
+    const globalAppInfo = {
+        ...classOptions,
+        ...queryObj,
+        ...getHost(),
+        query: classOptions.query,
+        appType: classOptions.appType,
+        markString: env,
+        env,
+        classType: classOptions.classType,
+        onClose: 'close', // 让课堂里退出时标识状态，详情见commFunction.js
+        electronSdkLoggerPath: logger.loggerPath ?? '',
+        electronSdkLoggerName: logger.logFileName ?? '',
+        flameshotPath: isMac
+            ? path.join(__dirname, '../lib/flameshot.app/Contents/MacOS/flameshot')
+            : path.join(__dirname, '../lib/flameshot/flameshot.exe'),
+        PlasoALDPath: isMac //
+            ? path.join(__dirname, '../lib/PlasoALD')
+            : '',
+        clientType: 'electron',
+        isElectronSdk: true,
+        openerId,
+        memoryConfigKey: classOptions.memoryConfigKey ?? queryObj.loginName ?? classOptions.loginName ?? '',
+        maximized: autoMaximized,
+        fullScreenable: queryObj.userType === 'listener', // 课堂最大化按钮是否是切换全屏模式
+        supportOnReportIssues: !!onReportIssuesFn,
+        supportOnFetchFavorites: !!onFetchFavoritesFn,
+        supportOnFetchCategories: !!onFetchCategoriesFn,
+        supportOnAddFavorite: !!onAddFavoriteFn,
+        supportOnRemoveFavorite: !!onRemoveFavoriteFn,
+    };
+
+    if (globalAppInfo.userType === 'monitor') {
+        globalAppInfo.monitor = true;
+    }
 
-                // 环境确认
-                const env = classOptions.env ? classOptions.env.toLowerCase() : 'www';
-                let rhost, dhost;
-                if (env == 'local') {
-                    rhost = 'http://localhost:4399/';
-                    dhost = 'https://dev.plaso.cn/';
-                } else if (env == 'dev') {
-                    rhost = `https://${env}.plaso.cn/static/yxtelectronsdk/`;
-                    dhost = `https://${env}.plaso.cn/`;
-                } else if (env == 'test' || env == 'itest' || env == 'ftest') {
-                    rhost = `https://${env}.plaso.cn/static/yxtsdk/`;
-                    dhost = `https://${env}.plaso.cn/`;
+    /* ------------------------------ electron 窗口配置 ----------------------------- */
+    const buildElectronWinOptions = () => {
+        const buildBounds = () => {
+            const bounds = remote.getCurrentWindow().getBounds();
+            const screenWidth = displayInfo.size.width;
+            const screenWorkAreaWidth = displayInfo.workAreaSize.width;
+            const screenHeight = displayInfo.size.height;
+            const screenWorkAreaHeight = displayInfo.workAreaSize.height;
+
+            const changeBoundsDate = (ischangeWidth, baseWidthOrHeight) => {
+                const newWidthOrHeight = baseWidthOrHeight - 10;
+                if (ischangeWidth) {
+                    bounds.height = Math.round((bounds.height * newWidthOrHeight) / bounds.width);
+                    bounds.width = newWidthOrHeight;
                 } else {
-                    rhost = `https://wwwr.plaso.cn/static/sdk/styleupime/${classOptions.version ?? '1.60.139'}/`;
-                    dhost = 'https://www.plaso.cn/';
+                    bounds.width = Math.round((bounds.width * newWidthOrHeight) / bounds.height);
+                    bounds.height = newWidthOrHeight;
                 }
+            };
+            // 课堂窗口创建时的宽或高和 屏幕宽高或屏幕工作区宽高 一致时，此时透明窗口会失效，需要调整进课堂时的窗口宽高
+            if (bounds.width === screenWidth || bounds.width === screenWorkAreaWidth) {
+                changeBoundsDate(true, Math.min(screenWidth, screenWorkAreaWidth));
+            }
+            if (bounds.height === screenHeight || bounds.height === screenWorkAreaHeight) {
+                changeBoundsDate(false, Math.min(screenHeight, screenWorkAreaHeight));
+            }
+            return bounds;
+        };
+
+        const defaultElectronWinOptions = {
+            frame: false,
+            /**
+             * electron 12.0.18之后，resizable设为true才能全屏和最大化，
+             * 而课堂窗口不允许通过electron自身的缩放行为来改变大小，因此进入课堂后会将resizable设为false
+             */
+            resizable: true,
+            /** 设置为true，mac上setFullScreen(true)才生效，setSimpleFullScreen(true)不依赖此参数 */
+            fullscreenable: true,
+            ...buildBounds(),
+            webPreferences: {
+                nodeIntegration: true,
+                enableRemoteModule: true,
+                contextIsolation: false,
+                nodeIntegrationInWorker: true,
+                webviewTag: true,
+            },
+        };
+
+        if (isMac) {
+            // 在Mac下要显式设置fullscreen为false，防止客户端全屏时进入课堂，课堂窗口也默认全屏，
+            // 导致部分按钮失效，以及独立窗口打开异常
+            defaultElectronWinOptions.fullscreen = false;
+        }
 
-                // 截图和虚拟声卡地址确认
-                let flameshotPath = path.join(__dirname, '../lib/flameshot/flameshot.exe');
-                let PlasoALD = '';
-                if (isMac) {
-                    flameshotPath = path.join(__dirname, '../lib/flameshot.app/Contents/MacOS/flameshot');
-                    PlasoALD = path.join(__dirname, '../lib/PlasoALD');
-                }
+        // 学生无需使用透明窗口（透明窗口问题多），减少影响
+        if (queryObj.userType !== 'listener') {
+            defaultElectronWinOptions.transparent = true;
+            defaultElectronWinOptions.backgroundColor = '#00ffffff';
+        }
 
-                const classOptionsObj = {
-                    ...classOptions,
-                    ...classInfo,
-                    rhost,
-                    dhost,
-                    query: classOptions.query,
-                    appType: classOptions.appType,
-                    markString: env,
-                    env,
-                    classType: classOptions.classType,
-                    // 让课堂里退出时标识状态，详情见commFunction.js
-                    onClose: 'close',
-                    electronSdkLoggerPath: logger.loggerPath ?? '',
-                    electronSdkLoggerName: logger.logFileName ?? '',
-                    flameshotPath: flameshotPath ?? '',
-                    PlasoALDPath: PlasoALD ?? '',
-                    clientType: 'electron',
-                    isElectronSdk: true,
-                    openerId: webContents.id,
-                    memoryConfigKey: classOptions.memoryConfigKey ?? classInfo.loginName ?? classOptions.loginName ?? '',
-                    maximized: autoMaximized,
-                    fullScreenable,
-                    supportOnReportIssues: !!onReportIssuesFn,
-                };
-
-                if (classOptionsObj.userType === 'monitor') {
-                    classOptionsObj.monitor = true;
-                }
+        if (queryObj.topic) {
+            defaultElectronWinOptions.title = queryObj.topic + '';
+        }
+        if (classOptions.topic && classOptions.classType === LESSON_TYPE.PREPARE_LESSONS) {
+            defaultElectronWinOptions.title = classOptions.topic + '';
+        }
 
-                /**----------------------------------------------------electron 窗口相关设置-----------------------------------*/
-
-                const bounds = win.getBounds();
-                const screenWidth = displayInfo.size.width;
-                const screenWorkAreaWidth = displayInfo.workAreaSize.width;
-                const screenHeight = displayInfo.size.height;
-                const screenWorkAreaHeight = displayInfo.workAreaSize.height;
-
-                const changeBoundsDate = (ischangeWidth, baseWidthOrHeight) => {
-                    const newWidthOrHeight = baseWidthOrHeight - 10;
-                    if (ischangeWidth) {
-                        bounds.height = Math.round((bounds.height * newWidthOrHeight) / bounds.width);
-                        bounds.width = newWidthOrHeight;
-                    } else {
-                        bounds.width = Math.round((bounds.width * newWidthOrHeight) / bounds.height);
-                        bounds.height = newWidthOrHeight;
-                    }
-                };
-                // 课堂窗口创建时的宽或高和 屏幕宽高或屏幕工作区宽高 一致时，此时透明窗口会失效，需要调整进课堂时的窗口宽高
-                if (bounds.width === screenWidth || bounds.width === screenWorkAreaWidth) {
-                    changeBoundsDate(true, Math.min(screenWidth, screenWorkAreaWidth));
-                }
-                if (bounds.height === screenHeight || bounds.height === screenWorkAreaHeight) {
-                    changeBoundsDate(false, Math.min(screenHeight, screenWorkAreaHeight));
-                }
+        return {
+            ...defaultElectronWinOptions,
+            ...(electronWinOptions || {}),
+        };
+    };
 
-                const defaultElecteonWinOptions = {
-                    frame: false,
-                    /**
-                     * electron 12.0.18之后，resizable设为true才能全屏和最大化，
-                     * 而课堂窗口不允许通过electron自身的缩放行为来改变大小，因此进入课堂后会将resizable设为false
-                     */
-                    resizable: true,
-                    /** 设置为true，mac上setFullScreen(true)才生效，setSimpleFullScreen(true)不依赖此参数 */
-                    fullscreenable: true,
-                    ...bounds,
-                    webPreferences: {
-                        nodeIntegration: true,
-                        enableRemoteModule: true,
-                        contextIsolation: false,
-                        nodeIntegrationInWorker: true,
-                    },
-                };
-                if (isMac) {
-                    // 在Mac下要显式设置fullscreen为false，防止客户端全屏时进入课堂，课堂窗口也默认全屏，
-                    // 导致部分按钮失效，以及独立窗口打开异常
-                    defaultElecteonWinOptions.fullscreen = false;
-                }
-                // 学生无需使用透明窗口（透明窗口问题多），减少影响
-                if (classInfo.userType !== 'listener') {
-                    defaultElecteonWinOptions.transparent = true;
-                    defaultElecteonWinOptions.backgroundColor = '#00ffffff';
-                }
-                if (classInfo.topic) defaultElecteonWinOptions.title = classInfo.topic + '';
-                if (classOptions.topic && classOptions.classType === LESSON_TYPE.PREPARE_LESSONS)
-                    defaultElecteonWinOptions.title = classOptions.topic + '';
-
-                const _electeonWinOptions = electronWinOptions
-                    ? {
-                          ...defaultElecteonWinOptions,
-                          ...electronWinOptions,
-                      }
-                    : defaultElecteonWinOptions;
-
-                /**---------------------------------------------------- 创建课堂/备课窗口-----------------------------------*/
-
-                const onClassWindowReady = (event) => {
-                    const classWindow = remote.BrowserWindow.fromId(currentWinId);
-                    classWindow.moveTop();
-                    classWindow.focus();
-                    logger.info(`课堂窗口ready，id:${currentWinId}`);
-                    if (onClassWindowReadyFn && currentWinId) onClassWindowReadyFn(currentWinId);
-                };
-                const onClassFinished = (event, value) => {
-                    const meetingId = value?.meetingId;
-                    logger.info(`课堂已结束，id:${currentWinId}, meetingId is ${meetingId}`);
-                    if (onClassFinishedFn && currentWinId) onClassFinishedFn(meetingId);
-                };
-                const onHtmlReady = (event, value) => {
-                    currentWebContentsId = value?.webContentId;
-                    logger.info(`课堂窗口 html ready，web contents id:${currentWebContentsId}`);
-
-                    if (currentWebContentsId) {
-                        ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.INIT_GLOBAL_APPINFO, classOptionsObj);
+    /* -------------------------------- 回调 bridge ------------------------------- */
+    const { ipcRenderer } = window.require('electron');
+
+    /**
+     * 适用范围
+     * 用于创建带回复的回调，要求
+     * ipc-request payload 格式为 (requestId, ...args)
+     * ipc-response payload 格式为 (requestId, returnValue)
+     *
+     * 整条链路
+     * [课堂窗口] --ipc-request--> [Handler] --> [classWindowProps.onXxxFn] --> [Handler] --ipc-response--> [课堂窗口]
+     * 本函数用来构建这个桥接用的 handler
+     *
+     * 内部流程
+     * - step 1 执行 beforeCallback，如果返回 false 则中止
+     * - step 2 如果 callback 不存在则中止
+     * - step 3 执行 callback
+     * - step 4 执行 afterCallback，如果返回 false 则中止
+     * - step 5 则把 callback 返回值发给课堂窗口
+     */
+    /** @type {import('./render').BuildReplyingCallback} */
+    const buildReplyingCallback = ({ requestMsgType, responseMsgType, callback, beforeCallback, afterCallback }) => {
+        return {
+            requestMsgType,
+            responseMsgType,
+            handler: async (event, requestId, ...args) => {
+                const info = `${requestMsgType} ${responseMsgType} ${requestId}`;
+                try {
+                    logger.info(`[callback bridge] start ${info}`);
+                    if (!currentWebContentsId || !responseMsgType || !requestId) {
+                        return;
                     }
-                };
-                const onSaveBoard = (event, value) => {
-                    logger.info(`保存板书:${JSON.stringify(value)}`);
-                    const cb = (value) => {
-                        if (currentWebContentsId) {
-                            ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.RESP_SAVE_BOARD, value);
-                        }
-                    };
-                    if (onSaveBoardFn && value) onSaveBoardFn(value, cb);
-                };
-
-                const onOpenResourceCenter = (event) => {
-                    if (onOpenResourceCenterFn) onOpenResourceCenterFn();
-                };
-
-                const onGetExtFileName = async (event, requestId, ...args) => {
-                    if (onGetExtFileNameFn && args.length > 0) {
-                        const url = await onGetExtFileNameFn(...args);
-                        if (url) {
-                            if (currentWebContentsId) {
-                                ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.RESP_GET_EXT_FILE_NAME, requestId, url);
-                            }
-                        }
+                    if (beforeCallback?.(...args) === false) {
+                        logger.info(`[callback bridge] beforeCallback guard, ${info}`);
+                        return;
                     }
-                };
-
-                const onGetPreParseFileName = async (event, requestId, ...args) => {
-                    if (onGetPreParseFileNameFn && args.length > 0) {
-                        const url = await onGetPreParseFileNameFn(...args);
-                        if (url) {
-                            ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.RESP_GET_PRE_PARSE_FILE_NAME, requestId, url);
-                        }
+                    if (!callback) {
+                        logger.info(`[callback bridge] callback is null, skip, ${info}`);
+                        return;
                     }
-                };
-
-                const onReportIssues = (event, info) => {
-                    onReportIssuesFn?.(info);
-                };
-
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.LIVE_WINDOW_READY, onClassWindowReady);
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.ON_CLASS_FINISHED, onClassFinished);
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.HTML_READY, onHtmlReady);
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.SAVE_BOARD, onSaveBoard);
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.OPEN_RESOURCE_CENTER, onOpenResourceCenter);
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.GET_EXT_FILE_NAME, onGetExtFileName);
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.GET_PRE_PARSE_FILE_NAME, onGetPreParseFileName);
-                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.REPORT_ISSUES, onReportIssues);
-
-                const url = require('url');
-                const htmlPath =
-                    (isMac
-                        ? url.format({
-                              pathname: path.join(__dirname, '../index.html'),
-                              protocol: 'file:',
-                              slashes: true,
-                          })
-                        : path.join(__dirname, '../index.html')) + `?openerId=${webContents.id}`;
-
-                appProxy.createWindow(
-                    {
-                        path: htmlPath,
-                        debug: classOptions?.debug ?? false,
-                        maximize: autoMaximized,
-                        windowOptions: _electeonWinOptions,
-                    },
-                    async (id) => {
-                        currentWinId = id;
-
-                        appProxy.addWinEventListener(id, 'closed', () => {
-                            logger.info(`课堂窗口关闭，id:${currentWinId}`);
-
-                            if (onClassWindowLeaveFn) onClassWindowLeaveFn(currentWinId);
-                            currentWinId = null;
-                            currentWebContentsId = null;
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.LIVE_WINDOW_READY, onClassWindowReady);
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.ON_CLASS_FINISHED, onClassFinished);
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.HTML_READY, onHtmlReady);
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.SAVE_BOARD, onSaveBoard);
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.OPEN_RESOURCE_CENTER, onOpenResourceCenter);
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.GET_EXT_FILE_NAME, onGetExtFileName);
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.GET_PRE_PARSE_FILE_NAME, onGetPreParseFileName);
-                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.REPORT_ISSUES, onReportIssues);
-                        });
-                    },
-                );
-                return 0;
-            } else {
-                logger.error('获取remote、displayInfo 失败');
-                if (!remote) return ERROR_CODE.GET_REMOTE_FAIL;
-                if (!displayInfo) return ERROR_CODE.GET_DISPLAY_INFO_FAIL;
-            }
-        } catch (error) {
-            logger.error(`异常错误，${JSON.stringify(error)}`);
-            return ERROR_CODE.COMMOM_ERROR;
+                    const result = await callback(...args);
+                    if (afterCallback?.(result) === false) {
+                        logger.info(`[callback bridge] afterCallback guard, ${info}`);
+                        return;
+                    }
+                    ipcRenderer.sendTo(currentWebContentsId, responseMsgType, requestId, result);
+                    logger.info(`[callback bridge] end ${info}`);
+                } catch (error) {
+                    logger.error(`[callback bridge] error ${info}`, error);
+                }
+            },
+        };
+    };
+
+    const onClassWindowReady = (event) => {
+        const classWindow = remote.BrowserWindow.fromId(currentWinId);
+        classWindow.moveTop();
+        classWindow.focus();
+        logger.info(`课堂窗口ready，id:${currentWinId}`);
+        if (onClassWindowReadyFn && currentWinId) {
+            onClassWindowReadyFn(currentWinId);
         }
-    } else {
-        logger.error('非Electron环境');
-        return ERROR_CODE.NO_ELECTRON_ENVIRONMENT;
-    }
-}
+    };
 
-/**
- * @param {classWindowType} liveClassWindowProps
- * @returns
- */
-function createLiveClassWindow(liveClassWindowProps) {
-    const classWindowProps = {
-        ...liveClassWindowProps,
-        classOptions: {
-            ...liveClassWindowProps.classOptions,
-            appType: 'liveclassSDK',
-            classType: LESSON_TYPE.LIVECLASS,
-        },
+    const onClassFinished = (event, value) => {
+        const meetingId = value?.meetingId;
+        logger.info(`课堂已结束，id:${currentWinId}, meetingId is ${meetingId}`);
+        if (onClassFinishedFn && currentWinId) {
+            onClassFinishedFn(meetingId);
+        }
     };
-    return createClassWindow(classWindowProps);
-}
 
-/**
- * @param {classWindowType} prepareClassWindowProps
- * @returns
- */
-function createPrepareClassWindow(prepareClassWindowProps) {
-    const classWindowProps = {
-        ...prepareClassWindowProps,
-        classOptions: {
-            ...prepareClassWindowProps.classOptions,
-            appType: 'prepareLessonSdk',
-            meetingType: LESSON_TYPE.PREPARE_LESSONS,
-            classType: LESSON_TYPE.PREPARE_LESSONS,
-            userType: 'speaker',
-            topic: prepareClassWindowProps.classOptions.topic ?? '备课课堂',
-        },
+    const onHtmlReady = (event, value) => {
+        currentWebContentsId = value?.webContentId;
+        logger.info(`课堂窗口 html ready，web contents id:${currentWebContentsId}`);
+        if (currentWebContentsId) {
+            ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.INIT_GLOBAL_APPINFO, globalAppInfo);
+        }
     };
-    return createClassWindow(classWindowProps);
-}
 
-/** 插入外部云盘里的文件，文件需要遵循特定的数据结构 */
-/**
- * @typedef {Object} fileDataObj
- * @property {number} type 插入文件的格式,内容参考 FILE_TYPE
- * @property {string} [title] 文件名称，传入后会显示在文件窗口标题栏上，建议带上文件后缀名
- * @property {string} [url] 公开的访问权限的文件全地址，建议https协议全地址
- * @property {any[]} [info] 具体的文件信息，除备课外，内容都由用户自己定义
- */
-/**
- * @param {fileDataObj} fileData 文件数据
- */
-function insertObject(fileData) {
-    try {
-        const { ipcRenderer } = window.require('electron');
-        if (currentWebContentsId) ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.INSERT_OBJECT, fileData);
-    } catch (error) {
-        logger.error(`insertObject error is: ${JSON.stringify(error)}}`);
-        return ERROR_CODE.COMMOM_ERROR;
+    const onSaveBoard = (event, value) => {
+        logger.info(`保存板书:${JSON.stringify(value)}`);
+        if (onSaveBoardFn && value) {
+            onSaveBoardFn(value, (value) => {
+                if (currentWebContentsId) {
+                    ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.RESP_SAVE_BOARD, value);
+                }
+            });
+        }
+    };
+
+    const onOpenResourceCenter = (event) => {
+        onOpenResourceCenterFn?.();
+    };
+
+    const onReportIssues = (event, info) => {
+        onReportIssuesFn?.(info);
+    };
+
+    const onGetExtFileName = buildReplyingCallback({
+        requestMsgType: CLASS_WINDOW_MESG_TYPE.GET_EXT_FILE_NAME,
+        beforeCallback: (...args) => args.length > 0,
+        callback: onGetExtFileNameFn,
+        afterCallback: (result) => !!result,
+        responseMsgType: CLASS_WINDOW_MESG_TYPE.RESP_GET_EXT_FILE_NAME,
+    });
+
+    const onGetPreParseFileName = buildReplyingCallback({
+        requestMsgType: CLASS_WINDOW_MESG_TYPE.GET_PRE_PARSE_FILE_NAME,
+        beforeCallback: (...args) => args.length > 0,
+        callback: onGetPreParseFileNameFn,
+        afterCallback: (result) => !!result,
+        responseMsgType: CLASS_WINDOW_MESG_TYPE.RESP_GET_PRE_PARSE_FILE_NAME,
+    });
+
+    const onFetchFavorites = buildReplyingCallback({
+        requestMsgType: CLASS_WINDOW_MESG_TYPE.FETCH_FAVORITES,
+        responseMsgType: CLASS_WINDOW_MESG_TYPE.RESP_FETCH_FAVORITES,
+        callback: onFetchFavoritesFn,
+    });
+
+    const onFetchCategories = buildReplyingCallback({
+        requestMsgType: CLASS_WINDOW_MESG_TYPE.FETCH_CATEGORIES,
+        responseMsgType: CLASS_WINDOW_MESG_TYPE.RESP_FETCH_CATEGORIES,
+        callback: onFetchCategoriesFn,
+    });
+
+    const onAddFavorite = buildReplyingCallback({
+        requestMsgType: CLASS_WINDOW_MESG_TYPE.ADD_FAVORITE,
+        responseMsgType: CLASS_WINDOW_MESG_TYPE.RESP_ADD_FAVORITE,
+        callback: onAddFavoriteFn,
+    });
+
+    const onRemoveFavorite = buildReplyingCallback({
+        requestMsgType: CLASS_WINDOW_MESG_TYPE.REMOVE_FAVORITE,
+        responseMsgType: CLASS_WINDOW_MESG_TYPE.RESP_REMOVE_FAVORITE,
+        callback: onRemoveFavoriteFn,
+    });
+
+    const callbacks = {
+        [CLASS_WINDOW_MESG_TYPE.LIVE_WINDOW_READY]: onClassWindowReady,
+        [CLASS_WINDOW_MESG_TYPE.ON_CLASS_FINISHED]: onClassFinished,
+        [CLASS_WINDOW_MESG_TYPE.HTML_READY]: onHtmlReady,
+        [CLASS_WINDOW_MESG_TYPE.SAVE_BOARD]: onSaveBoard,
+        [CLASS_WINDOW_MESG_TYPE.OPEN_RESOURCE_CENTER]: onOpenResourceCenter,
+        [CLASS_WINDOW_MESG_TYPE.REPORT_ISSUES]: onReportIssues,
+        [onGetExtFileName.requestMsgType]: onGetExtFileName.handler,
+        [onGetPreParseFileName.requestMsgType]: onGetPreParseFileName.handler,
+        [onFetchFavorites.requestMsgType]: onFetchFavorites.handler,
+        [onFetchCategories.requestMsgType]: onFetchCategories.handler,
+        [onAddFavorite.requestMsgType]: onAddFavorite.handler,
+        [onRemoveFavorite.requestMsgType]: onRemoveFavorite.handler,
+    };
+
+    Object.entries(callbacks).forEach(([type, callback]) => {
+        ipcRenderer.on(type, callback);
+    });
+
+    /* ---------------------------------- 窗口创建 ---------------------------------- */
+    const appProxy = require('@plasosdk/winproxy');
+
+    const indexHtmlPath = isMac
+        ? require('url').format({
+              pathname: path.join(__dirname, '../index.html'),
+              protocol: 'file:',
+              slashes: true,
+          })
+        : path.join(__dirname, '../index.html');
+
+    appProxy.createWindow(
+        {
+            path: indexHtmlPath + `?openerId=${openerId}`,
+            debug: classOptions?.debug ?? false,
+            maximize: autoMaximized,
+            windowOptions: buildElectronWinOptions(),
+        },
+        onWindowCreated,
+    );
+
+    async function onWindowCreated(id) {
+        currentWinId = id;
+        appProxy.addWinEventListener(id, 'closed', onWindowClosed);
     }
-}
 
-/**
- * 更新严禁词列表
- * @param {string[]} words 严禁词数组
- */
-function updateProhibitedWords(words) {
-    try {
-        const { ipcRenderer } = window.require('electron');
-        if (currentWebContentsId) ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.UPDATE_SENSITIVE_WORDS, words || []);
-    } catch (error) {
-        logger.error(`updateProhibitedWords error is: ${JSON.stringify(error)}}`);
+    /* ---------------------------------- 窗口关闭 ---------------------------------- */
+    function onWindowClosed() {
+        logger.info(`课堂窗口关闭，id:${currentWinId}`);
+        onClassWindowLeaveFn?.(currentWinId);
+        currentWinId = null;
+        currentWebContentsId = null;
+        Object.entries(callbacks).forEach(([type, callback]) => {
+            ipcRenderer.removeListener(type, callback);
+        });
     }
+
+    return 0;
 }
 
 function getVersion() {
@@ -426,23 +414,109 @@ function getVersion() {
     }
 }
 
-/** 日志文件地址 */
-function initLogConfig(logFilePath) {
-    if (logFilePath) {
-        logger.initLoggerFilePath(logFilePath);
-        const { ipcRenderer } = require('electron');
-        ipcRenderer.send(RENDER_TO_MAIN_MESG_TYPE.PLASO_INIT_LOG_PATH, logFilePath);
-    }
-}
+/** Plaso Electron SDK */
+module.exports = {
+    /**
+     * 课堂
+     * @param {import('./render').ClassWindowType} liveClassWindowProps
+     * @returns {number}
+     */
+    createLiveClassWindow(liveClassWindowProps) {
+        try {
+            return createClassWindow({
+                ...liveClassWindowProps,
+                classOptions: {
+                    ...liveClassWindowProps.classOptions,
+                    appType: 'liveclassSDK',
+                    classType: LESSON_TYPE.LIVECLASS,
+                },
+            });
+        } catch (error) {
+            logger.error(`异常错误，${JSON.stringify(error)}`);
+            return ERROR_CODE.COMMOM_ERROR;
+        }
+    },
+
+    /**
+     * 备课
+     * @param {import('./render').ClassWindowType} prepareClassWindowProps
+     * @returns {number}
+     */
+    createPrepareClassWindow(prepareClassWindowProps) {
+        try {
+            return createClassWindow({
+                ...prepareClassWindowProps,
+                classOptions: {
+                    ...prepareClassWindowProps.classOptions,
+                    appType: 'prepareLessonSdk',
+                    meetingType: LESSON_TYPE.PREPARE_LESSONS,
+                    classType: LESSON_TYPE.PREPARE_LESSONS,
+                    userType: 'speaker',
+                    topic: prepareClassWindowProps.classOptions.topic ?? '备课课堂',
+                },
+            });
+        } catch (error) {
+            logger.error(`异常错误，${JSON.stringify(error)}`);
+            return ERROR_CODE.COMMOM_ERROR;
+        }
+    },
+
+    /**
+     * 获取 sdk 版本
+     */
+    getVersion,
+
+    /**
+     *初始化日志文件路径
+     * @param {string} logFilePath 日志文件路径
+     */
+    initLogConfig(logFilePath) {
+        if (logFilePath) {
+            logger.initLoggerFilePath(logFilePath);
+            require('electron')
+                .ipcRenderer //
+                .send(RENDER_TO_MAIN_MESG_TYPE.PLASO_INIT_LOG_PATH, logFilePath);
+        }
+    },
+
+    /**
+     * 插入的资源文件类型定义
+     */
+    FILE_TYPE,
+
+    /**
+     * 插入外部云盘里的文件，文件需要遵循特定的数据结构
+     * @param {import('./render').FileDataObj} fileData 文件数据
+     */
+    insertObject(fileData) {
+        try {
+            if (currentWebContentsId) {
+                window
+                    .require('electron')
+                    .ipcRenderer //
+                    .sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.INSERT_OBJECT, fileData);
+            }
+        } catch (error) {
+            logger.error(`insertObject error is: ${JSON.stringify(error)}}`);
+            return ERROR_CODE.COMMOM_ERROR;
+        }
+    },
 
-const PlasoElectronSdk = {
-    createLiveClassWindow: createLiveClassWindow,
-    createPrepareClassWindow: createPrepareClassWindow,
-    getVersion: getVersion,
-    initLogConfig: initLogConfig,
-    insertObject: insertObject,
-    updateProhibitedWords: updateProhibitedWords,
-    FILE_TYPE: FILE_TYPE,
+    /**
+     * 更新严禁词列表
+     * @param {string[]} words 严禁词数组
+     */
+    updateProhibitedWords(words) {
+        try {
+            if (currentWebContentsId) {
+                window
+                    .require('electron')
+                    .ipcRenderer //
+                    .sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.UPDATE_SENSITIVE_WORDS, words || []);
+            }
+        } catch (error) {
+            logger.error(`updateProhibitedWords error is: ${JSON.stringify(error)}}`);
+            return ERROR_CODE.COMMOM_ERROR;
+        }
+    },
 };
-
-module.exports = PlasoElectronSdk;

package/jsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "checkJs": true,
+    "strict": false
+  },
+  "include": ["**/*.js"],
+  "exclude": ["node_modules"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasosdk/plaso-electron-sdk",
-  "version": "1.3.16-beta.0",
+  "version": "1.3.17-beta.0",
   "description": "伯索课堂Electron SDK",
   "main": "index.js",
   "scripts": {