Android蓝牙通信详解

蓝牙通信的大概步骤如下：

1，首先开启蓝牙

2，搜索可用设备

3，创建蓝牙socket，获取输入输出流

4，读取和写入数据

5，断开连接关闭蓝牙

还要发送配对码发送进行判断！

下面是所有的源代码；不会很难；认真看；

SearchDeviceActivity.java

[java] view
plaincopy

  1. package com.hello.project;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. import java.util.Set;
  6. import android.app.Activity;
  7. import android.app.AlertDialog;
  8. import android.bluetooth.BluetoothAdapter;
  9. import android.bluetooth.BluetoothDevice;
  10. import android.content.BroadcastReceiver;
  11. import android.content.Context;
  12. import android.content.DialogInterface;
  13. import android.content.Intent;
  14. import android.content.IntentFilter;
  15. import android.os.Bundle;
  16. import android.util.Log;
  17. import android.view.View;
  18. import android.view.View.OnClickListener;
  19. import android.widget.AdapterView;
  20. import android.widget.AdapterView.OnItemClickListener;
  21. import android.widget.ArrayAdapter;
  22. import android.widget.Button;
  23. import android.widget.ListView;
  24. public class SearchDeviceActivity extends Activity implements OnItemClickListener{
  25. private BluetoothAdapter blueadapter=null;
  26. private DeviceReceiver mydevice=new DeviceReceiver();
  27. private List<String> deviceList=new ArrayList<String>();
  28. private ListView deviceListview;
  29. private Button btserch;
  30. private ArrayAdapter<String> adapter;
  31. private boolean hasregister=false;
  32. @Override
  33. protected void onCreate(Bundle savedInstanceState) {
  34. super.onCreate(savedInstanceState);
  35. setContentView(R.layout.finddevice);
  36. setView();
  37. setBluetooth();
  38. }
  39. private void setView(){
  40. deviceListview=(ListView)findViewById(R.id.devicelist);
  41. adapter=new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, deviceList);
  42. deviceListview.setAdapter(adapter);
  43. deviceListview.setOnItemClickListener(this);
  44. btserch=(Button)findViewById(R.id.start_seach);
  45. btserch.setOnClickListener(new ClinckMonitor());
  46. }
  47. @Override
  48. protected void onStart() {
  49. //注册蓝牙接收广播
  50. if(!hasregister){
  51. hasregister=true;
  52. IntentFilter filterStart=new IntentFilter(BluetoothDevice.ACTION_FOUND);
  53. IntentFilter filterEnd=new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
  54. registerReceiver(mydevice, filterStart);
  55. registerReceiver(mydevice, filterEnd);
  56. }
  57. super.onStart();
  58. }
  59. @Override
  60. protected void onDestroy() {
  61. if(blueadapter!=null&&blueadapter.isDiscovering()){
  62. blueadapter.cancelDiscovery();
  63. }
  64. if(hasregister){
  65. hasregister=false;
  66. unregisterReceiver(mydevice);
  67. }
  68. super.onDestroy();
  69. }
  70. /**
  71. * Setting Up Bluetooth
  72. */
  73. private void setBluetooth(){
  74. blueadapter=BluetoothAdapter.getDefaultAdapter();
  75. if(blueadapter!=null){  //Device support Bluetooth
  76. //确认开启蓝牙
  77. if(!blueadapter.isEnabled()){
  78. //请求用户开启
  79. Intent intent=new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  80. startActivityForResult(intent, RESULT_FIRST_USER);
  81. //使蓝牙设备可见，方便配对
  82. Intent in=new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
  83. in.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 200);
  84. startActivity(in);
  85. //直接开启，不经过提示
  86. blueadapter.enable();
  87. }
  88. }
  89. else{   //Device does not support Bluetooth
  90. AlertDialog.Builder dialog = new AlertDialog.Builder(this);
  91. dialog.setTitle("No bluetooth devices");
  92. dialog.setMessage("Your equipment does not support bluetooth, please change device");
  93. dialog.setNegativeButton("cancel",
  94. new DialogInterface.OnClickListener() {
  95. @Override
  96. public void onClick(DialogInterface dialog, int which) {
  97. }
  98. });
  99. dialog.show();
  100. }
  101. }
  102. /**
  103. * Finding Devices
  104. */
  105. private void findAvalibleDevice(){
  106. //获取可配对蓝牙设备
  107. Set<BluetoothDevice> device=blueadapter.getBondedDevices();
  108. if(blueadapter!=null&&blueadapter.isDiscovering()){
  109. deviceList.clear();
  110. adapter.notifyDataSetChanged();
  111. }
  112. if(device.size()>0){ //存在已经配对过的蓝牙设备
  113. for(Iterator<BluetoothDevice> it=device.iterator();it.hasNext();){
  114. BluetoothDevice btd=it.next();
  115. deviceList.add(btd.getName()+‘\n‘+btd.getAddress());
  116. adapter.notifyDataSetChanged();
  117. }
  118. }else{  //不存在已经配对过的蓝牙设备
  119. deviceList.add("No can be matched to use bluetooth");
  120. adapter.notifyDataSetChanged();
  121. }
  122. }
  123. @Override
  124. protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  125. switch(resultCode){
  126. case RESULT_OK:
  127. findAvalibleDevice();
  128. break;
  129. case RESULT_CANCELED:
  130. break;
  131. }
  132. super.onActivityResult(requestCode, resultCode, data);
  133. }
  134. private class ClinckMonitor implements OnClickListener{
  135. @Override
  136. public void onClick(View v) {
  137. if(blueadapter.isDiscovering()){
  138. blueadapter.cancelDiscovery();
  139. btserch.setText("repeat search");
  140. }else{
  141. findAvalibleDevice();
  142. blueadapter.startDiscovery();
  143. btserch.setText("stop search");
  144. }
  145. }
  146. }
  147. /**
  148. * 蓝牙搜索状态广播监听
  149. * @author Andy
  150. *
  151. */
  152. private class DeviceReceiver extends BroadcastReceiver{
  153. @Override
  154. public void onReceive(Context context, Intent intent) {
  155. String action =intent.getAction();
  156. if(BluetoothDevice.ACTION_FOUND.equals(action)){    //搜索到新设备
  157. BluetoothDevice btd=intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  158. //搜索没有配过对的蓝牙设备
  159. if (btd.getBondState() != BluetoothDevice.BOND_BONDED) {
  160. deviceList.add(btd.getName()+‘\n‘+btd.getAddress());
  161. adapter.notifyDataSetChanged();
  162. }
  163. }
  164. else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)){   //搜索结束
  165. if (deviceListview.getCount() == 0) {
  166. deviceList.add("No can be matched to use bluetooth");
  167. adapter.notifyDataSetChanged();
  168. }
  169. btserch.setText("repeat search");
  170. }
  171. }
  172. }
  173. @Override
  174. public void onItemClick(AdapterView<?> arg0, View arg1, int pos, long arg3) {
  175. Log.e("msgParent", "Parent= "+arg0);
  176. Log.e("msgView", "View= "+arg1);
  177. Log.e("msgChildView", "ChildView= "+arg0.getChildAt(pos-arg0.getFirstVisiblePosition()));
  178. final String msg = deviceList.get(pos);
  179. if(blueadapter!=null&&blueadapter.isDiscovering()){
  180. blueadapter.cancelDiscovery();
  181. btserch.setText("repeat search");
  182. }
  183. AlertDialog.Builder dialog = new AlertDialog.Builder(this);// 定义一个弹出框对象
  184. dialog.setTitle("Confirmed connecting device");
  185. dialog.setMessage(msg);
  186. dialog.setPositiveButton("connect",
  187. new DialogInterface.OnClickListener() {
  188. @Override
  189. public void onClick(DialogInterface dialog, int which) {
  190. BluetoothMsg.BlueToothAddress=msg.substring(msg.length()-17);
  191. if(BluetoothMsg.lastblueToothAddress!=BluetoothMsg.BlueToothAddress){
  192. BluetoothMsg.lastblueToothAddress=BluetoothMsg.BlueToothAddress;
  193. }
  194. Intent in=new Intent(SearchDeviceActivity.this,BluetoothActivity.class);
  195. startActivity(in);
  196. }
  197. });
  198. dialog.setNegativeButton("cancel",
  199. new DialogInterface.OnClickListener() {
  200. @Override
  201. public void onClick(DialogInterface dialog, int which) {
  202. BluetoothMsg.BlueToothAddress = null;
  203. }
  204. });
  205. dialog.show();
  206. }
  207. }

