【Android】蓝牙连接使用

本文实现蓝牙连接，使用的GitHub开源库实现，调用封装好的API。

1.依赖

implementation 'com.vise.xiaoyaoyou:baseble:2.0.6'

2.权限申请

//android 6.0+以上需要进行动态权限申请
    <uses-permission android:name="android.permission.BLUETOOTH" /> 
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" /> 
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> 

3.实现

public class BLEDeviceManager {

    private static final String TAG = "BLEDevice";
    private static volatile BLEDeviceManager instance;
    private DeviceMirrorPool mDeviceMirrorPool;
    private Context mContext;
    private BluetoothLeDevice bluetoothLeDevice;

    private DetStatus detStatus;

    private BLEDeviceManager() {
    }

    /**
     * 单例模式 确保全局只有一个实例
     */
    public static BLEDeviceManager getInstance() {
        if (instance == null) {
            synchronized (BLEDeviceManager.class) {
                if (instance == null) {
                    instance = new BLEDeviceManager();
                }
            }
        }
        return instance;
    }

    /**
     * 蓝牙管理初始化
     *
     * @param context 环境
     */
    public void init(Context context) {
        if (context == null) {
            return;
        }
        mContext = context;
        //蓝牙相关配置修改
        ViseBle.config()
                .setScanTimeout(-1)//扫描超时时间，这里设置为永久扫描
                .setConnectTimeout(10 * 1000)//连接超时时间
                .setOperateTimeout(5 * 1000)//设置数据操作超时时间
                .setConnectRetryCount(3)//设置连接失败重试次数
                .setConnectRetryInterval(1000)//设置连接失败重试间隔时间
                .setOperateRetryCount(3)//设置数据操作失败重试次数
                .setOperateRetryInterval(1000)//设置数据操作失败重试间隔时间
                .setMaxConnectCount(3);//设置最大连接设备数量
        //蓝牙信息初始化，全局唯一，必须在应用初始化时调用
        ViseBle.getInstance().init(context.getApplicationContext());
        mDeviceMirrorPool = ViseBle.getInstance().getDeviceMirrorPool();
        detStatus = new DetStatus();
    }

    /**
     * 连接设备
     *
     * @param bleMAC 设备mac地址
     */
    public void connect(String bleMAC) {
        ViseBle.getInstance().connectByMac(bleMAC, connectCallback);
    }

    /**
     * 断开指定设备
     *
     * @param bluetoothLeDevice 设备名
     */
    public void disconnect(BluetoothLeDevice bluetoothLeDevice) {
        ViseBle.getInstance().disconnect(bluetoothLeDevice);
    }

    /**
     * 判断设备是否连接
     *
     * @param bluetoothLeDevice 设备名
     */
    public boolean isConnected(BluetoothLeDevice bluetoothLeDevice) {
        return ViseBle.getInstance().isConnect(bluetoothLeDevice);
    }

    /**
     * 连接回调
     */
    private IConnectCallback connectCallback = new IConnectCallback() {

        @Override
        public void onConnectSuccess(final DeviceMirror deviceMirror) {
            Log.e(TAG, "连接成功!");
            bluetoothLeDevice = deviceMirror.getBluetoothLeDevice();
            Log.e(TAG, "地址：" + bluetoothLeDevice.getAddress());

            List<BluetoothGattService> gattServices = deviceMirror.getBluetoothGatt().getServices();
            UUID serviceUUID = null;
            UUID characterUUID = null;
            UUID descUUID = null;
            if (gattServices.size() > 0) {
                Iterator<BluetoothGattService> serviceIterator = gattServices.iterator();
                label36:
                while (serviceIterator.hasNext()) {
                    BluetoothGattService gattService = serviceIterator.next();
                    UUID sUUID = gattService.getUuid();
                    if (sUUID.toString().contains("0000ffe0")) {
                        List<BluetoothGattCharacteristic> gattCharacteristics = gattService.getCharacteristics();
                        if (gattCharacteristics.size() > 0) {
                            characterUUID = gattCharacteristics.get(0).getUuid();
                            List<BluetoothGattDescriptor> gattDescriptors = gattCharacteristics.get(0).getDescriptors();

                            for (BluetoothGattDescriptor bgd : gattDescriptors) {
                                UUID dUUID = bgd.getUuid();
                                if (dUUID.toString().contains("00002902")) {
                                    serviceUUID = sUUID;
                                    descUUID = dUUID;
                                    break label36;
                                }
                            }
                        }
                        break;
                    }
                }
            }
            bindChannel(bluetoothLeDevice,
                    PropertyType.PROPERTY_NOTIFY,
                    serviceUUID,
                    characterUUID,
                    descUUID);
        }

        @Override
        public void onConnectFailure(BleException exception) {
            Log.e(TAG, "连接失败！");

        }

        @Override
        public void onDisconnect(boolean isActive) {
            Log.e(TAG, "已断开!");
           

        }
    };

    /**
     * 绑定数据通道，用于接收数据
     *
     * @param bluetoothLeDevice  设备名
     * @param propertyType       绑定方式
     * @param serviceUUID        服务UUID
     * @param characteristicUUID 特征UUID
     * @param descriptorUUID     描述UUID
     */
    public void bindChannel(BluetoothLeDevice bluetoothLeDevice, PropertyType propertyType, UUID serviceUUID,
                            UUID characteristicUUID, UUID descriptorUUID) {
        DeviceMirror deviceMirror = mDeviceMirrorPool.getDeviceMirror(bluetoothLeDevice);
        if (deviceMirror != null) {
            BluetoothGattChannel bluetoothGattChannel = new BluetoothGattChannel.Builder()
                    .setBluetoothGatt(deviceMirror.getBluetoothGatt())
                    .setPropertyType(propertyType)
                    .setServiceUUID(serviceUUID)
                    .setCharacteristicUUID(characteristicUUID)
                    .setDescriptorUUID(descriptorUUID)
                    .builder();
            deviceMirror.bindChannel(bleCallback, bluetoothGattChannel);
            deviceMirror.registerNotify(false);
        }
    }

    /**
     * 数据回调
     */
    private IBleCallback bleCallback = new IBleCallback() {
        @Override
        public void onSuccess(final byte[] data, BluetoothGattChannel bluetoothGattInfo, BluetoothLeDevice bluetoothLeDevice) {
            Log.e(TAG, "数据回调成功");
            DeviceMirror deviceMirror = mDeviceMirrorPool.getDeviceMirror(bluetoothLeDevice);
            deviceMirror.setNotifyListener(bluetoothGattInfo.getGattInfoKey(), receiveCallback);
        }

        @Override
        public void onFailure(BleException exception) {
            Log.e(TAG, "数据回调失败");
            
        }
    };

    /**
     * 接收数据回调
     */
    private IBleCallback receiveCallback = new IBleCallback() {
        @Override
        public void onSuccess(final byte[] data, BluetoothGattChannel bluetoothGattInfo, BluetoothLeDevice bluetoothLeDevice) {
            if (data == null) {
                return;
            }
            Log.e(TAG, "处理数据");
            //此时进行获取数据的处理
           
        }

        @Override
        public void onFailure(BleException exception) {
            if (exception == null) {
                return;
            }
            Log.e(TAG, "数据接收失败");
          
        }
    };

    /**
     * 断开连接
     */
    public void destroy() {
        if (isConnected(bluetoothLeDevice)) {
            disconnect(bluetoothLeDevice);
        }
    }
}

4.调用

//蓝牙连接
BLEDeviceManager.getInstance().init(this);
BLEDeviceManager.getInstance().connect("BA:7C:9B:23:65:00");