【Android】蓝牙开发——BLE（低功耗蓝牙）（附完整Demo）

最新推荐文章于 2024-09-22 04:58:30 发布
最新推荐文章于 2024-09-22 04:58:30 发布
阅读量3.8k 收藏 37
点赞数 2
分类专栏： # Android开发之蓝牙 文章标签： android 蓝牙 Bluetooth
原文链接：https://blog.csdn.net/qq_38950819/article/details/103067487
版权

原文出处

标题：【Android】蓝牙开发——BLE（低功耗蓝牙）（附完整Demo）

作者：摸爬滚打的程序媛

原文链接：【Android】蓝牙开发——BLE（低功耗蓝牙）（附完整Demo）_android ble 蓝牙开发-CSDN博客

前言

之前的几篇文章，主要介绍了经典蓝牙开发相关的知识，今天我们就来看看低功耗蓝牙的开发。如果小伙伴们对之前的文章感兴趣兴趣，也可以看看，欢迎提出不足或者建议。

【Android】蓝牙开发——经典蓝牙（附Demo源码）

【Android】蓝牙开发——经典蓝牙配对介绍（通过手机系统蓝牙演示）

【Android】蓝牙开发—— 经典蓝牙配对介绍（Java代码实现演示）附Demo源码

一、相关概念介绍

BLE，全称 Bluetooth Low Energy，即低功耗蓝牙。BLE关键术语和概念，可以查看官网介绍：

蓝牙低功耗概览  |  Android 开发者  |  Android Developers

首先，我们需要知道，BLE设备有以下几个方面的东西：

1、一个BLE设备包含多个服务，这些服务通过UUID来区分。

2、一个服务包含1个或多个特征，这些特征也是通过UUID来区分。

3、一个特征包含一个Value和多个描述符，一个描述符包含一个Value，

其次，我们来看一看Android中BLE相关的对象：

1、BluetoothDevice ：蓝牙设备

2、BluetoothGatt：建立的连接

3、BluetoothGattCallback：连接回调

3、BluetoothGattService：服务

4、BluetoothGattCharacteristic：服务的特征

5、BluetoothGattDescriptor：特征的描述

了解了这些之后，我们开始进入BLE开发阶段。

二、实战开发

注意：BLE是在Android 4.3(API 18)以后引入的，所以要进行BLE开发，必须在Android 4.3以上版本的机子上。

1、添加相关权限

（1）蓝牙权限

<!-- 应用使用蓝牙的权限 -->
<uses-permission android:name="android.permission.BLUETOOTH"/>
<!--启动设备发现或操作蓝牙设置的权限-->
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>

（2）位置权限

（BLE与经典蓝牙相比，还需要位置权限，如果没有，有的机型是扫描不到设备的，注意Android6.0以后还需要动态申请位置权限）

<!--位置权限-->
<!--Android 10以上系统，需要ACCESS_FINE_LOCATION-->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<!--Android 9以及以下系统，需要ACCESS_FINE_LOCATION-->
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

2、使用蓝牙之前，首先要检查当前手机是否支持BLE蓝牙。

如果支持BLE蓝牙，检查手机蓝牙是否已开启。如果没有开启，则需要先打开蓝牙。打开手机蓝牙，有两种方式，一种是直接enable()打开，另外一种是提示用户打开，推荐第二种方式。

 /**
     * 检测手机是否支持4.0蓝牙
     * @param context  上下文
     * @return true--支持4.0  false--不支持4.0
     */
    private boolean checkBle(Context context){
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {  //API 18 Android 4.3
            bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
            if(bluetoothManager == null){
                return false;
            }
            bluetooth4Adapter = bluetoothManager.getAdapter();  //BLUETOOTH权限
            if(bluetooth4Adapter == null){
                return false;
            }else{
                Log.d(TAG,"该设备支持蓝牙4.0");
                return true;
            }
        }else{
            return false;
        }
    }
/**
     * 获取蓝牙状态
     */
    public boolean isEnable(){
        if(bluetooth4Adapter == null){
            return false;
        }
        return bluetooth4Adapter.isEnabled();
    }
 
    /**
     * 打开蓝牙
     * @param isFast  true 直接打开蓝牙  false 提示用户打开
     */
    public void openBluetooth(Context context,boolean isFast){
        if(!isEnable()){
            if(isFast){
                Log.d(TAG,"直接打开手机蓝牙");
                bluetooth4Adapter.enable();  //BLUETOOTH_ADMIN权限
            }else{
                Log.d(TAG,"提示用户去打开手机蓝牙");
                Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                context.startActivity(enableBtIntent);
            }
        }else{
            Log.d(TAG,"手机蓝牙状态已开");
        }
    }

