Android Ble蓝牙开发

BLE Android 应用 开发

  • 1.权限设置
  • 2.获取蓝牙设备管理器
  • 3.设备搜索
    • 3.1 停止搜索
  • 4.设备连接
  • 5.设备的重连
  • 6.设备的断开与服务关闭
  • 7.通知的注册与接收
  • 8.数据的主动读取
  • 9.数据的写入
  • 9.关于UUID

1.权限设置

    
    
    
    
    

这里有人可能疑惑,使用蓝牙为啥要定位权限,其实蓝牙技术是可以实现定位的,要使用蓝牙必须要申请定位权限,android 9 之后动态权限申请

private void checkPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            int fine_location = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION);
            int cross_location = checkSelfPermission(android.Manifest.permission.ACCESS_COARSE_LOCATION);
            if (fine_location != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(this, new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION}, 1);
            } else {
                finish();
                return;
            }
            if (cross_location != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(this, new String[]{android.Manifest.permission.ACCESS_COARSE_LOCATION}, 1);
            } else {
                finish();
                return;
            }
        }
    }

动态申请,提示的是申请定位权限,这点个不要奇怪。

2.获取蓝牙设备管理器

private void getBleAdapter() {
        if (mAdapter != null) {
            return;
        }
        BluetoothManager bluetoothManager =
                (BluetoothManager) context.getSystemService (Context.BLUETOOTH_SERVICE);
        mAdapter = bluetoothManager.getAdapter ();
    }

这里获取到的是一个蓝牙适配器BluetoothAdapter ,后续通过适配器调用蓝牙适配器。

3.设备搜索

mAdapter.startLeScan (leScanCallback);
BluetoothAdapter.LeScanCallback leScanCallback = new BluetoothAdapter.LeScanCallback () {
        @Override
        public void onLeScan(BluetoothDevice device, int rssi, byte[] scanRecord) {
         //device.getName()  设备名称
         //device.getAddress()  mac地址
        }
    };

这个搜索方法在21 已经过期了后续使用

 mAdapter.getBluetoothLeScanner ().startScan (new ScanCallback () {
                    @Override
                    public void onScanResult(int callbackType, ScanResult result) {
                        super.onScanResult (callbackType, result);
                     //    BluetoothDevice device= result.getDevice ();  获取设备对象
                     //   result.getRssi ()  信号强度,根据这个可以计算出距离服务端蓝牙的距离
                    }
                });

3.1 停止搜索

mAdapter.stopLeScan (leScanCallback);

同样这个方法21后过期了,可以使用新的api

