578 lines
19 KiB
JavaScript
578 lines
19 KiB
JavaScript
/**
|
|
* voice-recorder.js — 跨端录音抽象层
|
|
*
|
|
* PR-FRONTEND-VOICE-INPUT (2026-09-24)
|
|
* 统一 H5 / 微信小程序 / App-Plus / 鸿蒙元服务 四端的录音接口,
|
|
* 把麦克风采集 + 振幅事件 + 自动停止 + 资源回收 收敛到一处。
|
|
*
|
|
* PR-FRONTEND-VOICE-WAV (2026-09-25)
|
|
* H5 分支从 MediaRecorder (产出 webm/opus) 改为 AudioContext + ScriptProcessor
|
|
* 采原始 PCM, 停止时手动封装成标准 WAV (PCM 16-bit LE mono, 16kHz).
|
|
* 原因: Chrome MediaRecorder 只支持 webm/ogg 容器, 不支持 wav/mp3 录制;
|
|
* 大多数 STT / 后端 Agent 框架无法解析 webm/opus.
|
|
* 产 wav 后所有 STT 服务 (Whisper / 达摩院 / 腾讯 ASR / ...) 都吃.
|
|
*
|
|
* 平台分支:
|
|
* - H5 : navigator.mediaDevices.getUserMedia → AudioContext
|
|
* → ScriptProcessor 采 PCM Float32 → 停止时封装 WAV.
|
|
* 振幅采样走 AnalyserNode (与采 PCM 并行, 不冲突).
|
|
* - MP / APP / 鸿蒙: uni.getRecorderManager()(uni-app 鸿蒙 runtime 已映射)
|
|
* 走 onFrameRecorded 推 progress 事件.
|
|
* uni-app format 参数可指定 wav/mp3/aac.
|
|
*
|
|
* 统一事件:
|
|
* progress → { level: 0..1, duration: ms } 持续采样, 用于驱动波形动画
|
|
* error → Error 录音失败
|
|
*
|
|
* 统一结果 (stop() 解析):
|
|
* {
|
|
* filePath?: string, // MP/APP/鸿蒙: tempFilePath; H5: blob URL
|
|
* blob?: Blob, // H5: WAV Blob (供 FileReader / uploadMedia 二次处理)
|
|
* fileName?: string, // H5: voice_<ts>.wav; MP 按 uni 约定
|
|
* duration: number, // ms
|
|
* mime: string, // 录音产物 MIME: H5='audio/wav', MP/APP/鸿蒙按 format
|
|
* size: number, // bytes
|
|
* cancelled: false
|
|
* }
|
|
*
|
|
* 取消时 resolve(null);调用方拿到 null 时不要 push 到 pendingFiles。
|
|
*/
|
|
|
|
const DEFAULT_MAX_DURATION_MS = 60 * 1000
|
|
|
|
// H5 录音参数: 16kHz mono PCM → 16-bit LE WAV
|
|
// 16kHz/16-bit 是大多数 STT 服务 (Whisper / 达摩院 / 腾讯 ASR 等) 最常见的输入规格.
|
|
const H5_SAMPLE_RATE = 16000
|
|
const H5_NUM_CHANNELS = 1
|
|
const H5_SCRIPT_PROCESSOR_BUFFER_SIZE = 4096
|
|
|
|
/**
|
|
* 构造带 code 字段的 Error
|
|
* - code: 稳定的英文枚举, 供调用方按 code 走 $lang() 翻译
|
|
* - message: 兜底英文 message, 用于开发/调试或未识别 code
|
|
* 注意: voice-recorder.js 自身不持有 Vue 上下文, 翻译必须在调用方完成
|
|
*/
|
|
function _err(code, message) {
|
|
const e = new Error(message || code)
|
|
e.code = code
|
|
return e
|
|
}
|
|
|
|
/**
|
|
* 检测当前运行环境 (避免编译器把所有分支都打进去)
|
|
* - true / false 都是运行时结果;条件编译靠注释里的 #ifdef
|
|
*/
|
|
function isH5() {
|
|
// #ifdef H5
|
|
return true
|
|
// #endif
|
|
// #ifndef H5
|
|
return false
|
|
// #endif
|
|
}
|
|
|
|
function isMpOrApp() {
|
|
// #ifdef MP-WEIXIN || APP-PLUS || MP-HARMONY
|
|
return true
|
|
// #endif
|
|
// #ifndef MP-WEIXIN || APP-PLUS || MP-HARMONY
|
|
return false
|
|
// #endif
|
|
}
|
|
|
|
/**
|
|
* 由 mime 反推文件扩展名
|
|
*/
|
|
function mimeToExt(mime) {
|
|
if (!mime) return 'wav'
|
|
if (mime.indexOf('wav') !== -1) return 'wav'
|
|
if (mime.indexOf('webm') !== -1) return 'webm'
|
|
if (mime.indexOf('ogg') !== -1) return 'ogg'
|
|
if (mime.indexOf('mp4') !== -1) return 'm4a'
|
|
if (mime.indexOf('mpeg') !== -1) return 'mp3'
|
|
if (mime.indexOf('aac') !== -1) return 'aac'
|
|
return 'audio'
|
|
}
|
|
|
|
/**
|
|
* 合并多个 Float32Array (PCM 帧缓冲) 为单个 Float32Array
|
|
*/
|
|
function mergeFloat32Arrays(arrays) {
|
|
let totalLength = 0
|
|
for (let i = 0; i < arrays.length; i++) totalLength += arrays[i].length
|
|
const out = new Float32Array(totalLength)
|
|
let offset = 0
|
|
for (let i = 0; i < arrays.length; i++) {
|
|
out.set(arrays[i], offset)
|
|
offset += arrays[i].length
|
|
}
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* 将 Float32 PCM (-1..1) 编码为标准 WAV (PCM 16-bit LE, RIFF/WAVE 头).
|
|
* 所有 STT 服务都吃这个格式; 浏览器 H5 录音不依赖 MediaRecorder 也能产出.
|
|
*
|
|
* 参考 RIFF/WAVE 规范:
|
|
* https://docs.fileformat.com/audio/wav/
|
|
* http://soundfile.sapp.org/doc/WaveFormat/
|
|
*/
|
|
function encodeWavPcm16LE(samples, sampleRate, numChannels) {
|
|
const bytesPerSample = 2 // 16-bit
|
|
const dataSize = samples.length * numChannels * bytesPerSample
|
|
const buffer = new ArrayBuffer(44 + dataSize)
|
|
const view = new DataView(buffer)
|
|
|
|
// RIFF chunk descriptor (12 bytes)
|
|
writeAscii(view, 0, 'RIFF')
|
|
view.setUint32(4, 36 + dataSize, true) // ChunkSize = 文件总字节 - 8
|
|
writeAscii(view, 8, 'WAVE')
|
|
|
|
// fmt subchunk (24 bytes)
|
|
writeAscii(view, 12, 'fmt ')
|
|
view.setUint32(16, 16, true) // Subchunk1Size for PCM = 16
|
|
view.setUint16(20, 1, true) // AudioFormat: 1 = PCM
|
|
view.setUint16(22, numChannels, true)
|
|
view.setUint32(24, sampleRate, true)
|
|
view.setUint32(28, sampleRate * numChannels * bytesPerSample, true) // ByteRate
|
|
view.setUint16(32, numChannels * bytesPerSample, true) // BlockAlign
|
|
view.setUint16(34, 16, true) // BitsPerSample
|
|
|
|
// data subchunk (8 + N bytes)
|
|
writeAscii(view, 36, 'data')
|
|
view.setUint32(40, dataSize, true)
|
|
|
|
// PCM 样本: Float32 (-1..1) → Int16 LE (clamp 到 [-1, 1] 防溢出)
|
|
let offset = 44
|
|
for (let i = 0; i < samples.length; i++) {
|
|
let s = samples[i]
|
|
if (s > 1) s = 1
|
|
else if (s < -1) s = -1
|
|
const int16 = s < 0 ? Math.round(s * 0x8000) : Math.round(s * 0x7FFF)
|
|
view.setInt16(offset, int16, true)
|
|
offset += 2
|
|
}
|
|
|
|
return buffer
|
|
}
|
|
|
|
function writeAscii(view, offset, str) {
|
|
for (let i = 0; i < str.length; i++) {
|
|
view.setUint8(offset + i, str.charCodeAt(i))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 创建录音器实例。
|
|
*
|
|
* @param {object} [opts]
|
|
* @param {number} [opts.maxDuration=60000] 自动停止时长 (ms)
|
|
* @param {string} [opts.format] MP/APP/鸿蒙 'mp3'|'aac'|'wav' (uni-app 文档)
|
|
* @param {number} [opts.sampleRate=16000]
|
|
* @param {number} [opts.numberOfChannels=1]
|
|
* @param {number} [opts.encodeBitRate=48000]
|
|
*
|
|
* @returns {VoiceRecorder}
|
|
*/
|
|
export function createVoiceRecorder(opts = {}) {
|
|
return new VoiceRecorder(opts)
|
|
}
|
|
|
|
class VoiceRecorder {
|
|
constructor(opts) {
|
|
this._maxDuration = opts.maxDuration || DEFAULT_MAX_DURATION_MS
|
|
this._format = opts.format || 'mp3'
|
|
this._sampleRate = opts.sampleRate || 16000
|
|
this._channels = opts.numberOfChannels || 1
|
|
this._bitRate = opts.encodeBitRate || 48000
|
|
|
|
this._listeners = { progress: [], error: [] }
|
|
this._isRecording = false
|
|
this._startTs = 0
|
|
this._autoStopTimer = null
|
|
|
|
// 平台相关句柄
|
|
this._h5 = null // { mediaRecorder, stream, audioCtx, analyser, chunks, mime, rafId }
|
|
this._uniRec = null // uni.getRecorderManager() 返回值
|
|
}
|
|
|
|
on(event, cb) {
|
|
if (!this._listeners[event]) this._listeners[event] = []
|
|
this._listeners[event].push(cb)
|
|
}
|
|
|
|
off(event, cb) {
|
|
const arr = this._listeners[event]
|
|
if (!arr) return
|
|
const idx = arr.indexOf(cb)
|
|
if (idx !== -1) arr.splice(idx, 1)
|
|
}
|
|
|
|
_emit(event, payload) {
|
|
const arr = this._listeners[event]
|
|
if (!arr) return
|
|
for (const cb of arr.slice()) {
|
|
try { cb(payload) } catch (e) { /* swallow */ }
|
|
}
|
|
}
|
|
|
|
get isRecording() { return this._isRecording }
|
|
|
|
/**
|
|
* 开始录音。
|
|
* resolve() 仅表示「启动成功」,真正的产物在 stop()/cancel() 中拿到。
|
|
*/
|
|
start() {
|
|
if (this._isRecording) {
|
|
return Promise.reject(_err('ALREADY_STARTED', 'recorder already started'))
|
|
}
|
|
|
|
if (isH5()) {
|
|
return this._startH5()
|
|
}
|
|
if (isMpOrApp()) {
|
|
return this._startUni()
|
|
}
|
|
return Promise.reject(_err('NOT_SUPPORTED', 'voice input not supported on this platform'))
|
|
}
|
|
|
|
/**
|
|
* 停止录音并返回产物。
|
|
* resolve(null) 表示已取消 / 无产物,调用方应忽略。
|
|
*/
|
|
stop() {
|
|
if (!this._isRecording) return Promise.resolve(null)
|
|
if (isH5()) return this._stopH5()
|
|
return this._stopUni()
|
|
}
|
|
|
|
/**
|
|
* 中断录音并丢弃产物。
|
|
*/
|
|
cancel() {
|
|
if (!this._isRecording) {
|
|
this._clearAutoStopTimer()
|
|
return Promise.resolve()
|
|
}
|
|
if (isH5()) return this._cancelH5()
|
|
return this._cancelUni()
|
|
}
|
|
|
|
// ===================== H5 实现 =====================
|
|
// PR-FRONTEND-VOICE-WAV (2026-09-25): 改为 AudioContext + ScriptProcessor 采 PCM,
|
|
// 停止时手动封装标准 WAV. 不再依赖 MediaRecorder, 解决 Chrome 只能产 webm/opus
|
|
// 导致后端 STT / Agent framework 无法解析的问题.
|
|
//
|
|
// 关键设计:
|
|
// 1. PCM 采样率固定 16kHz mono, 浏览器会自动 resample 麦克风输入
|
|
// (实际由 AudioContext sampleRate 参数保证)
|
|
// 2. ScriptProcessor 必须 connect 到 audioCtx.destination 才会触发
|
|
// onaudioprocess; 通过 GainNode(gain=0) 静音防止麦克风外放回声
|
|
// 3. 振幅采样走 AnalyserNode (与 PCM 采样并行, 不冲突)
|
|
// 4. onaudioprocess 每帧必须拷贝 channelData (new Float32Array(input)),
|
|
// 否则下一帧会覆盖导致 PCM 数据丢失
|
|
|
|
_startH5() {
|
|
return new Promise((resolve, reject) => {
|
|
if (typeof navigator === 'undefined' || !navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
|
|
reject(_err('H5_NO_MIC_API', 'mic API not available (HTTPS or localhost required)'))
|
|
return
|
|
}
|
|
const Ctx = window.AudioContext || window.webkitAudioContext
|
|
if (!Ctx) {
|
|
reject(_err('H5_NO_AUDIO_CTX', 'AudioContext not available'))
|
|
return
|
|
}
|
|
|
|
const buffers = []
|
|
let stream = null
|
|
let audioCtx = null
|
|
let source = null
|
|
let processor = null
|
|
let analyser = null
|
|
let silentGain = null
|
|
let rafId = null
|
|
|
|
// 清理 H5 资源 (失败 / 异常路径统一调用)
|
|
const cleanup = () => {
|
|
try { if (rafId) cancelAnimationFrame(rafId) } catch (e) { /* noop */ }
|
|
try { if (processor) processor.disconnect() } catch (e) { /* noop */ }
|
|
try { if (analyser) analyser.disconnect() } catch (e) { /* noop */ }
|
|
try { if (source) source.disconnect() } catch (e) { /* noop */ }
|
|
try { if (silentGain) silentGain.disconnect() } catch (e) { /* noop */ }
|
|
try { if (audioCtx && audioCtx.state !== 'closed') audioCtx.close().catch(() => {}) } catch (e) { /* noop */ }
|
|
try { if (stream) stream.getTracks().forEach(t => t.stop()) } catch (e) { /* noop */ }
|
|
}
|
|
|
|
navigator.mediaDevices.getUserMedia({
|
|
audio: {
|
|
channelCount: H5_NUM_CHANNELS,
|
|
// 注意: 部分浏览器会忽略 sampleRate 约束, 实际采样率以 AudioContext 为准
|
|
sampleRate: H5_SAMPLE_RATE,
|
|
echoCancellation: true,
|
|
noiseSuppression: true,
|
|
autoGainControl: true
|
|
}
|
|
})
|
|
.then((s) => {
|
|
stream = s
|
|
audioCtx = new Ctx({ sampleRate: H5_SAMPLE_RATE })
|
|
|
|
// 麦克风 → ScriptProcessor → 静音 GainNode → destination
|
|
// (ScriptProcessor 必须连到 destination 才会触发 onaudioprocess;
|
|
// 用 GainNode(gain=0) 静音, 防止麦克风声音外放产生回声)
|
|
source = audioCtx.createMediaStreamSource(stream)
|
|
const BufferSize = H5_SCRIPT_PROCESSOR_BUFFER_SIZE
|
|
processor = audioCtx.createScriptProcessor(BufferSize, H5_NUM_CHANNELS, H5_NUM_CHANNELS)
|
|
processor.onaudioprocess = (e) => {
|
|
const channelData = e.inputBuffer.getChannelData(0)
|
|
// 必须拷贝: inputBuffer 数据会被下一帧覆盖, 不拷贝会导致 PCM 丢失
|
|
buffers.push(new Float32Array(channelData))
|
|
}
|
|
silentGain = audioCtx.createGain()
|
|
silentGain.gain.value = 0
|
|
source.connect(processor)
|
|
processor.connect(silentGain)
|
|
silentGain.connect(audioCtx.destination)
|
|
|
|
// AnalyserNode 并行采振幅 (驱动波形动画)
|
|
analyser = audioCtx.createAnalyser()
|
|
analyser.fftSize = 256
|
|
source.connect(analyser)
|
|
const freqBuf = new Uint8Array(analyser.frequencyBinCount)
|
|
const tick = () => {
|
|
if (!this._isRecording) return
|
|
try {
|
|
analyser.getByteFrequencyData(freqBuf)
|
|
let sum = 0
|
|
for (let i = 0; i < freqBuf.length; i++) sum += freqBuf[i]
|
|
const level = Math.min(1, sum / (freqBuf.length * 255))
|
|
this._emit('progress', { level, duration: Date.now() - this._startTs })
|
|
} catch (e) { /* noop */ }
|
|
rafId = requestAnimationFrame(tick)
|
|
}
|
|
tick()
|
|
|
|
this._h5 = { stream, audioCtx, source, processor, analyser, silentGain, rafId, buffers, sampleRate: audioCtx.sampleRate, cleanup }
|
|
this._isRecording = true
|
|
this._startTs = Date.now()
|
|
this._setAutoStopTimer()
|
|
resolve()
|
|
})
|
|
.catch((err) => {
|
|
// 麦克风权限拒绝 / 设备不可用
|
|
cleanup()
|
|
reject(_err('H5_MIC_PERMISSION', (err && err.message) || 'mic permission denied or device unavailable'))
|
|
})
|
|
})
|
|
}
|
|
|
|
_stopH5() {
|
|
return new Promise((resolve) => {
|
|
const h5 = this._h5
|
|
if (!h5) { resolve(null); return }
|
|
|
|
// 1) 拆 audio graph + 停流 (避免 onprocess 继续累积 buffer)
|
|
try { h5.cleanup() } catch (e) { /* noop */ }
|
|
|
|
// 2) 合并 PCM 帧缓冲
|
|
const sampleRate = h5.sampleRate || H5_SAMPLE_RATE
|
|
const merged = mergeFloat32Arrays(h5.buffers || [])
|
|
|
|
// 3) 编码标准 WAV (PCM 16-bit LE mono)
|
|
const wavBuffer = encodeWavPcm16LE(merged, sampleRate, H5_NUM_CHANNELS)
|
|
const blob = new Blob([wavBuffer], { type: 'audio/wav' })
|
|
|
|
this._h5 = null
|
|
this._isRecording = false
|
|
this._clearAutoStopTimer()
|
|
|
|
if (merged.length === 0) {
|
|
// 没有采到任何 PCM (例如用户没说话或立即 stop)
|
|
resolve(null)
|
|
return
|
|
}
|
|
|
|
const fileName = `voice_${Date.now()}.wav`
|
|
const blobUrl = (typeof URL !== 'undefined' && URL.createObjectURL)
|
|
? URL.createObjectURL(blob)
|
|
: ''
|
|
|
|
resolve({
|
|
filePath: blobUrl,
|
|
blob,
|
|
fileName,
|
|
duration: Date.now() - this._startTs,
|
|
mime: 'audio/wav',
|
|
size: blob.size,
|
|
cancelled: false
|
|
})
|
|
})
|
|
}
|
|
|
|
_cancelH5() {
|
|
return new Promise((resolve) => {
|
|
const h5 = this._h5
|
|
if (!h5) {
|
|
this._isRecording = false
|
|
this._clearAutoStopTimer()
|
|
resolve()
|
|
return
|
|
}
|
|
try { h5.cleanup() } catch (e) { /* noop */ }
|
|
this._h5 = null
|
|
this._isRecording = false
|
|
this._clearAutoStopTimer()
|
|
resolve()
|
|
})
|
|
}
|
|
|
|
// ===================== uni-app (MP/APP/鸿蒙) 实现 =====================
|
|
|
|
_startUni() {
|
|
return new Promise((resolve, reject) => {
|
|
let rec = null
|
|
try {
|
|
rec = uni.getRecorderManager()
|
|
} catch (e) {
|
|
reject(_err('NO_RECORDER_MANAGER', 'uni.getRecorderManager unavailable'))
|
|
return
|
|
}
|
|
if (!rec) {
|
|
reject(_err('NO_RECORDER_MANAGER', 'recorder manager unavailable'))
|
|
return
|
|
}
|
|
|
|
this._uniRec = rec
|
|
|
|
rec.onStart(() => {
|
|
this._isRecording = true
|
|
this._startTs = Date.now()
|
|
this._setAutoStopTimer()
|
|
resolve()
|
|
})
|
|
|
|
rec.onStop((res) => {
|
|
// res = { tempFilePath, duration, fileSize }
|
|
this._uniRec = null
|
|
this._isRecording = false
|
|
this._clearAutoStopTimer()
|
|
const mime = this._format === 'wav' ? 'audio/wav'
|
|
: this._format === 'aac' ? 'audio/aac'
|
|
: 'audio/mpeg'
|
|
if (this._uniResolve) {
|
|
const r = this._uniResolve
|
|
this._uniResolve = null
|
|
r({
|
|
filePath: res.tempFilePath,
|
|
blob: null,
|
|
fileName: '',
|
|
duration: typeof res.duration === 'number' ? res.duration : (Date.now() - this._startTs),
|
|
mime,
|
|
size: res.fileSize || 0,
|
|
cancelled: false
|
|
})
|
|
}
|
|
})
|
|
|
|
rec.onError((err) => {
|
|
const e = _err('UNI_RECORD_ERROR', (err && (err.errMsg || err.message)) || 'record failed')
|
|
this._uniRec = null
|
|
this._isRecording = false
|
|
this._clearAutoStopTimer()
|
|
this._emit('error', e)
|
|
if (this._uniResolve) {
|
|
const r = this._uniResolve
|
|
this._uniResolve = null
|
|
r(null)
|
|
} else {
|
|
// 启动阶段的 reject
|
|
reject(e)
|
|
}
|
|
})
|
|
|
|
// 振幅事件 (uni-app 文档:onFrameRecorded, frameSize 单位 KB, frameBuffer ArrayBuffer)
|
|
if (typeof rec.onFrameRecorded === 'function') {
|
|
rec.onFrameRecorded((res) => {
|
|
if (!res || !res.frameBuffer) return
|
|
// frameBuffer 是 PCM 字节,简单用 |sample| / 0x8000 取平均振幅
|
|
try {
|
|
const view = new DataView(res.frameBuffer)
|
|
let sum = 0
|
|
const len = res.frameBuffer.byteLength
|
|
const step = Math.max(2, Math.floor(len / 256))
|
|
for (let i = 0; i < len; i += step) {
|
|
const v = view.getInt16(i, true)
|
|
sum += Math.abs(v)
|
|
}
|
|
const avg = sum / Math.max(1, Math.floor(len / step))
|
|
const level = Math.min(1, avg / 16384)
|
|
this._emit('progress', { level, duration: Date.now() - this._startTs })
|
|
} catch (e) { /* noop */ }
|
|
})
|
|
}
|
|
|
|
try {
|
|
rec.start({
|
|
duration: this._maxDuration / 1000, // uni-app 单位:秒
|
|
sampleRate: this._sampleRate,
|
|
numberOfChannels: this._channels,
|
|
encodeBitRate: this._bitRate,
|
|
format: this._format,
|
|
frameSize: 4 // KB,触发 onFrameRecorded 频率
|
|
})
|
|
} catch (e) {
|
|
this._uniRec = null
|
|
reject(e)
|
|
}
|
|
})
|
|
}
|
|
|
|
_stopUni() {
|
|
return new Promise((resolve) => {
|
|
const rec = this._uniRec
|
|
if (!rec) { resolve(null); return }
|
|
this._uniResolve = resolve
|
|
try { rec.stop() } catch (e) { resolve(null) }
|
|
})
|
|
}
|
|
|
|
_cancelUni() {
|
|
return new Promise((resolve) => {
|
|
const rec = this._uniRec
|
|
if (!rec) {
|
|
this._isRecording = false
|
|
this._clearAutoStopTimer()
|
|
resolve()
|
|
return
|
|
}
|
|
this._uniResolve = () => resolve()
|
|
try { rec.stop() } catch (e) {
|
|
this._isRecording = false
|
|
this._clearAutoStopTimer()
|
|
resolve()
|
|
}
|
|
})
|
|
}
|
|
|
|
// ===================== 工具 =====================
|
|
|
|
_setAutoStopTimer() {
|
|
this._clearAutoStopTimer()
|
|
this._autoStopTimer = setTimeout(() => {
|
|
// 自动停止 (上限到达)
|
|
if (this._isRecording) {
|
|
this.stop().catch(() => { /* swallow */ })
|
|
}
|
|
}, this._maxDuration)
|
|
}
|
|
|
|
_clearAutoStopTimer() {
|
|
if (this._autoStopTimer) {
|
|
clearTimeout(this._autoStopTimer)
|
|
this._autoStopTimer = null
|
|
}
|
|
}
|
|
}
|
|
|
|
export default createVoiceRecorder |