3、系统蓝牙已打开，则可以开启扫描设备。

需要注意的是，扫描设备是耗时的操作，一旦扫描结束，就要及时停止扫描。

  扫描设备  ///
    //扫描设备回调
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
    private BluetoothAdapter.LeScanCallback leScanCallback = new BluetoothAdapter.LeScanCallback() {
        @Override
        public void onLeScan(BluetoothDevice bluetoothDevice, int rssi, byte[] bytes) {
            //在onLeScan()回调中尽量做少的操作，可以将扫描到的设备扔到另一个线程中处理
            if(bluetoothDevice == null)
                return;
 
            if(bluetoothDevice.getName() != null){
                Log.d(TAG,bluetoothDevice.getName() + "-->" + bluetoothDevice.getAddress());
            }else{
                Log.d(TAG,"null" + "-->" + bluetoothDevice.getAddress());
            }
            BLEDevice bleDevice = new BLEDevice(bluetoothDevice,rssi);
            if(onDeviceSearchListener != null){
                onDeviceSearchListener.onDeviceFound(bleDevice);  //扫描到设备回调
            }
        }
    };
 
    /**
     * 设置时间段 扫描设备
     * @param onDeviceSearchListener  设备扫描监听
     * @param scanTime  扫描时间
     */
    public void startDiscoveryDevice(OnDeviceSearchListener onDeviceSearchListener,long scanTime){
        if(bluetooth4Adapter == null){
            Log.e(TAG,"startDiscoveryDevice-->bluetooth4Adapter == null");
            return;
        }
 
        this.onDeviceSearchListener = onDeviceSearchListener;
        if(onDeviceSearchListener != null){
            onDeviceSearchListener.onDiscoveryStart();  //开始扫描回调
        }
 
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            Log.d(TAG,"开始扫描设备");
            bluetooth4Adapter.startLeScan(leScanCallback);
 
        }else{
            return;
        }
 
        //设定最长扫描时间
        mHandler.postDelayed(stopScanRunnable,scanTime);
    }
 
    private Runnable stopScanRunnable = new Runnable() {
        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
        @Override
        public void run() {
            if(onDeviceSearchListener != null){
                onDeviceSearchListener.onDiscoveryOutTime();  //扫描超时回调
            }
            //scanTime之后还没有扫描到设备，就停止扫描。
            stopDiscoveryDevice();
        }
    };

4、扫描到目标设备之后，开始建立连接

这里注意，连接之前一定要关闭扫描，否则会影响连接。BLE与经典蓝牙不同，经典蓝牙一旦建立连接，就可以进行数据通讯，而BLE建立连接之后，还需要发现系统服务，获取特定服务及读写特征。

（1）建立连接 & 发现系统服务

