Android藍牙開發實例解析

       在使用手機時，藍牙通信給我們帶來很多方便。那麼在Android手機中怎樣進行藍牙開發呢？本文以實例的方式講解Android藍牙開發的知識。

       1、使用藍牙的響應權限

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

       2、配置本機藍牙模塊

       在這裡首先要了解對藍牙操作一個核心類BluetoothAdapter。

1. BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();       
2.       
3. //直接打開系統的藍牙設置面板       
4.       
5. Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);       
6.       
7. startActivityForResult(intent, 0x1);       
8.       
9. //直接打開藍牙       
10.       
11. adapter.enable();       
12.       
13. //關閉藍牙       
14.       
15. adapter.disable();       
16.       
17. //打開本機的藍牙發現功能（默認打開120秒，可以將時間最多延長至300秒）       
18.       
19. Intent discoveryIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);       
20.       
21. discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);//設置持續時間（最多300秒）  

       3、搜索藍牙設備

       使用BluetoothAdapter的startDiscovery()方法來搜索藍牙設備。

       startDiscovery()方法是一個異步方法，調用後會立即返回。該方法會進行對其他藍牙設備的搜索，該過程會持續12秒。該方法調用後，搜索過程實際上是在一個System Service中進行的，所以可以調用cancelDiscovery()方法來停止搜索（該方法可以在未執行discovery請求時調用）。

       請求Discovery後，系統開始搜索藍牙設備，在這個過程中，系統會發送以下三個廣播：

       ACTION_DISCOVERY_START：開始搜索
       ACTION_DISCOVERY_FINISHED：搜索結束
       ACTION_FOUND：找到設備，這個Intent中包含兩個extra fields：EXTRA_DEVICE和EXTRA_CLASS，分別包含BluetooDevice和BluetoothClass。

       我們可以自己注冊相應的BroadcastReceiver來接收響應的廣播，以便實現某些功能。

1. // 創建一個接收ACTION_FOUND廣播的BroadcastReceiver       
2.       
3. private final BroadcastReceiver mReceiver = new BroadcastReceiver() {       
4.       
5.     public void onReceive(Context context, Intent intent) {       
6.       
7.         String action = intent.getAction();       
8.       
9.         // 發現設備       
10.       
11.         if (BluetoothDevice.ACTION_FOUND.equals(action)) {       
12.       
13.             // 從Intent中獲取設備對象       
14.       
15.             BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);       
16.       
17.             // 將設備名稱和地址放入array adapter，以便在ListView中顯示       
18.       
19.             mArrayAdapter.add(device.getName() + "\n" + device.getAddress());        
20.         }        
21.     }        
22. };       
23.       
24. // 注冊BroadcastReceiver       
25.       
26. IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);       
27.       
28. registerReceiver(mReceiver, filter); // 不要忘了之後解除綁定     

       4、藍牙Socket通信

       如果打算建議兩個藍牙設備之間的連接，則必須實現服務器端與客戶端的機制。當兩個設備在同一個RFCOMM channel下分別擁有一個連接的BluetoothSocket，這兩個設備才可以說是建立了連接。

       服務器設備與客戶端設備獲取BluetoothSocket的途徑是不同的。服務器設備是通過accepted一個incoming connection來獲取的，而客戶端設備則是通過打開一個到服務器的RFCOMM channel來獲取的。

       服務器端的實現

       通過調用BluetoothAdapter的listenUsingRfcommWithServiceRecord(String, UUID)方法來獲取BluetoothServerSocket（UUID用於客戶端與服務器端之間的配對）。

       調用BluetoothServerSocket的accept()方法監聽連接請求，如果收到請求，則返回一個BluetoothSocket實例（此方法為block方法，應置於新線程中）。

       如果不想在accept其他的連接，則調用BluetoothServerSocket的close()方法釋放資源（調用該方法後，之前獲得的BluetoothSocket實例並沒有close。但由於RFCOMM一個時刻只允許在一條channel中有一個連接，則一般在accept一個連接後，便close掉BluetoothServerSocket）。

1. private class AcceptThread extends Thread {       
2.       
3.     private final BluetoothServerSocket mmServerSocket;        
4.       
5.     public AcceptThread() {       
6.       
7.         // Use a temporary object that is later assigned to mmServerSocket,       
8.       
9.         // because mmServerSocket is final       
10.       
11.         BluetoothServerSocket tmp = null;       
12.       
13.         try {       
14.       
15.             // MY_UUID is the app's UUID string, also used by the client code        
16.             tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);       
17.         } catch (IOException e) { }        
18.         mmServerSocket = tmp;        
19.     }       
20.        
21.     public void run() {        
22.         BluetoothSocket socket = null;       
23.       
24.         // Keep listening until exception occurs or a socket is returned       
25.       
26.         while (true) {        
27.             try {        
28.                 socket = mmServerSocket.accept();       
29.             } catch (IOException e) {        
30.                 break;       
31.             }       
32.       
33.             // If a connection was accepted        
34.             if (socket != null) {      
35.                 // Do work to manage the connection (in a separate thread)       
36.                 manageConnectedSocket(socket);        
37.                 mmServerSocket.close();        
38.                 break;       
39.             }       
40.         }        
41.     }         
42.       
43.     /** Will cancel the listening socket, and cause the thread to finish */        
44.     public void cancel() {        
45.         try {        
46.             mmServerSocket.close();        
47.         } catch (IOException e) { }        
48.     }        
49. }  

       客戶端的實現

       通過搜索得到服務器端的BluetoothService。

       調用BluetoothService的listenUsingRfcommWithServiceRecord(String, UUID)方法獲取BluetoothSocket（該UUID應該同於服務器端的UUID）。

       調用BluetoothSocket的connect()方法（該方法為block方法），如果UUID同服務器端的UUID匹配，並且連接被服務器端accept，則connect()方法返回。

       注意：在調用connect()方法之前，應當確定當前沒有搜索設備，否則連接會變得非常慢並且容易失敗。

