Android蓝牙

最新推荐文章于 2024-05-01 23:11:44 发布

cding1818

最新推荐文章于 2024-05-01 23:11:44 发布

阅读量1.6k

点赞数

分类专栏： Android开发

本文链接：https://blog.csdn.net/linghu_java/article/details/43058449

版权

Android开发专栏收录该内容

294 篇文章 2 订阅

订阅专栏

Android平台支持蓝牙网络栈协议Bluetooth network stack，允许蓝牙设备之间交换数据。通过Bluetooth API，framework层提供访问蓝牙的功能。能够让蓝牙设备之间点到点连接或者多点连接。

Android应用可以做的：扫描其他蓝牙设备；配对的蓝牙设备间询问蓝牙适配器；建立RFCOMM 通道；通过服务发现连接其他设备；在设备间传输数据；管理多连接；

使用Classic Bluetooth，主要是电池敏感的设备上是不错的选择。Android从4.3（API 18）开始支持Bluetooth Low Energy（BLE）。

Android Bluetooth通讯需要完成4个主要步骤任务，开启蓝牙setting up Bluetooth、find devices局域范围发现设备，connecting devices连接设备，transfering data设备间传输数据。

蓝牙API包是android.bluetooth，下面是几个主要的类和接口：

BluetoothAdapter：蓝牙适配器是所有蓝牙交互的入口。通过这个类能发现其他蓝牙设备，查询绑定的蓝牙设备，用MAC地址初始化一个蓝牙设备，创建BluetoothServerSocket监听蓝牙设备的连接。

BluetoothDevice：代表一个远端蓝牙设备，使用它通过BluetoothSocket发起一个到远端设备的连接或者查询设备的名字、地址、类名和配对状态等信息。

BluetoothSocket：类似TCP的Socket的Bluetooth socket，通过inputStream和outputStream允许应用与其他蓝牙设备交换数据的连接点。

BluetoothServerSocket:：代表Server端socket用来监听请求，为了使两个android设备连接起来，一个设备必须open这个server socket。当远端设备发送一个连接请求到该设备，BluetoothServerSocket接受连接请求后会返回一个BluetoothSocket。

BluetoothClass：描述蓝牙设备的一般特性和功能。

BluetoothProfile：蓝牙的profile文件。

BluetoothHeadset：蓝牙耳机。

BluetoothA2dp：定义了一个设备到另一个设备的高质量音频传输流。

BluetoothHealth：控制蓝牙服务的设备描述文件的代理。

BluetoothHealthCallback：需要实现BluetoothHealth callback的抽象类。实现更新应用的注册状态和蓝牙channel状态。

BluetoothHealthAppConfiguration：应用配置

BluetoothProfile.ServiceListener：通知BluetoothProfile IPC client，连接或者断开。

Bluetooth Permissions

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

Setting up Bluetooth：

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter == null) {
    // Device does not support Bluetooth
}

if (!mBluetoothAdapter.isEnabled()) {
    Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}

onActivityResult() RESULT_OK RESULT_CANCELED

还可以监听广播 ACTION_STATE_CHANGED。

Finding Devices

发现，蓝牙设备会回复一个发现请求信息，包括name class MAC。通过这些信息设备才可以建立连接。

配对请求发送给蓝牙设备，配对成功以后name class MAC信息都会被保存起来。通过已知的MAC地址，连接可以在任何时候初始化不必执行discovery。

配对和连接是不同的，配对是两个设备意识到设备之间的存在，有一个共享的link-key用作认证并且可以建立加密的连接。连接意味着设备共享一个RFCOMM channel并且可以传输数据。必须先配对再连接。（当你执行一个加密连接的初始化配对会自动的执行）。

查询配对设备：

Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
// If there are paired devices
if (pairedDevices.size() > 0) {
    // Loop through paired devices
    for (BluetoothDevice device : pairedDevices) {
        // Add the name and address to an array adapter to show in a ListView
        mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
    }
}

startDiscovery（）12秒中的扫描时间，需要注册一个广播Action_found

// Create a BroadcastReceiver for ACTION_FOUND
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        // When discovery finds a device
        if (BluetoothDevice.ACTION_FOUND.equals(action)) {
            // Get the BluetoothDevice object from the Intent
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            // Add the name and address to an array adapter to show in a ListView
            mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
        }
    }
};
// Register the BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter); // Don't forget to unregister during onDestroy

执行设备发现是一个比较中的程序，需要消耗需要资源。而且如果你的设备已经连接了一个蓝牙设备后，如果再执行startDiscovery（）那么带宽将受到减小的影响。当然可以使用cancelDiscovery（）来取消发现操作。

