集成前戏

首先进入科大讯飞官网

然后注册个账号，登入成功后点击右上方的控制台，进入控制台后点击创建应用

image

输入应用名称，分类，描述，平台等信息

image

提交过后页面会进行跳转这时候就可以看到刚才创建好的应用了，我们点击添加服务，这里我只选择在线语音合成和语音听写，有些功能是需要收费的。

image

’添加完成如下图

image

这时候点击右上角的SDK下载

image

下载完成后进行解压，我在桌面创建一个speak文件夹解压文件都放在这里

image

进入主题

步骤一

创建一个工程

image

步骤二

切换project工程，右击main目录，依次选择News-->Directory,创建一个jniLibs目录。

image

创建完成之后打开我们解压后的文件，将里面的文件拷贝到jniLibs目录下除了Msc.jar。最后将Msc.jar放到项目中的libs目录下，记得右击Add As Library。（注意：后面会用到json解析需要导入Gson，也可以用其他的Json框架）

image

照样右击main目录，依次选择News-->Folder--<Assets Folder.

image

创建完成之后将解压文件中的assets下的iflytek目录拷贝到刚才创建的Assets下。

image

步骤三

新建全局Application,然后初始化语音识别配置。

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
    //这里的APPID是你在控制台创建应用旁边的APPID
        SpeechUtility.createUtility(this, SpeechConstant.APPID + "=5a54cba7");
    }
}

记得在清单文件中配置

<application
        android:name=".MyApplication"
>

步骤四

配置权限

  <!--连接网络权限，用于执行云端语音能力 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <!--获取手机录音机使用权限，听写、识别、语义理解需要用到此权限 -->
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <!--读取网络信息状态 -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <!--获取当前wifi状态 -->
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <!--允许程序改变网络连接状态 -->
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
    <!--读取手机信息权限 -->
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <!--SD卡读写的权限（如果需要保存音频文件到本地的话）-->
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

步骤五

编写布局文件，这里我用两个按钮来演示带窗口和不带窗口的语音识别，然后用编辑框来接收用户输入的文本内容，下面的按钮时用来语音合成用户输入的文本

 <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.woodman.woodmansppch.MainActivity">
    <Button
        android:id="@+id/btn_with_dialog"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="打开带窗口的语音识别"
        />
    <Button
        android:id="@+id/btn_dialog"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="打开不带窗口的语音识别"
        />
    <EditText
        android:id="@+id/input_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        />
    <Button
        android:id="@+id/btn_synthetize"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="语音合成"
        />
</LinearLayout>

实现功能

语音识别后回调的是一个Json字符串，所以我们需要创建一个类DictationResult来接收转换后的数据

public class DictationResult {
    private String sn;
    private String ls;
    private String bg;
    private String ed;

    private List<Words> ws;

    public static class Words {
        private String bg;
        private List<Cw> cw;

        public static class Cw {
            private String w;
            private String sc;

            public String getW() {
                return w;
            }

            public void setW(String w) {
                this.w = w;
            }

            public String getSc() {
                return sc;
            }

            public void setSc(String sc) {
                this.sc = sc;
            }

            @Override
            public String toString() {
                return w;
            }
        }

        public String getBg() {
            return bg;
        }

        public void setBg(String bg) {
            this.bg = bg;
        }

        public List<Cw> getCw() {
            return cw;
        }

        public void setCw(List<Cw> cw) {
            this.cw = cw;
        }

        @Override
        public String toString() {
            String result = "";
            for (Cw cwTmp : cw) {
                result += cwTmp.toString();
            }
            return result;
        }
    }

    public String getSn() {
        return sn;
    }

    public void setSn(String sn) {
        this.sn = sn;
    }

    public String getLs() {
        return ls;
    }

    public void setLs(String ls) {
        this.ls = ls;
    }

    public String getBg() {
        return bg;
    }

    public void setBg(String bg) {
        this.bg = bg;
    }

    public String getEd() {
        return ed;
    }

    public void setEd(String ed) {
        this.ed = ed;
    }

    public List<Words> getWs() {
        return ws;
    }

