蓝牙开发、扫描、通知、发送指令

时间:2021-7-21 作者:qvyue

最近在做蓝牙相关的开发,虽然说 FastBleLib 这样的第三方蓝牙连接库非常方便,但是原生开发还是有必要了解一下的。

首先说明

  • 1.不需要问硬件工程师UUID
  • 2.不需要写 UI
  • 3.本案例只有一个类文件
  • 4.没有写动态请求蓝牙权限相关的,自己测试过程中,手动开启所有权限即可。
  • 5.代码解释全部写在注释,和日志
public class Main8Activity extends AppCompatActivity {

    //  蓝牙适配器对象,用于扫描蓝牙设备
    private BluetoothAdapter bluetoothAdapter;

    // GATT 通信,连接蓝牙,发送指令,以及接收蓝牙通知 ( 这里所谓的通知,就是蓝牙传过来的数据 )
    private BluetoothGatt bluetoothGatt;

    //  如果蓝牙没有开启
    private final static int REQUEST_ENABLE = 100;

    //  扫描到的蓝牙设备,因为 Set 不会重复,所以用这个数据结构
    private Set bluetoothDeviceSet;

    //  用户发送指令的操作
    private BluetoothGattCharacteristic writeBluetoothGattCharacteristic;

    //  用于开启通知的操作
    private BluetoothGattCharacteristic notificationBluetoothGattCharacteristic;

    //  服务和特征值
    private UUID write_UUID_service;
    private UUID write_UUID_chara;

    private UUID read_UUID_service;
    private UUID read_UUID_chara;

    private UUID notify_UUID_service;
    private UUID notify_UUID_chara;