BluetoothMsg.java

[java] view
plaincopy

  1. package com.hello.project;
  2. public class BluetoothMsg {
  3. /**
  4. * 蓝牙连接类型
  5. * @author Andy
  6. *
  7. */
  8. public enum ServerOrCilent{
  9. NONE,
  10. SERVICE,
  11. CILENT
  12. };
  13. //蓝牙连接方式
  14. public static ServerOrCilent serviceOrCilent = ServerOrCilent.NONE;
  15. //连接蓝牙地址
  16. public static String BlueToothAddress = null,lastblueToothAddress=null;
  17. //通信线程是否开启
  18. public static boolean isOpen = false;
  19. }

finddevice.xml

[java] view
plaincopy

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3. android:id = "@+id/devices"
  4. android:orientation="vertical"
  5. android:layout_width="fill_parent"
  6. android:layout_height="fill_parent"
  7. >
  8. <RelativeLayout
  9. android:layout_width="fill_parent"
  10. android:layout_height="wrap_content"
  11. android:layout_alignParentBottom = "true"
  12. android:id= "@+id/bt_bottombar">
  13. <Button android:id="@+id/start_seach"
  14. android:layout_width="match_parent"
  15. android:layout_height="wrap_content"
  16. android:layout_toRightOf="@+id/start_service"
  17. android:text="Began to search"/>
  18. </RelativeLayout>
  19. <ListView
  20. android:id="@+id/devicelist"
  21. android:layout_width="fill_parent"
  22. android:layout_height="fill_parent"
  23. android:scrollingCache="false"
  24. android:divider="#ffc6c6c6"
  25. android:layout_weight="1.0"
  26. android:layout_above = "@id/bt_bottombar"
  27. android:layout_below="@id/devices"
  28. />
  29. </RelativeLayout>