    public void setWs(List<Words> ws) {
        this.ws = ws;
    }

    @Override
    public String toString() {
        String result = "";
        for (Words wsTmp : ws) {
            result += wsTmp.toString();
        }
        return result;
    }

首先来写不带窗口的语音识别器

btnRecognizer.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showRecognizer();
            }
        });

 public void showRecognizer(){
        //1.创建SpeechRecognizer对象，第二个参数：本地识别时传InitListener
        SpeechRecognizer mIat = SpeechRecognizer.createRecognizer(this, null);
        //2.设置听写参数，详见SDK中《MSC Reference Manual》文件夹下的SpeechConstant类
        mIat.setParameter(SpeechConstant.DOMAIN,"iat");
        mIat.setParameter(SpeechConstant.LANGUAGE,"zh_cn");
        mIat.setParameter(SpeechConstant.ACCENT,"mandarin ");
        //保存音频文件到本地（有需要的话）   仅支持pcm和wav，且需要自行添加读写SD卡权限
        mIat.setParameter(SpeechConstant.ASR_AUDIO_PATH, Environment.getExternalStorageDirectory() + "/msc/mIat.wav");
        // 3.开始听写
        mIat.startListening(mRecoListener);
    }
    //听写监听器
    private RecognizerListener mRecoListener = new RecognizerListener() {
        //听写结果回调接口(返回Json格式结果，用户可参见附录13.1)；
        // 一般情况下会通过onResults接口多次返回结果，完整的识别内容是多次结果的累加；
        // 关于解析Json的代码可参见Demo中JsonParser类；
        // isLast等于true时会话结束。
        String resultJson = "[";//放置在外边做类的变量则报错，会造成json格式不对
        public void onResult(RecognizerResult results, boolean isLast) {
            Log.d(TAG, "result:" + results.getResultString());
            if (!isLast) {
                resultJson += results.getResultString() + ",";
            } else {
                resultJson += results.getResultString() + "]";
            }

            if (isLast) {
                //解析语音识别后返回的json格式的结果
                Gson gson = new Gson();
                List<DictationResult> resultList = gson.fromJson(resultJson,
                        new TypeToken<List<DictationResult>>() {
                        }.getType());
                String result = "";
                for (int i = 0; i < resultList.size() - 1; i++) {            
                    result += resultList.get(i).toString();                  
                }
               Log.d(TAG,"识别结果"+result);
            }
        }

        //会话发生错误回调接口
        public void onError(SpeechError error) {
            //打印错误码描述
            Log.d(TAG, "error:" + error.getPlainDescription(true));
        }
        //开始录音
        public void onBeginOfSpeech() {
        }
        //volume音量值0~30，data音频数据
        public void onVolumeChanged(int volume, byte[] data) {
        }
        //结束录音
        public void onEndOfSpeech() {
        }
        //扩展用接口
        public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
        }
    };

接下来写带窗口的语音识别器

 btnRecognizerDialog.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showRecognizerDialog();
            }
        });

 /*-------------------------------带窗口的语音识别--------------------------*/
    private void showRecognizerDialog() {
        //有动画效果
         RecognizerDialog iatDialog;
        // 初始化有交互动画的语音识别器
        iatDialog = new RecognizerDialog(MainActivity.this, mInitListener);
        //设置监听，实现听写结果的回调
        iatDialog.setListener(new RecognizerDialogListener() {
            String resultJson = "[";//放置在外边做类的变量则报错，会造成json格式不对
            @Override
            public void onResult(RecognizerResult recognizerResult, boolean isLast) {
                System.out.println("-----------------   onResult   -----------------");
                if (!isLast) {
                    resultJson += recognizerResult.getResultString() + ",";
                } else {
                    resultJson += recognizerResult.getResultString() + "]";
                }

                if (isLast) {
                    //解析语音识别后返回的json格式的结果
                    Gson gson = new Gson();
                    List<DictationResult> resultList = gson.fromJson(resultJson,
                            new TypeToken<List<DictationResult>>() {
                            }.getType());
                    String result = "";
                    for (int i = 0; i < resultList.size() - 1; i++) {
                        result += resultList.get(i).toString();
                        Log.d(TAG,"识别结果"+result);
                    }
                }
            }
            @Override
            public void onError(SpeechError speechError) {
                //自动生成的方法存根
                speechError.getPlainDescription(true);
            }
        });
        //开始听写，需将sdk中的assets文件下的文件夹拷入项目的assets文件夹下（没有的话自己新建）
        iatDialog.show();
    }
    private InitListener mInitListener = new InitListener() {
        @Override
        public void onInit(int code) {
            if (code != ErrorCode.SUCCESS) {
                Toast.makeText(MainActivity.this, "初始化失败，错误码：" + code, Toast.LENGTH_SHORT).show();
            }
        }
    };