mAdapter.getBluetoothLeScanner ().stopScan(// 搜索接口实例);

在搜到合适设备或者想停止设备搜索时可以调用这个api停止搜索。

  • 注意:如果去连接设备时,同时还在搜索设备,建议先调用stopScan 停止搜索,然后再连接,这样可以提高效率。

4.设备连接

一般情况下,根据业务不同有可能我们会将搜索到的BluetoothDevice 保存下来。
再次使用时可以用

BluetoothDevice device = mAdapter.getRemoteDevice (deviceInfo.getAddress ());

如果device 是空的,说明设备可能已经关闭了,后边就没必要链接了。
如果是直接搜索到连接可以直接用搜到的BluetoothDevice 直接连接。

BluetoothGatt  currentBindGatt = device.connectGatt (context, true, bluetoothGattCallback);
public BluetoothGatt connectGatt(Context context, boolean autoConnect,
            BluetoothGattCallback callback) {
        return (connectGatt(context, autoConnect, callback, TRANSPORT_AUTO));
    }
  • autoConnect 是否重连,如果true 异常断开后下次还会重新连接。
  • bluetoothGattCallback 连接回掉状态
   BluetoothGattCallback bluetoothGattCallback = new BluetoothGattCallback () {
        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        // 这个是发现服务,在这里可以注册蓝牙的通知
            LogS.d (TAG, "onServicesDiscovered()");
            if (gatt == null || gatt.getDevice () == null) {
                LogS.d (TAG, "Android GATT invalid!");
                return;
            }
            UUID uuid = BeanBleUtil.parseUUID (BeanCSConstant.PROFILE_FORMAT_SERVER_UUID);
    
            if (status == BluetoothGatt.GATT_SUCCESS) {
                //查询支持的Server uuid
                List services = gatt.getServices ();
                if (services != null) {
                    for (BluetoothGattService service : services) {
                        LogS.d (TAG, "onServicesDiscovered:" + service.getUuid ());
                    }
                }
                //查询支持的Characteristic uuid
                BluetoothGattService service = gatt.getService (uuid);
                if (service == null) {
                    LogS.d (TAG, "BluetoothGattService == null");
                    return;
                }
                List list = service.getCharacteristics ();
                if (list != null) {
                    for (BluetoothGattCharacteristic bluetoothGattCharacteristic : list) {
                    //这里将需要监听的通知进行注册,如果不需要监听,可以不用管这里
                        List listUUids = NoticeUUidList ();
                        if (bluetoothGattCharacteristic != null && listUUids.contains (bluetoothGattCharacteristic.getUuid ())) {
                            LogS.d (TAG, "readData support uuid:" + bluetoothGattCharacteristic.getUuid ().toString ());
                            enableNotification (true, gatt, bluetoothGattCharacteristic);
                        }
                    }
                }
            }
        }

        @Override
        public void onConnectionStateChange(final BluetoothGatt gatt, int status, int newState) {
            LogS.d (TAG, "onConnectionStateChange " + status + " ===> " + newState);
            if (gatt == null) {
                LogS.d (TAG, "gatt handler null");
                return;
            }
            BaseDeviceInfo cInfo = deviceHashMap.get (gatt.getDevice ().getAddress ());
            if (cInfo != null) {
                LogS.d (TAG, "onConnectionStateChange 链接成功,开始赋值对象:" + gatt.getDevice ().getAddress ());
            }
            if (status != BluetoothGatt.GATT_SUCCESS) {
                gatt.disconnect ();
                gatt.close ();
                LogS.d (TAG, "--GATT_SUCCESS");
                   currentBindGatt = null;      
                    LogS.d (TAG, "GATT_SUCCESS 连接失败操作");
                    return;
                }
            }

            if (newState == BluetoothGatt.STATE_CONNECTED) {
              //连接成功
            } else if (newState == BluetoothGatt.STATE_DISCONNECTED) {
              //链接失败
            }
        }

        //读取
        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        //数据的读取结果或者通知会通过这个函数返回
            LogS.d (TAG, "onCharacteristicRead:" + gatt.getDevice ().getName () + " address:" + gatt.getDevice ().getAddress () + " status:" + status + "characteristic.getUuid ():" + characteristic.getUuid ());
            if (status == BluetoothGatt.GATT_SUCCESS) {
                byte[] value = characteristic.getValue ();
                if (value != null) {
                    StringBuilder builder = new StringBuilder ();
                    for (byte data : value) {
                        //以十六进制的形式输出
                        LogS.d (TAG, "---------" + String.format ("%02X ", data));
                        builder.append (data);
                    }
                    LogS.d (TAG, "onCharacteristicRead:(uuid, value)= " + characteristic.getUuid ()
                            + "," + builder.toString () + ")");
                    UUID uuid = characteristic.getUuid ();
                    if (uuid == null) {
                        return;
                    }
                  //解析 收到的value 值
                }
            }
        }

        //写入
        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            LogS.d (TAG, "onCharacteristicWrite:" + gatt.getDevice ().getName () + " address:" + gatt.getDevice ().getAddress () + " status:" + status);
            if (status == BluetoothGatt.GATT_SUCCESS) {
                byte[] value = characteristic.getValue ();
                if (value != null) {
                    StringBuilder builder = new StringBuilder ();
                    for (byte data : value) {
                        builder.append (data);
                    }
                    LogS.d (TAG, "onCharacteristicWrite:" + builder.toString ());
                }
            } else if (status == BluetoothGatt.GATT_INVALID_ATTRIBUTE_LENGTH) {
                LogS.d (TAG, "写入操作超出了属性的最大长度");
            }
        }

        @Override
        public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
            super.onMtuChanged (gatt, mtu, status);
            LogS.d (TAG, "----onMtuChanged");
        }

        //数据变化通知 接收通知消息
        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            LogS.d (TAG, "通知回调 onCharacteristicChanged:" + gatt.getDevice ().getName () + " address:" + gatt.getDevice ().getAddress () + "通知uuid:" + characteristic.getUuid ().toString ());
            byte[] value = characteristic.getValue ();
            if (value != null) {
                StringBuilder builder = new StringBuilder ();
                for (byte data : value) {
                    builder.append (data);
                }
                LogS.d (TAG, "接收通知消息:" + builder.toString ());
               //处理通知消息
            }

        }

    };