可以设置发现蓝牙设备的时间，最长可以为3600s，如果设置成0则设备将总是处在发现。默认是120s。

Intent discoverableIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 100);
startActivity(discoverableIntent);

有个dialog提示用户允许蓝牙设备发现，如果用户同意，那之后就会执行蓝牙发现，再之后就会回调Activity的onActivityResult()；如果用户不同意或者错误发生了，则会回调RESULT_CANCELED的resultcode。

如果蓝牙设备没有开启，那么enable设备发现则会自动开启。

之后蓝牙就一直处于发现模式，你可以注册Action_scan_mode_changed的BroadcastReceiver，

SCAN_MODE_CONNECTABLE_DISCOVERABLE、SCAN_MODE_CONNECTABLE,或SCAN_MODE_NONE分别是发现模式、不在发现模式但仍然可以接受链接、不在发现模式也不能接受链接。

2.连接设备

通过你的应用产生一个蓝牙设备连接，必须实现CS机制，一个设备打开server socket而另一个设备要初始化连接。

server端和client端每一端通过不同的方式获取BluetoothSocket。

不想TCP/IP，RFCOMM一个channel只允许一个连接。accept不能在UI线程上执行

private class AcceptThread extends Thread {
    private final BluetoothServerSocket mmServerSocket;
 
    public AcceptThread() {
        // Use a temporary object that is later assigned to mmServerSocket,
        // because mmServerSocket is final
        BluetoothServerSocket tmp = null;
        try {
            // MY_UUID is the app's UUID string, also used by the client code
            tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
        } catch (IOException e) { }
        mmServerSocket = tmp;
    }
 
    public void run() {
        BluetoothSocket socket = null;
        // Keep listening until exception occurs or a socket is returned
        while (true) {
            try {
                socket = mmServerSocket.accept();
            } catch (IOException e) {
                break;
            }
            // If a connection was accepted
            if (socket != null) {
                // Do work to manage the connection (in a separate thread)
                manageConnectedSocket(socket);
                mmServerSocket.close();
                break;
            }
        }
    }
 
    /** Will cancel the listening socket, and cause the thread to finish */
    public void cancel() {
        try {
            mmServerSocket.close();
        } catch (IOException e) { }
    }
}

private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
 
    public ConnectThread(BluetoothDevice device) {
        // Use a temporary object that is later assigned to mmSocket,
        // because mmSocket is final
        BluetoothSocket tmp = null;
        mmDevice = device;
 
        // Get a BluetoothSocket to connect with the given BluetoothDevice
        try {
            // MY_UUID is the app's UUID string, also used by the server code
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) { }
        mmSocket = tmp;
    }
 
    public void run() {
        // Cancel discovery because it will slow down the connection
        mBluetoothAdapter.cancelDiscovery();
 
        try {
            // Connect the device through the socket. This will block
            // until it succeeds or throws an exception
            mmSocket.connect();
        } catch (IOException connectException) {
            // Unable to connect; close the socket and get out
            try {
                mmSocket.close();
            } catch (IOException closeException) { }
            return;
        }
 
        // Do work to manage the connection (in a separate thread)
        manageConnectedSocket(mmSocket);
    }
 
    /** Will cancel an in-progress connection, and close the socket */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;
 
    public ConnectedThread(BluetoothSocket socket) {
        mmSocket = socket;
        InputStream tmpIn = null;
        OutputStream tmpOut = null;
 
        // Get the input and output streams, using temp objects because
        // member streams are final
        try {
            tmpIn = socket.getInputStream();
            tmpOut = socket.getOutputStream();
        } catch (IOException e) { }
 
        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }
 
    public void run() {
        byte[] buffer = new byte[1024];  // buffer store for the stream
        int bytes; // bytes returned from read()
 
        // Keep listening to the InputStream until an exception occurs
        while (true) {
            try {
                // Read from the InputStream
                bytes = mmInStream.read(buffer);
                // Send the obtained bytes to the UI activity
                mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                break;
            }
        }
    }
 
    /* Call this from the main activity to send data to the remote device */
    public void write(byte[] bytes) {
        try {
            mmOutStream.write(bytes);
        } catch (IOException e) { }
    }
 
    /* Call this from the main activity to shutdown the connection */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

BluetoothHeadset mBluetoothHeadset;
 
// Get the default adapter
BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
 
// Establish connection to the proxy.
mBluetoothAdapter.getProfileProxy(context, mProfileListener, BluetoothProfile.HEADSET);
 