最后一个是语音合成

btnSynthesizer.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                SpeechSynthesizer(mEtInputText.getText().toString());
            }
        });

 /*-------------------------------语音合成--------------------------*/
    public void SpeechSynthesizer(String text){
        //1.创建SpeechSynthesizer对象, 第二个参数：本地合成时传InitListener
        SpeechSynthesizer mTts = SpeechSynthesizer.createSynthesizer(MainActivity.this, null);

        /**
         2.合成参数设置，详见《科大讯飞MSC API手册(Android)》SpeechSynthesizer 类
         *
         */
        // 清空参数
        mTts.setParameter(SpeechConstant.PARAMS, null);
        mTts.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD); //设置云端
        mTts.setParameter(SpeechConstant.VOICE_NAME, "xiaoyan");//设置发音人
        mTts.setParameter(SpeechConstant.SPEED, "50");//设置语速
        //设置合成音调
        mTts.setParameter(SpeechConstant.PITCH, "50");
        mTts.setParameter(SpeechConstant.VOLUME, "80");//设置音量，范围0~100
        mTts.setParameter(SpeechConstant.STREAM_TYPE, "3");
        // 设置播放合成音频打断音乐播放，默认为true
        mTts.setParameter(SpeechConstant.KEY_REQUEST_FOCUS, "true");

        // 设置音频保存路径，保存音频格式支持pcm、wav，设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
        // 注：AUDIO_FORMAT参数语记需要更新版本才能生效
//        mTts.setParameter(SpeechConstant.AUDIO_FORMAT, "wav");
//        boolean isSuccess = mTts.setParameter(SpeechConstant.TTS_AUDIO_PATH, Environment.getExternalStorageDirectory() + "/msc/tts2.wav");
//        Toast.makeText(MainActivity.this, "语音合成 保存音频到本地：\n" + isSuccess, Toast.LENGTH_LONG).show();
        //3.开始合成
        int code = mTts.startSpeaking(text, mSynListener);

        if (code != ErrorCode.SUCCESS) {
            if (code == ErrorCode.ERROR_COMPONENT_NOT_INSTALLED) {
                //上面的语音配置对象为初始化时：
                Toast.makeText(MainActivity.this, "语音组件未安装", Toast.LENGTH_LONG).show();
            } else {
                Toast.makeText(MainActivity.this, "语音合成失败,错误码: " + code, Toast.LENGTH_LONG).show();
            }
        }
    }
    //合成监听器
    private SynthesizerListener mSynListener = new SynthesizerListener() {
        //会话结束回调接口，没有错误时，error为null
        public void onCompleted(SpeechError error) {
        }
        //缓冲进度回调
        //percent为缓冲进度0~100，beginPos为缓冲音频在文本中开始位置，endPos表示缓冲音频在文本中结束位置，info为附加信息。
        public void onBufferProgress(int percent, int beginPos, int endPos, String info) {
        }
        //开始播放
        public void onSpeakBegin() {
        }
        //暂停播放
        public void onSpeakPaused() {
        }
        //播放进度回调
        //percent为播放进度0~100,beginPos为播放音频在文本中开始位置，endPos表示播放音频在文本中结束位置.
        public void onSpeakProgress(int percent, int beginPos, int endPos) {
        }
        //恢复播放回调接口
        public void onSpeakResumed() {
        }
        //会话事件回调接口
        public void onEvent(int arg0, int arg1, int arg2, Bundle arg3) {
        }
    };

