科大訊飛語音識別工具類的封裝

package com.jinkun.blindguide.service;

import java.util.HashMap;
import java.util.LinkedHashMap;

import org.json.JSONException;
import org.json.JSONObject;

import android.content.Context;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;

import com.iflytek.cloud.ErrorCode;
import com.iflytek.cloud.InitListener;
import com.iflytek.cloud.RecognizerListener;
import com.iflytek.cloud.RecognizerResult;
import com.iflytek.cloud.SpeechConstant;
import com.iflytek.cloud.SpeechError;
import com.iflytek.cloud.SpeechRecognizer;
import com.iflytek.cloud.SpeechUtility;
import com.jinkun.blindguide.utils.ApkInstaller;
import com.jinkun.blindguide.utils.FucUtil;
import com.jinkun.blindguide.utils.JsonParser;

/**
 * 語音識別服務類
 * 
 * @author mzzdxt
 *
 */
public class SpeechRecognizeService {
    private static final String TAG = "SpeechRecognizeService";
    
    public interface Config{
        String IFLYTEK_APPID = "須要本身去開發者平臺申請";
        
        String VAD_BOS_VALUE = "4000";
        String VAD_EOS_VALUE = "1000";
        String ASR_PTT_VALUE = "0";
    }
    
    public static final int ENGINE_ONLINE = 0;
    public static final int ENGINE_OFFLINE = 1;
    public static final int ENGINE_MIX = 2;

    private Context mContext;
    private int mEngineType = ENGINE_ONLINE;
    // 語音聽寫對象
    private SpeechRecognizer mRecognizer;
    private SpeechServiceListener mListener;
    // 用HashMap存儲聽寫結果
    private HashMap<String, String> mIatResults = new LinkedHashMap<String, String>();
    // 語記安裝助手類
    private ApkInstaller mInstaller;

    public void setSpeechServiceListener(SpeechServiceListener listener) {
        this.mListener = listener;
    }

    public SpeechRecognizeService(Context context,int engineType){
        mContext = context;
        mEngineType = engineType;
        
        // 根據語音識別類型,初始化對應參數
        initParams();
    }

    /**
     * 初始化語音識別參數
     */
    private void initParams() {
        SpeechUtility.createUtility(mContext, SpeechConstant.APPID + "=" + Config.IFLYTEK_APPID);
        
        mRecognizer = SpeechRecognizer.createRecognizer(mContext, mInitListener);
        
        String strEngineType = "";
        
        switch (mEngineType) {
            case ENGINE_ONLINE:
                strEngineType = SpeechConstant.TYPE_CLOUD;
                break;
            case ENGINE_OFFLINE:
                strEngineType = SpeechConstant.TYPE_LOCAL;
                break;
            case ENGINE_MIX:
                strEngineType = SpeechConstant.TYPE_MIX;
                break;
            default:
                // 默認使用混合識別模式
                strEngineType = SpeechConstant.TYPE_MIX;
                break;
        }
        
        if (mEngineType != ENGINE_ONLINE) {
            /**
             * 選擇本地聽寫 判斷是否安裝語記,未安裝則跳轉到提示安裝頁面
             */
            if (!SpeechUtility.getUtility().checkServiceInstalled()) {
                mInstaller.install();
            } else {
                String result = FucUtil.checkLocalResource();
                if (!TextUtils.isEmpty(result) && mListener != null) {
                    mListener.onLocalResourceError(result);
                }
            }
        }
        
        initCommonParams(strEngineType);
    }

    private void initCommonParams(String engineType) {
        // 清空參數
        mRecognizer.setParameter(SpeechConstant.PARAMS, null);

        // 設置聽寫引擎
        mRecognizer.setParameter(SpeechConstant.ENGINE_TYPE, engineType);
        
        // 設置返回結果格式
        mRecognizer.setParameter(SpeechConstant.RESULT_TYPE, "json");
        
        // 設置語言
        mRecognizer.setParameter(SpeechConstant.LANGUAGE, "zh_cn");
        
        // 設置語言區域
        mRecognizer.setParameter(SpeechConstant.ACCENT, "mandarin");

        // 設置語音前端點:靜音超時時間，即用戶多長時間不說話則當作超時處理
        mRecognizer.setParameter(SpeechConstant.VAD_BOS, Config.VAD_BOS_VALUE);
        
        // 設置語音後端點:後端點靜音檢測時間，即用戶中止說話多長時間內即認爲再也不輸入， 自動中止錄音
        mRecognizer.setParameter(SpeechConstant.VAD_EOS, Config.VAD_EOS_VALUE);
        
        // 設置標點符號,設置爲"0"返回結果無標點,設置爲"1"返回結果有標點
        mRecognizer.setParameter(SpeechConstant.ASR_PTT, Config.ASR_PTT_VALUE);
        
        // 設置音頻保存路徑，保存音頻格式支持pcm、wav，設置路徑爲sd卡請注意WRITE_EXTERNAL_STORAGE權限
        // 注：AUDIO_FORMAT參數語記須要更新版本才能生效
//      mRecognizer.setParameter(SpeechConstant.AUDIO_FORMAT, "wav");
//      mRecognizer.setParameter(SpeechConstant.ASR_AUDIO_PATH, Environment.getExternalStorageDirectory()+"/msc/iat.wav");      
    }
    
