1
  const {
2
    status, originText, cancel,
3
    convertAction, start, invalidInput, setInvalidInput
4
  } = useAudio2Order({
5
    onAddRows: onSuccess,
6
    onStop: () => setVisible(false)
7
  })

1
import {useCallback, useState} from "react";
2
import useRequest from "@taro-hooks/use-request";
3
import {textParse} from "@/modules/preOrder/services";
4
import Taro from "@tarojs/taro";
5
import useRecorderManager from "@/shared/hooks/useRecorderManager";
6

7
export enum Status {
8
  // 音频输入中
9
  audioInput,
10
  // 转换文本中
11
  convertText,
12
  // 转换文本成功
13
  invalid
14
}
15

16
export default ({onAddRows, onStop}: {
17
  onAddRows?: (data: PreOrder.PreOrderAddProductDTO[]) => void,
18
  onStop?: VoidFunction
19
}) => {
20
  const [originText, setOriginText] = useState('');
21
  const [invalidInput, setInvalidInput] = useState('')
22
  const [status, setStatus] = useState<Status | null>(null)
23

24
  const {runAsync: textParseAsyncAction, loading: textParseLoading} = useRequest(
25
    textParse, { manual: true }
26
  )
27

28
  const doParseText = useCallback(async (text: string) => {
29
    if (textParseLoading) {
30
      return;
31
    }
32
    if (!text) {
33
      Taro.showToast({
34
        title: '没有可识别的文本',
35
        icon: 'none',
36
      })
37
      return
38
    }
39
    const result = (await textParseAsyncAction(text)) as PreOrder.TextParseVO;
40
    if (!result) {
41
      Taro.showToast({
42
        title: '未能识别，请重试',
43
        icon: 'none',
44
      })
45
      return
46
    }
47
    let data = result
48
    let hasData = data.parseRespList && data.parseRespList.length > 0
49
    if (hasData) {
50
      onAddRows?.(data.parseRespList as PreOrder.PreOrderAddProductDTO[])
51
    }
52
    return data.badInput ?? '';
53
  }, [textParseLoading, textParseAsyncAction, onAddRows]);
54

55
  const {startRecord, stopRecording} = useRecorderManager({
56
    onRecognitionResult: setOriginText,
57
    onStop: () => convertAction(false)
58
  })
59

60
  const convertAction = async (st = true) => {
61
    if (status === Status.audioInput) {
62
      setStatus(Status.convertText)
63
      st && stopRecording()
64
      const otherText = await doParseText(originText)
65
      setOriginText('');
66
      if (otherText) {
67
        setInvalidInput(otherText)
68
        setStatus(Status.invalid)
69
        return Status.invalid;
70
      }
71
      setStatus(null)
72
      onStop?.();
73
      return null;
74
    }
75

76
    if (status === Status.invalid) {
77
      if (!invalidInput) {
78
        setStatus(null)
79
        return null;
80
      }
81
      const otherText = await doParseText(invalidInput)
82
      if (otherText) {
83
        setInvalidInput(otherText)
84
        return Status.invalid;
85
      }
86
      setStatus(null)
87
      onStop?.();
88
      return null;
89
    }
90
  }
91

92
  return {
93
    start: async () => {
94
      setOriginText('');
95
      setInvalidInput('');
96
      setStatus(Status.audioInput)
97
      await startRecord()
98
    },
99
    convertAction: () => convertAction(),
100
    cancel: async () => {
101
      await stopRecording()
102
    },
103
    originText,
104
    invalidInput,
105
    status,
106
    setInvalidInput,
107
    doParseText,
108
    loading: textParseLoading,
109
  }
110
}

1
  const {startRecord, stopRecording} = useRecorderManager({
2
    onRecognitionResult: setOriginText,
3
  })

1
import {
2
  authorizePermissions,
3
  createSocketConnection,
4
  handleMessageData,
5
  remainingTimeInterval,
6
  toBase64,
7
} from '@/shared/hooks/useRecorderManager/utils'
8

9
import Taro from '@tarojs/taro'
10
import {useCallback, useRef, useState} from 'react'
11

12
export interface UseRecorderManagerProps {
13
  /**
14
   * 语音录入时间，单位毫秒，最长60000毫秒
15
   * 默认也是60000毫秒
16
   */
17
  remainingTime?: number
18
  /**
19
   * 识别结果的回调
20
   * @param value
21
   */
22
  onRecognitionResult?: (value: string) => void
23
  /**
24
   * 剩余时间变化触发的方法 返回是秒
25
   * @param value
26
   */
27
  onRemainingTimeChange?: (value: number) => void
28
  onStop?: () => void
29
}
30