BluetoothActivity.java

[java] view
plaincopy

  1. package com.hello.project;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.util.ArrayList;
  6. import java.util.List;
  7. import java.util.UUID;
  8. import android.app.Activity;
  9. import android.bluetooth.BluetoothAdapter;
  10. import android.bluetooth.BluetoothDevice;
  11. import android.bluetooth.BluetoothServerSocket;
  12. import android.bluetooth.BluetoothSocket;
  13. import android.content.Context;
  14. import android.os.Bundle;
  15. import android.os.Handler;
  16. import android.os.Message;
  17. import android.util.Log;
  18. import android.view.View;
  19. import android.view.View.OnClickListener;
  20. import android.view.inputmethod.InputMethodManager;
  21. import android.widget.AdapterView;
  22. import android.widget.ArrayAdapter;
  23. import android.widget.Button;
  24. import android.widget.EditText;
  25. import android.widget.ListView;
  26. import android.widget.Toast;
  27. import android.widget.AdapterView.OnItemClickListener;
  28. public class BluetoothActivity extends  Activity{
  29. /* 一些常量，代表服务器的名称 */
  30. public static final String PROTOCOL_SCHEME_RFCOMM = "btspp";
  31. private ListView mListView;
  32. private Button sendButton;
  33. private Button disconnectButton;
  34. private EditText editMsgView;
  35. private ArrayAdapter<String> mAdapter;
  36. private List<String> msgList=new ArrayList<String>();
  37. Context mContext;
  38. private BluetoothServerSocket mserverSocket = null;
  39. private ServerThread startServerThread = null;
  40. private clientThread clientConnectThread = null;
  41. private BluetoothSocket socket = null;
  42. private BluetoothDevice device = null;
  43. private readThread mreadThread = null;;
  44. private BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  45. @Override
  46. public void onCreate(Bundle savedInstanceState) {
  47. super.onCreate(savedInstanceState);
  48. setContentView(R.layout.chat);
  49. mContext = this;
  50. init();
  51. }
  52. private void init() {
  53. mAdapter=new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, msgList);
  54. mListView = (ListView) findViewById(R.id.list);
  55. mListView.setAdapter(mAdapter);
  56. mListView.setFastScrollEnabled(true);
  57. editMsgView= (EditText)findViewById(R.id.MessageText);
  58. editMsgView.clearFocus();
  59. sendButton= (Button)findViewById(R.id.btn_msg_send);
  60. sendButton.setOnClickListener(new OnClickListener() {
  61. @Override
  62. public void onClick(View arg0) {
  63. String msgText =editMsgView.getText().toString();
  64. if (msgText.length()>0) {
  65. sendMessageHandle(msgText);
  66. editMsgView.setText("");
  67. editMsgView.clearFocus();
  68. //close InputMethodManager
  69. InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
  70. imm.hideSoftInputFromWindow(editMsgView.getWindowToken(), 0);
  71. }else
  72. Toast.makeText(mContext, "发送内容不能为空！", Toast.LENGTH_SHORT).show();
  73. }
  74. });
  75. disconnectButton= (Button)findViewById(R.id.btn_disconnect);
  76. disconnectButton.setOnClickListener(new OnClickListener() {
  77. @Override
  78. public void onClick(View arg0) {
  79. // TODO Auto-generated method stub
  80. if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.CILENT)
  81. {
  82. shutdownClient();
  83. }
  84. else if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.SERVICE)
  85. {
  86. shutdownServer();
  87. }
  88. BluetoothMsg.isOpen = false;
  89. BluetoothMsg.serviceOrCilent=BluetoothMsg.ServerOrCilent.NONE;
  90. Toast.makeText(mContext, "已断开连接！", Toast.LENGTH_SHORT).show();
  91. }
  92. });
  93. }
  94. private Handler LinkDetectedHandler = new Handler() {
  95. @Override
  96. public void handleMessage(Message msg) {
  97. //Toast.makeText(mContext, (String)msg.obj, Toast.LENGTH_SHORT).show();
  98. if(msg.what==1)
  99. {
  100. msgList.add((String)msg.obj);
  101. }
  102. else
  103. {
  104. msgList.add((String)msg.obj);
  105. }
  106. mAdapter.notifyDataSetChanged();
  107. mListView.setSelection(msgList.size() - 1);
  108. }
  109. };
  110. @Override
  111. protected void onResume() {
  112. BluetoothMsg.serviceOrCilent=BluetoothMsg.ServerOrCilent.CILENT;
  113. if(BluetoothMsg.isOpen)
  114. {
  115. Toast.makeText(mContext, "连接已经打开，可以通信。如果要再建立连接，请先断开！", Toast.LENGTH_SHORT).show();
  116. return;
  117. }
  118. if(BluetoothMsg.serviceOrCilent==BluetoothMsg.ServerOrCilent.CILENT)
  119. {
  120. String address = BluetoothMsg.BlueToothAddress;
  121. if(!address.equals("null"))
  122. {
  123. device = mBluetoothAdapter.getRemoteDevice(address);
  124. clientConnectThread = new clientThread();
  125. clientConnectThread.start();
  126. BluetoothMsg.isOpen = true;
  127. }
  128. else
  129. {
  130. Toast.makeText(mContext, "address is null !", Toast.LENGTH_SHORT).show();
  131. }
  132. }
  133. else if(BluetoothMsg.serviceOrCilent==BluetoothMsg.ServerOrCilent.SERVICE)
  134. {
  135. startServerThread = new ServerThread();
  136. startServerThread.start();
  137. BluetoothMsg.isOpen = true;
  138. }
  139. super.onResume();
  140. }
  141. //开启客户端
  142. private class clientThread extends Thread {
  143. @Override
  144. public void run() {
  145. try {
  146. //创建一个Socket连接：只需要服务器在注册时的UUID号
  147. // socket = device.createRfcommSocketToServiceRecord(BluetoothProtocols.OBEX_OBJECT_PUSH_PROTOCOL_UUID);
  148. socket = device.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
  149. //连接
  150. Message msg2 = new Message();
  151. msg2.obj = "请稍候，正在连接服务器:"+BluetoothMsg.BlueToothAddress;
  152. msg2.what = 0;
  153. LinkDetectedHandler.sendMessage(msg2);
  154. socket.connect();
  155. Message msg = new Message();
  156. msg.obj = "已经连接上服务端！可以发送信息。";
  157. msg.what = 0;
  158. LinkDetectedHandler.sendMessage(msg);
  159. //启动接受数据
  160. mreadThread = new readThread();
  161. mreadThread.start();
  162. }
  163. catch (IOException e)
  164. {
  165. Log.e("connect", "", e);
  166. Message msg = new Message();
  167. msg.obj = "连接服务端异常！断开连接重新试一试。";
  168. msg.what = 0;
  169. LinkDetectedHandler.sendMessage(msg);
  170. }
  171. }
  172. };
  173. //开启服务器
  174. private class ServerThread extends Thread {
  175. @Override
  176. public void run() {
  177. try {
  178. /* 创建一个蓝牙服务器
  179. * 参数分别：服务器名称、UUID   */
  180. mserverSocket = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(PROTOCOL_SCHEME_RFCOMM,
  181. UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
  182. Log.d("server", "wait cilent connect...");
  183. Message msg = new Message();
  184. msg.obj = "请稍候，正在等待客户端的连接...";
  185. msg.what = 0;
  186. LinkDetectedHandler.sendMessage(msg);
  187. /* 接受客户端的连接请求 */
  188. socket = mserverSocket.accept();
  189. Log.d("server", "accept success !");
  190. Message msg2 = new Message();
  191. String info = "客户端已经连接上！可以发送信息。";
  192. msg2.obj = info;
  193. msg.what = 0;
  194. LinkDetectedHandler.sendMessage(msg2);
  195. //启动接受数据
  196. mreadThread = new readThread();
  197. mreadThread.start();
  198. } catch (IOException e) {
  199. e.printStackTrace();
  200. }
  201. }
  202. };
  203. /* 停止服务器 */
  204. private void shutdownServer() {
  205. new Thread() {
  206. @Override
  207. public void run() {
  208. if(startServerThread != null)
  209. {
  210. startServerThread.interrupt();
  211. startServerThread = null;
  212. }
  213. if(mreadThread != null)
  214. {
  215. mreadThread.interrupt();
  216. mreadThread = null;
  217. }
  218. try {
  219. if(socket != null)
  220. {
  221. socket.close();
  222. socket = null;
  223. }
  224. if (mserverSocket != null)
  225. {
  226. mserverSocket.close();/* 关闭服务器 */
  227. mserverSocket = null;
  228. }
  229. } catch (IOException e) {
  230. Log.e("server", "mserverSocket.close()", e);
  231. }
  232. };
  233. }.start();
  234. }
  235. /* 停止客户端连接 */
  236. private void shutdownClient() {
  237. new Thread() {
  238. @Override
  239. public void run() {
  240. if(clientConnectThread!=null)
  241. {
  242. clientConnectThread.interrupt();
  243. clientConnectThread= null;
  244. }
  245. if(mreadThread != null)
  246. {
  247. mreadThread.interrupt();
  248. mreadThread = null;
  249. }
  250. if (socket != null) {
  251. try {
  252. socket.close();
  253. } catch (IOException e) {
  254. // TODO Auto-generated catch block
  255. e.printStackTrace();
  256. }
  257. socket = null;
  258. }
  259. };
  260. }.start();
  261. }
  262. //发送数据
  263. private void sendMessageHandle(String msg)
  264. {
  265. if (socket == null)
  266. {
  267. Toast.makeText(mContext, "没有连接", Toast.LENGTH_SHORT).show();
  268. return;
  269. }
  270. try {
  271. OutputStream os = socket.getOutputStream();
  272. os.write(msg.getBytes());
  273. } catch (IOException e) {
  274. e.printStackTrace();
  275. }
  276. msgList.add(msg);
  277. mAdapter.notifyDataSetChanged();
  278. mListView.setSelection(msgList.size() - 1);
  279. }
  280. //读取数据
  281. private class readThread extends Thread {
  282. @Override
  283. public void run() {
  284. byte[] buffer = new byte[1024];
  285. int bytes;
  286. InputStream mmInStream = null;
  287. try {
  288. mmInStream = socket.getInputStream();
  289. } catch (IOException e1) {
  290. // TODO Auto-generated catch block
  291. e1.printStackTrace();
  292. }
  293. while (true) {
  294. try {
  295. // Read from the InputStream
  296. if( (bytes = mmInStream.read(buffer)) > 0 )
  297. {
  298. byte[] buf_data = new byte[bytes];
  299. for(int i=0; i<bytes; i++)
  300. {
  301. buf_data[i] = buffer[i];
  302. }
  303. String s = new String(buf_data);
  304. Message msg = new Message();
  305. msg.obj = s;
  306. msg.what = 1;
  307. LinkDetectedHandler.sendMessage(msg);
  308. }
  309. } catch (IOException e) {
  310. try {
  311. mmInStream.close();
  312. } catch (IOException e1) {
  313. // TODO Auto-generated catch block
  314. e1.printStackTrace();
  315. }
  316. break;
  317. }
  318. }
  319. }
  320. }
  321. @Override
  322. protected void onDestroy() {
  323. super.onDestroy();
  324. if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.CILENT)
  325. {
  326. shutdownClient();
  327. }
  328. else if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.SERVICE)
  329. {
  330. shutdownServer();
  331. }
  332. BluetoothMsg.isOpen = false;
  333. BluetoothMsg.serviceOrCilent = BluetoothMsg.ServerOrCilent.NONE;
  334. }
  335. }