private BluetoothProfile.ServiceListener mProfileListener = new BluetoothProfile.ServiceListener() {
    public void onServiceConnected(int profile, BluetoothProfile proxy) {
        if (profile == BluetoothProfile.HEADSET) {
            mBluetoothHeadset = (BluetoothHeadset) proxy;
        }
    }
    public void onServiceDisconnected(int profile) {
        if (profile == BluetoothProfile.HEADSET) {
            mBluetoothHeadset = null;
        }
    }
};
 
// ... call functions on mBluetoothHeadset
 
// Close proxy connection after use.
mBluetoothAdapter.closeProfileProxy(mBluetoothHeadset);

更系统点介绍如下：（以下部分转载自http://blog.csdn.net/gd920129/article/details/7487761）

1. 使用蓝牙的相应权限

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

2. 配置本机蓝牙模块

在这里首先要了解对蓝牙操作一个核心类BluetoothAdapter

 
        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();  
       
        //直接打开系统的蓝牙设置面板  
       
        Intent intent =  
        new 
         Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);  
       
        startActivityForResult(intent,  
        0x1 
        );  
       
        //直接打开蓝牙  
       
        adapter.enable();  
       
        //关闭蓝牙  
       
        adapter.disable();  
       
        //打开本机的蓝牙发现功能（默认打开120秒，可以将时间最多延长至300秒）  
       
        discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,  
        300 
        ); 
        //设置持续时间（最多300秒）Intent discoveryIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);

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来接收响应的广播，以便实现某些功能

 
        // 创建一个接收ACTION_FOUND广播的BroadcastReceiver  
       
        private 
         final 
         BroadcastReceiver mReceiver =  
        new 
         BroadcastReceiver() {  
       
        public 
         void 
         onReceive(Context context, Intent intent) {  
       
        String action = intent.getAction();  
       
        // 发现设备  
       
        if 
         (BluetoothDevice.ACTION_FOUND.equals(action)) {  
       
        // 从Intent中获取设备对象  
       
        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);  
       
        // 将设备名称和地址放入array adapter，以便在ListView中显示  
       
        mArrayAdapter.add(device.getName() +  
        "\n" 
         + device.getAddress());  
       
        }  
       
        }  
       
        };  
       
        // 注册BroadcastReceiver  
       
        IntentFilter filter =  
        new 
         IntentFilter(BluetoothDevice.ACTION_FOUND);  
       
        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）

 
        private 
         class 
         AcceptThread  
        extends 
         Thread { 
       
        private 
         final 
         BluetoothServerSocket mmServerSocket; 
       
        public 
         AcceptThread() { 
       
        // Use a temporary object that is later assigned to mmServerSocket, 
       
        // because mmServerSocket is final 
       
        BluetoothServerSocket tmp =  
        null 
        ; 
       
        try 
         { 
       
        // MY_UUID is the app's UUID string, also used by the client code 
       
        tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID); 
       
        }  
        catch 
         (IOException e) { } 
       
        mmServerSocket = tmp; 
       
        } 
       
        public 
         void 
         run() { 
       
        BluetoothSocket socket =  
        null 
        ; 
       
        // Keep listening until exception occurs or a socket is returned 
       
        while 
         ( 
        true 
        ) { 
       
        try 
         { 
       
        socket = mmServerSocket.accept(); 
       
        }  
        catch 
         (IOException e) { 
       
        break 
        ; 
       
        } 
       
        // If a connection was accepted 
       
        if 
         (socket !=  
        null 
        ) { 
       
        // Do work to manage the connection (in a separate thread) 
       
        manageConnectedSocket(socket); 
       
        mmServerSocket.close(); 
       
        break 
        ; 
       
        } 
       
        } 
       
        } 
       
        /** Will cancel the listening socket, and cause the thread to finish */ 
       
        public 
         void 
         cancel() { 
       
        try 
         { 
       
        mmServerSocket.close(); 
       
        }  
        catch 
         (IOException e) { } 
       
        } 
       
        }

客户端的实现

通过搜索得到服务器端的BluetoothService

调用BluetoothService的listenUsingRfcommWithServiceRecord(String, UUID)方法获取BluetoothSocket（该UUID应该同于服务器端的UUID）

调用BluetoothSocket的connect()方法（该方法为block方法），如果UUID同服务器端的UUID匹配，并且连接被服务器端accept，则connect()方法返回

