您的位置：首页 > 移动开发 > Android开发

Android中蓝牙模块的使用

2016-05-05 09:32 435 查看
1. 使用蓝牙的响应权限
1
<uses-permission
android:name=
"android.permission.BLUETOOTH"
/>
2
<uses-permission
android:name=
"android.permission.BLUETOOTH_ADMIN"
/>
2. 配置本机蓝牙模块在这里首先要了解对蓝牙操作一个核心类BluetoothAdapter
01
BluetoothAdapter
adapter = BluetoothAdapter.getDefaultAdapter();
02
//直接打开系统的蓝牙设置面板
03
Intent
intent =
new
Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
04
startActivityForResult(intent,
0x1
);
05
//直接打开蓝牙
06
adapter.enable();
07
//关闭蓝牙
08
adapter.disable();
09
//打开本机的蓝牙发现功能（默认打开120秒，可以将时间最多延长至300秒）
10
Intent
discoveryIntent =
new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
11
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来接收响应的广播，以便实现某些功能
01
//
创建一个接收ACTION_FOUND广播的BroadcastReceiver
02
private
final
 
BroadcastReceiver mReceiver =
new
BroadcastReceiver() {
03
public
void
 
onReceive(Context context, Intent intent) {  
04
Stringaction = intent.getAction();
05
//发现设备  
06
if
(BluetoothDevice.ACTION_FOUND.equals(action)) {  
07
//从Intent中获取设备对象  
08
BluetoothDevicedevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
09
//将设备名称和地址放入array adapter，以便在ListView中显示  
10
mArrayAdapter.add(device.getName()+ 
"\n"
+ device.getAddress());
11
}
12
}
13
};
14
//注册BroadcastReceiver  
15
IntentFilterfilter = 
new
IntentFilter(BluetoothDevice.ACTION_FOUND);
16
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）
01
private
class
 
AcceptThread 
extends
Thread {  
02
private
final
 
BluetoothServerSocket mmServerSocket; 
03
public
AcceptThread() {  
04
//Use a temporary object that is later assigned to mmServerSocket,  
05
//because mmServerSocket is final  
06
BluetoothServerSockettmp = 
null
;
07
try
{  
08
//MY_UUID is the app's UUID string, also used by the client code  
09
tmp= mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
10
}
catch
(IOException e) { }
11
mmServerSocket= tmp;
12
}
13
public
void
 
run() {  
14
BluetoothSocketsocket = 
null
;
15
//Keep listening until exception occurs or a socket is returned  
16
while
(
true
){  
17
try
{  
18
socket= mmServerSocket.accept();
19
}
catch
(IOException e) {  
20
break
;
21
}
22
//If a connection was accepted  
23
if
(socket != 
null
){  
24
//Do work to manage the connection (in a separate thread)  
25
manageConnectedSocket(socket);
26
mmServerSocket.close();
27
break
;
28
}
29
}
30
}
31
/**Will cancel the listening socket, and cause the thread to finish */
  
32
public
void
 
cancel() {  
33
try
{  
34
mmServerSocket.close();
35
}
catch
(IOException e) { }
36
}
37
}
客户端的实现通过搜索得到服务器端的BluetoothService调用BluetoothService的listenUsingRfcommWithServiceRecord(String, UUID)方法获取BluetoothSocket（该UUID应该同于服务器端的UUID）调用BluetoothSocket的connect()方法（该方法为block方法），如果UUID同服务器端的UUID匹配，并且连接被服务器端accept，则connect()方法返回注意：在调用connect()方法之前，应当确定当前没有搜索设备，否则连接会变得非常慢并且容易失败
01
private
class
 
ConnectThread 
extends
Thread {  
02
private
final
 
BluetoothSocket mmSocket;
03
private
final
 
BluetoothDevice mmDevice;
04
 
05
public
ConnectThread(BluetoothDevice device) {  
06
//Use a temporary object that is later assigned to mmSocket,  
07
//because mmSocket is final  
08
BluetoothSockettmp = 
null
;
09
mmDevice= device; 
10
//Get a BluetoothSocket to connect with the given BluetoothDevice  
11
try
{  
12
//MY_UUID is the app's UUID string, also used by the server code  
13
tmp= device.createRfcommSocketToServiceRecord(MY_UUID);
14
}
catch
(IOException e) { }
15
mmSocket= tmp;
16
}
17
public
void
 
run() {  
18
//Cancel discovery because it will slow down the connection  
19
mBluetoothAdapter.cancelDiscovery();
20
 
21
try
{  
22
//Connect the device through the socket. This will block  
23
//until it succeeds or throws an exception  
24
mmSocket.connect();
25
}
catch
(IOException connectException) {  
26
//Unable to connect; close the socket and get out  
27
try
{  
28
mmSocket.close();
29
}
catch
(IOException closeException) { }
30
return
;
31
}
32
//Do work to manage the connection (in a separate thread)  
33
manageConnectedSocket(mmSocket);
34
}
35
/**Will cancel an in-progress connection, and close the socket */
  
36
public
void
 
cancel() {  
37
try
{  
38
mmSocket.close();
39
}
catch
(IOException e) { }
40
}
41
}
4.连接管理（数据通信）分别通过BluetoothSocket的getInputStream()和getOutputStream()方法获取InputStream和OutputStream使用read(bytes[])和write(bytes[])方法分别进行读写操作注意：read(bytes[])方法会一直block，知道从流中读取到信息，而write(bytes[])方法并不是经常的block（比如在另一设备没有及时read或者中间缓冲区已满的情况下，write方法会block）
预览源代码打印
01
private
class
 
ConnectedThread 
extends
Thread {  
02
private
final
 
BluetoothSocket mmSocket;
03
private
final
 
InputStream mmInStream;
04
private
final
 
OutputStream mmOutStream; 
05
public
ConnectedThread(BluetoothSocket socket) {  
06
mmSocket= socket;
07
InputStreamtmpIn = 
null
;
08
OutputStreamtmpOut = 
null
;
09
//Get the input and output streams, using temp objects because  
10
//member streams are final  
11
try
{  
12
tmpIn= socket.getInputStream();
13
tmpOut= socket.getOutputStream();
14
}
catch
(IOException e) { } 
15
mmInStream= tmpIn;
16
mmOutStream= tmpOut;
17
}
18
public
void
 
run() {  
19
byte
[]buffer = 
new
byte
[
1024
];
//buffer store for the stream  
20
int
bytes; 
//bytes returned from read() 
21
//Keep listening to the InputStream until an exception occurs  
22
while
(
true
){  
23
try
{  
24
//Read from the InputStream  
25
bytes= mmInStream.read(buffer);
26
//Send the obtained bytes to the UI Activity  
27
mHandler.obtainMessage(MESSAGE_READ,bytes, -
1
,buffer)  
28
.sendToTarget();
29
}
catch
(IOException e) {  
30
break
;
31
}
32
}
33
}
34
/*Call this from the main Activity to send data to the remote device */  
35
publicvoid write(byte[] bytes) {  
36
try{  
37
mmOutStream.write(bytes);
38
}catch (IOException e) { }
39
}
40
/*Call this from the main Activity to shutdown the connection */
  
41
public
void
 
cancel() {  
42
try
{  
43
mmSocket.close();
44
}
catch
(IOException e) { }
45
}
46
}

                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航