Android开发学习之使用百度语音识别SDK实现语音识别(下)

            今天我们来继续学习百度语音识别SDK的相关内容，今天我们以百度语音识别SDK提供的API接口为前提，来实现自己的语音识别交互界面。在正式开始今天的文章之前，我们首先来了解下百度语音识别SDK中的几个重要的类吧。

            1、VoiceRecognitionClient

             VoiceRecognitionClient是整个语音识别API中的入口API，我们对于语音识别的整体控制都集中在这个类当中。VoiceRecognitionClient提供了speakFinish()、startVoiceRecognition()、stopVoiceRecognition()三个主要的方法。分别用来控制语音识别结束(指已经说完)、语音识别停止、语音识别开始。通过VoiceRecognitionClient类我们可以对整个语音识别进行宏观上的调控(请原谅我这么说)，这是整个语音识别SDK中的入口类。 

            2、VoiceRecognitionConfig

            VoiceRecognitionConfig是语音识别的配置类，在这个类里我们可以对当前语音识别环境进行配置，如语音识别的模式、语音识别音效、语音识别采样率等。

            3、VoiceClientStatusChangeListener

            VoiceClientStatusChangeListener是语音识别的回调接口类，我们要调用百度语音识别API就必须实现这个类，因此这个类是整个语音识别中最重要的一个类，换句话说，如果说VoiceRecognitionClient控制整个宏观层面上的语音识别，那么VoiceClientStatusChangeListener就是在控制整个语音识别的微观层面，一个语音识别的过程包括语音识别开始、语音识别监听、语音识别识别、语音识别反馈，而通过VoiceClientStatusChangeListener我们就能对语音识别的每一个过程进行控制，这个类相对复杂，我们待会会做详细的讨论。

           好了，现在主要的类已经介绍完了，下面大家可以跟着我一起来学习今天的内容了。首先说一下今天想要实现的内容，在今天的程序中，我们将实现通过两个Button来控制语音识别的开始和结束并在界面上反馈当前语音识别的状态和最终的结果，通过一个进度条控件(程序演示需要，非必需)来显示当前用户说话音量的大小情况。首先，我们来初始化语音识别的入口类：

[java] view plaincopy

1.        @Override  
2. protected void onCreate(Bundle savedInstanceState)   
3. {  
4.     super.onCreate(savedInstanceState);  
5.     setContentView(R.layout.layout_voice);  
6.     InitView();  
7.     //获取mClent  
8.     mClient=VoiceRecognitionClient.getInstance(this);  
9.     //设置应用授权信息  
10.     mClient.setTokenApis(API_KEY, SECRET_KEY);  
11.     //初始化主线程  
12.     mHandler=new Handler();  
13. }  

         在这里为了让大家更好的关注于语音识别SDK，我将界面元素初始化的过程写到了InitView()方法中，大家可以参照最后给出的代码。其中的mHandler仅仅是为了配合进度条刷新界面，即非必需。接下来我们来写整个程序中最为重要的一个类，即VoiceClientStatusChangeListener接口，我们一起来看代码：

[java] view plaincopy