http://mscdoc.xfyun.cn/android/api/ 这是科大讯飞的API文档，如果想设置更多的参数可以看看这个文档。比如设置发音人，超时时间等。

工具类封装

昨天刚看到一个单例模式的写法，之前的写法都是通过DCL实现单例模式。下面就用这个写法来编写工具类。
首先是语音合成的工具类

public class SynthesisManager {

    private final String TAG = "SynthesisManager";
    private Context mContext;
    private SpeechSynthesizer mTts;

    //设置语言
    public SynthesisManager setLanguage(LanguageEnum arg) {
        mTts.setParameter(SpeechConstant.LANGUAGE,arg.toString());
        return this;
    }
    //设置方言
    public SynthesisManager setAccent(AccenteEnum accent) {
        mTts.setParameter(SpeechConstant.ACCENT,accent.toString());
        return this;
    }
    //设置发音人
    public SynthesisManager setSpeechPeople(SpeechPeopleEnum speechPeople) {
        mTts.setParameter(SpeechConstant.VOICE_NAME,speechPeople.toString());
        return this;
    }
    //设置语速 0-100 默认50
    public SynthesisManager setSpeed(String speed) {
        mTts.setParameter(SpeechConstant.SPEED,speed);
        return this;
    }
    //设置音量 0-100 默认50
    public SynthesisManager setVolume(String volume) {
        mTts.setParameter(SpeechConstant.VOLUME,volume);
        return this;
    }
    //设置合成音调 0-100 默认50
    public SynthesisManager setPitch(String pitch) {
        mTts.setParameter(SpeechConstant.PITCH,pitch);
        return this;
    }
    //音频采样率 8000-16000  默认16000
    public SynthesisManager setSampleRate(String sampleRate) {
        mTts.setParameter(SpeechConstant.SAMPLE_RATE,sampleRate);
        return this;
    }

    private SynthesisManager(){}
    //通过静态内部类获取实例
    public static  SynthesisManager getSingleton(){
        return SingletonHolder.singleton;
    }
    //静态内部类里实例化StaticClassSingleton对象
    public static class SingletonHolder{
        private static final SynthesisManager singleton = new      SynthesisManager();
    }


    /**开始语音
     * @param msg  合成的内容
     */
    public SynthesisManager startSpeaking(String msg){
        mTts.startSpeaking(msg, new SynthesizerListener() {
            //会话结束回调接口，没有错误时，error为null
            public void onCompleted(SpeechError error) {
                Log.d(TAG,"话结束回调");
                listen.onCompleted(error);
                onSepakingStateListen.onCompleted(error);
            }
            //缓冲进度回调
            //percent为缓冲进度0~100，beginPos为缓冲音频在文本中开始位置，endPos表示缓冲音频在文本中结束位置，info为附加信息。
            public void onBufferProgress(int percent, int beginPos, int endPos, String info) {
                Log.d(TAG,"缓冲进度" + percent);
                listen.onBufferProgress(percent,beginPos,endPos, info);
            }
            //开始播放
            public void onSpeakBegin() {
                Log.d(TAG,"开始播放" );
                listen.onSpeakBegin();
                onSepakingStateListen.onSpeakBegin();
            }
            //暂停播放
            public void onSpeakPaused() {
                Log.d(TAG,"暂停播放" );
                listen.onSpeakPaused();
                onSepakingStateListen.onSpeakPaused();
            }
            //播放进度回调
            //percent为播放进度0~100,beginPos为播放音频在文本中开始位置，endPos表示播放音频在文本中结束位置.
            public void onSpeakProgress(int percent, int beginPos, int endPos) {
                Log.d(TAG,"播放进度" + percent);
                listen.onSpeakProgress( percent,  beginPos,  endPos);
            }
            //恢复播放回调接口
            public void onSpeakResumed() {
                Log.d(TAG,"恢复播放回调接口");
                listen.onSpeakResumed();
            }
            //会话事件回调接口
            public void onEvent(int arg0, int arg1, int arg2, Bundle arg3) {
                Log.d(TAG,"onEvent");
               // listen.onEvent( arg0,  arg1,  arg2,  arg3);
            }
        });
        return this;
    }

