自定义蓝牙接入方式

/// 搜索到的设备
var blesArray: [JL_EntityM] {
    // 注意这里的 SettingInfo 记录了开发者是否启用自定义蓝牙连接和是否启用了 GATT over EDR 连接 的
    if SettingInfo.getCustomerBleConnect() || SettingInfo.getATTComunication() {
        return devices
    } else {
        return mBleMultiple.blePeripheralArr as! [JL_EntityM]
    }
}

/// 当前连接的设备
var currentEntity: JL_EntityM? {
    get {
        if SettingInfo.getCustomerBleConnect() || SettingInfo.getATTComunication() {
            assist.mCmdManager.mEntity
        } else {
            _currentEntity
        }
    }
    ...
}

/// 当前连接的命令管理对象
var currentCmdMgr: JL_ManagerM? {
    if SettingInfo.getCustomerBleConnect() || SettingInfo.getATTComunication() {
        assist.mCmdManager
    } else {
        currentEntity?.mCmdManager
    }
}

/// 杰理 SDK 的日志
JLLogManager.clearLog()
JLLogManager.setLog(true, isMore: false, level: .DEBUG)
JLLogManager.log(withTimestamp: true)
JLLogManager.saveLog(asFile: true)

func centralManagerDidUpdateState(_ central: CBCentralManager) {
    if central.state == .poweredOn {
        startSearchBle()
    }
    assist.assistUpdate(central.state)
}

func centralManager(_: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi _: NSNumber) {
    if devices.contains(where: { $0.mUUID == peripheral.identifier.uuidString }) {
    } else {
        let newEntity = JL_EntityM()
        newEntity.mUUID = peripheral.identifier.uuidString
        newEntity.setBlePeripheral(peripheral)
        if peripheral.name != nil {
            if devices.contains(where: { $0.mPeripheral.name == peripheral.name }) {
            } else {
                devices.append(newEntity)
            }
        }
    }
    ...
    JL_Tools.post(kJL_BLE_M_FOUND, object: blesArray)
}

func centralManager(_: CBCentralManager, didConnect peripheral: CBPeripheral) {
    peripheral.delegate = self
    peripheral.discoverServices(nil)
}

func peripheral(_ peripheral: CBPeripheral, didDiscoverServices _: Error?) {
    for service in peripheral.services! {
        peripheral.discoverCharacteristics(nil, for: service)
    }
}

func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error _: Error?) {
    assist.assistDiscoverCharacteristics(for: service, peripheral: peripheral)
}

func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error _: Error?) {
    if SettingInfo.getPairEnable() {
        // 自定义蓝牙连接时，连上设备后需要进行设备认证
        assist.assistUpdate(characteristic, peripheral: peripheral) { isPaired in
            if isPaired {
                SettingInfo.setToHistory(peripheral.identifier.uuidString)
                self.handleCbp = peripheral
                let entity = JL_EntityM()
                entity.setBlePeripheral(self.handleCbp!)
                self.assist.mCmdManager.mEntity = entity
                JL_Tools.post(kJL_BLE_M_ENTITY_CONNECTED, object: peripheral)
            } else {
                self.centerManager.cancelPeripheralConnection(peripheral)
            }
        }
    } else {
        // 不需要认证时，直接回调成功
        SettingInfo.setToHistory(peripheral.identifier.uuidString)
        handleCbp = peripheral
        let entity = JL_EntityM()
        entity.setBlePeripheral(handleCbp!)
        assist.mCmdManager.mEntity = entity
        JL_Tools.post(kJL_BLE_M_ENTITY_CONNECTED, object: peripheral)
    }
}

func peripheral(_: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error _: Error?) {
    // 自定义连接是设备更新数据过来时，需要通过此方法传入 SDK 处理
    assist.assistUpdateValue(for: characteristic)
}

func centralManager(_: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error _: Error?) {
    assist.assistDisconnectPeripheral(peripheral)
    assist.mCmdManager.mEntity = nil
    handleCbp = nil
    currentEntity = nil
    JL_Tools.post(kJL_BLE_M_ENTITY_DISCONNECTED, object: peripheral)
}

/// 设置是否启用设备认证
/// 若关闭，需要多方一起关闭包括设备端跟安卓端
/// - Parameter status: 设备认证开关
func setPairEnable(_ status: Bool) {
    SettingInfo.savePairEnable(status)
    mBleMultiple.ble_PAIR_ENABLE = status
    assist.mNeedPaired = status
}

func reConnectWithMac(_ mac: String) {
    pMac = mac
    startSearchBle()
}

// didDiscover 中：
if pMac != nil {
    if let blead = advertisementData["kCBAdvDataManufacturerData"] as? Data {
        if JL_BLEAction.otaBleMacAddress(pMac!, isEqualToCBAdvDataManufacturerData: blead) {
            stopSearchBle()
            DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: DispatchWorkItem(block: {
                self.centerManager.connect(peripheral, options: [CBConnectPeripheralOptionEnableTransportBridgingKey: true])
                self.pMac = nil
            }))
        }
    }
}