chat.xml

[java] view
plaincopy

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3. android:id = "@+id/container"
  4. android:orientation="vertical"
  5. android:layout_width="fill_parent"
  6. android:layout_height="fill_parent"
  7. >
  8. <RelativeLayout
  9. android:layout_width="fill_parent"
  10. android:layout_height="wrap_content"
  11. android:id= "@+id/edit_bottombar"
  12. android:layout_alignParentBottom = "true">
  13. <Button android:id="@+id/btn_disconnect"
  14. android:layout_width="65dp"
  15. android:layout_height="wrap_content"
  16. android:layout_alignParentLeft ="true"
  17. android:text="断开"/>
  18. <Button android:id="@+id/btn_msg_send"
  19. android:layout_width="65dp"
  20. android:layout_height="wrap_content"
  21. android:layout_alignParentRight ="true"
  22. android:text="发送"/>
  23. <EditText
  24. android:layout_width="fill_parent"
  25. android:layout_height = "wrap_content"
  26. android:layout_toLeftOf="@id/btn_msg_send"
  27. android:layout_toRightOf="@+id/btn_disconnect"
  28. android:hint = "说点什么呢?"
  29. android:textSize="15dip"
  30. android:id = "@+id/MessageText"/>
  31. </RelativeLayout>
  32. <ListView
  33. android:id="@+id/list"
  34. android:layout_width="fill_parent"
  35. android:layout_height="fill_parent"
  36. android:scrollingCache="false"
  37. android:divider="#ffc6c6c6"
  38. android:layout_weight="1.0"
  39. android:layout_above = "@id/edit_bottombar"
  40. android:layout_below="@id/container"
  41. />
  42. </RelativeLayout>