    /**
     * 停止语音
     */
    public void stopSpeaking(){
        mTts.stopSpeaking();
    }

    /**初始化
     * @param
     */
    public SynthesisManager init(Context mContext,String appID){
        this.mContext = mContext;
        //配置讯飞AppId
        SpeechUtility.createUtility(mContext, SpeechConstant.APPID +"="+appID);
        //配置参数
        //实例化语音合成对象
        if(mTts == null){
            mTts = SpeechSynthesizer.createSynthesizer(mContext, null);
        }
        return this;
    }

    //语音合成监听回调
    public interface speakingListen{
        //会话结束回调接口，没有错误时，error为null
        void onCompleted(SpeechError error);
        //缓冲进度回调
        //percent为缓冲进度0~100，beginPos为缓冲音频在文本中开始位置，endPos表示缓冲音频在文本中结束位置，info为附加信息。
        void onBufferProgress(int percent, int beginPos, int endPos, String info);
        //开始播放
        void onSpeakBegin();
        //暂停播放
        void onSpeakPaused();
        //播放进度回调
        //percent为播放进度0~100,beginPos为播放音频在文本中开始位置，endPos表示播放音频在文本中结束位置.
        void onSpeakProgress(int percent, int beginPos, int endPos);
        //恢复播放回调接口
        void onSpeakResumed();
        //会话事件回调接口
        void onEvent(int arg0, int arg1, int arg2, Bundle arg3);
    }
    public speakingListen listen;
    //设置语音合成监听回调
    public void setSpeakingListen(speakingListen listen){
        this.listen = listen;
    }

    //语音合成状态回调
    public interface onSepakingStateListen{
        //开始播放
        void onSpeakBegin();
        //暂停播放
        void onSpeakPaused();
        //会话结束回调接口，没有错误时，error为null
        void onCompleted(SpeechError error);
    }
    public onSepakingStateListen onSepakingStateListen;
    //设置语音合成状态监听回调
    public void setSepakingStateListen(onSepakingStateListen onSepakingStateListen){
        this.onSepakingStateListen = onSepakingStateListen;
    }

    //设置解析方向  本地 云端
    public void setEngineType(String type){
        mTts.setParameter(SpeechConstant.ENGINE_TYPE, type); //设置云端
    }

语音识别工具类

public class RecognitionManager {

    private Context mContext;
    private final String TAG = "RecognitionManager";
    private SpeechRecognizer mIat;

    public RecognitionManager setDomain(DomainEnum domain) {
        mIat.setParameter(SpeechConstant.DOMAIN, domain.toString());
        return this;
    }

    public RecognitionManager setLanguage(LanguageEnum language) {
        mIat.setParameter(SpeechConstant.LANGUAGE, language.toString());
        return this;
    }

    public RecognitionManager setAccent(AccenteEnum accent) {
        mIat.setParameter(SpeechConstant.ACCENT, accent.toString());
        return this;
    }

    public RecognitionManager setAudioPath(String audioPath) {
        //保存音频文件到本地（有需要的话）   仅支持pcm和wav，且需要自行添加读写SD卡权限
        mIat.setParameter(SpeechConstant.ASR_AUDIO_PATH, audioPath);
        return this;
    }

    private RecognitionManager() {
    }

    //通过静态内部类获取实例
    public static RecognitionManager getSingleton() {
        return SingletonHolder.singleton;
    }

    //静态内部类里实例化StaticClassSingleton对象
    public static class SingletonHolder {
        private static final RecognitionManager singleton = new RecognitionManager();
    }


    public RecognitionManager init(Context mContext, String appID) {
        SpeechUtility.createUtility(mContext, SpeechConstant.APPID + "=" + appID);
        this.mContext = mContext;
        if (mIat == null) {
            //1.创建SpeechRecognizer对象，第二个参数：本地识别时传InitListener
            mIat = SpeechRecognizer.createRecognizer(mContext, null);
        }
        return this;
    }

