fmode-ng 0.0.39 → 0.0.41

package/esm2022/lib/aigc/voice/fmode-voice.service.mjs

@@ -1,10 +1,503 @@
-
+import { Injectable } from '@angular/core';
+// import RecorderManager from "./lib/xunfei-recorder"
+// import {RecorderManager} from "./lib/recorder/recorder-manager"
+import Recorder from 'recorder-core';
+import 'recorder-core/src/engine/pcm';
+import 'recorder-core/src/engine/wav';
+import 'recorder-core/src/extensions/waveview';
+import CryptoJS from "crypto-js";
+import { pcmtoWav } from './lib/pcm2wav';
+import { convertFrameBufferToBase64, resampleBuffer } from './lib/resample';
+import { WebSpeech } from './class-asr';
+import { Platform } from '@ionic/angular';
+import { Diagnostic } from '@awesome-cordova-plugins/diagnostic/ngx';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@awesome-cordova-plugins/diagnostic/ngx";
+// import { FmodeTTSXunfei } fro./class-tts-xunfei.ts.bakfei'
+export class FmodeVoiceService {
+    constructor(platform, diagnostic) {
+        this.platform = platform;
+        this.diagnostic = diagnostic;
+        /**
+         * 讯飞TTS语音合成
+         */
+        // ttsXunfei = new FmodeTTSXunfei()
+        /**
+         * WebSpeech 语音库
+         */
+        this.webSpeech = WebSpeech;
+        /**
+          * 用户操作：完成录音，并处理转录结果
+         */
+        this.isUserFinish = false;
+        this.recordWavBlob = null;
+        this.recordPcmBlob = null;
+        this.recordDuration = 0;
+        this.recordType = "pcm";
+        this.encodingType = "raw";
+        this.connStatus = ""; // 录音中 建立连接中 关闭连接中
+        this.btnStatus = "UNDEFINED"; // "UNDEFINED" "CONNECTING" "OPEN" "CLOSING" "CLOSED"
+        this.resultText = "";
+        this.resultTextTemp = "";
+        /**
+         * 获取websocket url
+         * 该接口需要后端提供，这里为了方便前端处理
+         */
+        this.APPID = "50f4a46c";
+        this.API_SECRET = "NzFlNmFhZDJjMDNkZGM3NzI0Mzg2OGNm";
+        this.API_KEY = "106ddc40dfd4b9ca6d7b47c70fada749";
+        this.requestPermission();
+        // this.recorder.on("start",() => {
+        // })
+        // this.recorder.on("frameRecorded", ({ isLastFrame, frameBuffer }) => {
+        //   if (this.iatWS.readyState === this.iatWS.OPEN) {
+        //     this.iatWS.send(
+        //       JSON.stringify({
+        //         data: {
+        //           status: isLastFrame ? 2 : 1,
+        //           format: "audio/L16;rate=16000",
+        //           encoding: this.encodingType,
+        //           audio: this.toBase64(frameBuffer),
+        //         },
+        //       })
+        //     );
+        //     if (isLastFrame) {
+        //       this.changeBtnStatus("CLOSING");
+        //     }
+        //   }
+        // })
+        // this.recorder.on("stop",() => {
+        // })
+    }
+    /**()
+     * 用户操作：录音按钮快捷触发操作
+     */
+    toggleRecord() {
+        console.log(this.btnStatus);
+        if (this.btnStatus === "UNDEFINED" || this.btnStatus === "CLOSED") {
+            // 开始讲话`
+            this.startTalk();
+        }
+        else if (this.btnStatus === "CONNECTING" || this.btnStatus === "OPEN") {
+            // 结束录音 并发送消息等待回复
+            this.finishTalk();
+        }
+    }
+    finishTalk() {
+        this.isUserFinish = true;
+        this.onBeforeFinishTalk && this.onBeforeFinishTalk();
+        this.recordStop();
+    }
+    /**
+     * 用户操作：开始讲话，实时转录语言
+     */
+    async startTalk(evnet) {
+        this.resultText = "";
+        this.resultTextTemp = "";
+        this.onBeforeStartTalk && this.onBeforeStartTalk();
+        event?.preventDefault();
+        await this.openWithPriviledge();
+        setTimeout(() => {
+            this.connectWebSocket();
+        }, 100);
+        this.onAfterStartTalk && this.onAfterStartTalk();
+    }
+    /**
+     * 用户操作：取消讲话，且不发送结果
+     */
+    cancelTalk() {
+        this.onBeforeCancelTalk && this.onBeforeCancelTalk();
+        this.recordStop(); // 停止录制
+        this.iatWS?.close(); // 断开连接
+        this.resultText = null; // 设置转录结果为空
+        this.onAfterCancelTalk && this.onAfterCancelTalk();
+    }
     /**
-     * @copyright © 未来飞马 © 未来全栈 www.fmode.cn 
-     * 版权所有 © 未来飞马 © 江西脑控科技有限公司 Copyright © Fmode Technology Co., Ltd.
-     * 保留所有权利 All Rights Reserved.
-     * /home/ryan/workspace/nova/nova-admin/dist/fmode-ng/esm2022/lib/aigc/voice/fmode-voice.service.mjs
+     * 程序逻辑
      */
-    import{Injectable}from"@angular/core";import Recorder from"recorder-core";import"recorder-core/src/engine/pcm";import"recorder-core/src/engine/wav";import"recorder-core/src/extensions/waveview";import CryptoJS from"crypto-js";import{pcmtoWav}from"./lib/pcm2wav";import{convertFrameBufferToBase64,resampleBuffer}from"./lib/resample";import{WebSpeech}from"./class-asr";import{Platform}from"@ionic/angular";import{Diagnostic}from"@awesome-cordova-plugins/diagnostic/ngx";import*as i0 from"@angular/core";import*as i1 from"@ionic/angular";import*as i2 from"@awesome-cordova-plugins/diagnostic/ngx";export class FmodeVoiceService{constructor(t,e){this.platform=t,this.diagnostic=e,this.webSpeech=WebSpeech,this.isUserFinish=!1,this.recordWavBlob=null,this.recordPcmBlob=null,this.recordDuration=0,this.recordType="pcm",this.encodingType="raw",this.connStatus="",this.btnStatus="UNDEFINED",this.resultText="",this.resultTextTemp="",this.APPID="50f4a46c",this.API_SECRET="NzFlNmFhZDJjMDNkZGM3NzI0Mzg2OGNm",this.API_KEY="106ddc40dfd4b9ca6d7b47c70fada749",this.requestPermission()}toggleRecord(){console.log(this.btnStatus),"UNDEFINED"===this.btnStatus||"CLOSED"===this.btnStatus?this.startTalk():"CONNECTING"!==this.btnStatus&&"OPEN"!==this.btnStatus||this.finishTalk()}finishTalk(){this.isUserFinish=!0,this.onBeforeFinishTalk&&this.onBeforeFinishTalk(),this.recordStop()}async startTalk(t){this.resultText="",this.resultTextTemp="",this.onBeforeStartTalk&&this.onBeforeStartTalk(),event?.preventDefault(),await this.openWithPriviledge(),setTimeout((()=>{this.connectWebSocket()}),100),this.onAfterStartTalk&&this.onAfterStartTalk()}cancelTalk(){this.onBeforeCancelTalk&&this.onBeforeCancelTalk(),this.recordStop(),this.iatWS?.close(),this.resultText=null,this.onAfterCancelTalk&&this.onAfterCancelTalk()}async recordStart(){this.createRecorder(),await this.openWithPriviledge(),this.recorder.start(),this.changeBtnStatus("OPEN"),this.onAfterRecordStart&&this.onAfterRecordStart()}recordStop(){return new Promise((t=>{clearInterval(this.countdownInterval),this.changeBtnStatus("CLOSED"),this.recorder?.stop((async(e,i)=>{try{this.iatWS.send(JSON.stringify({data:{status:2,format:"audio/L16;rate=16000",encoding:this.encodingType,audio:""}}))}catch(t){}let s=(window.URL||webkitURL).createObjectURL(e);console.log(e,s,"时长:"+i+"ms"),this.recordPcmBlob=e,this.recordWavBlob=await this.pcmBlobToWavBlob(e,44100),this.recordDuration=i,console.log("this.recordWavBlob",this.recordWavBlob),setTimeout((()=>{this.isUserFinish&&(this.onAfterFinishTalk&&this.onAfterFinishTalk(),this.isUserFinish=!1)}),2e3),this.recorder?.close(),this.recorder=null,console.log("localUrl",s),t(!0)}),(e=>{console.log("录音失败:"+e),this.recorder.close(),this.recorder=null,t(null)}))}))}playRecord(){this.playPCM(this.recordPcmBlob,44100)}async pcmBlobToWavBlob(t,e){return new Promise((i=>{let s=new FileReader;s.onload=function(t){let s=t.target.result,o=pcmtoWav(s,e,1,16);i(o)},s.readAsArrayBuffer(t)}))}async playPCM(t,e){let i=await this.pcmBlobToWavBlob(t,e),s=window.URL.createObjectURL(i),o=new Audio;o.src=s,o.play()}async playBuffers(){let t=await this.BuffersToBlob(this.buffers);this.playPCM(t,44100)}BuffersToBlob(t){let e=[];return t.forEach((t=>{t.forEach((t=>{e.push(t)}))})),new Blob([e],{type:"audio/pcm"})}splitAudioData(t){const e=1280,i=Math.ceil(t.length/e),s=[];for(let o=0;o<i;o++){const i=o*e,r=i+e,a=t.slice(i,r);s.push(a)}return s}BufferToBlob(t){return new Blob([t],{type:"audio/pcm"})}createRecorder(){this.recorder||(this.recorder=Recorder({type:this.recordType,sampleRate:44100,bitRate:16,onProcess:(t,e,i,s,o,r)=>{let a=t.length&&t[t.length-1];if(this.buffers=t,a=resampleBuffer(a,44100,16e3),this.iatWS.readyState===this.iatWS.OPEN){if(this.disableASR)return;this.iatWS.send(JSON.stringify({data:{status:1,format:"audio/L16;rate=16000",encoding:this.encodingType,audio:convertFrameBufferToBase64(a)}}))}this.waveClient?.input(t[t.length-1],e,s)}}))}async openWithPriviledge(){return console.log(this.btnStatus),await this.requestPermission(),this.createRecorder(),!!Recorder.IsOpen()||new Promise((t=>{this.recorder.open((()=>{let e=document.querySelector(".record-wave");e&&(console.log(e),Recorder.WaveView&&(this.waveClient=Recorder.WaveView({elem:".record-wave"}))),t(!0)}),((t,e)=>{console.log((e?"UserNotAllow，":"")+"无法录音:"+t)}))}))}getWebSocketUrl(){let t="wss://iat-api.xfyun.cn/v2/iat",e="iat-api.xfyun.cn",i=this.API_KEY,s=this.API_SECRET,o=(new Date).toUTCString(),r=`host: ${e}\ndate: ${o}\nGET /v2/iat HTTP/1.1`,a=CryptoJS.HmacSHA256(r,s),n=CryptoJS.enc.Base64.stringify(a);return t=`${t}?authorization=${btoa(`api_key="${i}", algorithm="hmac-sha256", headers="host date request-line", signature="${n}"`)}&date=${o}&host=${e}`,t}toBase64(t){for(var e="",i=new Uint8Array(t),s=i.byteLength,o=0;o<s;o++)e+=String.fromCharCode(i[o]);return window.btoa(e)}countdown(){let t=60;this.connStatus=`录音中（${t}s）`,this.countdownInterval=setInterval((()=>{t-=1,console.log(t),t<=0?(clearInterval(this.countdownInterval),this.recordStop()):this.connStatus=`录音中（${t}s）`}),1e3)}changeBtnStatus(t){this.btnStatus=t,"CONNECTING"===t?this.connStatus="建立连接中":"OPEN"===t?this.countdown():"CLOSING"===t?this.connStatus="关闭连接中":"CLOSED"===t&&(this.connStatus="开始录音")}renderResult(t){let e=JSON.parse(t);if(e.data&&e.data.result){let t=e.data.result,i="",s=t.ws;for(let t=0;t<s.length;t++)i+=s[t].cw[0].w,console.log(i);t.pgs?("apd"===t.pgs&&(this.resultText=this.resultTextTemp),this.resultTextTemp=this.resultText+i):this.resultText=this.resultText+i,this.resultTextTemp||this.resultText,console.log("diff temp",this.resultTextTemp),console.log("diff result",this.resultText)}0===e.code&&2===e.data.status&&this.iatWS.close(),0!==e.code&&(this.iatWS.close(),console.error(e))}connectWebSocket(){console.log("connectWebSocket");const t=this.getWebSocketUrl();if("WebSocket"in window)this.iatWS=new WebSocket(t);else if(!("MozWebSocket"in window))return void alert("浏览器不支持WebSocket");console.log("connectWebSocket",this.btnStatus),this.changeBtnStatus("CONNECTING"),this.iatWS.onopen=t=>{this.recordStart();var e={common:{app_id:this.APPID},business:{language:"zh_cn",domain:"iat",accent:"mandarin",vad_eos:5e3,dwa:"wpgs"},data:{status:0,format:"audio/L16;rate=16000",encoding:this.encodingType}};this.iatWS.send(JSON.stringify(e))},this.iatWS.onmessage=t=>{console.log("onmessage"+this.resultText),this.renderResult(t.data)},this.iatWS.onerror=t=>{console.error("error",t),this.recordStop(),this.changeBtnStatus("CLOSED")},this.iatWS.onclose=async t=>{console.log("onclose"+this.resultText),console.error("close",t),await this.recordStop(),this.changeBtnStatus("CLOSED")}}isCapacitor(){return this.platform.is("capacitor")||this.platform.is("cordova")}async requestPermission(){if(this.isCapacitor())try{await this.requestStoagePermission(),await this.requestCameraPermission(),await this.requestMicPermission(),await this.requestRecordAudioPermission()}catch(t){console.error(t)}}async requestRecordAudioPermission(){let t=await this.diagnostic.requestRuntimePermissions([this.diagnostic.permission.RECORD_AUDIO]);console.log("record permission request:",t)}async requestMicPermission(){let t=await this.diagnostic.isMicrophoneAuthorized();if(console.log("permisson_MIC:",t),!t){await this.diagnostic.requestMicrophoneAuthorization()}}async requestStoagePermission(){let t=await this.diagnostic.isExternalStorageAuthorized();if(console.log("permisson_STORAGE:",t),!t){await this.diagnostic.requestExternalStorageAuthorization()}}async requestCameraPermission(){let t=await this.diagnostic.isCameraAuthorized();if(console.log("permisson_Camera:",t),!t){await this.diagnostic.requestCameraAuthorization()}}static{this.ɵfac=i0.ɵɵngDeclareFactory({minVersion:"12.0.0",version:"17.3.12",ngImport:i0,type:FmodeVoiceService,deps:[{token:i1.Platform},{token:i2.Diagnostic}],target:i0.ɵɵFactoryTarget.Injectable})}static{this.ɵprov=i0.ɵɵngDeclareInjectable({minVersion:"12.0.0",version:"17.3.12",ngImport:i0,type:FmodeVoiceService,providedIn:"root"})}}i0.ɵɵngDeclareClassMetadata({minVersion:"12.0.0",version:"17.3.12",ngImport:i0,type:FmodeVoiceService,decorators:[{type:Injectable,args:[{providedIn:"root"}]}],ctorParameters:()=>[{type:i1.Platform},{type:i2.Diagnostic}]});
-var MODULE_PATH_NEED = `6K+l5paH5Lu25piv5pys6aG555uu55qE5LiA6YOo5YiGIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBDb21wb25lbnRzIGluIEZtb2RlIEluYy4KICAgIOeJiOadg+aJgOaciSDCqSDmnKrmnaXpo57pqawgwqkg5rGf6KW/6ISR5o6n56eR5oqA5pyJ6ZmQ5YWs5Y+4IENvcHlyaWdodCDCqSBGbW9kZSBUZWNobm9sb2d5IENvLiwgTHRkLgogICAg5L+d55WZ5omA5pyJ5p2D5YipIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgICDkuKXnpoHlnKjmnKrnu4/mjojmnYPnmoTmg4XlhrXkuIvvvIzpgJrov4fku7vkvZXlqpLku4vlpI3liLbmraTmlofku7YgVW5hdXRob3JpemVkIGNvcHlpbmcgb2YgdGhpcyBmaWxlLCB2aWEgYW55IG1lZGl1bSBpcyBzdHJpY3RseSBwcm9oaWJpdGVkCiAgICDor6Xmlofku7bmmK/kuJPmnInnmoTmnLrlr4bmlofku7YgUHJvcHJpZXRhcnkgYW5kIGNvbmZpZGVudGlhbAogICAKICAgIENvcHlyaWdodCAyMDIxLW5vdyBGbW9kZSBJbmMuIHN1cHBvcnRAZm1vZGUuY24uIDE4NjA3MDA3MDczLgogICAg5L+d55WZ5omA5pyJ5p2D5YipIEFsbCByaWdodHMgcmVzZXJ2ZWQuCgogICAgUEFUSDovaG9tZS9yeWFuL3dvcmtzcGFjZS9ub3ZhL25vdmEtYWRtaW4vZGlzdC9mbW9kZS1uZy9lc20yMDIyL2xpYi9haWdjL3ZvaWNlL2Ztb2RlLXZvaWNlLnNlcnZpY2UubWpz`
-    
+    async recordStart() {
+        this.createRecorder();
+        await this.openWithPriviledge();
+        this.recorder.start();
+        this.changeBtnStatus("OPEN");
+        this.onAfterRecordStart && this.onAfterRecordStart();
+    }
+    recordStop() {
+        return new Promise((resolve) => {
+            clearInterval(this.countdownInterval);
+            this.changeBtnStatus("CLOSED");
+            this.recorder?.stop(async (blob, duration) => {
+                //录音结束后，发送录音结束帧
+                try {
+                    this.iatWS.send(JSON.stringify({ "data": { "status": 2, "format": "audio/L16;rate=16000", "encoding": this.encodingType, "audio": "" } }));
+                }
+                catch (err) { }
+                //简单利用URL生成本地文件地址，注意不用了时需要revokeObjectURL，否则霸占内存
+                //此地址只能本地使用，比如赋值给audio.src进行播放，赋值给a.href然后a.click()进行下载（a需提供download="xxx.mp3"属性）
+                let localUrl = (window.URL || webkitURL).createObjectURL(blob);
+                console.log(blob, localUrl, "时长:" + duration + "ms");
+                this.recordPcmBlob = blob;
+                this.recordWavBlob = await this.pcmBlobToWavBlob(blob, 44100);
+                this.recordDuration = duration;
+                console.log("this.recordWavBlob", this.recordWavBlob);
+                setTimeout(() => {
+                    if (this.isUserFinish) {
+                        this.onAfterFinishTalk && this.onAfterFinishTalk();
+                        this.isUserFinish = false;
+                    }
+                }, 2000);
+                this.recorder?.close(); //释放录音资源，当然可以不释放，后面可以连续调用start；但不释放时系统或浏览器会一直提示在录音，最佳操作是录完就close掉
+                this.recorder = null;
+                //已经拿到blob文件对象想干嘛就干嘛：立即播放、上传、下载保存
+                /*** 【立即播放例子】 ***/
+                // this.audioPlayer= new Audio();
+                // this.audioPlayer.controls=true;
+                // this.audioPlayer.src=localUrl;
+                console.log("localUrl", localUrl);
+                // 等待语音转义完成，处理转录结果
+                // 需要准确判断websocket已经close了
+                resolve(true);
+            }, (msg) => {
+                console.log("录音失败:" + msg);
+                this.recorder.close(); //可以通过stop方法的第3个参数来自动调用close
+                this.recorder = null;
+                resolve(null);
+            });
+        });
+    }
+    playRecord() {
+        this.playPCM(this.recordPcmBlob, 44100);
+    }
+    async pcmBlobToWavBlob(pcmBlob, sampleRate) {
+        return new Promise(resolve => {
+            let fileReader = new FileReader();
+            // 读取Blob数据
+            fileReader.onload = function (event) {
+                let pcmData = event.target.result;
+                // Convert PCM data to WAV format
+                let wavBlob = pcmtoWav(pcmData, sampleRate, 1, 16);
+                resolve(wavBlob);
+            };
+            // 将Blob转换为ArrayBuffer
+            fileReader.readAsArrayBuffer(pcmBlob);
+        });
+    }
+    async playPCM(pcmBlob, sampleRate) {
+        let wavBlob = await this.pcmBlobToWavBlob(pcmBlob, sampleRate);
+        let wavUrl = window.URL.createObjectURL(wavBlob);
+        let audio = new Audio();
+        audio.src = wavUrl;
+        audio.play();
+    }
+    async playBuffers() {
+        // let audioBuffer = []
+        // this.buffers.forEach(buffer=>{
+        //   audioBuffer.push(buffer)
+        // })
+        let audioBlob = await this.BuffersToBlob(this.buffers);
+        this.playPCM(audioBlob, 44100);
+    }
+    BuffersToBlob(buffers) {
+        let audioBuffer = [];
+        buffers.forEach(buffer => {
+            buffer.forEach(int16 => {
+                audioBuffer.push(int16);
+            });
+        });
+        return new Blob([audioBuffer], { type: 'audio/pcm' });
+    }
+    // 将录音数据分割为每次发送的音频片段 1280字节
+    splitAudioData(audioData) {
+        const segmentSize = 1280; // 目标切片大小，单位为字节
+        const segmentCount = Math.ceil(audioData.length / segmentSize); // 切片数量
+        const segments = [];
+        for (let i = 0; i < segmentCount; i++) {
+            const start = i * segmentSize;
+            const end = start + segmentSize;
+            const segment = audioData.slice(start, end);
+            segments.push(segment);
+        }
+        return segments;
+    }
+    BufferToBlob(buffer) {
+        return new Blob([buffer], { type: 'audio/pcm' });
+    }
+    createRecorder() {
+        if (this.recorder)
+            return;
+        this.recorder = Recorder({
+            type: this.recordType, sampleRate: 44100, bitRate: 16 //pcm格式，指定采样率hz、比特率kbps，其他参数使用默认配置；注意：是数字的参数必须提供数字，不要用字符串；需要使用的type类型，需提前把格式支持文件加载进来，比如使用wav格式需要提前加载wav.js编码引擎
+            ,
+            onProcess: (buffers, powerLevel, bufferDuration, bufferSampleRate, newBufferIdx, asyncEnd) => {
+                //录音实时回调，大约1秒调用12次本回调，buffers为开始到现在的所有录音pcm数据块(16位小端LE)
+                //可利用extensions/sonic.js插件实时变速变调，此插件计算量巨大，onProcess需要返回true开启异步模式
+                //可实时上传（发送）数据，配合Recorder.SampleData方法，将buffers中的新数据连续的转换成pcm上传，或使用mock方法将新数据连续的转码成其他格式上传，可以参考文档里面的：Demo片段列表 -> 实时转码并上传-通用版；基于本功能可以做到：实时转发数据、实时保存数据、实时语音识别（ASR）等
+                // 实时发送录音至接口
+                // console.log("asyncEnd:",asyncEnd)
+                // console.log(buffers.length,bufferDuration,bufferSampleRate,newBufferIdx)
+                let isLastFrame = false && this.btnStatus == "CLOSED"; // 主动关闭作为最后帧
+                // 录音默认为 44100 采样率 pcm不支持再process中实时转换
+                // 需要压缩为 16000 上传
+                let frameBuffer = buffers.length && buffers[buffers.length - 1];
+                this.buffers = buffers;
+                frameBuffer = resampleBuffer(frameBuffer, 44100, 16000);
+                // this.playPCM(this.BufferToBlob(frameBuffer),16000) // 切片数据播放，采样率测试
+                if (this.iatWS.readyState === this.iatWS.OPEN) {
+                    if (this.disableASR)
+                        return;
+                    this.iatWS.send(JSON.stringify({
+                        data: {
+                            status: isLastFrame ? 2 : 1,
+                            format: "audio/L16;rate=16000",
+                            encoding: this.encodingType,
+                            audio: convertFrameBufferToBase64(frameBuffer) // this.toBase64(audioData),
+                        },
+                    }));
+                    if (isLastFrame) {
+                        this.changeBtnStatus("CLOSING");
+                    }
+                }
+                //可实时绘制波形（extensions目录内的waveview.js、wavesurfer.view.js、frequency.histogram.view.js插件功能）
+                this.waveClient?.input(buffers[buffers.length - 1], powerLevel, bufferSampleRate);
+            }
+        });
+    }
+    async openWithPriviledge() {
+        console.log(this.btnStatus);
+        await this.requestPermission();
+        this.createRecorder();
+        if (Recorder.IsOpen())
+            return true;
+        return new Promise(resolve => {
+            //var dialog=createDelayDialog(); 我们可以选择性的弹一个对话框：为了防止移动端浏览器存在第三种情况：用户忽略，并且（或者国产系统UC系）浏览器没有任何回调，此处demo省略了弹窗的代码
+            this.recorder.open(() => {
+                //dialog&&dialog.Cancel(); 如果开启了弹框，此处需要取消
+                //rec.start() 此处可以立即开始录音，但不建议这样编写，因为open是一个延迟漫长的操作，通过两次用户操作来分别调用open和start是推荐的最佳流程
+                //创建可视化，指定一个要显示的div
+                let waveDiv = document.querySelector(".record-wave");
+                if (waveDiv) { // 存在波形区域时，加载渲染组件
+                    console.log(waveDiv);
+                    if (Recorder.WaveView)
+                        this.waveClient = Recorder.WaveView({ elem: ".record-wave" });
+                }
+                resolve(true);
+            }, (msg, isUserNotAllow) => {
+                //dialog&&dialog.Cancel(); 如果开启了弹框，此处需要取消
+                console.log((isUserNotAllow ? "UserNotAllow，" : "") + "无法录音:" + msg);
+            });
+        });
+    }
+    getWebSocketUrl() {
+        // 请求地址根据语种不同变化
+        let url = "wss://iat-api.xfyun.cn/v2/iat";
+        let host = "iat-api.xfyun.cn";
+        let apiKey = this.API_KEY;
+        let apiSecret = this.API_SECRET;
+        let date = new Date().toUTCString();
+        let algorithm = "hmac-sha256";
+        let headers = "host date request-line";
+        let signatureOrigin = `host: ${host}\ndate: ${date}\nGET /v2/iat HTTP/1.1`;
+        let signatureSha = CryptoJS.HmacSHA256(signatureOrigin, apiSecret);
+        let signature = CryptoJS.enc.Base64.stringify(signatureSha);
+        let authorizationOrigin = `api_key="${apiKey}", algorithm="${algorithm}", headers="${headers}", signature="${signature}"`;
+        let authorization = btoa(authorizationOrigin);
+        url = `${url}?authorization=${authorization}&date=${date}&host=${host}`;
+        return url;
+    }
+    toBase64(buffer) {
+        var binary = "";
+        var bytes = new Uint8Array(buffer);
+        var len = bytes.byteLength;
+        for (var i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return window.btoa(binary);
+    }
+    /**
+     * 倒计时：最长支持60秒实时语音转录，如果持续7-10秒无声音，服务端将自动CLOSE链接
+     */
+    countdown() {
+        let seconds = 60;
+        this.connStatus = `录音中（${seconds}s）`;
+        this.countdownInterval = setInterval(() => {
+            seconds = seconds - 1;
+            console.log(seconds);
+            if (seconds <= 0) {
+                clearInterval(this.countdownInterval);
+                this.recordStop();
+            }
+            else {
+                this.connStatus = `录音中（${seconds}s）`;
+            }
+        }, 1000);
+    }
+    changeBtnStatus(status) {
+        this.btnStatus = status;
+        if (status === "CONNECTING") {
+            this.connStatus = "建立连接中";
+        }
+        else if (status === "OPEN") {
+            this.countdown();
+        }
+        else if (status === "CLOSING") {
+            this.connStatus = "关闭连接中";
+        }
+        else if (status === "CLOSED") {
+            this.connStatus = "开始录音";
+        }
+    }
+    renderResult(resultData) {
+        // 识别结束
+        let jsonData = JSON.parse(resultData);
+        // console.log(jsonData.data.result)
+        if (jsonData.data && jsonData.data.result) {
+            let data = jsonData.data.result;
+            let str = "";
+            let ws = data.ws;
+            for (let i = 0; i < ws.length; i++) {
+                str = str + ws[i].cw[0].w;
+                console.log(str);
+            }
+            // 开启wpgs会有此字段(前提：在控制台开通动态修正功能)
+            // 取值为 "apd"时表示该片结果是追加到前面的最终结果；取值为"rpl" 时表示替换前面的部分结果，替换范围为rg字段
+            if (data.pgs) {
+                if (data.pgs === "apd") {
+                    // 将this.resultTextTemp同步给this.resultText
+                    this.resultText = this.resultTextTemp;
+                }
+                // 将结果存储在this.resultTextTemp中
+                this.resultTextTemp = this.resultText + str;
+            }
+            else {
+                this.resultText = this.resultText + str;
+            }
+            this.resultTextTemp || this.resultText || "";
+            console.log("diff temp", this.resultTextTemp);
+            console.log("diff result", this.resultText);
+        }
+        if (jsonData.code === 0 && jsonData.data.status === 2) {
+            this.iatWS.close();
+        }
+        if (jsonData.code !== 0) {
+            this.iatWS.close();
+            console.error(jsonData);
+        }
+    }
+    connectWebSocket() {
+        console.log("connectWebSocket");
+        const websocketUrl = this.getWebSocketUrl();
+        if ("WebSocket" in window) {
+            this.iatWS = new WebSocket(websocketUrl);
+        }
+        else if ("MozWebSocket" in window) {
+            // this.iatWS = new MozWebSocket(websocketUrl); // Moz兼容
+        }
+        else {
+            alert("浏览器不支持WebSocket");
+            return;
+        }
+        console.log("connectWebSocket", this.btnStatus);
+        this.changeBtnStatus("CONNECTING");
+        this.iatWS.onopen = (e) => {
+            // 开始录音
+            this.recordStart();
+            var params = {
+                common: {
+                    app_id: this.APPID,
+                },
+                business: {
+                    language: "zh_cn",
+                    domain: "iat",
+                    accent: "mandarin",
+                    vad_eos: 5000,
+                    dwa: "wpgs",
+                },
+                data: {
+                    status: 0,
+                    format: "audio/L16;rate=16000",
+                    encoding: this.encodingType,
+                    // encoding: "speex-wb",
+                },
+            };
+            this.iatWS.send(JSON.stringify(params));
+        };
+        this.iatWS.onmessage = (e) => {
+            console.log("onmessage" + this.resultText);
+            this.renderResult(e.data);
+        };
+        this.iatWS.onerror = (e) => {
+            console.error("error", e);
+            this.recordStop();
+            this.changeBtnStatus("CLOSED");
+        };
+        this.iatWS.onclose = async (e) => {
+            // 5秒停顿会导致结束录制
+            console.log("onclose" + this.resultText);
+            console.error("close", e);
+            await this.recordStop();
+            this.changeBtnStatus("CLOSED");
+        };
+    }
+    /**
+     * 移动端兼容方法
+     */
+    /**
+    * 移动端上传专用方法
+    * @returns
+    */
+    isCapacitor() {
+        return this.platform.is("capacitor") || this.platform.is("cordova");
+    }
+    async requestPermission() {
+        if (!this.isCapacitor())
+            return;
+        try {
+            await this.requestStoagePermission();
+            await this.requestCameraPermission();
+            await this.requestMicPermission();
+            await this.requestRecordAudioPermission();
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    async requestRecordAudioPermission() {
+        let data = await this.diagnostic.requestRuntimePermissions([this.diagnostic.permission.RECORD_AUDIO]);
+        console.log("record permission request:", data);
+        return;
+    }
+    async requestMicPermission() {
+        let isAvailable = await this.diagnostic.isMicrophoneAuthorized();
+        console.log("permisson_MIC:", isAvailable);
+        if (!isAvailable) {
+            let data = await this.diagnostic.requestMicrophoneAuthorization();
+        }
+        return;
+    }
+    async requestStoagePermission() {
+        let isAvailable = await this.diagnostic.isExternalStorageAuthorized();
+        console.log("permisson_STORAGE:", isAvailable);
+        if (!isAvailable) {
+            let data = await this.diagnostic.requestExternalStorageAuthorization();
+        }
+        return;
+    }
+    async requestCameraPermission() {
+        let isAvailable = await this.diagnostic.isCameraAuthorized();
+        console.log("permisson_Camera:", isAvailable);
+        if (!isAvailable) {
+            let data = await this.diagnostic.requestCameraAuthorization();
+        }
+        return;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FmodeVoiceService, deps: [{ token: i1.Platform }, { token: i2.Diagnostic }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FmodeVoiceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FmodeVoiceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Platform }, { type: i2.Diagnostic }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fmode-voice.service.js","sourceRoot":"","sources":["../../../../../../projects/fmode-ng/src/lib/aigc/voice/fmode-voice.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Injectable, Output } from '@angular/core';\n// import RecorderManager from \"./lib/xunfei-recorder\"\n// import {RecorderManager} from \"./lib/recorder/recorder-manager\"\nimport Recorder from 'recorder-core'\nimport 'recorder-core/src/engine/pcm'\nimport 'recorder-core/src/engine/wav'\nimport 'recorder-core/src/extensions/waveview'\nimport CryptoJS from \"crypto-js\"\nimport { pcmtoWav } from './lib/pcm2wav';\nimport { convertFrameBufferToBase64, resampleAudio, resampleBuffer } from './lib/resample';\nimport { WebSpeech } from './class-asr';\nimport { Platform } from '@ionic/angular';\nimport { Diagnostic } from '@awesome-cordova-plugins/diagnostic/ngx';\n// import { FmodeTTSXunfei } fro./class-tts-xunfei.ts.bakfei'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FmodeVoiceService {\n\n  /**\n   * 关闭ASR：用于测试其他功能时，可关闭ASR节省语音接口消耗\n   */\n  disableASR:false;\n  /**\n   * 讯飞TTS语音合成\n   */\n  // ttsXunfei = new FmodeTTSXunfei()\n  /**\n   * WebSpeech 语音库\n   */\n  webSpeech = WebSpeech\n  constructor(\n    private platform:Platform,\n    private diagnostic: Diagnostic, \n  ) { \n    this.requestPermission();\n    // this.recorder.on(\"start\",() => {\n    // })\n\n    // this.recorder.on(\"frameRecorded\", ({ isLastFrame, frameBuffer }) => {\n    //   if (this.iatWS.readyState === this.iatWS.OPEN) {\n    //     this.iatWS.send(\n    //       JSON.stringify({\n    //         data: {\n    //           status: isLastFrame ? 2 : 1,\n    //           format: \"audio/L16;rate=16000\",\n    //           encoding: this.encodingType,\n    //           audio: this.toBase64(frameBuffer),\n    //         },\n    //       })\n    //     );\n    //     if (isLastFrame) {\n    //       this.changeBtnStatus(\"CLOSING\");\n    //     }\n    //   }\n    // })\n\n    // this.recorder.on(\"stop\",() => {\n    // })\n\n\n  }\n\n\n\n  onResultTextChanged:Function\n  /**()\n   * 用户操作：录音按钮快捷触发操作\n   */\n   toggleRecord(){\n    console.log(this.btnStatus)\n    if (this.btnStatus === \"UNDEFINED\" || this.btnStatus === \"CLOSED\") {\n      // 开始讲话`\n      this.startTalk()\n    } else if (this.btnStatus === \"CONNECTING\" || this.btnStatus === \"OPEN\") {\n      // 结束录音 并发送消息等待回复\n      this.finishTalk()\n    }\n  }\n /**\n   * 用户操作：完成录音，并处理转录结果\n  */\n isUserFinish:boolean = false;\n finishTalk(){\n    this.isUserFinish = true;\n    this.onBeforeFinishTalk&&this.onBeforeFinishTalk()\n    this.recordStop()\n }\n onBeforeFinishTalk: Function\n onAfterFinishTalk: Function\n  /**\n   * 用户操作：开始讲话，实时转录语言\n   */\n  async startTalk(evnet?){\n    this.resultText = \"\"\n    this.resultTextTemp = \"\"\n    this.onBeforeStartTalk&&this.onBeforeStartTalk()\n    event?.preventDefault()\n    await this.openWithPriviledge()\n    setTimeout(() => {\n      this.connectWebSocket()\n    }, 100);\n\n    this.onAfterStartTalk&&this.onAfterStartTalk()\n  }\n  onBeforeStartTalk: Function\n  onAfterStartTalk: Function\n  \n  /**\n   * 用户操作：取消讲话，且不发送结果\n   */\n  cancelTalk(){\n    this.onBeforeCancelTalk&&this.onBeforeCancelTalk()\n    this.recordStop(); // 停止录制\n    this.iatWS?.close(); // 断开连接\n    this.resultText = null; // 设置转录结果为空\n    this.onAfterCancelTalk&&this.onAfterCancelTalk()\n  }\n  /**\n   * 操作回调\n   */\n  onBeforeCancelTalk: Function\n  onAfterCancelTalk: Function\n  onAfterRecordStart: Function\n\n  /**\n   * 程序逻辑\n   */\n  async recordStart(){\n    this.createRecorder();\n    await this.openWithPriviledge()\n    this.recorder.start();\n    this.changeBtnStatus(\"OPEN\");\n    this.onAfterRecordStart&&this.onAfterRecordStart()\n  }\n  recordStop(){\n    return new Promise((resolve)=>{\n      clearInterval(this.countdownInterval);\n      this.changeBtnStatus(\"CLOSED\");\n      this.recorder?.stop(async (blob:Blob,duration:number)=>{\n          //录音结束后，发送录音结束帧\n          try{\n            this.iatWS.send(\n              JSON.stringify({\"data\":{\"status\":2,\"format\":\"audio/L16;rate=16000\",\"encoding\":this.encodingType,\"audio\":\"\"}})\n              );\n          }catch(err){}\n\n          //简单利用URL生成本地文件地址，注意不用了时需要revokeObjectURL，否则霸占内存\n          //此地址只能本地使用，比如赋值给audio.src进行播放，赋值给a.href然后a.click()进行下载（a需提供download=\"xxx.mp3\"属性）\n          let localUrl=(window.URL||webkitURL).createObjectURL(blob);\n          console.log(blob,localUrl,\"时长:\"+duration+\"ms\");\n          this.recordPcmBlob = blob;\n          this.recordWavBlob = await this.pcmBlobToWavBlob(blob,44100);\n          this.recordDuration = duration;\n          console.log(\"this.recordWavBlob\",this.recordWavBlob)\n          setTimeout(() => {\n            if(this.isUserFinish){\n              this.onAfterFinishTalk&&this.onAfterFinishTalk()\n              this.isUserFinish = false;\n            }\n          }, 2000);\n          this.recorder?.close();//释放录音资源，当然可以不释放，后面可以连续调用start；但不释放时系统或浏览器会一直提示在录音，最佳操作是录完就close掉\n          this.recorder=null;\n          \n          //已经拿到blob文件对象想干嘛就干嘛：立即播放、上传、下载保存\n          \n          /*** 【立即播放例子】 ***/\n          // this.audioPlayer= new Audio();\n          // this.audioPlayer.controls=true;\n          // this.audioPlayer.src=localUrl;\n          console.log(\"localUrl\",localUrl)\n          // 等待语音转义完成，处理转录结果\n          // 需要准确判断websocket已经close了\n          resolve(true);\n      },(msg)=>{\n          console.log(\"录音失败:\"+msg);\n          this.recorder.close();//可以通过stop方法的第3个参数来自动调用close\n          this.recorder=null;\n          resolve(null)\n      })\n    })\n  }\n  recordWavBlob:Blob = null\n  recordPcmBlob:Blob = null\n  recordDuration:number = 0;\n  playRecord(){\n    this.playPCM(this.recordPcmBlob,44100)\n  }\n  async pcmBlobToWavBlob(pcmBlob, sampleRate):Promise<Blob>{\n    return new Promise(resolve=>{\n      let fileReader = new FileReader();\n      \n      // 读取Blob数据\n      fileReader.onload = function(event) {\n        let pcmData:any = event.target.result;\n        // Convert PCM data to WAV format\n        let wavBlob = pcmtoWav(pcmData, sampleRate,1,16);\n        resolve(wavBlob)\n      };\n      \n      // 将Blob转换为ArrayBuffer\n      fileReader.readAsArrayBuffer(pcmBlob);\n    })\n  }\n  async playPCM(pcmBlob, sampleRate) {\n    let wavBlob = await this.pcmBlobToWavBlob(pcmBlob,sampleRate);\n    let wavUrl = window.URL.createObjectURL(wavBlob)\n    let audio = new Audio();\n    audio.src = wavUrl;\n    audio.play();\n  }\n  buffers:Array<any>\n  async playBuffers(){\n    // let audioBuffer = []\n    // this.buffers.forEach(buffer=>{\n    //   audioBuffer.push(buffer)\n    // })\n    let audioBlob = await this.BuffersToBlob(this.buffers)\n    this.playPCM(audioBlob,44100)\n  }\n  BuffersToBlob(buffers) {\n    let audioBuffer:any = []\n    buffers.forEach(buffer=>{\n      buffer.forEach(int16=>{\n        audioBuffer.push(int16)\n      })\n    })\n    return new Blob([audioBuffer], { type: 'audio/pcm' });\n  }\n  // 将录音数据分割为每次发送的音频片段 1280字节\n   splitAudioData(audioData) {\n    const segmentSize = 1280; // 目标切片大小，单位为字节\n    const segmentCount = Math.ceil(audioData.length / segmentSize); // 切片数量\n    const segments = [];\n  \n    for (let i = 0; i < segmentCount; i++) {\n      const start = i * segmentSize;\n      const end = start + segmentSize;\n      const segment = audioData.slice(start, end);\n  \n      segments.push(segment);\n    }\n  \n    return segments;\n  }\n  BufferToBlob(buffer) {\n    return new Blob([buffer], { type: 'audio/pcm' });\n  }\n  recordType = \"pcm\"\n  encodingType = \"raw\"\n  createRecorder(){\n    if(this.recorder) return\n    this.recorder = Recorder({ //本配置参数请参考下面的文档，有详细介绍\n      type:this.recordType,sampleRate:44100,bitRate:16 //pcm格式，指定采样率hz、比特率kbps，其他参数使用默认配置；注意：是数字的参数必须提供数字，不要用字符串；需要使用的type类型，需提前把格式支持文件加载进来，比如使用wav格式需要提前加载wav.js编码引擎\n      ,onProcess:(buffers,powerLevel,bufferDuration,bufferSampleRate,newBufferIdx,asyncEnd)=>{\n          //录音实时回调，大约1秒调用12次本回调，buffers为开始到现在的所有录音pcm数据块(16位小端LE)\n          //可利用extensions/sonic.js插件实时变速变调，此插件计算量巨大，onProcess需要返回true开启异步模式\n          //可实时上传（发送）数据，配合Recorder.SampleData方法，将buffers中的新数据连续的转换成pcm上传，或使用mock方法将新数据连续的转码成其他格式上传，可以参考文档里面的：Demo片段列表 -> 实时转码并上传-通用版；基于本功能可以做到：实时转发数据、实时保存数据、实时语音识别（ASR）等\n          // 实时发送录音至接口\n          // console.log(\"asyncEnd:\",asyncEnd)\n          // console.log(buffers.length,bufferDuration,bufferSampleRate,newBufferIdx)\n          let isLastFrame = false && this.btnStatus==\"CLOSED\"; // 主动关闭作为最后帧\n          // 录音默认为 44100 采样率 pcm不支持再process中实时转换\n          // 需要压缩为 16000 上传\n          let frameBuffer = buffers.length&&buffers[buffers.length-1];\n          this.buffers = buffers\n          frameBuffer = resampleBuffer(frameBuffer,44100,16000);\n          // this.playPCM(this.BufferToBlob(frameBuffer),16000) // 切片数据播放，采样率测试\n\n          if (this.iatWS.readyState === this.iatWS.OPEN) {\n                if(this.disableASR) return\n                this.iatWS.send(\n                  JSON.stringify({\n                    data: {\n                      status: isLastFrame ? 2 : 1,\n                      format: \"audio/L16;rate=16000\",\n                      encoding: this.encodingType,\n                      audio: convertFrameBufferToBase64(frameBuffer)// this.toBase64(audioData),\n                    },\n                  })\n                );\n           \n            if (isLastFrame) {\n              this.changeBtnStatus(\"CLOSING\");\n            }\n          }\n          //可实时绘制波形（extensions目录内的waveview.js、wavesurfer.view.js、frequency.histogram.view.js插件功能）\n          this.waveClient?.input(buffers[buffers.length-1],powerLevel,bufferSampleRate);\n      }\n  });\n  }\n  \n  async openWithPriviledge(){\n    console.log(this.btnStatus)\n    await this.requestPermission();\n    this.createRecorder();\n    if(Recorder.IsOpen()) return true\n    return new Promise(resolve=>{\n      //var dialog=createDelayDialog(); 我们可以选择性的弹一个对话框：为了防止移动端浏览器存在第三种情况：用户忽略，并且（或者国产系统UC系）浏览器没有任何回调，此处demo省略了弹窗的代码\n      this.recorder.open(()=>{//打开麦克风授权获得相关资源\n        //dialog&&dialog.Cancel(); 如果开启了弹框，此处需要取消\n        //rec.start() 此处可以立即开始录音，但不建议这样编写，因为open是一个延迟漫长的操作，通过两次用户操作来分别调用open和start是推荐的最佳流程\n        //创建可视化，指定一个要显示的div\n        let waveDiv = document.querySelector(\".record-wave\");\n        if(waveDiv){ // 存在波形区域时，加载渲染组件\n          console.log(waveDiv)\n          if(Recorder.WaveView)this.waveClient=Recorder.WaveView({elem:\".record-wave\"});\n        }\n        resolve(true);\n    },(msg,isUserNotAllow)=>{//用户拒绝未授权或不支持\n        //dialog&&dialog.Cancel(); 如果开启了弹框，此处需要取消\n        console.log((isUserNotAllow?\"UserNotAllow，\":\"\")+\"无法录音:\"+msg);\n    });\n  })\n\n  }\n\n  connStatus = \"\" // 录音中 建立连接中 关闭连接中\n\n  btnStatus = \"UNDEFINED\"; // \"UNDEFINED\" \"CONNECTING\" \"OPEN\" \"CLOSING\" \"CLOSED\"\n\n  waveClient:any // 用户波形\n  recorder:any\n  // recorder = new RecorderManager();\n  // recorder = new RecorderManager(\"./lib/xunfei-recorder\");\n  \n  iatWS;\n  resultText = \"\";\n  resultTextTemp = \"\";\n  countdownInterval;\n\n  /**\n   * 获取websocket url\n   * 该接口需要后端提供，这里为了方便前端处理\n   */\n  APPID = \"50f4a46c\";\n  API_SECRET = \"NzFlNmFhZDJjMDNkZGM3NzI0Mzg2OGNm\";\n  API_KEY = \"106ddc40dfd4b9ca6d7b47c70fada749\";\n  getWebSocketUrl() {\n    // 请求地址根据语种不同变化\n    let url = \"wss://iat-api.xfyun.cn/v2/iat\";\n    let host = \"iat-api.xfyun.cn\";\n    \n    let apiKey = this.API_KEY;\n    let apiSecret = this.API_SECRET;\n    let date = new Date().toUTCString();\n    let algorithm = \"hmac-sha256\";\n    let headers = \"host date request-line\";\n    let signatureOrigin = `host: ${host}\\ndate: ${date}\\nGET /v2/iat HTTP/1.1`;\n    let signatureSha = CryptoJS.HmacSHA256(signatureOrigin, apiSecret);\n    let signature = CryptoJS.enc.Base64.stringify(signatureSha);\n    let authorizationOrigin = `api_key=\"${apiKey}\", algorithm=\"${algorithm}\", headers=\"${headers}\", signature=\"${signature}\"`;\n    let authorization = btoa(authorizationOrigin);\n    url = `${url}?authorization=${authorization}&date=${date}&host=${host}`;\n    return url;\n  }\n\n  toBase64(buffer) {\n    var binary = \"\";\n    var bytes = new Uint8Array(buffer);\n    var len = bytes.byteLength;\n    for (var i = 0; i < len; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }\n    return window.btoa(binary);\n  }\n\n  /**\n   * 倒计时：最长支持60秒实时语音转录，如果持续7-10秒无声音，服务端将自动CLOSE链接\n   */\n  countdown() {\n    let seconds = 60;\n    this.connStatus = `录音中（${seconds}s）`;\n    this.countdownInterval = setInterval(() => {\n      seconds = seconds - 1;\n      console.log(seconds);\n      if (seconds <= 0) {\n        clearInterval(this.countdownInterval);\n        this.recordStop();\n      } else {\n        this.connStatus = `录音中（${seconds}s）`;\n      }\n    }, 1000);\n  }\n\n  changeBtnStatus(status) {\n    this.btnStatus = status;\n    if (status === \"CONNECTING\") {\n      this.connStatus = \"建立连接中\";\n    } else if (status === \"OPEN\") {\n      this.countdown();\n    } else if (status === \"CLOSING\") {\n      this.connStatus = \"关闭连接中\";\n    } else if (status === \"CLOSED\") {\n      this.connStatus = \"开始录音\";\n    }\n  }\n\n  renderResult(resultData) {\n    // 识别结束\n    let jsonData = JSON.parse(resultData);\n    // console.log(jsonData.data.result)\n    if (jsonData.data && jsonData.data.result) {\n      let data = jsonData.data.result;\n      let str = \"\";\n      let ws = data.ws;\n      for (let i = 0; i < ws.length; i++) {\n        str = str + ws[i].cw[0].w;\n        console.log(str)\n      }\n      // 开启wpgs会有此字段(前提：在控制台开通动态修正功能)\n      // 取值为 \"apd\"时表示该片结果是追加到前面的最终结果；取值为\"rpl\" 时表示替换前面的部分结果，替换范围为rg字段\n      if (data.pgs) {\n        if (data.pgs === \"apd\") {\n          // 将this.resultTextTemp同步给this.resultText\n          this.resultText = this.resultTextTemp;\n        }\n        // 将结果存储在this.resultTextTemp中\n        this.resultTextTemp = this.resultText + str;\n      } else {\n        this.resultText = this.resultText + str;\n      }\n        this.resultTextTemp || this.resultText || \"\";\n      console.log(\"diff temp\",this.resultTextTemp)\n      console.log(\"diff result\",this.resultText)\n    }\n    if (jsonData.code === 0 && jsonData.data.status === 2) {\n      this.iatWS.close();\n    }\n    if (jsonData.code !== 0) {\n      this.iatWS.close();\n      console.error(jsonData);\n    }\n  }\n\n  connectWebSocket() {\n    console.log(\"connectWebSocket\");\n    const websocketUrl = this.getWebSocketUrl();\n    if (\"WebSocket\" in window) {\n      this.iatWS = new WebSocket(websocketUrl);\n    } else if (\"MozWebSocket\" in window) {\n      // this.iatWS = new MozWebSocket(websocketUrl); // Moz兼容\n    } else {\n      alert(\"浏览器不支持WebSocket\");\n      return;\n    }\n    console.log(\"connectWebSocket\",this.btnStatus);\n    this.changeBtnStatus(\"CONNECTING\");\n    this.iatWS.onopen = (e) => {\n      // 开始录音\n      this.recordStart();\n      var params = {\n        common: {\n          app_id: this.APPID,\n        },\n        business: {\n          language: \"zh_cn\",\n          domain: \"iat\",\n          accent: \"mandarin\",\n          vad_eos: 5000,\n          dwa: \"wpgs\",\n        },\n        data: {\n          status: 0,\n          format: \"audio/L16;rate=16000\",\n          encoding: this.encodingType,\n          // encoding: \"speex-wb\",\n        },\n      };\n      this.iatWS.send(JSON.stringify(params));\n    };\n    this.iatWS.onmessage = (e) => {\n      console.log(\"onmessage\"+this.resultText)\n      this.renderResult(e.data);\n    };\n    this.iatWS.onerror = (e) => {\n      console.error(\"error\",e);\n      this.recordStop();\n      this.changeBtnStatus(\"CLOSED\");\n    };\n    this.iatWS.onclose = async (e) => {\n      // 5秒停顿会导致结束录制\n      console.log(\"onclose\"+this.resultText)\n      console.error(\"close\",e)\n      await this.recordStop();\n      this.changeBtnStatus(\"CLOSED\");\n\n    };\n  }\n\n  /**\n   * 移动端兼容方法\n   */\n\n   /**\n   * 移动端上传专用方法\n   * @returns \n   */\n    isCapacitor(){\n      return this.platform.is(\"capacitor\") || this.platform.is(\"cordova\")\n    }\n    async requestPermission(){\n      if(!this.isCapacitor()) return\n      try{\n        await this.requestStoagePermission();\n        await this.requestCameraPermission();\n        await this.requestMicPermission();\n        await this.requestRecordAudioPermission();\n      }catch(err){\n        console.error(err)\n      }\n    }\n    async requestRecordAudioPermission(){\n      let data = await this.diagnostic.requestRuntimePermissions([this.diagnostic.permission.RECORD_AUDIO])\n      console.log(\"record permission request:\",data)\n      return\n  }\n    async requestMicPermission(){\n        let isAvailable = await this.diagnostic.isMicrophoneAuthorized()\n        console.log(\"permisson_MIC:\", isAvailable)\n        if (!isAvailable) {\n          let data = await this.diagnostic.requestMicrophoneAuthorization()\n        }\n        return\n    }\n    async requestStoagePermission(){\n        let isAvailable = await this.diagnostic.isExternalStorageAuthorized()\n        console.log(\"permisson_STORAGE:\", isAvailable)\n        if (!isAvailable) {\n          let data = await this.diagnostic.requestExternalStorageAuthorization()\n        }\n        return\n    }\n    async requestCameraPermission(){\n      let isAvailable = await this.diagnostic.isCameraAuthorized()\n      console.log(\"permisson_Camera:\", isAvailable)\n      if (!isAvailable) {\n        let data = await this.diagnostic.requestCameraAuthorization()\n      }\n      return\n  }\n}\n"]}

package/esm2022/lib/aigc/voice/index.mjs

@@ -1,10 +1,3 @@
-
-    /**
-     * @copyright © 未来飞马 © 未来全栈 www.fmode.cn 
-     * 版权所有 © 未来飞马 © 江西脑控科技有限公司 Copyright © Fmode Technology Co., Ltd.
-     * 保留所有权利 All Rights Reserved.
-     * /home/ryan/workspace/nova/nova-admin/dist/fmode-ng/esm2022/lib/aigc/voice/index.mjs
-     */
-    export*from"./fmode-voice.service";export*from"./audio.player";
-var MODULE_PATH_NEED = `6K+l5paH5Lu25piv5pys6aG555uu55qE5LiA6YOo5YiGIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBDb21wb25lbnRzIGluIEZtb2RlIEluYy4KICAgIOeJiOadg+aJgOaciSDCqSDmnKrmnaXpo57pqawgwqkg5rGf6KW/6ISR5o6n56eR5oqA5pyJ6ZmQ5YWs5Y+4IENvcHlyaWdodCDCqSBGbW9kZSBUZWNobm9sb2d5IENvLiwgTHRkLgogICAg5L+d55WZ5omA5pyJ5p2D5YipIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgICDkuKXnpoHlnKjmnKrnu4/mjojmnYPnmoTmg4XlhrXkuIvvvIzpgJrov4fku7vkvZXlqpLku4vlpI3liLbmraTmlofku7YgVW5hdXRob3JpemVkIGNvcHlpbmcgb2YgdGhpcyBmaWxlLCB2aWEgYW55IG1lZGl1bSBpcyBzdHJpY3RseSBwcm9oaWJpdGVkCiAgICDor6Xmlofku7bmmK/kuJPmnInnmoTmnLrlr4bmlofku7YgUHJvcHJpZXRhcnkgYW5kIGNvbmZpZGVudGlhbAogICAKICAgIENvcHlyaWdodCAyMDIxLW5vdyBGbW9kZSBJbmMuIHN1cHBvcnRAZm1vZGUuY24uIDE4NjA3MDA3MDczLgogICAg5L+d55WZ5omA5pyJ5p2D5YipIEFsbCByaWdodHMgcmVzZXJ2ZWQuCgogICAgUEFUSDovaG9tZS9yeWFuL3dvcmtzcGFjZS9ub3ZhL25vdmEtYWRtaW4vZGlzdC9mbW9kZS1uZy9lc20yMDIyL2xpYi9haWdjL3ZvaWNlL2luZGV4Lm1qcw==`
-    
+export * from "./fmode-voice.service";
+export * from "./audio.player";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mbW9kZS1uZy9zcmMvbGliL2FpZ2Mvdm9pY2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQTtBQUNyQyxjQUFjLGdCQUFnQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZm1vZGUtdm9pY2Uuc2VydmljZVwiXG5leHBvcnQgKiBmcm9tIFwiLi9hdWRpby5wbGF5ZXJcIiJdfQ==