31
const propsWithDefault = (props: UseRecorderManagerProps) => {
32
  if (!props.remainingTime) {
33
    props.remainingTime = 60 * 1000;
34
  }
35
  return props;
36
}
37

38
export default function useRecorderManager(props: UseRecorderManagerProps) {
39

40
  const propsRef = useRef<UseRecorderManagerProps>(props);
41
  propsRef.current = propsWithDefault(props);
42

43
  // 是否在录音中
44
  const [isRecording, _setRecording] = useState(false);
45
  const isRecordingRef = useRef<boolean>(isRecording);
46
  const setRecording = useCallback((v) => {
47
    isRecordingRef.current = v;
48
    _setRecording(v);
49
  }, [])
50

51
  // remainingTime 倒计时的 interval 的返回值
52
  const intervalTimer = useRef<any>()
53

54
  // 解析缓存
55
  const voiceResultMapRef = useRef<Map<number, any>>(new Map())
56

57
  // ws连接
58
  const socketConnection = useRef<Taro.SocketTask | null>(null)
59

60
  /**
61
   * 停止录音
62
   */
63
  const stopRecording = useCallback(() => {
64
    setRecording(false)
65
    clearInterval(intervalTimer.current)
66
    // 完整清理，关闭所有连接与状态
67
    try {
68
      Taro.getRecorderManager().stop()
69
    } catch {
70
    }
71
    try {
72
      socketConnection.current?.close({code: 1})
73
    } catch {
74
    }
75
    // 事件会调
76
    propsRef.current.onStop?.()
77
    // ws连接
78
    socketConnection.current = null
79
    // 解析缓存
80
    voiceResultMapRef.current = new Map()
81
  }, [])
82

83
  /**
84
   * 暂停录音
85
   */
86
  const pauseRecording = useCallback(() => {
87
    if (!isRecordingRef.current) {
88
      return;
89
    }
90
    Taro.getRecorderManager().pause()
91
    setRecording(false)
92
  }, [])
93

94
  /**
95
   * 继续录音
96
   */
97
  const resumeRecording = useCallback(() => {
98
    if (isRecordingRef.current) {
99
      return;
100
    }
101
    Taro.getRecorderManager().resume()
102
    setRecording(true)
103
  }, [])
104

105
  // 处理识别结果
106
  const onMessage = useCallback((res: string) => {
107
    if (!res) {
108
      return
109
    }
110

111
    // 解析讯飞的数据包
112
    try {
113
      const jsonData = JSON.parse(res)
114
      if (jsonData.data && jsonData.data.result) {
115
        const resultText = handleMessageData(jsonData.data.result, voiceResultMapRef.current)
116
        propsRef.current.onRecognitionResult?.(resultText)
117
      }
118
      if (jsonData.code === 0 && jsonData.data.status === 2) {
119
        stopRecording()
120
      }
121
      if (jsonData.code !== 0) {
122
        stopRecording()
123
        Taro.showToast({
124
          title: `讯飞调用失败:${jsonData.code}`,
125
          icon: 'none',
126
        })
127
      }
128
    } catch (err) {
129
      console.error('语音解析异常', err)
130
      stopRecording()
131
      Taro.showToast({
132
        title: `语音解析异常`,
133
        icon: 'none',
134
      })
135
    }
136
  }, [])
137

138
  const startRecord = useCallback(async () => {
139
    if (isRecordingRef.current) return
140
    setRecording(true)
141

142
    try {
143
      await authorizePermissions()
144

145
      const recorder = Taro.getRecorderManager()
146
      recorder.onStart(() => {
147
        clearInterval(intervalTimer.current)
148
        // 是否需要等待最后一个片段完成（ws 收到消息后关闭）？
149
        intervalTimer.current = remainingTimeInterval(
150
          propsRef.current.remainingTime!,
151
          v => propsRef.current.onRemainingTimeChange?.(v),
152
          stopRecording
153
        )
154
      })
155

156
      recorder.onError?.((error) => {
157
        console.error('录音失败，请重试', JSON.stringify(error));
158
        Taro.showToast({title: '录音失败，请重试', icon: 'none'})
159
      })
160

161
      const duration = Math.min(Math.max(propsRef.current.remainingTime!, 0), 60000)
162
      recorder.start({
163
        duration,
164
        sampleRate: 16000,
165
        numberOfChannels: 1,
166
        frameSize: 2,
167
        format: 'pcm' as any,
168
      })
169

170
      recorder.onFrameRecorded(({frameBuffer, isLastFrame}) => {
171
        if (!isRecordingRef.current) {
172
          return;
173
        }
174
        const u8Arr = new Uint8Array(frameBuffer)
175
        socketConnection.current?.send({
176
          data: JSON.stringify({
177
            data: {
178
              status: isLastFrame ? 2 : 1,
179
              format: 'audio/L16;rate=16000',
180
              encoding: 'raw',
181
              audio: toBase64(u8Arr),
182
            },
183
          }),
184
          fail: (err) => {
185
            console.error('音频发送失败', err)
186
            Taro.showToast({title: '音频发送失败', icon: 'none'})
187
          },
188
        })
189
      })
190

191
      // ws连接
192
      socketConnection.current = await createSocketConnection();
193
      socketConnection.current!.onMessage((e) => onMessage(e.data))
194
      socketConnection.current!.onError?.(() => Taro.showToast({title: '语音服务异常', icon: 'none'}))
195
    } catch (err) {
196
      console.error('连接语音服务失败', err)
197
      Taro.showToast({title: '连接语音服务失败', icon: 'none'})
198
      stopRecording()
199
    }
200
  }, [])
201
  return {
202
    startRecord,
203
    pauseRecording,
204
    resumeRecording,
205
    isRecording,
206
    stopRecording,
207
  }
208
}