    /**
     * 语音识别回调监听
     */
    public interface onRecognitionListen {
        void result(String msg);
        void error(String errorMsg);
        void onBeginOfSpeech();
        void onVolumeChanged(int volume, byte[] data);
        void onEndOfSpeech();
        }

    //有动画效果
    private RecognizerDialog iatDialog;

    public void startRecognitionWithDialog(Context mContext, final onRecognitionListen listen) {
        if (this.listen == null) {
            this.listen = listen;
        }
        // ②初始化有交互动画的语音识别器
        iatDialog = new RecognizerDialog(mContext, mInitListener);
        //③设置监听，实现听写结果的回调
        iatDialog.setListener( mRecognizersDialog);
        //开始听写，需将sdk中的assets文件下的文件夹拷入项目的assets文件夹下（没有的话自己新建）
        iatDialog.show();
    }

    private RecognizerDialogListener mRecognizersDialog = new RecognizerDialogListener() {
        @Override
        public void onResult(RecognizerResult recognizerResult, boolean b) {
            analyzeJson(recognizerResult,b);
                  /*  etText.setText(result);
                    //获取焦点
                    etText.requestFocus();
                    //将光标定位到文字最后，以便修改
                    etText.setSelection(result.length());*/
        }

        @Override
        public void onError(SpeechError speechError) {
            listen.error(speechError.getMessage());
            speechError.getPlainDescription(true);
        }
    };

    /**
     * 关闭语音识别对话框;
     */
    public void closeRecognitionDialog() {
        if (iatDialog != null) {
            iatDialog.dismiss();
            Log.d(TAG, "closeRecognitionDialog");
        } else {
            Log.d(TAG, "closeRecognitionDialog,iatDialog=null");
        }
    }

    private InitListener mInitListener = new InitListener() {
        @Override
        public void onInit(int code) {
            Log.d(TAG, "SpeechRecognizer init() code = " + code);
            if (code != ErrorCode.SUCCESS) {
                Log.d(TAG, "初始化失败，错误码：" + code);
            }
        }
    };

    private onRecognitionListen listen;

    public void startRecognition(onRecognitionListen listen) {
        if (this.listen == null) {
            this.listen = listen;
        }
       /* //2.设置听写参数，详见SDK中《MSC Reference Manual》文件夹下的SpeechConstant类
        mIat.setParameter(SpeechConstant.DOMAIN,"iat");
        mIat.setParameter(SpeechConstant.LANGUAGE,"zh_cn");
        mIat.setParameter(SpeechConstant.ACCENT,"mandarin ");
        //保存音频文件到本地（有需要的话）   仅支持pcm和wav，且需要自行添加读写SD卡权限
        mIat.setParameter(SpeechConstant.ASR_AUDIO_PATH, Environment.getExternalStorageDirectory() + "/msc/mIat.wav");*/
        // 3.开始听写
        mIat.startListening(mRecoListener);
    }


    //听写监听器
    private RecognizerListener mRecoListener = new RecognizerListener() {
        //听写结果回调接口(返回Json格式结果，用户可参见附录13.1)；
        // 一般情况下会通过onResults接口多次返回结果，完整的识别内容是多次结果的累加；
        // 关于解析Json的代码可参见Demo中JsonParser类；
        // isLast等于true时会话结束。
        public void onResult(RecognizerResult results, boolean isLast) {
            Log.d(TAG, "result:" + results.getResultString());
            analyzeJson(results,isLast);
        }

        //会话发生错误回调接口
        public void onError(SpeechError error) {
            //打印错误码描述
            Log.d(TAG, "error:" + error.getPlainDescription(true));
            listen.result(error.getMessage());
        }
        //开始录音
        public void onBeginOfSpeech() {
            Log.d(TAG, "开始录音");
            listen.onBeginOfSpeech();
        }

        //    volume音量值0~30，data音频数据
        public void onVolumeChanged(int volume, byte[] data) {
            Log.d(TAG, "音量为：" + volume);
            listen.onVolumeChanged(volume,data);
        }

        //结束录音
        public void onEndOfSpeech() {
            Log.d(TAG, "结束录音");
            listen.onEndOfSpeech();
        }

        //扩展用接口
        public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
        }
    };