    /**
     * 初始化監聽器。
     */
    private InitListener mInitListener = new InitListener() {

        @Override
        public void onInit(int code) {
            Log.d(TAG, "SpeechRecognizer init() code = " + code);
            if (code != ErrorCode.SUCCESS) {
                if (mListener != null) {
                    mListener.onInitError("初始化失敗，錯誤碼：" + code);
                }
            }
        }
    };
    
    /**
     * 開始監聽用戶講話
     */
    public void startListening(){
        if (mRecognizer != null && mRecognizerListener != null) {
            // 開始監聽以前,須要清除map中的歷史數據
            mIatResults.clear();
            
            mRecognizer.startListening(mRecognizerListener);
        } else {
            if (mListener != null) {
                mListener.onInitError("語音聽寫對象或監聽器初始化失敗");
            }
        }
    }
    
    /**
     * 聽寫監聽器。
     */
    private RecognizerListener mRecognizerListener = new RecognizerListener() {

        @Override
        public void onBeginOfSpeech() {
            // 此回調錶示：sdk內部錄音機已經準備好了，用戶能夠開始語音輸入
            if (mListener != null) {
                mListener.onRecognizerPrepared();
            }
        }

        @Override
        public void onError(SpeechError error) {
            // 錯誤碼：10118(您沒有說話)，多是錄音機權限被禁，須要提示用戶打開應用的錄音權限。
            // 若是使用本地功能（語記）須要提示用戶開啓語記的錄音權限。
            if (mListener != null) {
                mListener.onRecognizerError(error.getPlainDescription(true));
            }
        }

        @Override
        public void onEndOfSpeech() {
            // 此回調錶示：檢測到了語音的尾端點，已經進入識別過程，再也不接受語音輸入
            if (mListener != null) {
                mListener.onSpeechFinished();
            }
        }

        @Override
        public void onResult(RecognizerResult results, boolean isLast) {
            Log.d(TAG, results.getResultString());
            String printResult = printResult(results);
            
            if (mListener != null) {
                mListener.onGetRecognizerResult(printResult);
            }
            
            if (isLast) {
                if (mListener != null) {
                    mListener.onGetRecognizerResultEnd();
                }
            }
        }

        @Override
        public void onVolumeChanged(int volume, byte[] data) {
            Log.d(TAG, "返回音頻數據："+data.length);
            
            if (mListener != null) {
                mListener.onVolumeChanged(volume);
            }
        }

        @Override
        public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
            
        }
    };
    
    /**
     * 將語音識別結果轉換爲文字信息
     * 
     * @param results
     * @return
     */
    private String printResult(RecognizerResult results) {
        String text = JsonParser.parseIatResult(results.getResultString());

        String sn = null;
        // 讀取json結果中的sn字段
        try {
            JSONObject resultJson = new JSONObject(results.getResultString());
            sn = resultJson.optString("sn");
        } catch (JSONException e) {
            e.printStackTrace();
        }

        mIatResults.put(sn, text);

        StringBuffer resultBuffer = new StringBuffer();
        for (String key : mIatResults.keySet()) {
            resultBuffer.append(mIatResults.get(key));
        }

        return resultBuffer.toString();
    }
    
    /**
     * 結束使用後請務調用此方法來釋放資源
     */
    public void release() {
        if (mRecognizer != null) {
            mRecognizer.cancel();
            mRecognizer.destroy();
        }
    }
    
    public interface SpeechServiceListener {
        /**
         * 初始化失敗的回調
         * 
         * @param errorInfo 錯誤信息
         */
        void onInitError(String errorInfo);
        
        void onLocalResourceError(String result);

        /**
         * 音量發生變化時的回調
         * 
         * @param volume
         */
        void onVolumeChanged(int volume);

        /**
         * 已獲取最後的結果
         */
        void onGetRecognizerResultEnd();

        /**
         * 獲取到結果的回調
         * 
         * @param results
         */
        void onGetRecognizerResult(String result);

        /**
         * 用戶講話完畢的回調
         */
        void onSpeechFinished();

        /**
         * 準備完畢的回調
         */
        void onRecognizerPrepared();
        
        /**
         * 識別失敗的回調
         * 
         * @param errorInfo
         */
        void onRecognizerError(String errorInfo);
    }
}