@plasosdk/plaso-electron-sdk 1.3.6 → 1.3.8-beta.1

package/README.md

@@ -1,14 +1,29 @@
 # Plaso SDK for Electron
 
-## 🖥 环境支持
-
-- 🌈 支持 MacOS x86-64 和 arm64
-- ⚙️ 支持 Windows ia32 和 x64
-- [Electron](https://www.electronjs.org/): 14.0.0~22.3.27
-
-| MacOS | Windows | Electron |
-| --- | --- | --- |
-| x86 \| arm64 | ia32 \| x64 | 14.0.0~22.3.27                                                                        
+## 目录
+
+<!-- toc -->
+- [环境支持](#环境支持)
+- [安装](#安装)
+- [electron-builder打包特别说明](#electron-builder打包特别说明)
+- [使用](#使用)
+  - [在主进程中使用](#在主进程中使用)
+  - [在渲染进程中使用](#在渲染进程中使用)
+    - [打开实时课堂](#打开实时课堂)
+    - [打开备课课堂](#打开备课课堂)
+    - [打开实时课堂/备课课堂通用参数说明](#打开实时课堂备课课堂通用参数说明)
+    - [API参考](#api参考)
+- [资料中心](#资料中心)
+- [播放历史课堂](#播放历史课堂)
+- [注意点](#注意点)
+- [Q&A](#qa)
+<!-- tocstop -->
+
+## 环境支持
+
+- MacOS：x86-64、arm64
+- Windows：ia32、x64
+- Electron：14.0.0~22.3.27
 
 ## 安装
 
@@ -27,33 +42,63 @@ npm install @plasosdk/plaso-electron-sdk --global-style
 **<font color=red>注意: 不同平台需要单独安装，尤其是MacOS，请分别在Intel芯片和Apple芯片的电脑上安装</font>**
 
 ## electron-builder打包特别说明
-使用electron-builder打包时，需要对工程的node_modules中的agora-electron-sdk-v4进行特殊处理，该包是在安装@plasosdk/plaso-electron-sdk时动态安装的，因此需要通过配置extraResources单独拷贝。配置入如下
+
+### extraResources配置
+
+> ⚠️ 注意：该配置在 1.3.7 版本有所调整。如果你正在从 < 1.3.7 升级到 >= 1.3.7，请参照下列说明进行调整。
+
+agora-electron-sdk-v4包是在安装plaso-electron-sdk时通过脚本动态安装的，不在dependencies依赖树中，electron-builder打包时不会包含它。为了保留它，需要配置[extraResources](https://www.electron.build/configuration#extraresources)来单独拷贝一份，把它包含进来。
+
 ```json
-"extraResources": [
-    {
-        "from": "node_modules/agora-electron-sdk-v4",
-        "to": "app/node_modules/agora-electron-sdk-v4",
-        "filter": ["**/*"]
-    },
-    {
-        "from": "node_modules/agora-electron-sdk-v4/node_modules",
-        "to": "app/node_modules/agora-electron-sdk-v4/node_modules",
-        "filter": ["**/*"]
-    }
-]
+{
+    "extraResources": [
+        {
+            "from": "node_modules/@plasosdk/plaso-electron-sdk/node_modules/agora-electron-sdk-v4",
+            "to": "app/node_modules/@plasosdk/plaso-electron-sdk/node_modules/agora-electron-sdk-v4",
+            "filter": [
+                "**/*"
+            ]
+        },
+        {
+            "from": "node_modules/@plasosdk/plaso-electron-sdk/node_modules/agora-electron-sdk-v4/node_modules",
+            "to": "app/node_modules/@plasosdk/plaso-electron-sdk/node_modules/agora-electron-sdk-v4/node_modules",
+            "filter": [
+                "**/*"
+            ]
+        }
+    ]
+}
 ```
+
 同时，由于这个包是通过extraResources进行拷贝的，需要在签名脚本中额外配置这个包的路径。
 
-另外在打包MacOS的包时有几个需要额外进行授权的可执行文件。建议通过额外的脚本来执行。下面的可执行文件是在安装@plasosdk/plaso-electron-sdk时动态下载的，因此授权的脚本需要保证是在文件下载之后。
+### 关闭asar
+
+需要关闭asar，否则SDK会无法加载到node_modules。关闭方式详见electron-buider[官方文档](https://www.electron.build/configuration#asar)。
+
+```json
+{
+    "asar": false, // 关闭asar
+}
+```
+
+### MacOS赋予文件执行权限
+
+打MacOS的包时有几个需要额外进行授权的可执行文件。建议通过额外的脚本来执行。
+
+下面的可执行文件是在安装@plasosdk/plaso-electron-sdk时动态下载的，因此授权的脚本需要保证是在文件下载之后。
+
 ```shell
 // 截图会用到
-chmod +x node_modules/@plasosdk/plaso-electron-sdk/lib/flameshot  
+chmod +x node_modules/@plasosdk/plaso-electron-sdk/lib/flameshot.app
 
 // 桌面共享会用到
 chmod +x node_modules/@plasosdk/plaso-electron-sdk/lib/PlasoALD/PlasoALD.scpt
 ```
 
-MacOS打包完毕后，建议安装打好的包后自行验证上述的操作时候生效了。
+### 验证
+
+MacOS打包完毕后，建议安装打好的包，验证上述操作是否成功。核对清单：
 - 检查包内容中node_modules里面的agora-electron-sdk-v4包中是否包含node_modules，包含则说明打包正确。
 - 上课测试截图功能是否正常，截图正常说明授权正确。
 - 上课测试桌面共享功能，使用屏幕共享，并在浏览器里面播放一段视频，结束课堂后检查回放中能否听到桌面共享那一段播放的视频的声音，能听到说明授权正确。
@@ -98,7 +143,8 @@ interface CreateClassWindowPamras {
         callback: (result: boolean) => void,
     ) => void;
     onOpenResourceCenterFn?: () => void;
-    onGetExtFileNameFn?: (...args: any[]) => Promise<string>;
+    onGetExtFileNameFn?: (info: any[], ...args: any[]) => Promise<string>;
+    onGetPreParseFileNameFn?: (info: any[], option: { suffix: string }) => Promise<string>;
 }
 ```
 
@@ -205,6 +251,7 @@ interface IQueryParams {
     isNewMT?: number;
     enableNewClassExam?: number;
     d_enableReRecording?: number;
+    d_restrictAssistantPerm?: number;
 }
 ```
 
@@ -234,6 +281,7 @@ interface IQueryParams {
 | recordScreen | 否 | string | 传入`screen`表示录制屏幕（当前仅支持录制老师屏幕）|
 | enableNewClassExam | 否 | number | 是否启用新版随堂测，取值：<ul><li>0: 不启用</li><li>1: 启用选择题</li><li>2: 启用填空题</li><li>3: 启用选择题+填空题</li></ul>默认不启用，建议传3 |
 | d_enableReRecording | 否 | number | 是否允许老师/助教重新录制，取值：<ul><li>0: 不允许老师和助教重新录制</li><li>1: 仅允许老师重新录制</li><li>2: 仅允许助教重新录制</li><li>3: 允许老师和助教重新录制</li></ul>默认值为3 |
+| d_restrictAssistantPerm | 否 | number | 是否启用限制助教权限，取值：<ul><li>0: 不启用</li><li>1: 启用</li></ul>默认不启用 |
 
 **根据 queryParams 对象生成签名字符串**
 > 注意：为了安全和各端签名统一，建议将签名的计算放在服务端，前端通过接口获取带签名的query
@@ -390,31 +438,208 @@ type onOpenResourceCenterFn = () => void;
 // 通过 insertObject 插入的文件传入 参数 info 时，怎么从info中获取文件的可访问地址的逻辑在用户那，所以需要函数从外部用户获取外部用户传入的文件地址
 // 其中info会作为args中的第一个参数回传
 
-type onGetExtFileNameFn = (...args: any[]) => Promise<string>;
+type onGetExtFileNameFn = (info: any, ...args: any[]) => Promise<string>;
+```
+
+##### onGetPreParseFileNameFn
+```ts
+// 通过 insertObject 插入的文件传入 参数 info 时，如果该资源是预解析资源，SDK需要访问解析后的文件
+// 其中info会作为args中的第一个参数回传
+// 预解析结果是一个文件夹，要访问文件夹里的哪个文件，会通过suffix指出，如/index.html、/pre1.jpg等
+
+type onGetPreParseFileNameFn = (info: any, option: { suffix: string }) => Promise<string>;
 ```
 
 #### API参考
 
 ##### PlasoElectronSdk.initLogConfig
 
-**初始化课堂窗口日志位置**，窗口崩溃时会在同级目录下生成 reports 文件夹存储 dump，**在 调用 createLiveClassWindow 前设置**
-
-**日志默认位置**：
+该方法用于设置SDK日志位置，SDK崩溃时会在同级目录下生成`reports`文件夹存储 dump，在调用`createLiveClassWindow`前设置，不调用SDK会在默认位置写入日志，默认位置如下：
 
 ```js
+// 获取日志路径的代码如下
 require('path').join(require('electron').app.getPath('userData'), 'P403FileTemp');
 
 // Windows：C:\Users\${userName}\AppData\Roaming\${appName}\P403FileTemp
 // Mac：/Users/${userName}/Application\ Support/${appName}/P403FileTemp
 ```
 
-参数示例：
+参考示例：
 
 ```ts
 // 代码示例
 const PlasoElectronSdk = window.require('@plasosdk/plaso-electron-sdk');
-const logFilePath = 'C:/Users/userName/Desktop/electronDemo/electron12.0.18_x32/resources/app';
-PlasoElectronSdk.initLogConfig(logFilePath);
+const logDir = 'C:/Users/userName/Desktop/electronDemo/electron12.0.18_x32/resources/app';
+PlasoElectronSdk.initLogConfig(logDir);
+```
+
+> 重要：用户需要对日志目录做定期清理和及时上传日志到自己的服务器或OSS。推荐在退出SDK后做一次清理和上传，建议清理创建时间超过7天的日志即可。
+相关代码示例如下：
+```ts
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * 清理创建时间超过7天的日志
+ * @param logDir 日志目录
+ */
+function clearExpireLogs(logDir: string) {
+    try {
+        const logFile = fs.readdirSync(logDir).filter((fileName) => /\.(log|dmp|ips|diag)/.test(path.extname(fileName)));
+        logFile.forEach((fileName) => {
+            const fileInfo = fs.statSync(path.join(logDir, fileName));
+            const fileDate = new Date(fileInfo.birthtime).setHours(0, 0, 0, 0).valueOf();
+            const currentDate = new Date().setHours(0, 0, 0, 0);
+            if (currentDate - fileDate > 7 * 24 * 60 * 60 * 1000) {
+                fs.unlinkSync(path.join(logDir, fileName));
+            }
+        });
+    } catch (e) {
+        console.error('clear expire log error', e);
+    }
+}
+
+/**
+ * 收集崩溃日志
+ * @param logDir 日志目录
+ * @param pendingUploadDir 待上传目录
+ */
+function collectCrashLogs(logDir: string, pendingUploadDir: string) {
+    const platform = require('os').platform();
+    switch (platform) {
+        case 'darwin':
+            const newDumpFolder = path.join(logDir, '/new/');
+            const pendingDumpFolder = path.join(logDir, '/pending/');
+            const completedDumpFolder = path.join(logDir, '/completed/');
+            const diagnosticReports = path.normalize('/Library/Logs/DiagnosticReports');
+            collectDumpFiles(newDumpFolder);
+            collectDumpFiles(pendingDumpFolder);
+            collectDumpFiles(completedDumpFolder);
+            collectSystemLogs(diagnosticReports);
+            break;
+        case 'win32':
+            const reportsDumpFolder = path.join(logDir, '/reports/');
+            collectDumpFiles(reportsDumpFolder);
+            break;
+        default:
+            break;
+    }
+
+    function collectSystemLogs(folder: string) {
+        try {
+            const files = fs.readdirSync(folder);
+            const todayDate = new Date();
+            const formatDate = `${todayDate.getFullYear()}-${(todayDate.getMonth() + 1).toString().padStart(2, '0')}-${todayDate
+                .getDate()
+                .toString()
+                .padStart(2, '0')}`;
+            files.forEach((name) => {
+                const reg = new RegExp(`Electron Helper.*${formatDate}`);
+                if (name && name.match(reg)) {
+                    fs.copyFileSync(path.join(folder, name), path.join(pendingUploadDir, name));
+                }
+            });
+        } catch (e) {
+            console.error(e);
+        }
+    }
+
+    function collectDumpFiles(folder: string) {
+        try {
+            const files = fs.readdirSync(folder);
+            files.forEach((name) => {
+                if (name) {
+                    fs.copyFileSync(path.join(folder, name), path.join(pendingUploadDir, name));
+                    fs.unlinkSync(path.join(folder, name));
+                }
+            });
+        } catch (e) {
+            console.error(e);
+        }
+    }
+}
+
+/**
+ * 收集业务日志
+ * @param logDir 日志目录
+ * @param pendingUploadDir 待上传目录
+ */
+function collectBussinessLogs(logDir: string, pendingUploadDir: string) {
+    const logFiles = fs.readdirSync(logDir).filter((fileName) => /\.(log|dmp|ips|diag)/.test(path.extname(fileName)));
+    logFiles.forEach((fileName) => {
+        fs.copyFileSync(path.join(logDir, fileName), path.join(pendingUploadDir, fileName));
+    });
+}
+
+/**
+ * 收集日志
+ * @param logDir 日志目录
+ * @param pendingUploadDir 待上传目录
+ */
+function collectLogs(logDir: string, pendingUploadDir: string) {
+    collectCrashLogs(logDir, pendingUploadDir);
+    collectBussinessLogs(logDir, pendingUploadDir);
+}
+
+/**
+ * 压缩日志
+ * @param pendingUploadDir 待上传目录
+ */
+function zipLogs(pendingUploadDir: string): Promise<string> {
+    return new Promise((resolve) => {
+        const zipLogPath = path.join(pendingUploadDir, 'xxx.zip'); // 这边的xxx.zip取名时建议将用户名以及上传时间拼接上去，方便查询
+        // TODO: 这边做压缩，压缩完毕后将zip文件路径返回
+        resolve(zipLogPath);
+    });
+}
+
+/**
+ * 上传日志到服务器
+ * @param filePath zip文件路径
+ */
+function uploadToServer(filePath: string): Promise<boolean> {
+    return new Promise((resolve) => {
+        // TODO: 这边做上传
+        resolve(true);
+    });
+}
+
+/**
+ * 上传日志
+ * @param logDir 日志目录
+ */
+export function uploadLogs(logDir: string): Promise<boolean> {
+    return new Promise(async (resolve) => {
+        try {
+            // 上传前先清理过期的日志，避免垃圾日志太多
+            clearExpireLogs(logDir);
+
+            // 创建待上传目录
+            const pendingUploadDir = path.join(logDir, 'pendingUpload');
+            if (fs.existsSync(pendingUploadDir)) {
+                fs.rmdirSync(pendingUploadDir, { recursive: true });
+            }
+            fs.mkdirSync(pendingUploadDir);
+
+            // 将日志复制到待上传目录
+            collectLogs(logDir, pendingUploadDir);
+
+            // 压缩待上传目录
+            const zipName = await zipLogs(pendingUploadDir);
+
+            // 将压缩后的日志上传到服务器
+            await uploadToServer(zipName);
+
+            // 上传完成后删除临时文件
+            fs.unlinkSync(zipName);
+            fs.rmdirSync(pendingUploadDir, { recursive: true });
+
+            resolve(true);
+        } catch (error) {
+            resolve(false);
+        }
+    });
+}
 ```
 
 ##### PlasoElectronSdk.getVersion
@@ -465,6 +690,8 @@ const enum FILE_TYPE {
     DOC,
     /** 这种模式传入真实EXCEL地址 */
     XLS,
+    /** 预解析PPT */
+    ISPRINGPPT,
     /** 备课文件 */
     PREPARE_LESSONS,
 };
@@ -483,6 +710,9 @@ interface IFileData {
     /** 访问权限为公开的全地址，建议使用https协议的全地址，传入`info`时会忽略该属性 */
     url?: string;
 
+    /** 预解析结果的页数（插入预解析PDF/DOC/XLS时要传入这个属性） */
+    totalPages?: number;
+
     /**
      * 当用户插入的文件有签名时效时需要以info属性插入文件，这种方式需要配合onGetExtFileNameFn回调使用。
      * `info`的值由SDK用户自行决定，SDK内部会把`info`作为onGetExtFileNameFn回调函数的参数传入，由SDK用户
@@ -553,6 +783,18 @@ const fileDataWithUrl = {
 };
 ```
 
+###### 插入预解析PPT
+
+```ts
+// 预解析PPT仅支持info插入
+
+const fileDataWithInfo = {
+    type: PlasoElectronSdk.FILE_TYPE.ISPRINGPPT,
+    title: 'xxx',
+	info: ['xxx', ...],
+};
+```
+
 ###### 插入音视频
 
 ```ts
@@ -589,6 +831,17 @@ const fileDataWithInfo = {
 }
 ```
 
+###### 插入预解析PDF
+```ts
+// 预解析PDF仅支持info接入，且需要传入totalPages总页数
+
+const fileDataWithInfo = {
+	type: PlasoElectronSdk.FILE_TYPE.PDF,
+	title: 'xxx',
+	info: ['xxx', ...],
+    totalPages: 12,
+}
+```
 
 ###### 插入WORD/EXCEL/DOC/XLS
 
@@ -602,6 +855,19 @@ const fileDataWithUrl = {
 }
 ```
 
+###### 插入预解析DOC/XLS
+
+```ts
+// 预解析DOC/XLS仅支持info插入，且需要传入totalPages总页数
+
+const fileDataWithInfo = {
+	type: PlasoElectronSdk.FILE_TYPE/.DOC/.XLS,
+	title: 'xxx',
+	info: ['xxx', ...],
+    totalPages: 12,
+}
+```
+
 ## 资料中心
 
 step1、进课堂时，对象 **classOptions.supportShowResourceCenter** 需要是 true
@@ -610,7 +876,9 @@ step2、在课堂内点击资料中心后，会触发进课堂时传入的回调
 
 step3、选择文件后，通过 **PlasoElectronSdk.insertObject** 方法插入文件,方法入参参考 [insertObject](#insert-object) 说明
 
-step4、insertObject 方法 入参 有 info 时，此时 会触发进课堂时传入的回调函数 **onGetExtFileNameFn** 来获取文件的全地址
+step4.1、insertObject 方法 入参 有 info 时，此时 会触发进课堂时传入的回调函数 **onGetExtFileNameFn** 来获取文件的全地址
+
+step4.2、insertObject 方法插入的如果是预解析资源，那么就会触发回调 **onGetPreParseFileNameFn** 来获取解析后资源的全地址
 
 ## 播放历史课堂
 
@@ -618,6 +886,8 @@ step4、insertObject 方法 入参 有 info 时，此时 会触发进课堂时
 
 2、当课堂中insertObject使用了`info`属性时，SDK内部需要外部传入`getExtFileName`，因此历史课堂需要使用jssdk的接入方式， 详见：**[Web播放器-jssdk接入](https://open.plaso.cn/doc-6285192#jssdk%E6%8E%A5%E5%85%A5)**
 
+3、当课堂中insertObject插入了预解析资源时，SDK内部需要外部传入`getPreParseFileName`，因此历史课堂需要使用jssdk的接入方式，同上。
+
 ## 注意点
 
 （1）用户的课堂外主窗口销毁时需要销毁课堂窗口
@@ -625,3 +895,10 @@ step4、insertObject 方法 入参 有 info 时，此时 会触发进课堂时
 （2）**基于 此包封装新包时**：注意 @electron/remote 这个包的位置需要 和新包处于同级目录，需要把 和该包同级的@electron/remote 移到新包的同级目录处
 
 （3）确保 仅最后的 node_moudles 的顶层有 @electron/remote
+
+## Q&A
+
+### 进课堂遇到闪退/崩溃怎么办？
+- 检查应用程序路径中是否存在中文，路径中不应出现中文</br>
+可通过在主进程中，用`console.log(require.resolve('@plasosdk/plaso-electron-sdk'))`来检查路径
+- 如果是Mac，进课堂会需要麦克风权限。打开系统设置->隐私与安全性->麦克风，查看列表里你的应用程序是否被授权。

package/index.html

@@ -137,14 +137,63 @@
     document.head.appendChild(ele);
   }
 
+  let hasInit = false;
+  function init(appinfo) {
+    if (hasInit) {
+      return;
+    } else {
+      hasInit = true;
+    }
 
-  function init(classObj) {
-    let query;
-    if (classObj) {
-      globalAppInfo = Object.assign({}, classObj)
+    // from url
+    var query;
+    if (window.location.search) {
+      query = window.location.search.substring(1).split("&");
+      for (var i = 0, l = query.length; i < l; i++) {
+        var temp = query[i].split('=');
+        if (temp.length == 2) {
+          globalAppInfo[temp[0]] = decodeURIComponent(temp[1]);
+        } else if (
+          typeof globalAppInfo[temp[0]] === 'string' &&
+          globalAppInfo[temp[0]].length > 0 &&
+          !isNaN(Number(globalAppInfo[temp[0]])) &&
+          Number(globalAppInfo[temp[0]]) !== undefined &&
+          !globalAppInfo[temp[0]]?.includes?.('.')
+        ) {
+          globalAppInfo[temp[0]] = Number(globalAppInfo[temp[0]]);
+        }
+      }
+    }
+
+    // from ipc
+    if (appinfo) {
+      globalAppInfo = Object.assign({}, globalAppInfo, appinfo)
     }
-    globalAppInfo.needFullScreen = false;
 
+    // properties init
+    if (globalAppInfo.rhost == undefined && location.protocol.indexOf('http') == 0) {
+      globalAppInfo.rhost = './';
+      if (!globalAppInfo.dhost) {
+        if (globalAppInfo.env) {
+          if (globalAppInfo.env === 'local') {
+            globalAppInfo.dhost = location.origin;
+          } else {
+            globalAppInfo.dhost = `${location.protocol}//${globalAppInfo.env}.plaso.cn/`;
+          }
+        } else if (location.origin.indexOf('plaso.cn') > -1) {
+          globalAppInfo.dhost = location.origin.replace('wwwr', 'www');
+          globalAppInfo.env = location.host.split('.')[0];
+        } else if (location.origin.indexOf('127.0.0.1') > -1 || location.origin.indexOf('192.168') > -1) {
+          globalAppInfo.env = 'dev';
+          globalAppInfo.dhost = `${location.protocol}//${globalAppInfo.env}.plaso.cn/`;
+        } else {
+          globalAppInfo.dhost = `${location.protocol}//www.plaso.cn/`;
+        }
+      }
+    }
+    if (!globalAppInfo.env) globalAppInfo.env = 'www';
+    globalAppInfo.markString = globalAppInfo.markString ?? '';
+    globalAppInfo.needFullScreen = false;
     if (globalAppInfo.rhost && globalAppInfo.rhost.substring(globalAppInfo.rhost.length - 1) != '/') {
       globalAppInfo.rhost += "/";
     }
@@ -152,6 +201,7 @@
       globalAppInfo.dhost += "/";
     }
 
+    // load all.js
     path = globalAppInfo.initjs || "js/all.js";
     include(path);
   }
@@ -166,14 +216,14 @@
       if (key === 'openerId') openerId = Number(value);
     });
 
-    ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.INIT_CLASS_OPTIONS, (_, classObj) => {
-      if (classObj) init(classObj);
+    ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.INIT_GLOBAL_APPINFO, (_, appinfo) => {
+      if (appinfo) init(appinfo);
     });
 
     if(openerId){
       const remote = getElectronRemote();
       const webContents = remote.getCurrentWebContents();
-      ipcRenderer.sendTo(openerId, CLASS_WINDOW_MESG_TYPE.CLASS_READY, {webContentId: webContents.id});
+      ipcRenderer.sendTo(openerId, CLASS_WINDOW_MESG_TYPE.HTML_READY, {webContentId: webContents.id});
     }
 
   }

package/js/macro.js

@@ -24,10 +24,10 @@ const CLASS_WINDOW_MESG_TYPE = {
     LIVE_WINDOW_READY: 'liveWindowReady',
     /** 课堂结束 */
     ON_CLASS_FINISHED: 'onClassFinished',
-    /** 初始化进课堂参数 */
-    INIT_CLASS_OPTIONS: 'init_class_options',
-    /** 课堂窗口 html ready */
-    CLASS_READY: 'class_ready',
+    /** 初始化 globalAppInfo */
+    INIT_GLOBAL_APPINFO: 'init_global_appinfo',
+    /** html ready */
+    HTML_READY: 'html_ready',
     /** 保存白板文件 */
     SAVE_BOARD: 'save_board',
     /** 响应保存白板文件 */
@@ -42,6 +42,10 @@ const CLASS_WINDOW_MESG_TYPE = {
     GET_EXT_FILE_NAME: 'getExtFileName',
     /** 响应getExtFileName */
     RESP_GET_EXT_FILE_NAME: 'respGetExtFileName',
+    /** 通知外部调用getPreParseFileName */
+    GET_PRE_PARSE_FILE_NAME: 'getPreParseFileName',
+    /** 响应getPreParseFileName */
+    RESP_GET_PRE_PARSE_FILE_NAME: 'respGetPreParseFileName',
 };
 
 const LEVEL = {
@@ -68,6 +72,7 @@ const FILE_TYPE = {
     VIDEO: 7,
     DOC: 14,
     XLS: 15,
+    ISPRINGPPT: 21,
     PREPARE_LESSONS: 22,
 };
 

package/js/render.js

@@ -46,7 +46,8 @@ let currentWebContentsId = null;
  *   callback: (result: boolean) => void
  * ) => void} [onSaveBoardFn] 保存板书，具体的保存逻辑由外部实现，取消保存板书时，callback传false, 不然传true
  * @property {()=>void} [onOpenResourceCenterFn] 通知外部用户打开自己的资料中心，资料中心的具体ui和逻辑由外部用户自己实现
- * @property {(...args: any[])=>Promise<string>} [onGetExtFileNameFn] 通过insertObject插入的文件传入 参数 info 时，怎么从info中获取文件的可访问地址的逻辑在用户那，所以需要函数从外部用户获取外部用户传入的文件地址
+ * @property {(info: any, option: any)=>Promise<string>} [onGetExtFileNameFn] 通过insertObject插入的文件传入 参数 info 时，怎么从info中获取文件的可访问地址的逻辑在用户那，所以需要函数从外部用户获取外部用户传入的文件地址
+ * @property {(info: any, option: { suffix: string })=>Promise<string>} [onGetPreParseFileNameFn] 类似onGetExtFileNameFn，只是获取的文件地址是预解析文件地址，通过suffix得到预解析文件路径
  *
  */
 
@@ -64,10 +65,11 @@ function createClassWindow(classWindowProps) {
         onSaveBoardFn,
         onOpenResourceCenterFn,
         onGetExtFileNameFn,
+        onGetPreParseFileNameFn,
     } = classWindowProps;
 
     logger.info(
-        `课堂窗口创建信息: classOptions is ${JSON.stringify(classOptions)},electronWinOptions is ${JSON.stringify(
+        `课堂窗口创建信息: version is ${getVersion()}, classOptions is ${JSON.stringify(classOptions)},electronWinOptions is ${JSON.stringify(
             electronWinOptions,
         )}`,
     );
@@ -108,7 +110,7 @@ function createClassWindow(classWindowProps) {
                     rhost = `https://${env}.plaso.cn/static/yxtelectronsdk/`;
                     dhost = `https://${env}.plaso.cn/`;
                 } else {
-                    rhost = `https://wwwr.plaso.cn/static/sdk/styleupime/${classOptions.version ?? '1.58.307'}/`;
+                    rhost = `https://wwwr.plaso.cn/static/sdk/styleupime/${classOptions.version ?? '1.59.201'}/`;
                     dhost = 'https://www.plaso.cn/';
                 }
 
@@ -225,12 +227,12 @@ function createClassWindow(classWindowProps) {
                     logger.info(`课堂已结束，id:${currentWinId}, meetingId is ${meetingId}`);
                     if (onClassFinishedFn && currentWinId) onClassFinishedFn(meetingId);
                 };
-                const onClassHtmlReady = (event, value) => {
+                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_CLASS_OPTIONS, classOptionsObj);
+                        ipcRenderer.sendTo(currentWebContentsId, CLASS_WINDOW_MESG_TYPE.INIT_GLOBAL_APPINFO, classOptionsObj);
                     }
                 };
                 const onSaveBoard = (event, value) => {
@@ -258,12 +260,22 @@ function createClassWindow(classWindowProps) {
                     }
                 };
 
+                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);
+                        }
+                    }
+                };
+
                 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.CLASS_READY, onClassHtmlReady);
+                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);
 
                 const url = require('url');
                 const htmlPath =