最后别忘了加入权限

[java] view
plaincopy

  1. <uses-permission android:name="android.permission.BLUETOOTH"/>
  2. <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
  3. <uses-permission android:name="android.permission.READ_CONTACTS"/>

扩展：蓝牙后台配对实现（网上看到的整理如下）

[java] view
plaincopy

  1. static public boolean createBond(Class btClass, BluetoothDevice btDevice)
  2. throws Exception {
  3. Method createBondMethod = btClass.getMethod("createBond");
  4. Log.i("life", "createBondMethod = " + createBondMethod.getName());
  5. Boolean returnValue = (Boolean) createBondMethod.invoke(btDevice);
  6. return returnValue.booleanValue();
  7. }
  8. static public boolean setPin(Class btClass, BluetoothDevice btDevice,
  9. String str) throws Exception {
  10. Boolean returnValue = null;
  11. try {
  12. Method removeBondMethod = btClass.getDeclaredMethod("setPin",
  13. new Class[] { byte[].class });
  14. returnValue = (Boolean) removeBondMethod.invoke(btDevice,
  15. new Object[] { str.getBytes() });
  16. Log.i("life", "returnValue = " + returnValue);
  17. } catch (SecurityException e) {
  18. // throw new RuntimeException(e.getMessage());
  19. e.printStackTrace();
  20. } catch (IllegalArgumentException e) {
  21. // throw new RuntimeException(e.getMessage());
  22. e.printStackTrace();
  23. } catch (Exception e) {
  24. // TODO Auto-generated catch block
  25. e.printStackTrace();
  26. }
  27. return returnValue;
  28. }
  29. // 取消用户输入
  30. static public boolean cancelPairingUserInput(Class btClass,
  31. BluetoothDevice device) throws Exception {
  32. Method createBondMethod = btClass.getMethod("cancelPairingUserInput");
  33. // cancelBondProcess()
  34. Boolean returnValue = (Boolean) createBondMethod.invoke(device);
  35. Log.i("life", "cancelPairingUserInputreturnValue = " + returnValue);
  36. return returnValue.booleanValue();
  37. }