class BleManager: NSObject {
    /// 单例
    static let shared = BleManager()

    /// 当前正在使用的设备（含广播信息对象）
    private var _currentEntity: JL_EntityM?

    /// 设备管理
    private var mBleMultiple: JL_BLEMultiple = .init()

    /// 自定义蓝牙接入助手
    private let assist: JL_Assist = .init()

    /// 搜索到的设备
    private var devices: [JL_EntityM] = []

    /// 当前连接的设备
    private var handleCbp: CBPeripheral?

    /// 设备的 mac 地址
    private var pMac: String?

    /// 蓝牙中心管理
    lazy var centerManager: CBCentralManager = .init(delegate: self, queue: .main)

    /// 开始搜索
    func startSearchBle() {
        // 启用 GATT over EDR 时需要先连接上设备的 EDR 否则会搜索不到
        if SettingInfo.getATTComunication() {
            devices.removeAll()
            let uuid = SettingInfo.getAttDevUUID() ?? "AE00"
            let matchingOptions = [CBConnectionEventMatchingOption.serviceUUIDs: [uuid]]
            centerManager.registerForConnectionEvents(options: matchingOptions)
            centerManager.scanForPeripherals(withServices: nil, options: [CBConnectPeripheralOptionEnableTransportBridgingKey: true])
            return
        }
        // 启用自定义蓝牙连接是开发者自行搜索设备
        if SettingInfo.getCustomerBleConnect() {
            devices.removeAll()
            centerManager.scanForPeripherals(withServices: nil, options: [CBConnectPeripheralOptionEnableTransportBridgingKey: true])
        } else {
            // 启用 SDK 蓝牙连接时，调用库里的方法直接搜索
            mBleMultiple.scanStart()
        }
    }

    /// 连接设备
    func connectEntity(_ entity: JL_EntityM) {
        if SettingInfo.getATTComunication() {
            centerManager.connect(entity.mPeripheral)
            return
        }
        stopSearchBle()
        if SettingInfo.getCustomerBleConnect() {
            // 这里的连接增加了一个连接参数，用于设备支持 CTKD 协议时的，GATT OVER EDR 连接时可忽略
            centerManager.connect(entity.mPeripheral, options: [CBConnectPeripheralOptionEnableTransportBridgingKey: true])
        } else {
            mBleMultiple.connectEntity(entity) { st in
                // 结果回调：bleOFF / connectFail / connecting / connectRepeat /
                // connectTimeout / connectRefuse / pairFail / pairTimeout /
                // paired / masterChanging / disconnectOk / null
                switch st { ... }
            }
        }
    }

    /// 断开连接
    func disconnectEntity() {
        if SettingInfo.getCustomerBleConnect() {
            centerManager.cancelPeripheralConnection(BleManager.shared.handleCbp!)
        } else {
            mBleMultiple.disconnectEntity(BleManager.shared.currentEntity!) { _ in }
        }
    }

    /// 根据历史记录连接
    func connectByHistory() {
        if let uuid = SettingInfo.getToHistory() {
            // 当设备支持 ANCS 协议时，可通过这个方法找到已连接的设备
            if let entity = BleManager.shared.mBleMultiple.makeEntity(withUUID: uuid) {
                if SettingInfo.getCustomerBleConnect() {
                    startSearchBle()
                } else {
                    connectEntity(entity)
                }
            }
        }
    }
}

extension BleManager: CBPeripheralDelegate {
    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error _: Error?) {
        assist.assistDiscoverCharacteristics(for: service, peripheral: peripheral)
    }

    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error _: Error?) {
        if SettingInfo.getPairEnable() {
            // 自定义蓝牙连接时，连上设备后需要进行设备认证
            assist.assistUpdate(characteristic, peripheral: peripheral) { isPaired in
                if isPaired {
                    SettingInfo.setToHistory(peripheral.identifier.uuidString)
                    self.handleCbp = peripheral
                    let entity = JL_EntityM()
                    entity.setBlePeripheral(self.handleCbp!)
                    self.assist.mCmdManager.mEntity = entity
                    JL_Tools.post(kJL_BLE_M_ENTITY_CONNECTED, object: peripheral)
                } else {
                    self.centerManager.cancelPeripheralConnection(peripheral)
                }
            }
        } else {
            // 不需要认证时，直接回调成功
            SettingInfo.setToHistory(peripheral.identifier.uuidString)
            handleCbp = peripheral
            let entity = JL_EntityM()
            entity.setBlePeripheral(handleCbp!)
            assist.mCmdManager.mEntity = entity
            JL_Tools.post(kJL_BLE_M_ENTITY_CONNECTED, object: peripheral)
        }
    }

    func peripheral(_: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error _: Error?) {
        // 自定义连接是设备更新数据过来时，需要通过此方法传入 SDK 处理
        assist.assistUpdateValue(for: characteristic)
    }
}