注意：在调用connect()方法之前，应当确定当前没有搜索设备，否则连接会变得非常慢并且容易失败

 
        <strong>     
        private 
         class 
         ConnectThread  
        extends 
         Thread {  
       
        private 
         final 
         BluetoothSocket mmSocket;  
       
        private 
         final 
         BluetoothDevice mmDevice;  
       
        public 
         ConnectThread(BluetoothDevice device) {  
       
        // Use a temporary object that is later assigned to mmSocket,  
       
        // because mmSocket is final  
       
        BluetoothSocket tmp =  
        null 
        ;  
       
        mmDevice = device;  
       
        // Get a BluetoothSocket to connect with the given BluetoothDevice  
       
        try 
         {  
       
        // MY_UUID is the app's UUID string, also used by the server code  
       
        tmp = device.createRfcommSocketToServiceRecord(MY_UUID);  
       
        }  
        catch 
         (IOException e) { }  
       
        mmSocket = tmp;  
       
        }  
       
        public 
         void 
         run() {  
       
        // Cancel discovery because it will slow down the connection  
       
        mBluetoothAdapter.cancelDiscovery();  
       
        try 
         {  
       
        // Connect the device through the socket. This will block  
       
        // until it succeeds or throws an exception  
       
        mmSocket.connect();  
       
        }  
        catch 
         (IOException connectException) {  
       
        // Unable to connect; close the socket and get out  
       
        try 
         {  
       
        mmSocket.close();  
       
        }  
        catch 
         (IOException closeException) { }  
       
        return 
        ;  
       
        }  
       
        // Do work to manage the connection (in a separate thread)  
       
        manageConnectedSocket(mmSocket);  
       
        }  
       
        /** Will cancel an in-progress connection, and close the socket */  
       
        public 
         void 
         cancel() {  
       
        try 
         {  
       
        mmSocket.close();  
       
        }  
        catch 
         (IOException e) { }  
       
        }  
       
        }  </strong>

连接管理（数据通信）

分别通过BluetoothSocket的getInputStream()和getOutputStream()方法获取InputStream和OutputStream

使用read(bytes[])和write(bytes[])方法分别进行读写操作

注意：read(bytes[])方法会一直block，知道从流中读取到信息，而write(bytes[])方法并不是经常的block（比如在另一设备没有及时read或者中间缓冲区已满的情况下，write方法会block）

 
        <strong>     
        private 
         class 
         ConnectedThread  
        extends 
         Thread {  
       
        private 
         final 
         BluetoothSocket mmSocket;  
       
        private 
         final 
         InputStream mmInStream;  
       
        private 
         final 
         OutputStream mmOutStream;  
       
        public 
         ConnectedThread(BluetoothSocket socket) {  
       
        mmSocket = socket;  
       
        InputStream tmpIn =  
        null 
        ;  
       
        OutputStream tmpOut =  
        null 
        ;  
       
        // Get the input and output streams, using temp objects because  
       
        // member streams are final  
       
        try 
         {  
       
        tmpIn = socket.getInputStream();  
       
        tmpOut = socket.getOutputStream();  
       
        }  
        catch 
         (IOException e) { }  
       
        mmInStream = tmpIn;  
       
        mmOutStream = tmpOut;  
       
        }  
       
        public 
         void 
         run() {  
       
        byte 
        [] buffer =  
        new 
         byte 
        [ 
        1024 
        ];   
        // buffer store for the stream  
       
        int 
         bytes;  
        // bytes returned from read()  
       
        // Keep listening to the InputStream until an exception occurs  
       
        while 
         ( 
        true 
        ) {  
       
        try 
         {  
       
        // Read from the InputStream  
       
        bytes = mmInStream.read(buffer);  
       
        // Send the obtained bytes to the UI Activity  
       
        mHandler.obtainMessage(MESSAGE_READ, bytes, - 
        1 
        , buffer)  
       
        .sendToTarget();  
       
        }  
        catch 
         (IOException e) {  
       
        break 
        ;  
       
        }  
       
        }  
       
        }  
       
        /* Call this from the main Activity to send data to the remote device */  
       
        public void write(byte[] bytes) {  
       
        try {  
       
        mmOutStream.write(bytes);  
       
        } catch (IOException e) { }  
       
        }  
       
        /* Call this from the main Activity to shutdown the connection */  
       
        public 
         void 
         cancel() {  
       
        try 
         {  
       
        mmSocket.close();  
       
        }  
        catch 
         (IOException e) { }  
       
        }  
       
        }  </strong>

cding1818

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Android蓝牙

Android平台支持蓝牙网络栈协议Bluetooth network stack，允许蓝牙设备之间交换数据。通过Bluetooth API，framework层提供访问蓝牙的功能。能够让蓝牙设备之间点到点连接或者多点连接。Android应用可以做的：扫描其他蓝牙设备；配对的蓝牙设备间询问蓝牙适配器；建立RFCOMM 通道；通过服务发现连接其他设备；在设备间传输数据；管理多连接；
复制链接

扫一扫

专栏目录