iOS 解决蓝牙配对弹框的问题，解决ANCS带来的问题，获取已配

不知道小伙伴们在开发蓝牙相关app时，有没有遇到出现配对弹框的情况,如下：

WechatIMG2428.jpeg

在我的另一文章里面也能看到配对弹框的出来;flutter 实战App 之 提词器app;也是为了解决这个app的问题，就好好研究一下此问题~

上面的弹框，如果客户点击了取消，那么一切正常；如果客户点击了配对,那么你就会发现，你下次无法扫描到此设备，也没有办法去连接它，或者断开它。即使你关闭手机蓝牙开关，再打开，也没有用， 就算你把app kill掉，也无法解决。草~~

回到正题：什么时候会弹出配对，什么原因导致的

当硬件设备支持了ANCS标准，就会弹出配对框，（ 苹果iOS 7开始提供的ANCS协议，ANCS（苹果通知中心, Apple Notification Center Service）的目的是提供给蓝牙外设一种简单、方便的获取iOS设备通知信息的方式。使得蓝牙手环、手表可以收到苹果手机的来电、短信及各种应用的通知信息），更多信息可以参阅下面的链接，相信对你帮助

iOS ANCS介绍
处理ANCS设备连接绑定问题

那什么原因导致，选择了配对后，下次就再也没有办法发现外设呢；蓝牙有2层连接，一层连接是外设与app应用层之间的连接，还有一层连接是系统层的连接，也就是外设支持ANCS服务，客户选择了配对后，就建立起了连接。 选择配对后，如上所述，即使你关闭手机蓝牙开关，再打开，也没有用， 就算你把app kill掉，也无法解决,但此时，如果去手机里面蓝牙权限观察，就能看出，外设与手机在系统层连接一直是连接着的，外设一打开蓝牙，就自动连接上手机。

WechatIMG128.jpeg

但是我们要知道，虽然系统层的连接是建立的，这时app应用与外设的连接还没有建立 ，是没有办法控制设备的，或者说，代码级别我们是没有办法去扫描到设备，控制设备，连接设备的。如果想app应用能控制设备，是需要建立app应用层连接的。

解决办法

解决思路

那么我们能不能获取到，已经与手机系统层建立起连接的所有设备呢，如果能获取到设备列表，那么，我们找到此设备，就再直接去建立app应用层的连接就可以了，刚好，SDK里面有提供了获取设备列表的方法,如下

image.png

所以，代码思路就是，先去获取已经连接设备的列表 ，如果没有连接的设备，那么就直接当作一个新外设来扫描，扫描到了，去建立应用层连接；如果有连接的设备，就直接去建立应用层的连接，下面直接上代码了

    // Mark: 开始扫描
    func startScan() {
        
        let uuid2:CBUUID = CBUUID(string: "00001000-xxxx-419b-bc43-821e71a409b7")
        
        //用于获取已连接的设备,uuid是必传参数
        let peripherals = centralManager.retrieveConnectedPeripherals(withServices: [uuid2])
        if peripherals.count>0 {
            let temPeripheral = peripherals.first
            self.peripheral = temPeripheral
            self.peripheral.delegate = self
            centralManager.connect(self.peripheral)
            print("已经有设备连接,名称为：\(String(describing: self.peripheral.name))")
            
        } else {
            let uuid:CBUUID = CBUUID(string: "1812")
            centralManager.scanForPeripherals(withServices: [uuid], options: nil)
            print("没有设备连接")
            
        }
    }

完整代码如下：

//  ViewController.swift
//  Teleprompter_BLE
//  Created by zz on 2022/1/19.
import UIKit
import CoreBluetooth

class ViewController: UIViewController {
    
    //    var mBleTool: BleTool!
    
    //系统蓝牙设备管理对象，可以把他理解为主设备，通过他，可以去扫描和链接外设
    var centralManager: CBCentralManager!
    