/  执行连接  //
    //连接/通讯结果回调
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
    private BluetoothGattCallback bluetoothGattCallback = new BluetoothGattCallback() {
        @Override
        public void onPhyUpdate(BluetoothGatt gatt, int txPhy, int rxPhy, int status) {
            super.onPhyUpdate(gatt, txPhy, rxPhy, status);
        }
 
        @Override
        public void onPhyRead(BluetoothGatt gatt, int txPhy, int rxPhy, int status) {
            super.onPhyRead(gatt, txPhy, rxPhy, status);
        }
 
        //连接状态回调-连接成功/断开连接
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            super.onConnectionStateChange(gatt, status, newState);
            Log.d(TAG,"status:" + status);
            Log.d(TAG,"newState:" + newState);
 
            switch(status){
                case BluetoothGatt.GATT_SUCCESS:
                    Log.w(TAG,"BluetoothGatt.GATT_SUCCESS");
                    break;
                case BluetoothGatt.GATT_FAILURE:
                    Log.w(TAG,"BluetoothGatt.GATT_FAILURE");
                    break;
                case BluetoothGatt.GATT_CONNECTION_CONGESTED:
                    Log.w(TAG,"BluetoothGatt.GATT_CONNECTION_CONGESTED");
                    break;
                case BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION:
                    Log.w(TAG,"BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION");
                    break;
                case BluetoothGatt.GATT_INSUFFICIENT_ENCRYPTION:
                    Log.w(TAG,"BluetoothGatt.GATT_INSUFFICIENT_ENCRYPTION");
                    break;
                case BluetoothGatt.GATT_INVALID_OFFSET:
                    Log.w(TAG,"BluetoothGatt.GATT_INVALID_OFFSET");
                    break;
                case BluetoothGatt.GATT_READ_NOT_PERMITTED:
                    Log.w(TAG,"BluetoothGatt.GATT_READ_NOT_PERMITTED");
                    break;
                case BluetoothGatt.GATT_REQUEST_NOT_SUPPORTED:
                    Log.w(TAG,"BluetoothGatt.GATT_REQUEST_NOT_SUPPORTED");
                    break;
            }
 
            BluetoothDevice bluetoothDevice = gatt.getDevice();
            Log.d(TAG,"连接的设备：" + bluetoothDevice.getName() + "  " + bluetoothDevice.getAddress());
 
            isConnectIng = false;
            //移除连接超时
            mHandler.removeCallbacks(connectOutTimeRunnable);
 
            if(newState == BluetoothGatt.STATE_CONNECTED){
                Log.w(TAG,"连接成功");
                //连接成功去发现服务
                gatt.discoverServices();
                //设置发现服务超时时间
                mHandler.postDelayed(serviceDiscoverOutTimeRunnable,MAX_CONNECT_TIME);
 
                if(onBleConnectListener != null){
                    onBleConnectListener.onConnectSuccess(gatt,bluetoothDevice,status);   //连接成功回调
                }
            }else if(newState == BluetoothGatt.STATE_DISCONNECTED) {
                //清空系统缓存
                ClsUtils.refreshDeviceCache(gatt);
                Log.e(TAG, "断开连接status:" + status);
                gatt.close();  //断开连接释放连接
 
                if(status == 133){
                    //无法连接
                    if(onBleConnectListener != null){
                        onBleConnectListener.onConnectFailure(gatt,bluetoothDevice,"连接异常！",status);  //133连接异常 异常断开
                        Log.e(TAG,"连接失败status：" + status + "  " + bluetoothDevice.getAddress());
                    }
                }else if(status == 62){
                    //成功连接没有发现服务断开
                    if(onBleConnectListener != null){
                        onBleConnectListener.onConnectFailure(gatt,bluetoothDevice,"连接成功服务未发现断开！",status); //62没有发现服务 异常断开
                        Log.e(TAG,"连接成功服务未发现断开status:" + status);
                    }
 
                }else if(status == 0){
                    if(onBleConnectListener != null){
                        onBleConnectListener.onDisConnectSuccess(gatt,bluetoothDevice,status); //0正常断开 回调
                    }
                }else if(status == 8){
                    //因为距离远或者电池无法供电断开连接
                    // 已经成功发现服务
                    if(onBleConnectListener != null){
                        onBleConnectListener.onDisConnectSuccess(gatt,bluetoothDevice,status); //8断电断开  回调
                    }
                }else if(status == 34){
                    if(onBleConnectListener != null){
                        onBleConnectListener.onDisConnectSuccess(gatt,bluetoothDevice,status); //34断开
                    }
                }else {
                    //其它断开连接
                    if(onBleConnectListener != null){
                        onBleConnectListener.onDisConnectSuccess(gatt,bluetoothDevice,status); //其它断开
                    }
                }
            }else if(newState == BluetoothGatt.STATE_CONNECTING){
                Log.d(TAG,"正在连接...");
                if(onBleConnectListener != null){
                    onBleConnectListener.onConnecting(gatt,bluetoothDevice);  //正在连接回调
                }
            }else if(newState == BluetoothGatt.STATE_DISCONNECTING){
                Log.d(TAG,"正在断开...");
                if(onBleConnectListener != null){
                    onBleConnectListener.onDisConnecting(gatt,bluetoothDevice); //正在断开回调
                }
            }
        }
 
        //发现服务
        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            super.onServicesDiscovered(gatt, status);
            //移除发现服务超时
            mHandler.removeCallbacks(serviceDiscoverOutTimeRunnable);
            Log.d(TAG,"移除发现服务超时");
 
            Log.d(TAG,"发现服务");
 
            //获取特定服务及特征
            if(setupService(gatt,serviceUUID,readUUID,writeUUID)){
                if(onBleConnectListener != null){
                    onBleConnectListener.onServiceDiscoverySucceed(gatt,gatt.getDevice(),status);  //成功发现服务回调
                }
            }else{
                if(onBleConnectListener != null){
                    onBleConnectListener.onServiceDiscoveryFailed(gatt,gatt.getDevice(),"获取服务特征异常");  //发现服务失败回调
                }
            }
            }
        }
 
        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicRead(gatt, characteristic, status);
            Log.d(TAG,"读status: " + status);
        }
 
        //向蓝牙设备写入数据结果回调
        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicWrite(gatt, characteristic, status);
 
            if(characteristic.getValue() == null){
                Log.e(TAG,"characteristic.getValue() == null");
                return;
            }
            //将收到的字节数组转换成十六进制字符串
            String msg = TypeConversion.bytes2HexString(characteristic.getValue(),characteristic.getValue().length);
            if(status == BluetoothGatt.GATT_SUCCESS){
                //写入成功
                Log.w(TAG,"写入成功：" + msg);
                if(onBleConnectListener != null){
                    onBleConnectListener.onWriteSuccess(gatt,gatt.getDevice(),characteristic.getValue());  //写入成功回调
                }
 
            }else if(status == BluetoothGatt.GATT_FAILURE){
                //写入失败
                Log.e(TAG,"写入失败：" + msg);
                if(onBleConnectListener != null){
                    onBleConnectListener.onWriteFailure(gatt,gatt.getDevice(),characteristic.getValue(),"写入失败");  //写入失败回调
                }
            }else if(status == BluetoothGatt.GATT_WRITE_NOT_PERMITTED){
                //没有权限
                Log.e(TAG,"没有权限！");
            }
        }
 
        //读取蓝牙设备发出来的数据回调
        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            super.onCharacteristicChanged(gatt, characteristic);
 
            //接收数据
            byte[] bytes = characteristic.getValue();
            Log.w("TAG","收到数据str:" + TypeConversion.bytes2HexString(bytes,bytes.length));
            if(onBleConnectListener != null){
                onBleConnectListener.onReceiveMessage(gatt,gatt.getDevice(),characteristic,characteristic.getValue());  //接收数据回调
            }
        }
 
        @Override
        public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
            super.onDescriptorRead(gatt, descriptor, status);
        }
 
        @Override
        public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
            super.onDescriptorWrite(gatt, descriptor, status);
        }
 
        @Override
        public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
            super.onReliableWriteCompleted(gatt, status);
            Log.d(TAG,"onReliableWriteCompleted");
        }
        
        @Override
        public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
            super.onReadRemoteRssi(gatt, rssi, status);
            if(status == BluetoothGatt.GATT_SUCCESS){
                Log.w(TAG,"读取RSSI值成功，RSSI值：" + rssi + ",status" + status);
                if(onBleConnectListener != null){
                    onBleConnectListener.onReadRssi(gatt,rssi,status);  //成功读取连接的信号强度回调
                }
            }else if(status == BluetoothGatt.GATT_FAILURE){
                Log.w(TAG,"读取RSSI值失败，status：" + status);
            }
        }
 
        //修改MTU值结果回调
        @Override
        public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
            super.onMtuChanged(gatt, mtu, status);
            ///设置mtu值，即bluetoothGatt.requestMtu()时触发，提示该操作是否成功
            if(status == BluetoothGatt.GATT_SUCCESS){  //设置MTU成功  
                //MTU默认取的是23，当收到 onMtuChanged 后，会根据传递的值修改MTU，注意由于传输用掉3字节，因此传递的值需要减3。
                //mtu - 3
                Log.w(TAG,"设置MTU成功，新的MTU值：" + (mtu-3) + ",status" + status);
                if(onBleConnectListener != null){
                    onBleConnectListener.onMTUSetSuccess("设置后新的MTU值 = " + (mtu-3) + "   status = " + status,mtu - 3);  //MTU设置成功
                }
 
            }else if(status == BluetoothGatt.GATT_FAILURE){  //设置MTU失败  
                Log.e(TAG,"设置MTU值失败：" + (mtu-3) + ",status" + status);
                if(onBleConnectListener != null){
                    onBleConnectListener.onMTUSetFailure("设置MTU值失败：" + (mtu-3) + "   status：" + status);  //MTU设置失败
                }
            }
 
        }
    };
 
    /**
     * 通过蓝牙设备连接
     * @param context  上下文
     * @param bluetoothDevice  蓝牙设备
     * @param outTime          连接超时时间
     * @param onBleConnectListener  蓝牙连接监听者
     * @return
     */
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
    public BluetoothGatt connectBleDevice(Context context, BluetoothDevice bluetoothDevice, long outTime,OnBleConnectListener onBleConnectListener){
        if(bluetoothDevice == null){
            Log.e(TAG,"addBLEConnectDevice-->bluetoothDevice == null");
            return null;
        }
 
        this.onBleConnectListener = onBleConnectListener;
 
        this.curConnDevice = bluetoothDevice;
        Log.d(TAG,"开始准备连接：" + bluetoothDevice.getName() + "-->" + bluetoothDevice.getAddress());
        //出现 BluetoothGatt.android.os.DeadObjectException 蓝牙没有打开
        try{
            if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
                mBluetoothGatt = bluetoothDevice.connectGatt(context, false, bluetoothGattCallback,
                        BluetoothDevice.TRANSPORT_LE,BluetoothDevice.PHY_LE_1M_MASK);
            }else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                mBluetoothGatt = bluetoothDevice.connectGatt(context, false, bluetoothGattCallback,
                        BluetoothDevice.TRANSPORT_LE);
            } else {
                mBluetoothGatt = bluetoothDevice.connectGatt(context, false, bluetoothGattCallback);
            }
 
        }catch(Exception e){
            Log.e(TAG,"e:" + e.getMessage());
        }
 
        mHandler.postDelayed(connectOutTimeRunnable,outTime);
 
        return mBluetoothGatt;
    }
 
    //连接超时
    private Runnable connectOutTimeRunnable = new Runnable() {
        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
        @Override
        public void run() {
            if(mBluetoothGatt == null){
                Log.e(TAG,"connectOuttimeRunnable-->mBluetoothGatt == null");
                return;
            }
 
            isConnectIng = false;
            mBluetoothGatt.disconnect();
 
            //连接超时当作连接失败回调
            if(onBleConnectListener != null){
                onBleConnectListener.onConnectFailure(mBluetoothGatt,curConnDevice,"连接超时！",-1);  //连接失败回调
            }
        }
    };
 
    //发现服务超时
    private Runnable serviceDiscoverOutTimeRunnable = new Runnable() {
        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
        @Override
        public void run() {
            if(mBluetoothGatt == null){
                Log.e(TAG,"connectOuttimeRunnable-->mBluetoothGatt == null");
                return;
            }
 
            isConnectIng = false;
            mBluetoothGatt.disconnect();
 
            //发现服务超时当作连接失败回调
            if(onBleConnectListener != null){
                onBleConnectListener.onConnectFailure(mBluetoothGatt,curConnDevice,"发现服务超时！",-1);  //连接失败回调
            }
        }
    };