1. /** 语音识别回调接口  **/  
2. private VoiceClientStatusChangeListener mListener=new VoiceClientStatusChangeListener()  
3. {  
4.        public void onClientStatusChange(int status, Object obj) {  
5.            switch (status) {  
6.                // 语音识别实际开始，这是真正开始识别的时间点，需在界面提示用户说话。  
7.                case VoiceRecognitionClient.CLIENT_STATUS_START_RECORDING:  
8.                    IsRecognition = true;  
9.                    mVolumeBar.setVisibility(View.VISIBLE);  
10.                    BtnCancel.setEnabled(true);  
11.                    BtnStart.setText("说完");  
12.                    Status.setText("当前状态:请说话");  
13.                    mHandler.removeCallbacks(mUpdateVolume);  
14.                    mHandler.postDelayed(mUpdateVolume, UPDATE_INTERVAL);  
15.                    break;  
16.                case VoiceRecognitionClient.CLIENT_STATUS_SPEECH_START: // 检测到语音起点  
17.                    Status.setText("当前状态:说话中");  
18.                    break;  
19.                case VoiceRecognitionClient.CLIENT_STATUS_AUDIO_DATA:  
20.                    //这里可以什么都不用作，简单地对传入的数据做下记录  
21.                    break;  
22.                // 已经检测到语音终点，等待网络返回  
23.                case VoiceRecognitionClient.CLIENT_STATUS_SPEECH_END:  
24.                    Status.setText("当前状态:正在识别....");  
25.                    BtnCancel.setEnabled(false);  
26.                    mVolumeBar.setVisibility(View.INVISIBLE);  
27.                    break;  
28.                // 语音识别完成，显示obj中的结果  
29.                case VoiceRecognitionClient.CLIENT_STATUS_FINISH:  
30.                    Status.setText(null);  
31.                    UpdateRecognitionResult(obj);  
32.                    IsRecognition = false;  
33.                    ReSetUI();  
34.                    break;  
35.                // 处理连续上屏  
36.                case VoiceRecognitionClient.CLIENT_STATUS_UPDATE_RESULTS:  
37.                    UpdateRecognitionResult(obj);  
38.                    break;  
39.                // 用户取消  
40.                case VoiceRecognitionClient.CLIENT_STATUS_USER_CANCELED:  
41.                    Status.setText("当前状态:已取消");  
42.                    IsRecognition = false;  
43.                    ReSetUI();  
44.                    break;  
45.                default:   
46.                    break;  
47.            }  
48.   
49.        }  
50.   
51.        @Override  
52.        public void onError(int errorType, int errorCode) {  
53.            IsRecognition = false;  
54.            Result.setText("出错: 0x%1$s"+Integer.toHexString(errorCode));  
55.            ReSetUI();  
56.        }  
57.   
58.        @Override  
59.        public void onNetworkStatusChange(int status, Object obj)   
60.        {  
61.            // 这里不做任何操作不影响简单识别  
62.        }  
63. };  

           在上面的代码中，我们需要深入了解的就是整个语音识别过程中不同的状态下具体应该做什么，这是我们真正要去考虑的事情。在这里我们给出几个辅助的方法：

           1、对识别结果的解析

[java] view plaincopy

1. /* 
2.      *将识别结果显示到界面上 
3.      */  
4.     private void UpdateRecognitionResult(Object result) {  
5.         if (result != null && result instanceof List) {  
6.             @SuppressWarnings("rawtypes")  
7.             List results = (List) result;  
8.             if (results.size() > 0) {  
9.                 if (mType==VOICE_TYPE_SEARCH) {  
10.                     Result.setText(results.get(0).toString());  
11.                 } else if (mType == VOICE_TYPE_INPUT) {  
12.                     @SuppressWarnings("unchecked")  
13.                     List<List<Candidate>> sentences = ((List<List<Candidate>>) result);  
14.                     StringBuffer sb = new StringBuffer();  
15.                     for (List<Candidate> candidates : sentences) {  
16.                         if (candidates != null && candidates.size() > 0) {  
17.                             sb.append(candidates.get(0).getWord());  
18.                         }  
19.                     }  
20.                     Result.setText(sb.toString());  
21.                 }  
22.             }  
23.         }  
24.     }  

          

            2、识别类型

            识别的类型有两种，一种是Search、一种是Input。Search适用于较短的句子的识别，即短语的识别；Input适用于长句子的识别，即长句的识别。总体来说，百度语音识别的效果还是很不错的

           接下来，我们对语音识别进行一个控制，一起来看代码吧：

[java] view plaincopy