    private String resultJson = "[";//放置在外边做类的变量则报错，会造成json格式不对（？）
    private String result = "";

    private void analyzeJson(RecognizerResult recognizerResult, boolean isLast) {
        if (!isLast) {
            resultJson += recognizerResult.getResultString() + ",";
        } else {
            resultJson += recognizerResult.getResultString() + "]";
        }
        if (isLast) {
            //解析语音识别后返回的json格式的结果
            Gson gson = new Gson();
            List<DictationResult> resultList = gson.fromJson(resultJson,
                    new TypeToken<List<DictationResult>>() {
                    }.getType());
            for (int i = 0; i < resultList.size() - 1; i++) {
                result += resultList.get(i).toString();
            }
            listen.result(result);
        }
    }

对应的枚举

public enum AccenteEnum {
    mandarin,    //普通话
    cantonese,   //粤 语
    lmz          //四川话
}

public enum DomainEnum {
    iat,     //短信和日常用语
    video,   //视频
    poi,    //地图
    music  //音乐
}

public enum LanguageEnum {
    zh_cn, //简体中文
    en_us  //美式英文
}

public enum SpeechPeopleEnum {
    xiaoyan,        //小燕 女声 青年 中英文
    xiaoyu,         //小宇 男声 青年 中英文
    catherine,      //凯瑟琳 女声 青年 英文
    henry,          //亨利 男声 青年 英文
    vimary,         //玛丽 女声 青年 英文
    vixy,           //小研 女声 青年 中英文
    xiaoqi,         //小琪 女声 青年 中英文
    vixf,           //小峰 男声 青年 中英文
    xiaomei,        //小梅 女声 青年 中英文粤语
    vixl,           //小莉 女声 青年 中英文台湾普通话
    xiaolin,        //晓琳 女声 青年 中英文台湾普通话
    xiaorong,        //小蓉 女声 青年 汉语四川话
    vixyun,         //小芸 女声 青年   汉语东北话
    xiaoqian,        //小倩 女声 青年 汉语东北话
    xiaokun,        //小坤 男声 青年  汉语河南话
    xiaoqiang,        //小强 男声 青年 汉语湖南话
    vixying,        //小莹 女声 青年 汉语陕西话
    xiaoxin,        //小新 男声 童年 汉语普通话
    nannan,        //楠楠 女声 童年 汉语普通话
    vils,        //老孙 男声 老年 汉语普通话

测试

//在全局Application里
        SynthesisManager.getSingleton().init(this,"5a54cba7");
        RecognitionManager.getSingleton().init(this,"5a54cba7");

//语音识别调用方式
RecognitionManager.getSingleton().startRecognitionWithDialog(this, new RecognitionManager.onRecognitionListen() {
            @Override
            public void result(String msg) {
                QuestionTemplet questionTemplet = list.get(index);
                AnswerEntity answerEntity = new AnswerEntity();
                answerEntity.setAnswer(questionTemplet.getQuestion());
                answerEntity.setSelectText(msg);
                mAnswerEntities.add(answerEntity);
                index++;
                showRecognitionDialog();
            }
            @Override
            public void error(String errorMsg) {
                if(errorMsg==null){
                    return;
                }
                Log.d(TAG,errorMsg);
            }
            @Override
            public void onBeginOfSpeech() {

            }
            @Override
            public void onVolumeChanged(int volume, byte[] data) {}
            @Override
            public void onEndOfSpeech() {}
        });

//语音合成调用方式
 SynthesisManager.getSingleton().startSpeaking("你好");

//设置参数
      RecognitionManager
                .getSingleton()
                .setAccent(AccenteEnum.lmz)
                .setAudioPath("50") ;

//更新 2018.6.1
github地址
科大讯飞的appkey必须与下载的so文件一起用才可以，library中是使用我自己的appkey对应的so,所以你们要使用自己的appkey的时候自己去替换否则初始化错误。