feat(App): getRecorderManager

packages/uni-api/src/index.ts

@@ -51,6 +51,7 @@ export * from './protocols/media/previewImage'
 export * from './protocols/media/getVideoInfo'
 export * from './protocols/media/saveImageToPhotosAlbum'
 export * from './protocols/media/saveVideoToPhotosAlbum'
+export * from './protocols/media/getRecorderManager'
 
 export * from './protocols/network/request'
 export * from './protocols/network/downloadFile'

packages/uni-api/src/protocols/media/getRecorderManager.ts

+export const API_GET_RECORDER_MANAGER = 'getRecorderManager'
+export type API_TYPE_GET_RECORDER_MANAGER = typeof uni.getRecorderManager

packages/uni-app-plus/src/service/api/index.ts

@@ -12,6 +12,7 @@ export * from './device/makePhoneCall'
 export * from './media/getImageInfo'
 export * from './media/getVideoInfo'
 export * from './media/previewImage'
+export * from './media/getRecorderManager'
 
 export * from './keyboard/keyboard'
 

packages/uni-app-plus/src/service/api/media/getRecorderManager.ts

+import { extend } from '@vue/shared'
+import {
+  API_GET_RECORDER_MANAGER,
+  API_TYPE_GET_RECORDER_MANAGER,
+  defineSyncApi,
+} from '@dcloudio/uni-api'
+import { TEMP_PATH } from '../constants'
+
+interface Recorder {
+  start: (args: UniApp.RecorderManagerStartOptions) => void
+  stop: Function
+  pause: Function
+  resume: Function
+}
+
+let recorder: PlusAudioAudioRecorder
+let recording: boolean = false
+let recordTimeout: number
+
+const publishRecorderStateChange = (state: string, res = {}) => {
+  onRecorderStateChange(
+    extend(
+      {
+        state,
+      },
+      res
+    )
+  )
+}
+
+const Recorder: Recorder = {
+  start({
+    duration = 60000,
+    sampleRate,
+    numberOfChannels,
+    encodeBitRate,
+    format = 'mp3',
+    frameSize,
+    // audioSource = 'auto',
+  }) {
+    if (recording) {
+      return publishRecorderStateChange('start')
+    }
+    recorder = plus.audio.getRecorder()
+    recorder.record(
+      {
+        format,
+        samplerate: String(sampleRate),
+        filename: TEMP_PATH + '/recorder/',
+      },
+      (res) =>
+        publishRecorderStateChange('stop', {
+          tempFilePath: res,
+        }),
+      (err) =>
+        publishRecorderStateChange('error', {
+          errMsg: err.message,
+        })
+    )
+    recordTimeout = setTimeout(() => {
+      Recorder.stop()
+    }, duration)
+    publishRecorderStateChange('start')
+    recording = true
+  },
+  stop() {
+    if (recording) {
+      recorder.stop()
+      recording = false
+      recordTimeout && clearTimeout(recordTimeout)
+    }
+  },
+  pause() {
+    if (recording) {
+      publishRecorderStateChange('error', {
+        errMsg: 'Unsupported operation: pause',
+      })
+    }
+  },
+  resume() {
+    if (recording) {
+      publishRecorderStateChange('error', {
+        errMsg: 'Unsupported operation: resume',
+      })
+    }
+  },
+}
+
+const callbacks: Record<string, null | Function> = {
+  pause: null,
+  resume: null,
+  start: null,
+  stop: null,
+  error: null,
+}
+
+function onRecorderStateChange(res: { state?: string; errMsg?: string }) {
+  const state = res.state
+  delete res.state
+  delete res.errMsg
+  if (state && typeof callbacks[state] === 'function') {
+    callbacks[state]!(res)
+  }
+}
+
+class RecorderManager implements UniApp.RecorderManager {
+  constructor() {}
+
+  onError(callback: Function) {
+    callbacks.error = callback
+  }
+
+  onFrameRecorded(callback: Function) {}
+
+  onInterruptionBegin(callback: Function) {}
+
+  onInterruptionEnd(callback: Function) {}
+
+  onPause(callback: Function) {
+    callbacks.pause = callback
+  }
+
+  onResume(callback: Function) {
+    callbacks.resume = callback
+  }
+
+  onStart(callback: Function) {
+    callbacks.start = callback
+  }
+
+  onStop(callback: Function) {
+    callbacks.stop = callback
+  }
+
+  pause() {
+    Recorder.pause()
+  }
+
+  resume() {
+    Recorder.resume()
+  }
+
+  start(options: UniApp.RecorderManagerStartOptions) {
+    Recorder.start(options)
+  }
+
+  stop() {
+    Recorder.stop()
+  }
+}
+
+let recorderManager: RecorderManager
+
+export const getRecorderManager = defineSyncApi<API_TYPE_GET_RECORDER_MANAGER>(
+  API_GET_RECORDER_MANAGER,
+  () => recorderManager || (recorderManager = new RecorderManager())
+)