（2）发现系统服务之后，还需要获取特定服务及读写特征才能进行数据通讯。

一般，读特征是用来读取蓝牙设备发出来的数据，写特征是向蓝牙设备写入数据，其中，读特征一定要设置打开通知，否则接收不到消息。

/**
     * 获取特定服务及特征
     * 1个serviceUUID -- 1个readUUID -- 1个writeUUID
     * @param bluetoothGatt
     * @param serviceUUID
     * @param readUUID
     * @param writeUUID
     * @return
     */
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
    private boolean setupService(BluetoothGatt bluetoothGatt,String serviceUUID,String readUUID,String writeUUID) {
        if (bluetoothGatt == null) {
            Log.e(TAG, "setupService()-->bluetoothGatt == null");
            return false;
        }
 
        if(serviceUUID == null){
            Log.e(TAG, "setupService()-->serviceUUID == null");
            return false;
        }
 
        for (BluetoothGattService service : bluetoothGatt.getServices()) {
//            Log.d(TAG, "service = " + service.getUuid().toString());
            if (service.getUuid().toString().equals(serviceUUID)) {
                bluetoothGattService = service;
            }
        }
        //通过上面方法获取bluetoothGattService
//        bluetoothGattService = bleManager.getBluetoothGattService(bluetoothGatt,ConsData.MY_BLUETOOTH4_UUID);
        if (bluetoothGattService == null) {
            Log.e(TAG, "setupService()-->bluetoothGattService == null");
            return false;
        }
        Log.d(TAG, "setupService()-->bluetoothGattService = " + bluetoothGattService.toString());
 
        if(readUUID == null || writeUUID == null){
            Log.e(TAG, "setupService()-->readUUID == null || writeUUID == null");
            return false;
        }
 
        for (BluetoothGattCharacteristic characteristic : bluetoothGattService.getCharacteristics()) {
            if (characteristic.getUuid().toString().equals(readUUID)) {  //读特征
                readCharacteristic = characteristic;
            } else if (characteristic.getUuid().toString().equals(writeUUID)) {  //写特征
                writeCharacteristic = characteristic;
            }
        }
        if (readCharacteristic == null) {
            Log.e(TAG, "setupService()-->readCharacteristic == null");
            return false;
        }
        if (writeCharacteristic == null) {
            Log.e(TAG, "setupService()-->writeCharacteristic == null");
            return false;
        }
        //打开读通知
        enableNotification(true, bluetoothGatt, readCharacteristic);
 
        //重点中重点，需要重新设置
        List<BluetoothGattDescriptor> descriptors = readCharacteristic.getDescriptors();
        for (BluetoothGattDescriptor descriptor : descriptors) {
            descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
            bluetoothGatt.writeDescriptor(descriptor);
        }
 
        //延迟2s，保证所有通知都能及时打开
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
 
            }
        }, 2000);
 
        return true;
 
    }
 
    /  打开通知  //
 
    /**
     * 设置读特征接收通知
     * @param enable  为true打开通知
     * @param gatt    连接
     * @param characteristic  特征
     */
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
    public void enableNotification(boolean enable, BluetoothGatt gatt, BluetoothGattCharacteristic characteristic){
        if(gatt == null){
            Log.e(TAG,"enableNotification-->gatt == null");
            return;
        }
        if(characteristic == null){
            Log.e(TAG,"enableNotification-->characteristic == null");
            return;
        }
        //这一步必须要有，否则接收不到通知
        gatt.setCharacteristicNotification(characteristic,enable);
    }

