接入讯飞SDK及参数设置

简要描述

主要协助云上越秀App接入讯飞SDK，并且设置讯飞相应参数的功能代码示例；

主要内容

版本号：1.1140

包大小：2.7M（jar包+so文件大小）

引入方式:jar包+so库，本地引入

代码设置

1、10s内无声音自动中断

核心代码段为 SpeechConstant.VAD_BOS 和 SpeechConstant.VAD_EOS

  1. //kotlin实现
  2. SpeechRecognizer.createRecognizer(mContext, mTtsInitListener).apply {
  3.             // 清空参数
  4.             setParameter(SpeechConstant.PARAMS, null)
  5.             // 设置听写引擎
  6.             setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD)
  7.             // 设置返回结果格式
  8.             setParameter(SpeechConstant.RESULT_TYPE, "json")
  9.             // * 在线听写支持多种小语种设置。支持语言类型如下：
  10.             // *         <item>zh_cn</item> 中文   默认
  11.             // *         <item>en_us</item> 英文
  12.             // *         <item>ja_jp</item> 日语
  13.             // *         <item>ru-ru</item> 俄语
  14.             // *         <item>es_es</item> 西班牙语
  15.             // *         <item>fr_fr</item> 法语
  16.             // *         <item>ko_kr</item> 韩语
  17.             setParameter(SpeechConstant.LANGUAGE, "zh_cn")
  18.             // 设置语言区域
  19.             setParameter(SpeechConstant.ACCENT, "mandarin")
  21.             // 设置语音前端点:静音超时时间，即用户多长时间不说话则当做超时处理
  22.             setParameter(SpeechConstant.VAD_BOS, "10000")
  24.             // 设置语音后端点:后端点静音检测时间，即用户停止说话多长时间内即认为不再输入， 自动停止录音
  25.             setParameter(SpeechConstant.VAD_EOS, "10000")
  27.             // 设置标点符号,设置为"0"返回结果无标点,设置为"1"返回结果有标点
  28.             setParameter(SpeechConstant.ASR_PTT, "1")
  30.             // 设置音频保存路径，保存音频格式支持pcm、wav，设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
  31.             setParameter(SpeechConstant.AUDIO_FORMAT, "pcm")
  32.         }

2、监听讯飞回调
实现RecognizerListener接口（kotlin）

  1.   fun startListening(
  2.         filePath: (String) -> Unit,
  3.         ready: () -> Unit,
  4.         endSpeak: () -> Unit,
  5.         error: (SpeechError?) -> Unit,
  6.         result: (String?) -> Unit,
  7.         finish: () -> Unit
  8.     ): Int {
  9.         val value = object : RecognizerListener {
  10.             override fun onVolumeChanged(volume: Int, data: ByteArray?) {
  11.                 // SparringLog.d(TAG,"当前正在说话，音量大小：$volume")
  12.                 // SparringLog.d(TAG,"返回音频数据：" + data?.size)
  13.             }
  15.             override fun onResult(results: RecognizerResult?, isLast: Boolean) {
  16.                 val resultString = results?.resultString
  17.                 SparringLog.d(TAG, resultString.toString())
  18.                 result(resultString)
  19.                 if (isLast) {
  20.                     finish()
  21.                 }
  22.             }
  24.             override fun onBeginOfSpeech() {
  25.                 // 此回调表示：sdk内部录音机已经准备好了，用户可以开始语音输入
  26.                 SparringLog.d(TAG, "开始说话")
  27.                 ready()
  28.             }
  30.             override fun onEvent(eventType: Int, arg1: Int, arg2: Int, obj: Bundle?) {
  31.                 // 以下代码用于获取与云端的会话id，当业务出错时将会话id提供给技术支持人员，可用于查询会话日志，定位出错原因
  32.                 // 若使用本地能力，会话id为null
  33.                 //    if (SpeechEvent.EVENT_SESSION_ID == eventType) {
  34.                 //        String sid = obj.getString(SpeechEvent.KEY_EVENT_SESSION_ID);
  35.                 //        Log.d(TAG, "session id =" + sid);
  36.                 //    }
  37.             }
  39.             override fun onEndOfSpeech() {
  40.                 // 此回调表示：检测到了语音的尾端点，已经进入识别过程，不再接受语音输入
  41.                 SparringLog.d(TAG, "结束说话")
  42.                 endSpeak()
  43.             }
  45.             override fun onError(error: SpeechError?) {
  46.                 // TODO: 处理此权限的错误 立即停止回调的也是10118 没有权限也是10118 怎么区分开？
  47.                 // 错误码：10118(您没有说话)，可能是录音机权限被禁，需要提示用户打开应用的录音权限。
  48.                 SparringLog.e(TAG, error?.toString())
  49.                 error(error)
  50.                 finish()
  51.             }
  53.         }
  55.         return mIat.run {
  56.             val tempPath =
  57.                 com.yxt.sparring.utils.FileUtil.sInstance.PATH_APP_MEDIA +
  58.                         File.separator + UUID.randomUUID().toString() + ".pcm"
  59.             filePath(tempPath)
  60.             setParameter(SpeechConstant.ASR_AUDIO_PATH, tempPath)
  61.             startListening(value)
  62.         }
  63.     }