5.设备的重连

在很多时候,如果设备已经连接过了,但是中间断开,再次需要链接的时候是不需要再次调用connectGatt 连接方法的。只要调用重连方法就可以了。
重连的前提是之前已经连接过,获取到了BluetoothGatt 实例对象。

 if (currentBindGatt.connect ()) {
 //调用重连成功,即使设备不在范围内,等设备在范围内可自动连接成功
 }

6.设备的断开与服务关闭

在需要断开设备时可以调用

currentBindGatt.disconnect ();

调用断开后,后续需要链接时,只需重新调用重连方法即可。
如果需要关闭Gatt 服务可以调用

 currentBindGatt.close ();

调用close 方法后就不能再调用重连方法了,必须重新调用connectGatt ,

  • 在实际的项目中可能会出现重连失败等操作,或者连接失败,这时需要调用下close方法,然后重新connectGatt 。

7.通知的注册与接收

ble支持通知类型的事件,当然,想要收到通知必须提前注册通知的uuid,有些uuid 是蓝牙的标准uuid ,有些则是厂商自定义的uuid .这个要适情况而定。

在Gatt 监听器的 onServicesDiscovered(BluetoothGatt gatt, int status)回掉函数中来注册。

  • 查询支持的Server uuid
    List services = gatt.getServices ();
    这里获取到设备所有的uuid 特服务
  • 查询支持的Characteristic uuid
    BluetoothGattService service = gatt.getService (uuid);
    这里的uuid 用的是181c 一般厂商都会给的,是服务端的uuid 。注意这个uuid 是UUID 类
    需要通过:
    String code = “0000” + 181c+ “-0000-1000-8000-00805f9b34fb”;
    UUID uuid=UUID.fromString(code);
    转为标准的UUID 类。
  • 获取这个服务下的所有特征列表
    List list = service.getCharacteristics ();
    然后比对下是否是我们需要注册的那个uuid 的特征值。
 if (list != null) {
                    for (BluetoothGattCharacteristic bluetoothGattCharacteristic : list) {
                        List listUUids =NoticeUUidList ();
                        if (bluetoothGattCharacteristic != null && listUUids.contains (bluetoothGattCharacteristic.getUuid ())) {
                            LogS.d (TAG, "readData support uuid:" + bluetoothGattCharacteristic.getUuid ().toString ());
                            enableNotification (true, gatt, bluetoothGattCharacteristic);
                        }
                    }
                }

NoticeUUidList 是一个UUID 的list 是我想要监听的通知的uuid ,然后通过BluetoothGattCharacteristic
特征值来注册通知

 /**
     * 设置是否开启通知
     */
    private boolean enableNotification(boolean enable, BluetoothGatt
            gatt, BluetoothGattCharacteristic characteristic) {
        if (gatt == null || characteristic == null) return false; 
        boolean setNotification = false;
        try {
            String uuid =“2902”;
            BluetoothGattDescriptor characteristicDescriptor = characteristic.getDescriptor (BeanBleUtil.parseUUID (uuid));
            if (characteristicDescriptor != null) {
                byte[] value = enable ? BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE : BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE;
                characteristicDescriptor.setValue (value);
                gatt.writeDescriptor (characteristicDescriptor);
            }
            setNotification = gatt.setCharacteristicNotification (characteristic, enable);
            LogS.d (TAG, "设置通知" + characteristic.getUuid ().toString () + "结果:" + setNotification);
        } catch (Exception e) {
            LogS.d (TAG, "enableNotification 统一设置通知 失败" + e.getMessage () + "--uuid:" + characteristic.getUuid ().toString ());
            e.printStackTrace ();
        }
        return setNotification;
    }