5、数据通讯

（1）发送数据

mBluetoothGatt.writeCharacteristic()方法的返回值，并不能真正的表示数据是否发送成功，而是通过BluetoothGattCallback回调方法onCharacteristicWrite()来判断数据是否已成功写入底层。

 //向蓝牙设备写入数据结果回调
        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicWrite(gatt, characteristic, status);
 
            if(characteristic.getValue() == null){
                Log.e(TAG,"characteristic.getValue() == null");
                return;
            }
            //将收到的字节数组转换成十六进制字符串
            String msg = TypeConversion.bytes2HexString(characteristic.getValue(),characteristic.getValue().length);
            if(status == BluetoothGatt.GATT_SUCCESS){
                //写入成功
                Log.w(TAG,"写入成功：" + msg);
                if(onBleConnectListener != null){
                    onBleConnectListener.onWriteSuccess(gatt,gatt.getDevice(),characteristic.getValue());  //写入成功回调
                }
 
            }else if(status == BluetoothGatt.GATT_FAILURE){
                //写入失败
                Log.e(TAG,"写入失败：" + msg);
                if(onBleConnectListener != null){
                    onBleConnectListener.onWriteFailure(gatt,gatt.getDevice(),characteristic.getValue(),"写入失败");  //写入失败回调
                }
            }else if(status == BluetoothGatt.GATT_WRITE_NOT_PERMITTED){
                //没有权限
                Log.e(TAG,"没有权限！");
            }
        }