1
import Taro from "@tarojs/taro";
2

3
export const toBase64 = (buffer: Uint8Array) => {
4
   ...
5
}
6

7
export const handleMessageData = (data: any, map: Map<number, any>) => {
8
  let sn = data.sn
9
  let pgs = data.pgs
10
  if (sn && pgs) {
11
    map.set(sn, data)
12
    if (pgs == 'rpl') {
13
      let rg = data.rg
14
      if (rg != null && rg.length == 2) {
15
        for (let key = rg[0]; key <= rg[1]; key++) {
16
          map.delete(key)
17
        }
18
      }
19
    }
20
  }
21
  // 将Map的entries转换为数组并按键排序
22
  const sortedEntries = Array.from(map.entries()).sort(
23
    (a, b) => a[0] - b[0],
24
  )
25
  // 使用reduce累积拼接文本，模拟StringBuffer的行为
26
  return sortedEntries.reduce((stringBuffer, [, cur]) => {
27
    const ws = cur.ws
28

29
    // 如果ws为空，返回之前的累积结果
30
    if (!ws) {
31
      return stringBuffer
32
    }
33

34
    // 遍历词组列表，拼接每个词组的第一个候选词
35
    for (let i = 0; i < ws.length; i++) {
36
      const cw = ws[i].cw
37
      if (cw) {
38
        stringBuffer += cw[0].w
39
      }
40
    }
41
    return stringBuffer
42
  }, '')
43
}
44

45
export const createSocketConnection = async () => {
46
  const connect = await Taro.connectSocket({url: '讯飞音频转换ws服务地址' })
47
  await new Promise<void>((resolve, reject) => {
48
    connect.onOpen(() => {
49
      connect.send({
50
        data: '配置',
51
        fail: () => {
52
          Taro.showToast({title: '语音服务握手失败', icon: 'none'})
53
        },
54
      })
55
      resolve();
56
    })
57
    connect.onError?.((err) => {
58
      console.error('语音服务异常', err)
59
      Taro.showToast({title: '语音服务异常', icon: 'none'});
60
      reject(err)
61
    })
62
  })
63
  return connect!;
64
}
65

66
export const authorizePermissions = () => {
67
  return new Promise((resolve, reject) => {
68
    Taro.authorize({
69
      scope: 'scope.record',
70
      fail: (err) => {
71
        Taro.showModal({
72
          title: '提示',
73
          content: '您未授权录音，功能将无法使用',
74
          confirmColor: '#06AE56',
75
          cancelColor: '#000000',
76
          confirmText: '去授权',
77
          success: ({confirm}) => {
78
            confirm && Taro.openSetting()
79
          },
80
        })
81
        reject(err)
82
      },
83
      success: resolve,
84
    })
85
  })
86
}
87

88
export const remainingTimeInterval = (remainingTime, onRemainingTimeChange, stopRecording) => {
89
  let currentRemaining = Math.min(Math.max(remainingTime!, 0), 60000)
90
  onRemainingTimeChange?.(currentRemaining / 1000)
91
  const timer = setInterval(() => {
92
    currentRemaining -= 500
93
    if (currentRemaining <= 0) {
94
      clearInterval(timer)
95
      stopRecording()
96
      onRemainingTimeChange?.(0)
97
      return
98
    }
99
    onRemainingTimeChange?.(currentRemaining / 1000)
100
  }, 500)
101
  return timer;
102
}