然后监听蓝牙配对的广播  匹配“android.bluetooth.device.action.PAIRING_REQUEST”这个action

然后调用上面的setPin(mDevice.getClass(), mDevice, "1234"); // 手机和蓝牙采集器配对

createBond(mDevice.getClass(), mDevice);

cancelPairingUserInput(mDevice.getClass(), mDevice);

mDevice是你要去连接的那个蓝牙的对象 ， 1234为配对的pin码

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-10 06:23:04

Android蓝牙通信详解的相关文章

Android 蓝牙操作详解

1.启用蓝牙并使设备处于可发现状态 1.1 在使用BluetoothAdapter类的实例进操作之前,应启用isEnable()方法检查设备是否启用了蓝牙适配器. // 使用意图提示用户启用蓝牙,并使设备处于可发现状态 private void startBluetooth() { BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter(); // 检测蓝牙是否开启 if (!bt.isEnabled()) { Intent enable

Android 蓝牙API详解

随着近两年可穿戴式产品逐渐进入人们的生活,蓝牙开发也成为了Android开发的一个重要模块,下面我们就来说一说蓝牙的这些API. 1.蓝牙开发有两个主要的API: BuletoothAdapter:本地蓝牙的适配器,也就是说当前应用程序所运行的Android设备上的蓝牙 BuletoothDevice  : 远程的蓝牙适配器,也就是说你要连接的Android设备的适配器. 2.蓝牙权限 : android.permission.BLUETOOTH : 允许程序连接到已配对的蓝牙设备, 请求连接/