///  发送数据  ///
 
    /**
     * 发送消息  byte[]数组
     * @param msg  消息
     * @return  true  false
     */
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
    public boolean sendMessage( byte[] msg){
        if(writeCharacteristic == null){
            Log.e(TAG,"sendMessage(byte[])-->writeGattCharacteristic == null");
            return false;
        }
 
        if(mBluetoothGatt == null){
            Log.e(TAG,"sendMessage(byte[])-->mBluetoothGatt == null");
            return false;
        }
 
        boolean  b = writeCharacteristic.setValue(msg);
        Log.d(TAG, "写特征设置值结果：" + b);
        return mBluetoothGatt.writeCharacteristic(writeCharacteristic);
    }

（2）接收数据

接收的数据是直接通过BluetoothGattCallback回调方法onCharacteristicChanged()来获取的。

//读取蓝牙设备发出来的数据回调
        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            super.onCharacteristicChanged(gatt, characteristic);
 
            //接收数据
            byte[] bytes = characteristic.getValue();
            Log.w("TAG","收到数据str:" + TypeConversion.bytes2HexString(bytes,bytes.length));
            if(onBleConnectListener != null){
                onBleConnectListener.onReceiveMessage(gatt,gatt.getDevice(),characteristic,characteristic.getValue());  //接收数据回调
            }
        }

6、断开连接

BLE通讯结束之后，需要及时断开连接,并且在断开连接的回调处释放资源。否则会导致下一次执行连接操作时，导致133异常。所以，一般连接出现133异常，都是因为断开后及时释放资源。

断开连接的结果是在BluetoothGattCallback回调方法onConnectionStateChange()来获取的。（可查看上面建立连接处的代码）

 ///  断开连接  ///
    /**
     * 断开连接
     */
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
    public void disConnectDevice(){
        if(mBluetoothGatt == null){
            Log.e(TAG,"disConnectDevice-->bluetoothGatt == null");
            return;
        }
 
        //系统断开
        mBluetoothGatt.disconnect();
    }

三、项目演示