    //一个全局的:CBPeripheral属性
    var peripheral:CBPeripheral!
    
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .red
        //设置主设备的委托，设置完成后会执行下面的centralManagerDidUpdateState函数
        centralManager = CBCentralManager(delegate: self, queue: nil)
        
        
        //        mBleTool = BleTool(uuid: "00001000-xxxx-419b-bc43-821e71a409b7")
        //        DispatchQueue.main.asyncAfter(deadline: .now()+0.1) {
        //            let list = self.mBleTool.getConnectedDevices()
        //            print("设备连接list=\(list)")
        //
        //        }
        
        
        
    }
    
    
    // Mark: 开始扫描
    func startScan() {
        
        let uuid2:CBUUID = CBUUID(string: "00001000-xxxx-419b-bc43-821e71a409b7")
        
        //用于获取已连接的设备,uuid是必传参数
        let peripherals = centralManager.retrieveConnectedPeripherals(withServices: [uuid2])
        if peripherals.count>0 {
            let temPeripheral = peripherals.first
            self.peripheral = temPeripheral
            self.peripheral.delegate = self
            centralManager.connect(self.peripheral)
            print("已经有设备连接,名称为：\(String(describing: self.peripheral.name))")
            
        } else {
            let uuid:CBUUID = CBUUID(string: "1812")
            centralManager.scanForPeripherals(withServices: [uuid], options: nil)
            print("没有设备连接")
            
        }
    }
    
    
}




extension ViewController: CBCentralManagerDelegate {
    
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        //确保本中心设备支持蓝牙低能耗（BLE）并开启时才能继续操作
        switch central.state{
        case .unknown:
            print("未知")
        case .resetting:
            print("蓝牙重置中")
        case .unsupported:
            print("本机不支持BLE")
        case .unauthorized:
            print("未授权")
        case .poweredOff:
            print("蓝牙未开启")
        case .poweredOn:
            do {
                print("蓝牙开启")
                
                startScan()
                
                
            }
        @unknown default:
            print("来自未来的错误")
        }
    }
    //MARK: didDiscover peripheral方法
    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
        
        print("didDiscover name:\(String(describing: peripheral.name))")
        
        //MARK: 注意点
        //如果想连接这个外设的话，一定要赋给某个变量（弄了个强引用）
        //不然系统不会把当前发现的这个外设分配给下面钩子函数里面的peripheral参数
        self.peripheral = peripheral
        
        centralManager.connect(self.peripheral, options: nil)
    }
    
    //MARK: 连接成功
    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
        //即将要使用peripheral的delegate方法，所以先委托self
        //寻找服务--立即（由已连接上的peripheral来）调用didDiscoverServices方法
        print("didConnect name:\(String(describing: peripheral.name))")
        
        
        //设置当前类为代理，接着去寻找外设服务，在CBPeripheralDelegate的代理方法中监听
        peripheral.delegate = self
        peripheral.discoverServices(nil)
        
        
    }
    
    //MARK: 连接失败
    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
        if let error = error {
            print("连接失败,原因是\(error.localizedDescription)")
        }
    }
    
    //MARK: 连接断开
    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
        
        if let error = error {
            print("连接失败,原因是\(error.localizedDescription)")
            
        }
        
    }
    
    
    
}


extension ViewController: CBPeripheralDelegate  {
    
    //MARK: 已发现服务（或发现失败）
    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        
        if let error = error {
            
            print("没找到服务，原因是\(error.localizedDescription)")
            
        }
        
        for service in peripheral.services! {
            
            //MARK: 寻找特征--立即调用didDiscoverCharacteristicsFor方法
            peripheral.discoverCharacteristics(nil, for: service)
        }
        
    }
    
    //MARK: 发现特征(重要方法）
    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        if let error = error {
            print("没找到特征，原因是\(error.localizedDescription)")
        }
        
        guard let characteristics = service.characteristics else { return }
        
        for characteristic in characteristics{
            
            print("didDiscoverCharacteristicsFor\(characteristic)")
            
            //type--若需要反馈，则调用didWriteValueForCharacteristic方法
            if characteristic.properties.contains(.write){
                peripheral.writeValue("100".data(using: .utf8)!, for: characteristic, type: .withResponse)
                
            }
            
            if characteristic.properties.contains(.read){
                //读取外设的数据(其实就是读取外设里某个特征的值value)--立即调用didUpdateValueFor
                //若读取成功则可通过characteristic.value取出值
                //适合读取静态值
                peripheral.readValue(for: characteristic)
            }
            if characteristic.properties.contains(.notify){
                //订阅外设的某个数据（某个特征的值）--达到实时更新数据的目的
                //订阅后会先调用didUpdateNotificationStateFor
                //若订阅成功，则每当特征值变化时都会（若true）调用didUpdateValueFor
                //适合读动态值--一直在变化的值--如：心率
                peripheral.setNotifyValue(true, for: characteristic)
            }
            //这里可以继续发现特征下面的描述--也可不做for循环而单独指定某个特征
            //peripheral.discoverDescriptors(for: characteristic)
            //之后会立即调用didDiscoverDescriptorsFor，可在里面获取描述值
        }
        
    }
    
    //MARK: 订阅状态
    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error{
            print("订阅失败，原因是\(error.localizedDescription)")
        }
        print("订阅成功")
    }
    
    //MARK: 读取(订阅)characteristic
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
        
        print("didUpdateValueFor value=\(String(describing: characteristic.value))")
        
        let bytes = [UInt8](characteristic.value!)
        print(bytes)
        
        print("ANCS：\(peripheral.ancsAuthorized)")
        
        if let error = error {
            print("读取失败，原因是\(error.localizedDescription)")
        }
        
    }
    
    //MARK: 写入characteristic
    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("写入失败，原因是\(error.localizedDescription)")
        }
        
    }
    
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor descriptor: CBDescriptor, error: Error?) {
        print("didUpdateValueFor descriptor")
        
    }
    
    func peripheral(_ peripheral: CBPeripheral, didModifyServices invalidatedServices: [CBService]) {
        print("didModifyServices")
        
    }
    
}