1. /* 
2.      * 处理Click事件 
3.      */  
4.     @Override  
5.     public void onClick(View v)   
6.     {  
7.        switch(v.getId())  
8.        {  
9.          case R.id.Start:  
10.              if (IsRecognition) { // 用户说完  
11.                  mClient.speakFinish();  
12.              } else { // 用户重试，开始新一次语音识别  
13.                  Result.setText(null);  
14.                  // 需要开始新识别,首先设置参数  
15.                  config = new VoiceRecognitionConfig();  
16.                  if (mType == VOICE_TYPE_INPUT)   
17.                  {  
18.                      config.setSpeechMode(VoiceRecognitionConfig.SPEECHMODE_MULTIPLE_SENTENCE);  
19.                  } else {  
20.                      config.setSpeechMode(VoiceRecognitionConfig.SPEECHMODE_SINGLE_SENTENCE);  
21.   
22.                  }  
23.                  //开启语义解析  
24.                  config.enableNLU();  
25.                  //开启音量反馈  
26.                  config.enableVoicePower(true);  
27.                  config.enableBeginSoundEffect(R.raw.bdspeech_recognition_start); // 设置识别开始提示音  
28.                  config.enableEndSoundEffect(R.raw.bdspeech_speech_end); // 设置识别结束提示音  
29.                  config.setSampleRate(VoiceRecognitionConfig.SAMPLE_RATE_8K); //设置采样率  
30.                  //使用默认的麦克风作为音频来源  
31.                  config.setUseDefaultAudioSource(true);  
32.                  // 下面发起识别  
33.                  int code = VoiceRecognitionClient.getInstance(this).startVoiceRecognition(  
34.                          mListener, config);  
35.                  if (code == VoiceRecognitionClient.START_WORK_RESULT_WORKING)   
36.                  { // 能够开始识别，改变界面  
37.                      BtnStart.setEnabled(false);  
38.                      BtnStart.setText("说完");  
39.                      BtnCancel.setEnabled(true);  
40.                  } else {  
41.                      Result.setText("启动失败: 0x%1$s"+code);  
42.                  }  
43.              }  
44.              break;  
45.          case R.id.Cancel:  
46.              mClient.stopVoiceRecognition();  
47.              break;  
48.        }  
49.     }  

             注意到我们在上面的代码中是开启了音量反馈的，因此我们需要一个线程来刷新声音的进度条：

[java] view plaincopy

1.       /** 音量更新时间间隔   **/  
2. private static final int UPDATE_INTERVAL=200;  
3.   
4. /** 音量更新任务   **/  
5. private Runnable mUpdateVolume=new Runnable()  
6. {  
7.     @Override  
8.     public void run()   
9.     {  
10.         if (IsRecognition)   
11.         {  
12.                long vol = VoiceRecognitionClient.getInstance(BaiduVoiceActivity.this)  
13.                        .getCurrentDBLevelMeter();  
14.                mVolumeBar.setProgress((int)vol);  
15.                mHandler.removeCallbacks(mUpdateVolume);  
16.                mHandler.postDelayed(mUpdateVolume, UPDATE_INTERVAL);  
17.            }  
18.           
19.     }  
20. };  

           当然，这段代码是可以不要的，如果我们取消了音量反馈的话；其次，在实际的语音识别应用中，我们通常会看到界面会根据用户输入的声音的大小绘制一定的波形，这已经超出了本文的研究范围，但是至少说明我们需要在实际的应用中研究这一过程，或者我们可以偷下懒，直接放个动画了事。最后，我们需要写一些用于释放语音识别资源的方法：

[java] view plaincopy

1. @Override  
2.     protected void onDestroy()   
3.     {  
4.         VoiceRecognitionClient.releaseInstance(); // 释放识别库  
5.         super.onDestroy();  
6.     }  
7.   
8.     @Override  
9.     protected void onPause()   
10.     {  
11.         if (IsRecognition) {  
12.             mClient.stopVoiceRecognition(); // 取消识别  
13.         }  
14.         super.onPause();  
15.     }  
16.       

 
      到目前为止，百度语音识别SDK的所有API我们都已经研究完了，大家可以自己梳理下思路，最后我给出全部的代码：

