主要实现步骤如下：

1.确保已经和蓝牙耳机配对连接上。

2.开启蓝牙信道

AudioManager mAudioManager = (AudioManager)getSystemService(Context.AUDIO_SERVICE);

mAudioManager.setBluetoothScoOn(true);

mAudioManager.startBluetoothSco();

3.开启语音识别

4.退出时关闭蓝牙信道

mAudioManager.setBluetoothScoOn(false);

mAudioManager.stopBluetoothSco();

5.额外需要添加的权限：

<uses-permission android:name="android.permission.BROADCAST_STICKY" />  注：部分手机如无此权限会报错

<uses-permission android:name="android.permission.BLUETOOTH" />

<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

以上方法到android5.0以上可能无用

提供另外一种方法

1. package com.example.dkdh.testrecord;
3. import android.app.Activity;
4. import android.bluetooth.BluetoothAdapter;
5. import android.bluetooth.BluetoothDevice;
6. import android.bluetooth.BluetoothHeadset;
7. import android.bluetooth.BluetoothProfile;
8. import android.content.BroadcastReceiver;
9. import android.content.Context;
10. import android.content.Intent;
11. import android.content.IntentFilter;
12. import android.media.AudioManager;
13. import android.media.MediaPlayer;
14. import android.media.MediaRecorder;
15. import android.os.Bundle;
17. import android.os.Environment;
18. import android.util.Log;
19. import android.view.View;
20. import android.widget.Button;
22. import android.widget.TextView;
23. import android.widget.Toast;
25. import com.example.dkdh.testrecord.util.FucUtil;
26. import com.example.dkdh.testrecord.util.JsonParser;
27. import com.iflytek.cloud.InitListener;
28. import com.iflytek.cloud.RecognizerListener;
29. import com.iflytek.cloud.RecognizerResult;
30. import com.iflytek.cloud.SpeechConstant;
31. import com.iflytek.cloud.SpeechError;
32. import com.iflytek.cloud.SpeechRecognizer;
33. import com.iflytek.cloud.SpeechUtility;
34. import com.iflytek.cloud.ErrorCode;
36. import java.io.IOException;
37. import java.util.HashMap;
38. import java.util.LinkedHashMap;
39. import java.util.List;
41. public class MainActivity extends Activity implements View.OnClickListener{
42.     private final String TAG = MainActivity.class.getSimpleName();
43.     private final String XF_APP_ID = "xxxxxx";
44.     BluetoothHeadset headset;
45.     private Button start,stop;
46.     private TextView result;
48.     private AudioManager mAudioManager = null;
50.     private BluetoothHeadset mBluetoothHeadset;
51.     private BluetoothAdapter mBluetoothAdapter;
52.     private BluetoothDevice mBluetoothDevice;
54.     private SpeechRecognizer mIat;
55.     //    // 语音听写UI
56. //    private RecognizerDialog mIatDialog;
57. //    // 用HashMap存储听写结果
58.     private HashMap<String, String> mIatResults = new LinkedHashMap<String, String>();
60.     @Override
61.     protected void onCreate(Bundle savedInstanceState) {
62.         super.onCreate(savedInstanceState);
63.         setContentView(R.layout.activity_main);
65.         SpeechUtility.createUtility(this, SpeechConstant.APPID + "=" + XF_APP_ID);
66.         result = (TextView)findViewById(R.id.result);
67.         start = (Button)findViewById(R.id.startRec);
68.         stop = (Button)findViewById(R.id.stopRec);
70.         start.setOnClickListener(this);
71.         stop.setOnClickListener(this);
72.        
73.         
74.         mAudioManager = (AudioManager)getSystemService(Context.AUDIO_SERVICE);
76.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
77.         mBluetoothAdapter.getProfileProxy(this, mProfileListener, BluetoothProfile.HEADSET);
78.         //        // 初始化识别无UI识别对象
79. //        // 使用SpeechRecognizer对象，可根据回调消息自定义界面；第二个参数：本地识别时传mInitListener
80.         mIat = SpeechRecognizer.createRecognizer(this, mInitListener);
81.     }
82.     private BluetoothProfile.ServiceListener mProfileListener = new BluetoothProfile.ServiceListener(){
84.         @Override
85.         public void onServiceConnected(int profile, BluetoothProfile proxy) {
86.             if (profile == BluetoothProfile.HEADSET){
87.                 mBluetoothHeadset = (BluetoothHeadset) proxy;
88.                 List<BluetoothDevice> devices = mBluetoothHeadset.getConnectedDevices();
89.                 if (devices.size()>0){
90.                     mBluetoothDevice = devices.get(0);
91.                     int state = mBluetoothHeadset.getConnectionState(mBluetoothDevice);
92.                     Log.e("==============","headset state:"+state);
93.                     if (state==BluetoothHeadset.STATE_CONNECTED){
94.                         Log.e("=================","bluetooth headset connected");
95.                     }
96.                 }
97.             }
98.         }
100.         @Override
101.         public void onServiceDisconnected(int profile) {
102.             if (profile == BluetoothProfile.HEADSET){
103.                 mBluetoothHeadset = null;
104.             }
105.         }
106.     };
107.     @Override
108.     public void onClick(View v) {
109.         switch (v.getId()){
110.             case R.id.startRec:
111.           startRecordWav();
112.           break;
113.             case R.id.stopRec:
114.       stopRecordWav();
115.      break;
116.             default:
117.      break;
118.         }
119.     }
120.     /**
121.      * 识别实时语音
122.      */
123.     private void recog(){
124.         mIatResults.clear();
125.         // 设置参数
126.         setParam();
127.         int ret = 0;
128.             // 不显示听写对话框
129.             ret = mIat.startListening(mRecognizerListener);
130.             if (ret != ErrorCode.SUCCESS) {
131.                 showTip("听写失败,错误码：" + ret);
132.             } else {
133. //                showTip("");
134.             }
135.     }
136.    
138.     /**
139.      * 初始化监听器。
140.      */
141.     private InitListener mInitListener = new InitListener() {
143.         @Override
144.         public void onInit(int code) {
145.             Log.i(TAG, "SpeechRecognizer init() code = " + code);
146.             if (code != ErrorCode.SUCCESS) {
147.                 showTip("初始化失败，错误码：" + code);
148.             }
149.         }
150.     };
151.     /**
152.      * 听写监听器。
153.      */
154.     private RecognizerListener mRecognizerListener = new RecognizerListener() {
156.         @Override
157.         public void onBeginOfSpeech() {
158.             // 此回调表示：sdk内部录音机已经准备好了，用户可以开始语音输入
159.             showTip("开始说话");
160.         }
162.         @Override
163.         public void onError(SpeechError error) {
164.             // Tips：
165.             // 错误码：10118(您没有说话)，可能是录音机权限被禁，需要提示用户打开应用的录音权限。
166.             showTip(error.getPlainDescription(true));
167. //            showTip("错误码：10118(您没有说话)，可能是录音机权限被禁，请打开应用的录音权限。");
168.         }
170.         @Override
171.         public void onEndOfSpeech() {
172.             // 此回调表示：检测到了语音的尾端点，已经进入识别过程，不再接受语音输入
173.             showTip("结束说话");
174.         }
176.         @Override
177.         public void onResult(RecognizerResult results, boolean isLast) {
178.             String text = JsonParser.parseIatResult(results.getResultString());
179.             Log.i(TAG, text);
180.             showTip(text);
182.             if(isLast) {
183.                 //TODO 最后的结果
184.                 result.append(text);
185.             }
186.         }
188.         @Override
189.         public void onVolumeChanged(int volume, byte[] data) {
190. //            showTip("当前正在说话，音量大小：" + volume);
191.             Log.i(TAG,"当前正在说话，音量大小：" + volume);
192.             Log.i(TAG, "返回音频数据：" + data.length);
193.         }
195.         @Override
196.         public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
197.             // 以下代码用于获取与云端的会话id，当业务出错时将会话id提供给技术支持人员，可用于查询会话日志，定位出错原因
198.             // 若使用本地能力，会话id为null
199.             //        if (SpeechEvent.EVENT_SESSION_ID == eventType) {
200.             //                String sid = obj.getString(SpeechEvent.KEY_EVENT_SESSION_ID);
201.             //                Log.d(TAG, "session id =" + sid);
202.             //        }
203.         }
204.     };
206.     /**
207.      * Toast显示提示
208.      */
209.     private void showTip(String str){
210.         Toast.makeText(this,str,Toast.LENGTH_SHORT).show();
211.     }
213.     /**
214.      * 参数设置
215.      * @return
216.      */
217.     public void setParam(){
218.         // 清空参数
219.         mIat.setParameter(SpeechConstant.PARAMS, null);
220.         // 设置引擎
221.         mIat.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD);
222.         // 设置返回结果格式
223.         mIat.setParameter(SpeechConstant.RESULT_TYPE, "json");
225.         // 设置语言
226.         mIat.setParameter(SpeechConstant.LANGUAGE, "zh_cn");
227.         // 设置语言区域
228.         mIat.setParameter(SpeechConstant.ACCENT,"mandarin");
230.         // 设置语音前端点:静音超时时间，即用户多长时间不说话则当做超时处理
231.         mIat.setParameter(SpeechConstant.VAD_BOS, "8000");
233.         // 设置语音后端点:后端点静音检测时间，即用户停止说话多长时间内即认为不再输入， 自动停止录音
234.         mIat.setParameter(SpeechConstant.VAD_EOS, "1000");
236.         // 设置标点符号,设置为"0"返回结果无标点,设置为"1"返回结果有标点
237.         mIat.setParameter(SpeechConstant.ASR_PTT, "0");
239.         // 设置音频保存路径，保存音频格式支持pcm、wav，设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
240.         // 注：AUDIO_FORMAT参数语记需要更新版本才能生效
241.         mIat.setParameter(SpeechConstant.AUDIO_FORMAT,"wav");
242.         mIat.setParameter(SpeechConstant.ASR_AUDIO_PATH, Environment.getExternalStorageDirectory()+"/msc/iat.wav");
244. //       设置录音时长，单位ms
245.         mIat.setParameter(SpeechConstant.KEY_SPEECH_TIMEOUT,"60000");
246.         //设置音频源，MIC、VOICE_RECOGNITION、VOICE_COMMUNICATION可用，但与不同android系统有关
247.         mIat.setParameter(SpeechConstant.AUDIO_SOURCE, MediaRecorder.AudioSource.VOICE_COMMUNICATION+"");
248.     }
249.    
250.     /**
251.      * 停止录音
252.      */
253.     private void stopRecordWav(){
254.         Log.e(TAG, "停止录音");
255.         mBluetoothHeadset.stopVoiceRecognition(mBluetoothDevice);
256.     }
258.     /**
259.      * 录音，自主控制录音格式、速率等
260.      */
261.     private void startRecordWav(final int source){
262.         if (!mAudioManager.isBluetoothScoAvailableOffCall()) {
263.             Log.d(TAG, "系统不支持蓝牙录音");
264.             return;
265.         }
266.         if (mBluetoothHeadset == null){
267.             Toast.makeText(this, "蓝牙耳机对象null",Toast.LENGTH_SHORT).show();
268.             return;
269.         }
270.         if (mBluetoothDevice!=null){
271.             mBluetoothHeadset.startVoiceRecognition(mBluetoothDevice);
272.         }
273.         IntentFilter audioStateFilter = new IntentFilter();
274.         audioStateFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
275.         audioStateFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
276.         registerReceiver(new BroadcastReceiver() {
277.             @Override
278.             public void onReceive(Context context, Intent intent) {
279.                 String action = intent.getAction();
280.                 if (action.equals(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED)){
281.                     int state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE,-1);
282.                     if (state==BluetoothHeadset.STATE_AUDIO_CONNECTED){
283.                         Log.e("==============","开始蓝牙语音识别");
284.                         recog();
285.                         unregisterReceiver(this); // 别遗漏
286.                     }
287.                 }
288.             }
289.         },audioStateFilter);
292.     }
294.     @Override
295.     protected void onResume(){
296.         super.onResume();
297.     }
298. }