效果如下

888.gif

彩蛋：封装工具类BleTool，获取已连接着的设备列表

999.gif

BleTool类完整代码如下

//  BLETool.swift
//  Teleprompter_BLE
//  Created by zz on 2022/1/21.
//

import Foundation
import CoreBluetooth
@objc class BleTool: NSObject {
    
    //系统蓝牙设备管理对象，可以把他理解为主设备，通过他，可以去扫描和链接外设
    var centralManager: CBCentralManager!
    
    //一个全局的:CBPeripheral属性
    var peripheral:CBPeripheral!
    
    var currentUUID:String?
    
    
    
    init(uuid:String) {
        super.init()
        centralManager = CBCentralManager(delegate: self, queue: nil)
        currentUUID = uuid
        
    }
    
    
    func getConnectedDevices() ->[[String:String]] {
        
        var desList = [[String:String]]()
        
        
        guard let tempUUID = currentUUID else {
            
            print("uuid 传过来有问题")
            return []
        }
        
        let uuid:CBUUID = CBUUID(string: tempUUID)
        //用于获取已连接的设备
        let peripherals = centralManager.retrieveConnectedPeripherals(withServices: [uuid])
        if peripherals.count == 0 {
            print("没有连接着的设备")
            return []
        }
        print("连接着的设备数量:\(peripherals.count)")
        
        peripherals.forEach { peripheral in
            var dict = [String :String]()
            dict["id"] = peripheral.identifier.uuidString
            dict["name"] = peripheral.name
            desList.append(dict)
            
        }
        
        return desList
    }
    
    
    
    func startScan() {
        let uuid:CBUUID = CBUUID(string: "1812")
        
        centralManager.scanForPeripherals(withServices: [uuid], options: nil)
        print("开始扫描")
        
    }

    
}




extension BleTool: CBCentralManagerDelegate {
    
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        //确保本中心设备支持蓝牙低能耗（BLE）并开启时才能继续操作
        switch central.state{
        case .unknown:
            print("未知")
        case .resetting:
            print("蓝牙重置中")
        case .unsupported:
            print("本机不支持BLE")
        case .unauthorized:
            print("未授权")
        case .poweredOff:
            print("蓝牙未开启")
        case .poweredOn:
            do {
                print("蓝牙开启")
                
                //                startScan()
                
            }
        @unknown default:
            print("来自未来的错误")
        }
    }
    //MARK: didDiscover peripheral方法
    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
        
        print("didDiscover name:\(String(describing: peripheral.name))")
        
        //        let name = advertisementData[CBAdvertisementDataLocalNameKey] as? String
        //
        //        print("name\(name)")
        
        //在这里（还未连接设备时）可以获取advertisementData和rssi
        //MARK: 注意点
        //如果想连接这个外设的话，一定要赋给某个变量（弄了个强引用）
        //不然系统不会把当前发现的这个外设分配给下面钩子函数里面的peripheral参数
        self.peripheral = peripheral
        
        centralManager.connect(self.peripheral, options: nil)
    }
    //MARK: 连接成功
    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
        //即将要使用peripheral的delegate方法，所以先委托self
        //寻找服务--立即（由已连接上的peripheral来）调用didDiscoverServices方法
        print("didConnect name:\(String(describing: peripheral.name))")
        
        peripheral.delegate = self
        peripheral.discoverServices(nil)
        
        
    }
    
    //MARK: 连接失败
    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
        if let error = error {
            print("连接失败,原因是\(error.localizedDescription)")
        }
    }
    
    //MARK: 连接断开
    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
        
        if let error = error {
            print("连接失败,原因是\(error.localizedDescription)")
            
        }
        
    }
    
    
    
}