    private UUID indicate_UUID_service;
    private UUID indicate_UUID_chara;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main8);

        log("初始化蓝牙扫描 的 set 集合");
        bluetoothDeviceSet = new HashSet();

        log("开始获取蓝牙适配器");
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        if(bluetoothAdapter != null){

            log("bluetoothAdapter 不为 null 当前设备支持蓝牙");

            if(!bluetoothAdapter.isEnabled()){
                log("蓝牙未启动,正在使用 intent 启用蓝牙");
                Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                startActivityForResult(intent,REQUEST_ENABLE);
            }else{
                log("蓝牙已经启动,不需要使用 intent 启动蓝牙");

                bluetoothAdapter.getBluetoothLeScanner().startScan(scanCallback);
                log("开始扫描蓝牙设备");
            }

        }else{
            log("bluetoothAdapter 为 null 所以当前设备不支持蓝牙");
        }

    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if(requestCode == REQUEST_ENABLE){
            if(resultCode == RESULT_OK){

                log("用户允许了开启蓝牙的请求");

                log("开始扫描蓝牙设备");
                bluetoothAdapter.getBluetoothLeScanner().startScan(scanCallback);

            }else if(resultCode == RESULT_CANCELED){
                log("用户拒绝了开启蓝牙的请求");
            }
        }

    }

    //  蓝牙开始扫描回调
    private ScanCallback scanCallback = new ScanCallback() {
        @Override
        public void onScanResult(int callbackType, ScanResult result) {
            super.onScanResult(callbackType, result);

            //  bluetoothDevice 为扫描到的蓝牙设备
            BluetoothDevice bluetoothDevice = result.getDevice();

            //  添加扫描到的蓝牙设备到 set 集合
            boolean addResult = bluetoothDeviceSet.add(bluetoothDevice);

            //  如果 set 集合中未存在该蓝牙对象,则返回true
            if(addResult){
                //log("onScanResult() 发现蓝牙设备" + bluetoothDevice.getName() + "," + bluetoothDevice.getAddress());

                //log("目前已经发现" + bluetoothDeviceSet.size() + "个蓝牙设备");

                //  如果当前添加的设备 蓝牙名称为 HTC_38908 MAC地址为  88:25:83:F1:04:58,则发起连接
                //  懒得写 列表 UI 了,这里先直接指定好自己用来测试蓝牙的设备
                if("HTC_38908".equals(bluetoothDevice.getName()) && "88:25:83:F1:04:58".equals(bluetoothDevice.getAddress()) ){

                    log("发现需要连接的设备");

                    log("因为蓝牙扫描比较消耗资源,所以连接前就关闭扫描");

                    //  bluetoothAdapter.stopScan(scanCallback);
                    bluetoothAdapter.cancelDiscovery();

                    log("开始 GATT 通信");
                    bluetoothGatt = bluetoothDevice.connectGatt(Main8Activity.this,true,bluetoothGattCallback);

                }
            }
        }

        @Override
        public void onBatchScanResults(List results) {
            super.onBatchScanResults(results);
        }

        @Override
        public void onScanFailed(int errorCode) {
            super.onScanFailed(errorCode);
        }
    };

    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);

            if(BluetoothGatt.STATE_CONNECTED == newState){      //  蓝牙连接状态改变 为 -- 已连接

                // 将会回调 本类中的 onServicesDiscovered() 这个方法
                boolean result = gatt.discoverServices();

                if(result){
                    log("蓝牙连接成功");
                }else{
                    log("蓝牙连接失败");
                }

            }else if(BluetoothGatt.STATE_DISCONNECTED == newState){     //  蓝牙连接状态改变为 -- 连接断开

                log("断开连接");

            }
        }

        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            super.onServicesDiscovered(gatt, status);

            //  这里初始化 各种 服务 和 描述 ,用来发送蓝牙指令的对象,还有接收蓝牙数据对象
            initServiceAndChara();

        }

        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicRead(gatt, characteristic, status);

            log("onCharacteristicRead");
        }

        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicWrite(gatt, characteristic, status);

            log("onCharacteristicWrite");
        }

        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            super.onCharacteristicChanged(gatt, characteristic);

            //  这里将蓝牙传过来的数据转换为 16 进制格式的字符串,便于阅读
            byte[] bytes = characteristic.getValue();

            StringBuilder stringBuilder = new StringBuilder();
            for (byte b : bytes) {
                stringBuilder.append(String.format("%02x", b));
            }

            log("蓝牙传回来的内容 ( 16进制 ) : " + stringBuilder.toString());
        }

        @Override
        public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
            super.onDescriptorRead(gatt, descriptor, status);

            log("onDescriptorRead");
        }

        @Override
        public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
            super.onDescriptorWrite(gatt, descriptor, status);

            log("onDescriptorWrite");
        }

        @Override
        public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
            super.onReliableWriteCompleted(gatt, status);

            log("onReliableWriteCompleted");
        }

        @Override
        public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
            super.onReadRemoteRssi(gatt, rssi, status);

            log("onReadRemoteRssi");
        }

        @Override
        public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
            super.onMtuChanged(gatt, mtu, status);

            log("onMtuChanged");
        }
    };

    private void initServiceAndChara(){

        List bluetoothGattServices= bluetoothGatt.getServices();

        for (BluetoothGattService bluetoothGattService:bluetoothGattServices){

            List characteristics=bluetoothGattService.getCharacteristics();

            for (BluetoothGattCharacteristic characteristic:characteristics){

                int charaProp = characteristic.getProperties();

                if ((charaProp & BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
                    read_UUID_chara=characteristic.getUuid();
                    read_UUID_service=bluetoothGattService.getUuid();
                    log("read_chara="+read_UUID_chara+"----read_service="+read_UUID_service);
                }

                if ((charaProp & BluetoothGattCharacteristic.PROPERTY_INDICATE) > 0) {
                    indicate_UUID_chara=characteristic.getUuid();
                    indicate_UUID_service=bluetoothGattService.getUuid();
                    log("indicate_chara="+indicate_UUID_chara+"----indicate_service="+indicate_UUID_service);

                }

                if ((charaProp & BluetoothGattCharacteristic.PROPERTY_WRITE) > 0) {
                    write_UUID_chara=characteristic.getUuid();
                    write_UUID_service=bluetoothGattService.getUuid();
                    log("write_chara="+write_UUID_chara+"----write_service="+write_UUID_service);
                }

                if ((charaProp & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) > 0) {
                    write_UUID_chara=characteristic.getUuid();
                    write_UUID_service=bluetoothGattService.getUuid();
                    log("write_chara="+write_UUID_chara+"----write_service="+write_UUID_service);

                    //  写入服务
                    BluetoothGattService service = bluetoothGatt.getService(write_UUID_service);
                    writeBluetoothGattCharacteristic = service.getCharacteristic(write_UUID_chara);

                    //  发送指令
                    sendBleData("*".getBytes());

                }

                if ((charaProp & BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                    notify_UUID_chara=characteristic.getUuid();
                    notify_UUID_service=bluetoothGattService.getUuid();
                    log("notify_chara="+notify_UUID_chara+"----notify_service="+notify_UUID_service);

                    //  初始化通知服务
                    BluetoothGattService service = bluetoothGatt.getService(notify_UUID_service);
                    notificationBluetoothGattCharacteristic = service.getCharacteristic(notify_UUID_chara);

                    //  开启通知
                    bluetoothGatt.setCharacteristicNotification(notificationBluetoothGattCharacteristic,true);
                }

            }
        }
    }

    /**
     * 发送数据给蓝牙
     * @param data 数据byte[]
     * */
    private void sendBleData(byte[] data){
        writeBluetoothGattCharacteristic.setValue(data);
        bluetoothGatt.writeCharacteristic(writeBluetoothGattCharacteristic);
    }

    /**
     * 日志
     * @param log 日志内容
     * */
    private void log(String log){
        Log.i("蓝牙",log);
    }

}

以上,相信注释里面已经写的很清楚了。

然后打开日志看就行了

蓝牙开发、扫描、通知、发送指令
image

参考

蓝牙概览官方文档参考
蓝牙参考文章

作者:norkm
链接:https://www.jianshu.com/p/cdb5bc8f9d85
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。