实现一边录音一边转化为文字的功能

我们知道，讯飞可以实现在线语音转化功能，可以将语音实时的进行翻译，同时录音，但是这个实时转为文字功能，不是长连接，是个短连接，导致没法长时间的实现一边录音一边转换功能，本文便是为此完成的一种思路设计。

主要动作：本来实现的是一直去检测录音，当语音识别库停止录音后重启语音识别，让继续实现转换。这里因为出现一个问题，当再次重启时，之前的录音文件则会丢掉，这样使得我们本地的录音文件不完整，于是换了一种新的思路。主要依据于语音识别可以传语音数据，让识别。那么我们可以去做如此设计：让本地一直录音，录音过程实时将录音数据传给语音识别，完成转换功能。思路描述完成，具体实现代码：（不能提供完整的代码，给出主要代码）

    private void creatAudioRecord() {
        // 获得缓冲区字节大小
        bufferSizeInBytes = AudioRecord.getMinBufferSize(AudioFileFunc.AUDIO_SAMPLE_RATE,
                AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
        // 创建AudioRecord对象
        audioRecord = new AudioRecord(AudioFileFunc.AUDIO_INPUT, AudioFileFunc.AUDIO_SAMPLE_RATE,
                AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, bufferSizeInBytes);
    }
       private void writeDateToFileAndRecongnizer() {
        // new一个byte数组用来存一些字节数据，大小为缓冲区大小
        byte[] audiodata = new byte[bufferSizeInBytes];
        FileOutputStream fos = null;
        int readsize = 0;
        try {
            File file = FileUtils.makeFilePath(getOutBase(), mOutPcm);
            if (file.exists()) {
                file.delete();
            }
            fos = new FileOutputStream(file);// 建立一个可存取字节的文件
        } catch (Exception e) {
            e.printStackTrace();
        }
        while (mIsRecognizer && !Thread.currentThread().isInterrupted()) {
            readsize = audioRecord.read(audiodata, 0, bufferSizeInBytes);
            if (AudioRecord.ERROR_INVALID_OPERATION != readsize && fos != null) {
                try {
                    mSpeechRecognizer.writeAudio(audiodata, 0, audiodata.length);
                    fos.write(audiodata);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        try {
            if (fos != null)
                fos.close();// 关闭写入流
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    mSpeechRecognizer = SpeechRecognizer.createRecognizer(DiaryPost.this, mInitListener);
     /**
     * 初始化监听器。
     */
    private InitListener mInitListener = new InitListener() {

        @Override
        public void onInit(int code) {
            L.d("SpeechRecognizer init() code = " + code);
            if (code != ErrorCode.SUCCESS) {
                showToast("初始化失败，错误码：" + code);
            }
        }
    };
    /**
     * 听写监听器。
     */
    private RecognizerListener recognizerListener = new RecognizerListener() {

        @Override
        public void onBeginOfSpeech() {
            if (!mIsRecognizer) {
                onRecognizerEnd();
            }
        }

        @Override
        public void onError(SpeechError error) {
            if (mIsRecognizer) {
                onRecognizerStart();
            }
        }

        @Override
        public void onEndOfSpeech() {
            if (mIsRecognizer) {
                onRecognizerStart();
            }
        }

        @Override
        public void onResult(RecognizerResult results, boolean isLast) {
            showResult(results);
            if (isLast) {
                // TODO 最后的结果
            }
        }

        @Override
        public void onVolumeChanged(int i, byte[] bytes) {
            if (mIsRecognizer) {
                int decibel = calculateDecibel(bytes);
                mVisualizer.receive(decibel);
            }

        }

        @Override
        public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
        }
    };

       private void showResult(RecognizerResult results) {
        String text = JsonParser.parseIatResult(results.getResultString());
        mSpeechRecognizerIndex++;
        mSpeechRecognizerResults.put(mSpeechRecognizerIndex, text);
        StringBuffer resultBuffer = new StringBuffer();
        for (int key : mSpeechRecognizerResults.keySet()) {
            resultBuffer.append(mSpeechRecognizerResults.get(key));
        }
        mEditText.setText(resultBuffer.toString());
        mEditText.setSelection(mEditText.length());
    }

       public void bindParams() {
        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
        // 清空参数
        mSpeechRecognizer.setParameter(SpeechConstant.PARAMS, null);
        mSpeechRecognizer.setParameter(SpeechConstant.AUDIO_SOURCE, "-1");
        // 设置听写引擎
        mSpeechRecognizer.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD);
        // 设置返回结果格式
        mSpeechRecognizer.setParameter(SpeechConstant.RESULT_TYPE, "json");
        String lag = sp.getString("iat_language_preference",
                "mandarin");
        if (lag.equals("en_us")) {
            // 设置语言
            mSpeechRecognizer.setParameter(SpeechConstant.LANGUAGE, "en_us");
        } else {
            // 设置语言
            mSpeechRecognizer.setParameter(SpeechConstant.LANGUAGE, "zh_cn");
            // 设置语言区域
            mSpeechRecognizer.setParameter(SpeechConstant.ACCENT, lag);
        }

        // 设置语音前端点:静音超时时间，即用户多长时间不说话则当做超时处理
        mSpeechRecognizer.setParameter(SpeechConstant.VAD_BOS, sp.getString("iat_vadbos_preference", "3000"));

        // 设置语音后端点:后端点静音检测时间，即用户停止说话多长时间内即认为不再输入， 自动停止录音
        mSpeechRecognizer.setParameter(SpeechConstant.VAD_EOS, sp.getString("iat_vadeos_preference", "1000"));

        // 设置标点符号,设置为"0"返回结果无标点,设置为"1"返回结果有标点
        mSpeechRecognizer.setParameter(SpeechConstant.ASR_PTT, sp.getString("iat_punc_preference", "1"));

        // 设置听写结果是否结果动态修正，为“1”则在听写过程中动态递增地返回结果，否则只在听写结束之后返回最终结果
        // 注：该参数暂时只对在线听写有效
        mSpeechRecognizer.setParameter(SpeechConstant.ASR_DWA, sp.getString("iat_dwa_preference", "0"));
    }

        private void onRecognizerStart() {
        Intent intent = new Intent();
        bindParams();
        mSpeechRecognizer.startListening(recognizerListener);
    }