@lambo-design-mobile/lambo-js-bridge 1.0.0-beta.22 → 1.0.0-beta.24

package/CHANGELOG.md

@@ -1,4 +1,18 @@
 # Changelog
+## [1.0.0-beta.24](http://git.inspur.com/ecbh/lambo-design/lambo-design/-/compare/@lambo-design-mobile/lambo-js-bridge@1.0.0-beta.23...@lambo-design-mobile/lambo-js-bridge@1.0.0-beta.24) (2025-03-04)
+
+
+### ✨ Features | 新功能
+
+* **@lambo-design-mobile/js-bridge:** 录音新增base64出参；新增下载接口 ([131e4a6](http://git.inspur.com/ecbh/lambo-design/lambo-design/-/commit/131e4a68228d528badea094d057a3d81c41f359b))
+
+## [1.0.0-beta.23](http://git.inspur.com/ecbh/lambo-design/lambo-design/-/compare/@lambo-design-mobile/lambo-js-bridge@1.0.0-beta.22...@lambo-design-mobile/lambo-js-bridge@1.0.0-beta.23) (2025-02-28)
+
+
+### ✨ Features | 新功能
+
+* **@lambo-design-mobile/js-bridge:** 更改录音功能调用方式 ([2aa9dd0](http://git.inspur.com/ecbh/lambo-design/lambo-design/-/commit/2aa9dd033c77b2cdb8f14787f3420f903da7e961))
+
 ## [1.0.0-beta.22](http://git.inspur.com/ecbh/lambo-design/lambo-design/-/compare/@lambo-design-mobile/lambo-js-bridge@1.0.0-beta.21...@lambo-design-mobile/lambo-js-bridge@1.0.0-beta.22) (2025-02-21)
 
 

package/README.md

@@ -324,50 +324,66 @@ async openLocation() {
 data() {
     return {
       audioUrl: null, // 用于存储录音文件的 URL
-      fileName: '',  // 录音文件名
-      fileSize: 0,   // 录音文件大小
-      fileType: '',  // 录音文件类型
       recordingStatus: "not started", // 用于记录当前录音状态
-      recordingOptions: {
-        isAuto: false,                 // 是否自动录音
-        fftSize: 512,                  // FFT 大小
-        fileName: 'audio.ogg',        // 默认录音文件名
-        silenceThreshold: 100,           // 静音检测音量阈值
-        silenceDuration: 1000,         // 静音持续时长
-        silenceDelay: 2000             // 静音检测延迟
-      }
     };
   },
-async startRecording() {
-  try {
-    this.recordingStatus = 'recording'; // 设置录音状态为进行中
-    const { audioUrl, file } = await this.$lamboJsBridge.startRecording(this.recordingOptions);
-    this.audioUrl = audioUrl; // 存储录音文件URL
-    this.fileName = file.name; // 存储文件名
-    this.fileSize = file.size; // 存储文件大小
-    this.fileType = file.type; // 存储文件类型
-    console.log(this.recordingOptions.isAuto ? '自动录音已开始' : '录音已开始');
-  } catch (error) {
-    console.error('录音失败:', error);
-    this.recordingStatus = 'failed'; // 设置录音状态为失败
-  }
+method:{
+// 开始手动录音
+    async startRecording() {
+      // 清空之前的录音数据
+      this.audioUrl = null;
+      this.recordingStatus = 'recording';
+      try {
+        // 传入 { auto: false } 表示手动录音
+        const result = await this.$lamboJsBridge.startRecording({ auto: false });
+        console.log("录音开始成功：", result);
+      } catch (error) {
+        console.error("录音开始失败：", error);
+        this.recordingStatus = 'failed';
+      }
+    },
+
+    // 开始自动录音
+    async startAutoRecording() {
+      // 清空之前的录音数据
+      this.audioUrl = null;
+      this.recordingStatus = 'recording';
+      try {
+        // 传入 { auto: true } 表示启用自动录音
+        const result = await this.$lamboJsBridge.startRecording({ auto: true });
+        console.log("自动录音开始成功：", result);
+      } catch (error) {
+        console.error("自动录音开始失败：", error);
+        this.recordingStatus = 'failed';
+      }
+    },
+
+    // 停止录音
+    async stopRecording() {
+      try {
+        const result = await this.$lamboJsBridge.stopRecording();
+        console.log("录音停止成功：", result);
+        this.recordingStatus = 'stopped';
+        // 更新录音文件信息
+        this.audioUrl = result.fileUrl || result.msg;
+        // 如果你非要用全局函数更新，也可以调用它
+        this.updateAudioDisplay(result);
+      } catch (error) {
+        console.error("录音停止失败：", error);
+        this.recordingStatus = 'failed';
+      }
+    },
+
+    // 如果你希望借助类似全局函数的形式更新页面，可以这样定义：
+    updateAudioDisplay(data) {
+      // 更新组件中的数据，页面会自动响应
+      this.recordingStatus = 'stopped';
+      this.audioUrl = data.fileUrl;
+    },
 },
-async startAutoRecording() {
-  // 启动自动录音
-  this.recordingOptions.isAuto = true;
-  await this.startRecording(); // 调用startRecording方法进行录音
+mounted() {
+  window.updateAudioDisplay = this.updateAudioDisplay;
 },
-async stopRecording() {
-  try {
-    await this.$lamboJsBridge.stopRecording(); // 调用接口停止录音
-    this.recordingStatus = 'stopped'; // 设置录音状态为停止
-    console.log('录音已停止');
-  } catch (error) {
-    console.error('停止录音失败:', error);
-    this.recordingStatus = 'failed'; // 设置录音状态为失败
-  }
-},
-
 ```
 
 ### 参数说明
@@ -377,24 +393,17 @@ async stopRecording() {
 | 属性        | 类型 | 默认值      | 必填  | 支持平台 | 说明                                                          |
 |-----------|--|----------|-----|----------|-------------------------------------------------------------|
 | isAuto  | boolean | false    | 否   |   Yuntu     | 是否开启自动录音。若为 true，则自动开始录音。 |
-| fftSize | number | 512      | 否   |   Yuntu         | FFT大小，用于声音信号处理。            |
-| fileName      | string | 录音文件.ogg | 否  |   Yuntu      | 录音文件的默认文件名。       |
-| silenceThreshold  | number | 20       | 否  |   Yuntu      | 	静音检测音量阈值。 |
-| silenceDuration     | number | 3000     | 否  |   Yuntu      | 静音持续时长。|
-| silenceDelay     | number | 1000     | 否  |   Yuntu       |  静音检测延迟。 |
 
 
 ### 返回说明
 
 `Promise<Object>`
 
-| 属性        | 类型 | 默认值      | 必填  | 支持平台 | 说明              |
-|-----------|--|----------|-----|----------|-----------------|
-| audioUrl  | string |    | 是   |   Yuntu     | 录音文件的BlobURL    |
-| file | Object |      | 是   |   Yuntu         | 录音文件的详细信息 |
-| file.name	      | string |  | 是  |   Yuntu      | 录音文件的名称     |
-| file.size	  | number |      | 是  |   Yuntu      | 		录音文件的大小，单位为字节      |
-| file.type	     | string |     | 是  |   Yuntu      | 录音文件的类型         |
+| 属性        | 类型 | 默认值      | 必填  | 支持平台 | 说明            |
+|-----------|--|----------|-----|----------|---------------|
+| fileUrl  | string |    | 是   |   Yuntu     | 录音文件的URL      |
+| filePath  | string |    | 是   |   Yuntu     | 录音文件的路径       |
+| fileData  | string |    | 是   |   Yuntu     | 录音文件的base64文件 |
 <br>
 
 **录音状态** <br>
@@ -402,3 +411,37 @@ async stopRecording() {
 **not started**：录音未开始。<br>
 **stopped**：录音已停止。<br>
 **failed**：录音失败。<br>
+
+### 下载文件（downloadFile）
+
+调用文件下载功能，通过指定文件 URL 下载文件，并自动触发下载行为。
+``` javascript
+async downloadFile() {
+  try {
+    const fileUrl = 'http://10.110.34.27/yc_scrm.apk'; // 需要下载的文件 URL
+    const fileName = '下载文件'; // 文件保存名称
+    await this.$lamboJsBridge.downloadFile({ fileUrl, fileName });
+    console.log('Download initiated');
+  } catch (error) {
+    console.error('Download failed:', error);
+  }
+}
+```
+
+### 参数说明
+
+`params`: Object
+
+| 属性        | 类型 | 默认值      | 必填  | 支持平台 | 说明                                                          |
+|-----------|--|----------|-----|----------|-------------------------------------------------------------|
+| fileUrl  | string | 无    | 是   |   Yuntu     | 要下载文件的 URL 地址 |
+| fileName  | string | 'downloadedFile'	    | 否   |   Yuntu     | 下载后保存的文件名称，建议不包含文件扩展名（可由调用者自行添加扩展名） |
+
+
+### 返回说明
+
+`Promise<Object>`
+
+| 属性        | 类型 | 默认值      | 必填  | 支持平台 | 说明      |
+|-----------|--|----------|-----|----------|---------|
+| filePath  | string |    | 是   |   Yuntu     | 录音文件的路径 |

package/demo/index.vue

@@ -29,7 +29,7 @@
       <pre v-show="openLocationResult"><code>{{ openLocationResult }}</code></pre>
     </demo-block>
     <demo-block title="文件预览">
-      <a href="javascript:void(0);" @click="previewFile">点击这里预览文件</a>
+      <a href="javascript:void(0);" @click="filePreview">点击这里预览文件</a>
     </demo-block>
     <demo-block title="录音（仅在Flutter环境下可用）">
       <van-button @click="startRecording">开始录音</van-button>
@@ -50,12 +50,15 @@
       <div v-if="audioUrl">
         <h3>录音已完成</h3>
         <audio :src="audioUrl" controls></audio>
-        <p>录音文件: {{ fileName }}</p>
-        <p>文件大小: {{ fileSize }} 字节</p>
-        <p>文件类型: {{ fileType }}</p>
-        <p>文件地址：{{ audioUrl }}</p>
+        <p>FileUrl：{{ audioUrl }}</p>
+        <p>FilePath：{{ audioPath }}</p>
+        <p>FileData：{{ audioData }}</p>
       </div>
     </demo-block>
+    <demo-block title="下载">
+      <van-button @click="downloadFile">下载文件</van-button>
+      <p v-if="downloadLink">文件已下载，路径：{{ downloadLink }}</p>
+    </demo-block>
 
 
 
@@ -90,18 +93,10 @@ export default {
       photoPreviews: [],
       initKeyMessage: '', // 用于存储 initKey 的返回消息
       audioUrl: null, // 用于存储录音文件的 URL
-      fileName: '',  // 录音文件名
-      fileSize: 0,   // 录音文件大小
-      fileType: '',  // 录音文件类型
+      audioPath: null,
+      audioData: null,
       recordingStatus: "not started", // 用于记录当前录音状态
-      recordingOptions: {
-        isAuto: false,                 // 是否自动录音
-        fftSize: 512,                  // FFT 大小
-        fileName: 'audio.ogg',        // 默认录音文件名
-        silenceThreshold: 100,           // 静音检测音量阈值
-        silenceDuration: 1000,         // 静音持续时长
-        silenceDelay: 2000             // 静音检测延迟
-      }
+      downloadLink : null,
     };
   },
   computed: {
@@ -128,7 +123,7 @@ export default {
       weComId:this.weComId,
       agentId:this.agentId,
       dingTalkId:this.dingTalkId,
-      pluginConfig:["localAuthPlugin","amapPlugin","tabBarPlugin","scanCodePlugin","filePreviewPlugin"],
+      pluginConfig:["localAuthPlugin","amapPlugin","tabBarPlugin","scanCodePlugin","filePreviewPlugin","autoRecordPlugin","downloadFilePlugin"],
     };
     this.$lamboJsBridge = new LamboJsBridge(options);
     await this.getPlatform();
@@ -144,40 +139,89 @@ export default {
         console.error('Error getting init info:', error);
       }
     },
+
+    // 开始手动录音
     async startRecording() {
+      // 清空之前的录音数据
+      this.audioUrl = null;
+      this.recordingStatus = 'recording';
       try {
-        this.recordingStatus = 'recording';
-        const { audioUrl, file } = await this.$lamboJsBridge.startRecording(this.recordingOptions);
-        this.audioUrl = audioUrl;
-        this.fileName = file.name;
-        this.fileSize = file.size;
-        this.fileType = file.type;
-        console.log(this.recordingOptions.isAuto ? '自动录音已开始' : '录音已开始');
+        // 传入 { auto: false } 表示手动录音
+        const result = await this.$lamboJsBridge.startRecording({ auto: false });
+        console.log("录音开始成功：", result);
       } catch (error) {
-        console.error('录音失败:', error);
+        console.error("录音开始失败：", error);
         this.recordingStatus = 'failed';
       }
     },
 
     // 开始自动录音
     async startAutoRecording() {
-      // 更改 recordingOptions 中的 isAuto 值为 true
-      this.recordingOptions.isAuto = true;
-      await this.startRecording(); // 调用 startRecording
+      // 清空之前的录音数据
+      this.audioUrl = null;
+      this.recordingStatus = 'recording';
+      try {
+        // 传入 { auto: true } 表示启用自动录音
+        const result = await this.$lamboJsBridge.startRecording({ auto: true });
+        console.log("自动录音开始成功：", result);
+      } catch (error) {
+        console.error("自动录音开始失败：", error);
+        this.recordingStatus = 'failed';
+      }
     },
 
     // 停止录音
     async stopRecording() {
       try {
-        await this.$lamboJsBridge.stopRecording();
+        const result = await this.$lamboJsBridge.stopRecording();
+        console.log("录音停止成功：", result);
         this.recordingStatus = 'stopped';
-        console.log('录音已停止');
+        // 更新录音文件信息
+        this.audioUrl = result.fileUrl || result.msg;
+        // 如果你非要用全局函数更新，也可以调用它
+        this.updateAudioDisplay(result);
       } catch (error) {
-        console.error('停止录音失败:', error);
+        console.error("录音停止失败：", error);
         this.recordingStatus = 'failed';
       }
     },
 
+    // 如果你希望借助类似全局函数的形式更新页面，可以这样定义：
+    updateAudioDisplay(data) {
+      // 更新组件中的数据，页面会自动响应
+      this.recordingStatus = 'stopped';
+      this.audioUrl = data.fileUrl;
+      this.audioPath = data.filePath;
+      this.audioData = data.fileData;
+    },
+
+
+    async downloadFile(){
+      try {
+        const fileUrl = 'http://10.110.34.27/sampleFile.txt'; // 要下载的文件 URL
+        const fileName = '下载文件.txt'; // 文件名称（建议带上扩展名）
+        // 注意传递的参数键需与插件内部代码一致：title 和 path
+        let result = await this.$lamboJsBridge.downloadFile({ title: fileName, path: fileUrl });
+        console.log('Download initiated, result:', result);
+
+        // 如果返回的数据为字符串，则尝试解析为对象
+        if (typeof result === 'string') {
+          try {
+            result = JSON.parse(result);
+          } catch (e) {
+            console.error('解析下载结果失败：', e);
+          }
+        }
+
+        // 假设返回的对象中包含 path 属性（如果没有则直接使用 result）
+        const filePath = result.path || result;
+        // 更新组件数据，显示文件下载路径
+        this.downloadLink = filePath;
+      } catch (error){
+        console.error('Download failed:', error);
+      }
+    },
+
     async getLocation() {
       try {
         const options ={
@@ -259,7 +303,7 @@ export default {
         console.error('Error opening location:', error);
       }
     },
-    async previewFile() {
+    async filePreview() {
       try {
         const options = {
           title: '预览文件.txt', // 文件的标题
@@ -283,6 +327,9 @@ export default {
       }
     },
   },
+  mounted() {
+    window.updateAudioDisplay = this.updateAudioDisplay;
+  },
   beforeRouteEnter (to, from, next) {
     next(vm => {
       if (from.name !== null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambo-design-mobile/lambo-js-bridge",
-  "version": "1.0.0-beta.22",
+  "version": "1.0.0-beta.24",
   "description": "",
   "main": "index.js",
   "author": "lambo",

package/src/sdk/LamboJsBridge.js

@@ -88,6 +88,10 @@ class LamboJsBridge {
         return this.platform.stopRecording(options);
     }
 
+    async downloadFile(options={}){
+        return this.platform.downloadFile(options);
+    }
+
     // 创建一个 Vue 插件
     static install(Vue) {
         // 将 LamboJsBridge 实例挂载到 Vue 原型上，全局可用

package/src/sdk/YunTuAdapter.js

@@ -6,12 +6,7 @@ class YunTuAdapter {
         this.isInitialized = false;
         this.audioUrl = null; // 录音文件的 URL
         this.fileName = ''; // 录音文件名称
-        this.fileSize = 0; // 录音文件大小
         this.fileType = ''; // 录音文件类型
-        this.errorMessage = ''; // 错误信息
-        this.recorder = null; // MediaRecorder 实例
-        this.streams = null; // 音频流
-        this.chunks = []; // 录音数据块
         this.initializePlugin(options.pluginConfig);
     }
 
@@ -33,143 +28,94 @@ class YunTuAdapter {
         }
     }
 
-    // 启动录音
-    async startRecording({
-                             isAuto = false,
-                             fftSize = 512,
-                             fileName = '录音文件.ogg',
-                             silenceThreshold = 20, // 静音检测的音量阈值
-                             silenceDuration = 3000, // 超过多少秒静音就停止录音
-                             silenceDelay = 1000 // 延迟多少秒开始静音检测
-                         }) {
-        console.log("开始录音，模式：", isAuto ? "自动录音" : "普通录音");
-        this.errorMessage = ''; // 清空错误信息
-
-        try {
-            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-            console.log("成功获取麦克风权限，开始录音...");
-            this.streams = stream;
-
-            // 创建音频上下文
-            this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
-            console.log("创建音频上下文：", this.audioContext);
-
-            // 创建音频分析器
-            this.analyser = this.audioContext.createAnalyser();
-            console.log("创建音频分析器：", this.analyser);
-
-            const microphone = this.audioContext.createMediaStreamSource(stream);
-            microphone.connect(this.analyser);
-            this.analyser.fftSize = fftSize;
-            console.log("音频分析器配置完成，FFT Size:", this.analyser.fftSize);
-
-            // 创建 MediaRecorder 实例
-            this.recorder = new MediaRecorder(stream);
-            console.log("创建 MediaRecorder 实例：", this.recorder);
-
-            // 监听数据可用事件
-            this.recorder.ondataavailable = (e) => {
-                console.log("收到录音数据块，大小：", e.data.size, "字节");
-                this.chunks.push(e.data);
-            };
-
-            // 返回 Promise
-            return new Promise((resolve, reject) => {
-                // 监听录音停止事件
-                this.recorder.onstop = () => {
-                    console.log("录音停止，生成音频文件...");
-                    const blob = new Blob(this.chunks, { type: 'audio/ogg' });
-                    this.audioUrl = URL.createObjectURL(blob);  // 生成录音文件 URL
-                    const file = new File([blob], fileName, { type: 'audio/ogg' });
-                    this.fileName = file.name;
-                    this.fileSize = file.size;
-                    this.fileType = file.type;
-                    console.log("生成的音频文件：", file);
-
-                    // 返回包含音频 URL 和文件对象的对象
-                    resolve({
-                        audioUrl: this.audioUrl,
-                        file: file
-                    });
-                };
-
-                // 启动静音检测
-                this.startSilenceDetection({
-                    silenceThreshold,
-                    silenceDuration,
-                    silenceDelay
-                });
-
-                // 开始录音
-                this.recorder.start();
-                console.log("录音已开始");
-            });
-        } catch (err) {
-            console.error("获取麦克风权限失败:", err);
-            this.errorMessage = "无法访问麦克风，请检查权限设置";
-            return Promise.reject(new Error(this.errorMessage));  // 返回错误
-        }
-    }
-
-    // 静音检测
-    startSilenceDetection({
-                              silenceThreshold = 20, // 静音检测的音量阈值
-                              silenceDuration = 3000, // 超过多少秒静音就停止录音
-                              silenceDelay = 1000 // 延迟多少秒开始静音检测
-                          }) {
-        console.log("启动静音检测...");
-        const bufferLength = this.analyser.frequencyBinCount;
-        const dataArray = new Uint8Array(bufferLength);
-        let silenceStart = Date.now();
-        let isSpeaking = false;
-
-        const checkVolume = () => {
-            this.analyser.getByteFrequencyData(dataArray);
-            const volume = Math.max(...dataArray);
-            console.debug("当前音量：", volume);
-
-            if (volume > silenceThreshold) { // 音量阈值
-                console.debug("检测到声音，重置静音计时器");
-                isSpeaking = true;
-                silenceStart = Date.now();
-            } else if (isSpeaking && Date.now() - silenceStart > silenceDuration) {
-                // 超过指定静音时长
-                console.log(`检测到持续 ${silenceDuration / 1000} 秒静音，停止录音`);
-                this.stopRecording();
-                return;
+    // 录音：开始录音（支持自动和手动模式）
+    async startRecording(options = { auto: false }) {
+        return new Promise((resolve, reject) => {
+            if (window.autoRecord && typeof window.autoRecord.startRecording === 'function') {
+                window.autoRecord.startRecording(
+                    (result) => {
+                        console.log("录音开始:", result);
+                        resolve(result);
+                    },
+                    (error) => {
+                        console.error("录音错误:", error);
+                        reject(error);
+                    },
+                    JSON.stringify(options) // 传入参数：{auto: false} 表示手动录音，{auto: true} 表示自动录音
+                );
+            } else {
+                reject(new Error("autoRecord 接口不可用"));
             }
+        });
+    }
 
-            if (this.recorder && this.recorder.state === 'recording') {
-                requestAnimationFrame(checkVolume);
+    // 录音：结束录音，并返回录音结果
+    async stopRecording() {
+        return new Promise((resolve, reject) => {
+            if (window.autoRecord && typeof window.autoRecord.stopRecording === 'function') {
+                window.autoRecord.stopRecording(
+                    (result) => {
+                        console.log("录音停止，返回结果:", result);
+                        // 如果返回数据为字符串，则尝试解析为对象
+                        try {
+                            if (typeof result === "string") {
+                                result = JSON.parse(result);
+                            }
+                        } catch (e) {
+                            console.error("JSON.parse error:", e);
+                        }
+                        resolve(result);
+                    },
+                    (error) => {
+                        console.error("录音结束错误:", error);
+                        // 同样尝试解析错误信息
+                        try {
+                            if (typeof error === "string") {
+                                error = JSON.parse(error);
+                            }
+                        } catch (e) {
+                            console.error("JSON.parse error:", e);
+                        }
+                        reject(error);
+                    }
+                );
+            } else {
+                reject(new Error("autoRecord 接口不可用"));
             }
-        };
+        });
+    }
 
-        // 延迟开始静音检测
-        setTimeout(() => {
-            if (this.recorder && this.recorder.state === 'recording') {
-                console.log("静音检测正式开始");
-                requestAnimationFrame(checkVolume);
+    // 新增下载文件接口，options 作为参数传入
+    async downloadFile(options) {
+        return new Promise((resolve, reject) => {
+            if (window.fileDownload && typeof window.fileDownload.downloadFile === 'function') {
+                window.fileDownload.downloadFile(
+                    // 成功回调
+                    (result) => {
+                        console.log("文件下载成功:", result);
+                        try {
+                            if (typeof result === "string") {
+                                result = JSON.parse(result);
+                            }
+                        } catch (e) {
+                            console.error("JSON.parse error:", e);
+                        }
+                        resolve(result);
+                    },
+                    // 失败回调
+                    (error) => {
+                        console.error("文件下载失败:", error);
+                        reject(error);
+                    },
+                    // 直接将传入的 options 对象转为字符串
+                    JSON.stringify(options)
+                );
+            } else {
+                reject(new Error("downloadFile 接口不可用"));
             }
-        }, silenceDelay);
+        });
     }
 
-    // 停止录音
-    async stopRecording() {
-        console.log("停止录音...");
-        if (this.recorder && this.recorder.state === 'recording') {
-            this.recorder.stop();
-            console.log("录音已停止");
-        }
-        if (this.streams) {
-            this.streams.getTracks().forEach((track) => {
-                track.stop();
-                console.log("停止音频轨道：", track);
-            });
-        }
-        this.chunks = []; // 清空录音数据块
-        this.audioContext.close();
-        console.log("音频上下文已关闭");
-    }
 
     async getPlatform() {
         return {