2902 是蓝牙特征值的配置uuid ,如果没有配置这个uuid ,设置通知是没有效果的。
BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE 是用于启动通知的描述符,必须配置。
然后就是通过 gatt.setCharacteristicNotification 来设置通知的特征值,设置成功后,服务端数据变化发起的通知,客户端就可以收到通知了,通知的接收是 onCharacteristicChanged函数

public static UUID parseUUID(String name) {
        if (TextUtils.isEmpty(name)) {
            return null;
        }
        String code = "0000" + name + "-0000-1000-8000-00805f9b34fb";
        if (!TextUtils.isEmpty(code)) {
            return UUID.fromString(code);
        }
        return null;
    }

8.数据的主动读取

通过蓝牙可以读取设备服务端的值,但是必须通过uuid 来完成。

public boolean readDataByUuid(String uuid) {
        LogS.d (TAG, "开始读取数据:readData() uuid: " + uuid);
        boolean ret = false;
        LogS.d (TAG, "readData:" + BeanBleUtil.parseUUID (uuid).toString ());
        if (currentBindGatt != null) {
            BluetoothGattService bleService = currentBindGatt.getService (BeanBleUtil.parseUUID (“181c));
            if (bleService == null) {
                Log.e (TAG, "readDataByUuid:  BluetoothGattService==null");
                return false;
            }
            BluetoothGattCharacteristic characteristic = bleService.getCharacteristic (BeanBleUtil.parseUUID (uuid));
            if (characteristic != null) {
                ret = currentBindGatt.readCharacteristic (characteristic);
            }
            LogS.d (TAG, "readData(" + uuid + ") ret: " + ret);
        } else {
            LogS.d (TAG, "readData currentBindGatt == null!");
        }
        return ret;
    }

读取完成后,数据是通过onCharacteristicRead 函数回掉回来。

9.数据的写入

写入和读取类似,都是先获取gatt服务,然后通过服务和uuid 获取特征值,然后写入数据。

public boolean writeByte(byte[] sendValue, String uuid1) {
        UUID uuid = BeanBleUtil.parseUUID (uuid1);
        boolean su = false;
        LogS.d (TAG, "writeByte() sendValue: " + sendValue.toString () + ", uuid: " + uuid);
        if (currentBindGatt != null) {
            BluetoothGattService bleService = currentBindGatt.getService (BeanBleUtil.parseUUID (”181c"));
            BluetoothGattCharacteristic characteristic = bleService.getCharacteristic (uuid);
            if (characteristic != null) {
                characteristic.setValue (sendValue);
                su = currentBindGatt.writeCharacteristic (characteristic);
    
            }
        }
        return su;
    }

如果写入成功onCharacteristicWrite 回掉函数会执行。

9.关于UUID

UUID 本身指的是一个类UUID ,他包含uuid ,我们所说的特征值id。
uuid 是一串十六进制组成的数字,提示唯一识别码,就像身份证一样,只不过ble中它代表服务,特征的号码,uuid 是128bit 的,因为太长所有SIG将uuid 进行预设,预设过后uuid 的一些部分就变成了固定部分,就比如我们本次服务的uuid 是: “0000” + 181c+ “-0000-1000-8000-00805f9b34fb”;
除了181c ,其他部分都是固定的。

最后:对于很对没有开发过蓝牙的同学来说需要搞明白,ble 是不需要去配对的,需要配对的是传统蓝牙,这点不要傻傻分不清楚,其次,ble 蓝牙只需要搜索到设备,可以直接连接了,过程相对简单,但是任何设备在连接的过程中都可能发生异常,所以我建议在连接的时候设置超时机制,可以有效减少程序故障。

你可能感兴趣的:(蓝牙,android,java)