[java] view plaincopy

1. package com.Android.BaiduVoice;  
2.   
3.   
4. import java.util.List;  
5.   
6. import com.baidu.voicerecognition.android.Candidate;  
7. import com.baidu.voicerecognition.android.VoiceRecognitionClient;  
8. import com.baidu.voicerecognition.android.VoiceRecognitionConfig;  
9. import com.baidu.voicerecognition.android.VoiceRecognitionClient.VoiceClientStatusChangeListener;  
10.   
11. import android.app.Activity;  
12. import android.os.Bundle;  
13. import android.os.Handler;  
14. import android.view.View;  
15. import android.view.View.OnClickListener;  
16. import android.widget.Button;  
17. import android.widget.ProgressBar;  
18. import android.widget.TextView;  
19.   
20. public class BaiduVoiceActivity extends Activity implements OnClickListener  
21. {  
22.     /** 应用授权信息 **/  
23.     private String API_KEY="8MAxI5o7VjKSZOKeBzS4XtxO";  
24.     private String SECRET_KEY="Ge5GXVdGQpaxOmLzc8fOM8309ATCz9Ha";  
25.   
26.     /** 界面布局元素 **/  
27.     private TextView Status,Result;  
28.     private ProgressBar mVolumeBar;  
29.     private Button BtnStart,BtnCancel;  
30.       
31.     /** 语音识别Client **/  
32.     private VoiceRecognitionClient mClient;  
33.       
34.     /** 语音识别配置 **/  
35.     private VoiceRecognitionConfig config;  
36.       
37.     /** 语音识别回调接口  **/  
38.     private VoiceClientStatusChangeListener mListener=new VoiceClientStatusChangeListener()  
39.     {  
40.         public void onClientStatusChange(int status, Object obj) {  
41.             switch (status) {  
42.                 // 语音识别实际开始，这是真正开始识别的时间点，需在界面提示用户说话。  
43.                 case VoiceRecognitionClient.CLIENT_STATUS_START_RECORDING:  
44.                     IsRecognition = true;  
45.                     mVolumeBar.setVisibility(View.VISIBLE);  
46.                     BtnCancel.setEnabled(true);  
47.                     BtnStart.setText("说完");  
48.                     Status.setText("当前状态:请说话");  
49.                     mHandler.removeCallbacks(mUpdateVolume);  
50.                     mHandler.postDelayed(mUpdateVolume, UPDATE_INTERVAL);  
51.                     break;  
52.                 case VoiceRecognitionClient.CLIENT_STATUS_SPEECH_START: // 检测到语音起点  
53.                     Status.setText("当前状态:说话中");  
54.                     break;  
55.                 case VoiceRecognitionClient.CLIENT_STATUS_AUDIO_DATA:  
56.                     //这里可以什么都不用作，简单地对传入的数据做下记录  
57.                     break;  
58.                 // 已经检测到语音终点，等待网络返回  
59.                 case VoiceRecognitionClient.CLIENT_STATUS_SPEECH_END:  
60.                     Status.setText("当前状态:正在识别....");  
61.                     BtnCancel.setEnabled(false);  
62.                     mVolumeBar.setVisibility(View.INVISIBLE);  
63.                     break;  
64.                 // 语音识别完成，显示obj中的结果  
65.                 case VoiceRecognitionClient.CLIENT_STATUS_FINISH:  
66.                     Status.setText(null);  
67.                     UpdateRecognitionResult(obj);  
68.                     IsRecognition = false;  
69.                     ReSetUI();  
70.                     break;  
71.                 // 处理连续上屏  
72.                 case VoiceRecognitionClient.CLIENT_STATUS_UPDATE_RESULTS:  
73.                     UpdateRecognitionResult(obj);  
74.                     break;  
75.                 // 用户取消  
76.                 case VoiceRecognitionClient.CLIENT_STATUS_USER_CANCELED:  
77.                     Status.setText("当前状态:已取消");  
78.                     IsRecognition = false;  
79.                     ReSetUI();  
80.                     break;  
81.                 default:   
82.                     break;  
83.             }  
84.   
85.         }  
86.   
87.         @Override  
88.         public void onError(int errorType, int errorCode) {  
89.             IsRecognition = false;  
90.             Result.setText("出错: 0x%1$s"+Integer.toHexString(errorCode));  
91.             ReSetUI();  
92.         }  
93.   
94.         @Override  
95.         public void onNetworkStatusChange(int status, Object obj)   
96.         {  
97.             // 这里不做任何操作不影响简单识别  
98.         }  
99.     };  
100.       
101.     /** 语音识别类型定义 **/  
102.     public static final int VOICE_TYPE_INPUT=0;  
103.     public static final int VOICE_TYPE_SEARCH=1;  
104.       
105.     /** 音量更新时间间隔   **/  
106.     private static final int UPDATE_INTERVAL=200;  
107.       
108.     /** 音量更新任务   **/  
109.     private Runnable mUpdateVolume=new Runnable()  
110.     {  
111.         @Override  
112.         public void run()   
113.         {  
114.             if (IsRecognition)   
115.             {  
116.                 long vol = VoiceRecognitionClient.getInstance(BaiduVoiceActivity.this)  
117.                         .getCurrentDBLevelMeter();  
118.                 mVolumeBar.setProgress((int)vol);  
119.                 mHandler.removeCallbacks(mUpdateVolume);  
120.                 mHandler.postDelayed(mUpdateVolume, UPDATE_INTERVAL);  
121.             }  
122.               
123.         }  
124.     };  
125.       
126.     /** 主线程Handler */  
127.     private Handler mHandler;  
128.       
129.     /** 正在识别中 */  
130.     private boolean IsRecognition = false;  
131.       
132.     /** 当前语音识别类型  **/  
133.     private int mType=VOICE_TYPE_INPUT;  
134.     @Override  
135.     protected void onCreate(Bundle savedInstanceState)   
136.     {  
137.         super.onCreate(savedInstanceState);  
138.         setContentView(R.layout.layout_voice);  
139.         InitView();  
140.         //获取mClent  
141.         mClient=VoiceRecognitionClient.getInstance(this);  
142.         //设置应用授权信息  
143.         mClient.setTokenApis(API_KEY, SECRET_KEY);  
144.         //初始化主线程  
145.         mHandler=new Handler();  
146.     }  
147.       
148.     /* 
149.      * 界面初始化 
150.      */  
151.     private void InitView()  
152.     {  
153.         Status=(TextView)findViewById(R.id.Status);  
154.         Result=(TextView)findViewById(R.id.Result);  
155.         mVolumeBar=(ProgressBar)findViewById(R.id.VolumeProgressBar);  
156.         BtnStart=(Button)findViewById(R.id.Start);  
157.         BtnStart.setOnClickListener(this);  
158.         BtnCancel=(Button)findViewById(R.id.Cancel);  
159.         BtnCancel.setOnClickListener(this);  
160.           
161.     }  
162.     @Override  
163.     protected void onDestroy()   
164.     {  
165.         VoiceRecognitionClient.releaseInstance(); // 释放识别库  
166.         super.onDestroy();  
167.     }  
168.   
169.     @Override  
170.     protected void onPause()   
171.     {  
172.         if (IsRecognition) {  
173.             mClient.stopVoiceRecognition(); // 取消识别  
174.         }  
175.         super.onPause();  
176.     }  
177.       
178.     /* 
179.      * 处理Click事件 
180.      */  
181.     @Override  
182.     public void onClick(View v)   
183.     {  
184.        switch(v.getId())  
185.        {  
186.          case R.id.Start:  
187.              if (IsRecognition) { // 用户说完  
188.                  mClient.speakFinish();  
189.              } else { // 用户重试，开始新一次语音识别  
190.                  Result.setText(null);  
191.                  // 需要开始新识别,首先设置参数  
192.                  config = new VoiceRecognitionConfig();  
193.                  if (mType == VOICE_TYPE_INPUT)   
194.                  {  
195.                      config.setSpeechMode(VoiceRecognitionConfig.SPEECHMODE_MULTIPLE_SENTENCE);  
196.                  } else {  
197.                      config.setSpeechMode(VoiceRecognitionConfig.SPEECHMODE_SINGLE_SENTENCE);  
198.   
199.                  }  
200.                  //开启语义解析  
201.                  config.enableNLU();  
202.                  //开启音量反馈  
203.                  config.enableVoicePower(true);  
204.                  config.enableBeginSoundEffect(R.raw.bdspeech_recognition_start); // 设置识别开始提示音  
205.                  config.enableEndSoundEffect(R.raw.bdspeech_speech_end); // 设置识别结束提示音  
206.                  config.setSampleRate(VoiceRecognitionConfig.SAMPLE_RATE_8K); //设置采样率  
207.                  //使用默认的麦克风作为音频来源  
208.                  config.setUseDefaultAudioSource(true);  
209.                  // 下面发起识别  
210.                  int code = VoiceRecognitionClient.getInstance(this).startVoiceRecognition(  
211.                          mListener, config);  
212.                  if (code == VoiceRecognitionClient.START_WORK_RESULT_WORKING)   
213.                  { // 能够开始识别，改变界面  
214.                      BtnStart.setEnabled(false);  
215.                      BtnStart.setText("说完");  
216.                      BtnCancel.setEnabled(true);  
217.                  } else {  
218.                      Result.setText("启动失败: 0x%1$s"+code);  
219.                  }  
220.              }  
221.              break;  
222.          case R.id.Cancel:  
223.              mClient.stopVoiceRecognition();  
224.              break;  
225.        }  
226.     }  
227.       
228.     /* 
229.      * 重置界面 
230.      */  
231.     private void ReSetUI()  
232.     {  
233.         BtnStart.setEnabled(true); // 可以开始重试  
234.         BtnStart.setText("重试");  
235.         BtnCancel.setEnabled(false); // 还没开始不能取消  
236.     }  
237.       
238.     /* 
239.      *将识别结果显示到界面上 
240.      */  
241.     private void UpdateRecognitionResult(Object result) {  
242.         if (result != null && result instanceof List) {  
243.             @SuppressWarnings("rawtypes")  
244.             List results = (List) result;  
245.             if (results.size() > 0) {  
246.                 if (mType==VOICE_TYPE_SEARCH) {  
247.                     Result.setText(results.get(0).toString());  
248.                 } else if (mType == VOICE_TYPE_INPUT) {  
249.                     @SuppressWarnings("unchecked")  
250.                     List<List<Candidate>> sentences = ((List<List<Candidate>>) result);  
251.                     StringBuffer sb = new StringBuffer();  
252.                     for (List<Candidate> candidates : sentences) {  
253.                         if (candidates != null && candidates.size() > 0) {  
254.                             sb.append(candidates.get(0).getWord());  
255.                         }  
256.                     }  
257.                     Result.setText(sb.toString());  
258.                 }  
259.             }  
260.         }  
261.     }  
262.   
263.       
264. }  

           当然，和上一篇文章一样，我们需要加入必要的权限，否则程序会报错的：

[html] view plaincopy

1. <uses-permission android:name="android.permission.RECORD_AUDIO"/>  
2. <uses-permission android:name="android.permission.INTERNET"/>  
3. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>  
4. <uses-permission android:name="android.permission.READ_PHONE_STATE"/>  

          这样，今天的内容就学习完了，在下一篇文章中，我们会以前面两篇文章所介绍的技术为基础，来实现一个较为实际的应用，并对当下主流的语音识别软件进行一个对比，再次谢谢大家的关注！