以下是我们封装的讯飞工具类，供参考
XunFeiUtil

  2. import android.content.Context
  3. import android.os.Bundle
  4. import android.os.Environment
  5. import android.os.MemoryFile
  6. import com.iflytek.cloud.*
  7. import com.iflytek.cloud.msc.util.FileUtil
  8. import com.yxt.sparring.utils.common.log.SparringLog
  9. import java.io.File
  10. import java.io.IOException
  11. import java.util.*
  13. class XunFeiUtil private constructor() {
  15.     companion object {
  16.         private var TAG = XunFeiUtil::class.java.simpleName
  18.         @JvmStatic
  19.         val instance: XunFeiUtil by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
  20.             XunFeiUtil()
  21.         }
  22.     }
  24.     private lateinit var mContext: Context
  26.     fun init(context: Context) {
  27.         mContext = context
  28.         SpeechUtility.createUtility(context, SpeechConstant.APPID + "=5ab0cdad")
  29.     }
  31.     fun startListening(
  32.         filePath: (String) -> Unit,
  33.         ready: () -> Unit,
  34.         endSpeak: () -> Unit,
  35.         error: (SpeechError?) -> Unit,
  36.         result: (String?) -> Unit,
  37.         finish: () -> Unit
  38.     ): Int {
  39.         val value = object : RecognizerListener {
  40.             override fun onVolumeChanged(volume: Int, data: ByteArray?) {
  41.                 // SparringLog.d(TAG,"当前正在说话，音量大小：$volume")
  42.                 // SparringLog.d(TAG,"返回音频数据：" + data?.size)
  43.             }
  45.             override fun onResult(results: RecognizerResult?, isLast: Boolean) {
  46.                 val resultString = results?.resultString
  47.                 SparringLog.d(TAG, resultString.toString())
  48.                 result(resultString)
  49.                 if (isLast) {
  50.                     finish()
  51.                 }
  52.             }
  54.             override fun onBeginOfSpeech() {
  55.                 // 此回调表示：sdk内部录音机已经准备好了，用户可以开始语音输入
  56.                 SparringLog.d(TAG, "开始说话")
  57.                 ready()
  58.             }
  60.             override fun onEvent(eventType: Int, arg1: Int, arg2: Int, obj: Bundle?) {
  61.                 // 以下代码用于获取与云端的会话id，当业务出错时将会话id提供给技术支持人员，可用于查询会话日志，定位出错原因
  62.                 // 若使用本地能力，会话id为null
  63.                 //    if (SpeechEvent.EVENT_SESSION_ID == eventType) {
  64.                 //        String sid = obj.getString(SpeechEvent.KEY_EVENT_SESSION_ID);
  65.                 //        Log.d(TAG, "session id =" + sid);
  66.                 //    }
  67.             }
  69.             override fun onEndOfSpeech() {
  70.                 // 此回调表示：检测到了语音的尾端点，已经进入识别过程，不再接受语音输入
  71.                 SparringLog.d(TAG, "结束说话")
  72.                 endSpeak()
  73.             }
  75.             override fun onError(error: SpeechError?) {
  76.                 // TODO: 处理此权限的错误 立即停止回调的也是10118 没有权限也是10118 怎么区分开？
  77.                 // 错误码：10118(您没有说话)，可能是录音机权限被禁，需要提示用户打开应用的录音权限。
  78.                 SparringLog.e(TAG, error?.toString())
  79.                 error(error)
  80.                 finish()
  81.             }
  83.         }
  85.         return mIat.run {
  86.             val tempPath =
  87.                 com.yxt.sparring.utils.FileUtil.sInstance.PATH_APP_MEDIA +
  88.                         File.separator + UUID.randomUUID().toString() + ".pcm"
  89.             filePath(tempPath)
  90.             setParameter(SpeechConstant.ASR_AUDIO_PATH, tempPath)
  91.             startListening(value)
  92.         }
  94.     }
  96.     // 语音合成
  97.     fun startSpeaking(name: String?, content: String, needDelay: (Boolean) -> Unit) {
  98.         mTts.apply {
  99. //            后台api没有返回speaker的时候是否返回性别问题；旁白声音问题；
  100. //            已确认2020.5.9（开会小组）-----后端不返回speaker时，App端不需要转语音，跟旁白一样处理
  101.             if (name.isNullOrBlank()) {
  102.                 needDelay(true)
  103.             } else {
  104.                 setParameter(SpeechConstant.VOICE_NAME, name)
  105.                 startSpeaking(content, object : SynthesizerListener {
  106.                     val container = Vector<ByteArray?>()
  108.                     override fun onBufferProgress(percent: Int, beginPos: Int, endPos: Int, info: String?) {
  109.                         // 合成进度
  110.                         SparringLog.d(TAG, "缓冲进度为$percent")
  111.                     }
  113.                     override fun onSpeakBegin() {
  114.                         SparringLog.d(TAG, "开始播放")
  115.                     }
  117.                     override fun onSpeakProgress(percent: Int, beginPos: Int, endPos: Int) {
  118.                         SparringLog.d(TAG, "播放进度为$percent")
  119.                     }
  121.                     override fun onEvent(eventType: Int, arg1: Int, arg12: Int, obj: Bundle?) {
  122.                         //     以下代码用于获取与云端的会话id，当业务出错时将会话id提供给技术支持人员，可用于查询会话日志，定位出错原因
  123.                         //     若使用本地能力，会话id为null
  124.                         if (SpeechEvent.EVENT_SESSION_ID == eventType) {
  125.                             val sid: String? = obj?.getString(SpeechEvent.KEY_EVENT_SESSION_ID)
  126.                             SparringLog.d(TAG, "session id =$sid")
  127.                         }
  129.                         //当设置SpeechConstant.TTS_DATA_NOTIFY为1时，抛出buf数据
  130.                         if (SpeechEvent.EVENT_TTS_BUFFER == eventType) {
  131.                             val buf: ByteArray? = obj?.getByteArray(SpeechEvent.KEY_EVENT_TTS_BUFFER)
  132.                             SparringLog.d(TAG, "buf is =" + buf?.size)
  133.                             container.add(buf)
  134.                         }
  135.                     }
  137.                     override fun onSpeakPaused() {
  138.                         SparringLog.d(TAG, "暂停播放")
  139.                     }
  141.                     override fun onSpeakResumed() {
  142.                         SparringLog.d(TAG, "继续播放")
  143.                     }
  145.                     override fun onCompleted(error: SpeechError?) {
  146.                         if (error == null) {
  147.                             SparringLog.d(TAG, "播放完成," + container.size)
  148.                             needDelay.invoke(false)
  149.                             try {
  150.                                 for (i in container.indices) {
  151.                                     writeToFile(container[i])
  152.                                 }
  153.                             } catch (e: IOException) {
  154.                             }
  155.                             FileUtil.saveFile(
  156.                                 memFile,
  157.                                 mTotalSize,
  158.                                 Environment.getExternalStorageDirectory().toString() + "/real.pcm"
  159.                             )
  160.                         } else {
  161.                             needDelay.invoke(true)
  162.                             SparringLog.e(TAG, error.toString())
  163.                         }
  165.                     }
  166.                 })
  168.             }
  170.         }
  172.     }
  174.     fun stopListening() {
  175.         if (mIat.isListening) {
  176.             mIat.stopListening()
  177.         }
  178.     }
  180.     fun stopSpeaking() {
  181.         if (mTts.isSpeaking) {
  182.             mTts.stopSpeaking()
  183.         }
  184.     }
  186.     fun pauseSpeaking() {
  187.         mTts.pauseSpeaking()
  188.     }
  190.     fun resumeSpeaking() {
  191.         mTts.resumeSpeaking()
  192.     }
  194.     @Volatile
  195.     private var mTotalSize: Long = 0
  197.     private val memFile: MemoryFile by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
  198.         val mFilepath = Environment.getExternalStorageDirectory().toString() + "/real.pcm"
  199.         MemoryFile(mFilepath, 1920000)
  200.     }
  202.     @Throws(IOException::class)
  203.     private fun writeToFile(data: ByteArray?) {
  204.         if (data == null || data.isEmpty()) return
  205.         try {
  206.             memFile.allowPurging(false)
  207.             memFile.writeBytes(data, 0, mTotalSize.toInt(), data.size)
  208.             mTotalSize += data.size.toLong()
  209.         } finally {
  210.         }
  211.     }
  213.     private val mTts: SpeechSynthesizer by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
  214.         SpeechSynthesizer.createSynthesizer(mContext, mTtsInitListener).apply {
  215.             // 清空参数
  216.             setParameter(SpeechConstant.PARAMS, null)
  217.             // 根据合成引擎设置相应参数 目前只使用了cloud
  218.             setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD)
  219.             //支持实时音频返回，仅在synthesizeToUri条件下支持
  220.             setParameter(SpeechConstant.TTS_DATA_NOTIFY, "0")
  221.             //    setParameter(SpeechConstant.TTS_BUFFER_TIME,"1");
  222.             // 设置在线合成发音人
  223. //            setParameter(SpeechConstant.VOICE_NAME, SPUtil.getString(SpeechConstant.VOICE_NAME, "xiaofeng"))
  224.             //设置合成语速
  225.             setParameter(SpeechConstant.SPEED, "50")
  226.             //设置合成音调
  227.             setParameter(SpeechConstant.PITCH, "50")
  228.             //设置合成音量
  229.             setParameter(SpeechConstant.VOLUME, "50")
  230.             //设置播放器音频流类型 参见demo  通话/系统/铃声/*音乐*/闹铃/通知
  231.             setParameter(SpeechConstant.STREAM_TYPE, "3")
  232.             // 设置播放合成音频打断音乐播放，默认为true
  233. //            setParameter(SpeechConstant.KEY_REQUEST_FOCUS, "true")
  235.             // 设置音频保存路径，保存音频格式支持pcm、wav，设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
  236.             setParameter(SpeechConstant.AUDIO_FORMAT, "pcm")
  237.             setParameter(
  238.                 SpeechConstant.TTS_AUDIO_PATH,
  239.                 Environment.getExternalStorageDirectory().toString() + "/msc/tts.pcm"
  240.             )
  241.         }
  243.     }
  245.     private val mTtsInitListener: (Int) -> Unit = { code ->
  246.         if (code != ErrorCode.SUCCESS) {
  247.             SparringLog.e(
  248.                 TAG,
  249.                 "初始化失败，错误码：$code,请点击网址https://www.xfyun.cn/document/error-code查询解决方案"
  250.             )
  251.         }
  252.     }
  254.     // 在线听写
  255.     private val mIat: SpeechRecognizer by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
  257.         SpeechRecognizer.createRecognizer(mContext, mTtsInitListener).apply {
  259.             // 清空参数
  260.             setParameter(SpeechConstant.PARAMS, null)
  261.             // 设置听写引擎
  262.             setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD)
  263.             // 设置返回结果格式
  264.             setParameter(SpeechConstant.RESULT_TYPE, "json")
  267.             // * 在线听写支持多种小语种设置。支持语言类型如下：
  268.             // *         <item>zh_cn</item> 中文   默认
  269.             // *         <item>en_us</item> 英文
  270.             // *         <item>ja_jp</item> 日语
  271.             // *         <item>ru-ru</item> 俄语
  272.             // *         <item>es_es</item> 西班牙语
  273.             // *         <item>fr_fr</item> 法语
  274.             // *         <item>ko_kr</item> 韩语
  275.             setParameter(SpeechConstant.LANGUAGE, "zh_cn")
  276.             // 设置语言区域
  277.             setParameter(SpeechConstant.ACCENT, "mandarin")
  279.             // 设置语音前端点:静音超时时间，即用户多长时间不说话则当做超时处理
  280.             setParameter(SpeechConstant.VAD_BOS, "10000")
  282.             // 设置语音后端点:后端点静音检测时间，即用户停止说话多长时间内即认为不再输入， 自动停止录音
  283.             setParameter(SpeechConstant.VAD_EOS, "10000")
  285.             // 设置标点符号,设置为"0"返回结果无标点,设置为"1"返回结果有标点
  286.             setParameter(SpeechConstant.ASR_PTT, "1")
  288.             // 设置音频保存路径，保存音频格式支持pcm、wav，设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
  289.             setParameter(SpeechConstant.AUDIO_FORMAT, "pcm")
  291. //            setParameter(SpeechConstant.ASR_AUDIO_PATH, Environment.getExternalStorageDirectory().toString() + "/pcm/2.pcm")
  292.         }
  293.     }
  295.     fun stop() {
  296.         stopListening()
  297.         // 退出时释放连接
  298.         mIat.cancel()
  299.         mIat.destroy()
  301.         stopSpeaking()
  302.         mTts.destroy()
  303.     }
  306. }

IatBean

  1. data class IatBean(
  2.     val bg: Int,
  3.     val ed: Int,
  4.     val ls: Boolean,
  5.     val sn: Int,
  6.     val ws: List<W>
  7. ) {
  8.     val plainText :String?
  9.         get() {
  10.             val buffer = StringBuffer()
  11.             for (w in ws) {
  12.                 // 转写结果词，默认使用第一个结果
  13. //                如果需要多候选结果，解析数组其他字段
  14. //                for(int j = 0; j < items.length(); j++)
  15. //                {
  16. //                    JSONObject obj = items.getJSONObject(j);
  17. //                    ret.append(obj.getString("w"));
  18. //                }
  19.                 buffer.append(w.cw[0].w)
  20.             }
  21.             return buffer.toString()
  22.         }
  23. }
  26. data class W(
  27.     val bg: Int,
  28.     val cw: List<Cw>
  29. )
  31. data class Cw(
  32.     val sc: Double,
  33.     val w: String
  34. )