Android aidl通信详解

前段时间研究了不少android二次开发,其中有一种方法就是通过aidl通信,留接口提供给外面二次开发.从这里也可以看出:aidl通信是两个应用程序之间的进程通信了.在这篇博客中,主要写了两个应用程序,一个是serverdemo,可以称为服务端,也是提供接口的应用程序,在这里面我写了一个加法计算.二是客户端:clientdemo,在这个程序中调用了加法计算接口,把值传到serverdemo进行加法计算,返回结果,进行显示. 1.aidl的定义 aidl是 Android Interface de

Android中实现java与PHP服务器（基于新浪云免费云平台）http通信详解

Android中实现java与PHP服务器(基于新浪云免费云平台)http通信详解 (本文转自: http://blog.csdn.net/yinhaide/article/details/44756989) 前言:现在很多APP都需要云的功能,也就是通过网络与服务器交换数据.有的采用tcp/ip协议,但是你必须拥有一个固定ip的服务器,可以购买阿里云服务器之类的,就是贵了点.如果只是个人的小应用的的话可以采用新浪云平台这种免费的服务器,采用的协议是http协议,具体实现方式如下: 方式一.在线

Android 四大组件 详解

[置顶] Android四大组件详解 分类: Android四大组件2013-02-09 16:23 19411人阅读 评论(13) 收藏 举报 Android开发 注:本文主要来自网易的一个博主的文章,经过阅读,总结,故留下文章在此 Android四大基本组件介绍与生命周期 Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接收器. 一:了解四大基本组件 Activity : 应用程序中,一个

Android AIDL使用详解

1.什么是aidl:aidl是 Android Interface definition language的缩写,一看就明白,它是一种android内部进程通信接口的描述语言,通过它我们可以定义进程间的通信接口 icp:interprocess communication :内部进程通信 2.既然aidl可以定义并实现进程通信,那么我们怎么使用它呢?文档/android-sdk/docs/guide/developing/tools/aidl.html中对步骤作了详细描述: --1.Create

Android Service使用详解

Service是Android系统中的四大组件之一,主要有两个应用场景:后台运行和跨进程访问.Service可以在后台执行长时间运行操作而不提供用户界面,除非系统必须回收内存资源,否则系统不会停止或销毁服务.服务可由其他应用组件启动,而且即使用户切换到其他应用,服务仍将在后台继续运行. 此外,组件可以绑定到服务,以与之进行交互,甚至是执行进程间通信 (IPC) 需要注意的是,Service是在主线程里执行操作的,可能会因为执行耗时操作而导致ANR 一.基础知识 Service可以分为以下三种形式

Android BroadcastReceiver基础详解一

-.BroadcastReceivcer概述 1.什么是广播 BroadcastReceiver是Android四大组件之一,本质是一种全局的监听器,用于监听系统全局的广播消息.因此它可以非常方便的实现不同组件之间的通信. 2.BroadcastReceiver的创建启动 BroadcastReceiver是用用于接受程序所放出的Broadcast Intent,与应用程序启动的Activity.Service相同.也只需要两步: ①.创建需要启动的Broadcast的Intent ②.创建一个

Android GLSurfaceView用法详解（二）

输入如何处理       若是开发一个交互型的应用(如游戏),通常需要子类化 GLSurfaceView,由此可以获取输入事件.下面有个例子: java代码: package eoe.ClearTest; import javax.microedition.khronos.egl.EGLConfig; import javax.microedition.khronos.opengles.GL10; import android.app.Activity; import android.conte