extension BleTool: CBPeripheralDelegate{
    
    //MARK: 已发现服务（或发现失败）
    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        
        if let error = error {
            
            print("没找到服务，原因是\(error.localizedDescription)")
            
        }
        
        for service in peripheral.services! {
            
            //MARK: 寻找特征--立即调用didDiscoverCharacteristicsFor方法
            peripheral.discoverCharacteristics(nil, for: service)
        }
        
    }
    
    //MARK: 发现特征(重要方法）
    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        if let error = error {
            print("没找到特征，原因是\(error.localizedDescription)")
        }
        
        guard let characteristics = service.characteristics else { return }
        
        for characteristic in characteristics{
            
            print("didDiscoverCharacteristicsFor\(characteristic)")
            
            //type--若需要反馈，则调用didWriteValueForCharacteristic方法
            if characteristic.properties.contains(.write){
                peripheral.writeValue("100".data(using: .utf8)!, for: characteristic, type: .withResponse)
                
            }
            
            if characteristic.properties.contains(.read){
                //读取外设的数据(其实就是读取外设里某个特征的值value)--立即调用didUpdateValueFor
                //若读取成功则可通过characteristic.value取出值
                //适合读取静态值
                peripheral.readValue(for: characteristic)
            }
            if characteristic.properties.contains(.notify){
                //订阅外设的某个数据（某个特征的值）--达到实时更新数据的目的
                //订阅后会先调用didUpdateNotificationStateFor
                //若订阅成功，则每当特征值变化时都会（若true）调用didUpdateValueFor
                //适合读动态值--一直在变化的值--如：心率
                peripheral.setNotifyValue(true, for: characteristic)
            }
            //这里可以继续发现特征下面的描述--也可不做for循环而单独指定某个特征
            //peripheral.discoverDescriptors(for: characteristic)
            //之后会立即调用didDiscoverDescriptorsFor，可在里面获取描述值
        }
        
    }
    
    //MARK: 订阅状态
    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error{
            print("订阅失败，原因是\(error.localizedDescription)")
        }
        print("订阅成功")
    }
    
    //MARK: 读取(订阅)characteristic
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
        
        print("didUpdateValueFor value=\(String(describing: characteristic.value))")
        
        let bytes = [UInt8](characteristic.value!)
        print(bytes)
        
        
        print("ANCS：\(peripheral.ancsAuthorized)")
        
        
        if let error = error {
            print("读取失败，原因是\(error.localizedDescription)")
        }
        
    }
    
    //MARK: 写入characteristic
    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("写入失败，原因是\(error.localizedDescription)")
        }
        
    }
    
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor descriptor: CBDescriptor, error: Error?) {
        print("didUpdateValueFor descriptor")
        
    }
    
    func peripheral(_ peripheral: CBPeripheral, didModifyServices invalidatedServices: [CBService]) {
        print("didModifyServices")
        
    }
    
}

调用工具类BleTool的地方,就简单清爽了，哈哈

//  ViewController.swift
//  Teleprompter_BLE
//  Created by zz on 2022/1/19.

import UIKit
import CoreBluetooth

class ViewController: UIViewController {
    
    var mBleTool: BleTool!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .red
        
        mBleTool = BleTool(uuid: "00001000-xxxx-419b-bc43-821e71a409b7")
        DispatchQueue.main.asyncAfter(deadline: .now()+0.1) {
            let list = self.mBleTool.getConnectedDevices()
            print("设备连接list=\(list)")
            
            if list.count == 0 {
                
                self.mBleTool.startScan()
            }
            
        }
        
    }
    
}

结尾

今天的分享至此接近尾声喽，小伴们,觉得有点用的话，或者已经看到这里面来的请点赞加关注吧~~ 后续分享更多物联网相关技术的文章。如果有疑问的话，欢迎在下方留言~ 新年好运！！！！