@@ -293,10 +305,11 @@ function createClassWindow(classWindowProps) {
                             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.CLASS_READY, onClassHtmlReady);
+                            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);
                         });
                     },
                 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasosdk/plaso-electron-sdk",
-  "version": "1.3.6",
+  "version": "1.3.8-beta.1",
   "description": "伯索课堂Electron SDK",
   "main": "index.js",
   "scripts": {
@@ -14,6 +14,9 @@
     "electron",
     "classroom"
   ],
+  "peerDependencies": {
+    "@electron/remote": "^2.1.2"
+  },
   "dependencies": {
     "@plasosdk/screenshot": "^1.3.4",
     "@plasosdk/winproxy": "^1.1.5",

package/scripts/downloadPrebuild.js

@@ -94,10 +94,10 @@ const npmInstall = () => {
             installCb(agora_electron_sdk_v4, installAgora, error, stdout, stderr);
             if (!error?.message) {
                 const oldAgoraV4Path = path.join(__dirname, '../node_modules', 'agora-electron-sdk');
-                const newAgoraV4Path = path.join(__dirname, '../../../', 'agora-electron-sdk-v4');
+                const newAgoraV4Path = path.join(__dirname, '../node_modules', 'agora-electron-sdk-v4');
                 fs.move(oldAgoraV4Path, newAgoraV4Path, { overwrite: true }, (err) => {
                     if (!err) {
-                        logger.info('更新agora_electron_sdk_v4成功');
+                        logger.info('命名agora_electron_sdk_v4成功');
                     }
                 });
             }