1. private class ConnectThread extends Thread {    
2.     private final BluetoothSocket mmSocket;       
3.       
4.     private final BluetoothDevice mmDevice;       
5.       
6.        
7.       
8.     public ConnectThread(BluetoothDevice device) {       
9.       
10.         // Use a temporary object that is later assigned to mmSocket,       
11.       
12.         // because mmSocket is final       
13.       
14.         BluetoothSocket tmp = null;       
15.       
16.         mmDevice = device;       
17.       
18.        
19.       
20.         // Get a BluetoothSocket to connect with the given BluetoothDevice       
21.       
22.         try {       
23.       
24.             // MY_UUID is the app's UUID string, also used by the server code       
25.             tmp = device.createRfcommSocketToServiceRecord(MY_UUID);       
26.         } catch (IOException e) { }        
27.         mmSocket = tmp;       
28.     }       
29.       
30.        
31.       
32.     public void run() {       
33.         // Cancel discovery because it will slow down the connection        
34.         mBluetoothAdapter.cancelDiscovery();       
35.         try {        
36.             // Connect the device through the socket. This will block        
37.             // until it succeeds or throws an exception        
38.             mmSocket.connect();        
39.         } catch (IOException connectException) {       
40.       
41.             // Unable to connect; close the socket and get out        
42.             try {        
43.                 mmSocket.close();       
44.             } catch (IOException closeException) { }       
45.              return;       
46.         }       
47.       
48.           // Do work to manage the connection (in a separate thread)        
49.         manageConnectedSocket(mmSocket);        
50.     }        
51.       
52.     /** Will cancel an in-progress connection, and close the socket */       
53.      public void cancel() {       
54.         try {        
55.             mmSocket.close();       
56.       
57.         } catch (IOException e) { }       
58.      }        
59. }   

       5、連接管理（數據通信）

       分別通過BluetoothSocket的getInputStream()和getOutputStream()方法獲取InputStream和OutputStream。

       使用read(bytes[])和write(bytes[])方法分別進行讀寫操作。

       注意：read(bytes[])方法會一直block，知道從流中讀取到信息，而write(bytes[])方法並不是經常的block（比如在另一設備沒有及時read或者中間緩沖區已滿的情況下，write方法會block）。

1. private class ConnectedThread extends Thread {       
2.       
3.     private final BluetoothSocket mmSocket;       
4.       
5.     private final InputStream mmInStream;       
6.       
7.     private final OutputStream mmOutStream;       
8.       
9.        
10.       
11.     public ConnectedThread(BluetoothSocket socket) {       
12.       
13.         mmSocket = socket;       
14.       
15.         InputStream tmpIn = null;       
16.       
17.         OutputStream tmpOut = null;       
18.       
19.        
20.       
21.         // Get the input and output streams, using temp objects because       
22.       
23.         // member streams are final       
24.       
25.         try {       
26.       
27.             tmpIn = socket.getInputStream();       
28.       
29.             tmpOut = socket.getOutputStream();       
30.       
31.         } catch (IOException e) { }       
32.       
33.        
34.       
35.         mmInStream = tmpIn;       
36.       
37.         mmOutStream = tmpOut;       
38.       
39.     }       
40.       
41.        
42.       
43.     public void run() {       
44.       
45.         byte[] buffer = new byte[1024];  // buffer store for the stream       
46.       
47.         int bytes; // bytes returned from read()       
48.       
49.        
50.       
51.         // Keep listening to the InputStream until an exception occurs       
52.       
53.         while (true) {       
54.       
55.             try {       
56.       
57.                 // Read from the InputStream       
58.       
59.                 bytes = mmInStream.read(buffer);       
60.       
61.                 // Send the obtained bytes to the UI Activity       
62.       
63.                 mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)       
64.       
65.                         .sendToTarget();       
66.       
67.             } catch (IOException e) {       
68.       
69.                 break;       
70.       
71.             }       
72.       
73.         }       
74.       
75.     }       
76.       
77.        
78.       
79.     /* Call this from the main Activity to send data to the remote device */       
80.       
81.     public void write(byte[] bytes) {       
82.       
83.         try {       
84.       
85.             mmOutStream.write(bytes);       
86.       
87.         } catch (IOException e) { }       
88.       
89.     }       
90.       
91.        
92.       
93.     /* Call this from the main Activity to shutdown the connection */       
94.       
95.     public void cancel() {       
96.       
97.         try {       
98.       
99.             mmSocket.close();       
100.       
101.         } catch (IOException e) { }       
102.       
103.     }       
104.       
105. }