（1）扫描目标设备(BLEyqy)，点击“连接”按钮， 会在“搜索”按钮下方显示连接结果 。

（2）手机给目标设备发送数据成功之后，蓝牙设备把接收到的数据再回发送给手机。

（3）断开连接。点击“断开”按钮， 会在“搜索”按钮下方显示断开结果 。

四、Demo案例源码地址

码云：Android Bluetooth Low Energy: Android 低功耗蓝牙开发

CSDN：AndroidBLE.rar-Android代码类资源-CSDN下载

五、更新记录

1、2020/12/29 ：修改 setupService()中错误

2、2021/05/14 ：更新连接方法（解决部分蓝牙设备连接失败的问题）

3、2022/11/25 ：实际开发过程，需要将三个UUID改成具体蓝牙设备的UUID

问：如何查看具体蓝牙设备中的这三个UUID？

答：手机下载nrf工具app，搜索连接上蓝牙设备后，即可查看蓝牙设备中支持的服务UUID、读写特征UUID等信息。

Android低功耗蓝牙（BLE）使用详解
findhappy117的博客
09-17 2313
代码地址如下：http://www.demodashi.com/demo/13390.html 与普通蓝牙相比，低功耗蓝牙显著降低了能量消耗，允许Android应用程序与具有更严格电源要求的BLE设备进行通信，如接近传感器、心率传感器等低功耗设备。 声明蓝牙权限   和使用普通蓝牙一样，在使用低功耗蓝牙时也需要在AndroidManifest声明蓝牙权限，声明蓝牙权限的代...
Android之BLE（低功耗）蓝牙开发，kotlin开发安卓
m0_64319242的博客
11-17 874
} return bleUtil; } public void startBle() { if (!isStandByBle) { Toast.makeText(context, “该设备不支持蓝牙功能”, Toast.LENGTH_SHORT).show(); return; } bleDevices = new ArrayList<>(); BleScanRuleConfig scanRuleConfig = new BleScanRuleConfig.Builder() //
Android之BLE（低功耗）蓝牙开发
最新发布
2401_87255264的博客
09-22 1146
/ Log.e(“发送数据异常------------>”, exception.toString());// Log.e(“发送数据成功------------>”, str);Log.e(“接收数据成功------------>”, stringBuilder.toString());Log.e(“接收数据异常------------>”, e.toString());Log.e(TAG, “连接成功”);
【Android -- 蓝牙】BLE 蓝牙开发入门
Kevin Learn Android
11-15 3208
Android 4.3（API Level 18）开始引入Bluetooth Low Energy（BLE，低功耗蓝牙）的核心功能并提供了相应的 API， 应用程序通过这些 API 扫描蓝牙设备、查询 services、读写设备的 characteristics（属性特征）等操作。......
Android蓝牙bt/ble开发
juzi_zg的博客
04-16 2452
参看文档： 蓝牙开发：https://www.jianshu.com/p/4ecc99679451 蓝牙bt/ble区别：https://zhuanlan.zhihu.com/p/59907996 安卓BLE蓝牙开发详解：https://www.jianshu.com/p/a27f3ca027e3 安卓蓝牙开发之坑：https://www.jianshu.com/p/71116665fd08 目录 1：经典蓝牙开发 1.1：经典蓝牙简介 1.2：基础知识 1.3：经典蓝牙模块 2：.
Android低功耗蓝牙(BLE)开发（一）
king的专栏
06-16 3300
BLE是指低功耗蓝牙（Bluetooth Low Energy），也被称为蓝牙4.0。它是蓝牙技术的一种变体，旨在消耗更少的电量，具有便携性，并且可以在无线传输距离较短的范围内实现低速数据传输。BLE技术已经广泛应用于智能家居、健康监测、物联网等场景中。
Android 蓝牙开发(三) -- 低功耗蓝牙开发
QG
11-10 1056
BLE
Android蓝牙BLE开发
weixin_51890646的博客
01-09 7353
这篇文章是本人这几天对BLE开发基础的大概总结
android ble 开发
weixin_42104906的博客
08-12 273
Android BLE 开发入门 随着物联网的发展，蓝牙低功耗（BLE，Bluetooth Low Energy）成为了设备间通信的重要方式。其低功耗、高效能的特点使得BLE广泛应用于医疗设备、健康监测、智能家居等各个领域。本文将带您了解如何在Android中开发BLE应用，提供代码示例，并展示状态图和旅行图以帮助理解开发...
低功耗蓝牙（BLE）开发——Qt
xiaopei_yan的博客
10-12 2471
低功耗蓝牙(BLE)，有时被称为“智能蓝牙”，是经典蓝牙的轻量级子集，作为蓝牙4.0核心规范的一部分引入。虽然与传统蓝牙有一些重叠，但BLE实际上有一个完全不同的血统，在被蓝牙技术联盟采用之前，它是由诺基亚作为一个内部项目开始的，名为“Wibree”。
Android-BLE低功耗蓝牙开发Demo
03-25
相关介绍参考本人博客:http://blog.csdn.net/github_34224676/article/details/65937410
Android代码-一个简单的安卓低功耗蓝牙demo
08-06
AndroidBleDemo 简单安卓低功耗蓝牙教程见我的csdn博客 http://blog.csdn.net/will4906/article/details/53042382
BLE蓝牙开发安卓案例
03-07
通用的安卓和ble设备配对demo.连接超级快，稳定不会断连。可以根据自己的uuid修改数据传输和解析规则。
低功耗蓝牙demo
07-06
在这个"低功耗蓝牙demo"中，开发者通过Android平台进行应用开发，利用Android的BluetoothGatt API来与BLE设备进行交互。Android BLE库提供了连接、读写特征值、订阅通知等功能，使得开发者能够轻松地控制和支持BLE...
Bluetooth:Android 蓝牙开发入门demo
05-12
我们将主要关注Android的经典蓝牙（Bluetooth Classic）部分，而非低功耗蓝牙（Bluetooth Low Energy, BLE）。 首先，我们需要理解Android蓝牙API的核心概念。在Android系统中，`BluetoothAdapter`是蓝牙的主要入口...
低功耗蓝牙（BLE）开发——如何妥善处理包大小（MTU）限制
热门推荐
qiandaxiong的博客
12-26 2万+
最近出于项目需要，花了几天时间，研究了一下低功耗蓝牙（BLE）的开发，为了让有需要的小伙伴们少走弯路，现将我所遇到的问题分享出来。 刚开始，我被低功耗蓝牙（BLE）的基础概念所困扰，想当然的以为低功耗蓝牙仅仅是传统蓝牙的升级版本，只要传统蓝牙能做的，低功耗蓝牙理应可以做到。这从一开始就陷入误区了。此外，也想当然地把低功耗蓝牙外设和中心的概念直接往C/S模式硬套，认为低功耗蓝牙的外设就是client
Android 蓝牙BLE开发详解
weixin_34274029的博客
07-12 1143
1.介绍 蓝牙是一种短距离的无线通信技术，可以实现固定设备、移动设备之间的数据交换。一般将蓝牙分为两大类，蓝牙3.0规范之前的版本称为传统蓝牙，蓝牙4.0规范之后的版本称为低功耗蓝牙，也就是常说的BLE（Bluetooth Low Energy）。 本文主要讲解的是Android设备与BLE设备之间的通信，Android 从4.3版本（API Level 18）开始支持BLE通信。 2.开发流程 ...
android】蓝牙开发——ble(低功耗蓝牙)
08-12
BLE（低功耗蓝牙）是一种通过蓝牙无线技术进行低功耗通信的协议。它是在传统蓝牙（Classic Bluetooth）的基础上发展而来，主要用于物联网、智能家居和健康追踪等领域。 BLE主要特点有以下几个方面： 1. 低功耗：BLE采用了一种优化的通信方式，使设备在通信过程中的功耗大大降低，从而延长了设备的电池寿命，这对于需要长时间运行的设备非常重要。 2. 简化传输：BLE使用了一种称为GATT（通用属性）的协议，将数据分为服务和特征，通过读、写或订阅操作来传输数据，这种简化了传输过程，减少了额外的开销。 3. 快速连接：BLE的连接速度比传统蓝牙更快，可以在几十毫秒内建立连接，这对于移动设备和传感器等需要快速响应的设备非常重要。 4. 多设备连接：BLE支持同时连接多个设备，可以通过同一个移动设备与多个BLE设备进行通信，提高了系统的灵活性和可扩展性。 Android提供了一套完整的BLE开发API，开发者可以使用这些API来实现BLE通信功能。在Android中，开发BLE应用涉及到四个主要组件：BLE设备扫描、设备连接、数据传输和GATT服务管理。 开发者可以使用Android的BluetoothAdapter类来进行设备扫描和连接操作，可以通过BluetoothGatt类来进行GATT服务的操作，包括读、写、订阅等。 总之，BLE作为一种低功耗的蓝牙通信协议，在物联网和智能设备领域应用广泛。在Android平台上进行BLE开发，可以借助Android提供的API，快速实现BLE通信功能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值