0f4fb7f553
* fix: 重构 * fix: 1 * fix: 重构 * fix: 修复 iOS 和 macOS 代码错误 * fix: 优化项目 * fix: 构建项目 * fix: 修复权限问题 * fix: 解决 macOS 沙盒权限问题 * fix: 修复代码问题 * fix: 更新依赖 * fix: 更新依赖项 * fix: 添加缺失的位置权限
723 lines
29 KiB
Swift
723 lines
29 KiB
Swift
//
|
|
// MyCentralController.swift
|
|
// bluetooth_low_energy_ios
|
|
//
|
|
// Created by 闫守旺 on 2023/8/13.
|
|
//
|
|
|
|
import Foundation
|
|
import CoreBluetooth
|
|
#if os(iOS)
|
|
import Flutter
|
|
#elseif os(macOS)
|
|
import FlutterMacOS
|
|
#else
|
|
#error("Unsupported platform.")
|
|
#endif
|
|
|
|
class MyCentralController: MyCentralControllerHostApi {
|
|
init(_ binaryMessenger: FlutterBinaryMessenger) {
|
|
myApi = MyCentralControllerFlutterApi(binaryMessenger: binaryMessenger)
|
|
}
|
|
|
|
private let myApi: MyCentralControllerFlutterApi
|
|
private lazy var myCentralManagerDelegate = MyCentralManagerDelegate(self)
|
|
private lazy var myPeripheralDelegate = MyPeripheralDelegate(self)
|
|
private let centralManager = CBCentralManager()
|
|
|
|
private var cachedPeripherals = [Int: CBPeripheral]()
|
|
private var cachedServices = [Int: [Int: CBService]]()
|
|
private var cachedCharacteristics = [Int: [Int: CBCharacteristic]]()
|
|
private var cachedDescriptors = [Int: [Int: CBDescriptor]]()
|
|
|
|
var setUpCompletion: ((Result<MyCentralControllerArgs, Error>) -> Void)?
|
|
var connectCompletions = [Int: (Result<Void, Error>) -> Void]()
|
|
var disconnectCompletions = [Int: (Result<Void, Error>) -> Void]()
|
|
var discoverGattCompletions = [Int: (Result<Void, Error>) -> Void]()
|
|
var unfinishedServices = [Int: [CBService]]()
|
|
var unfinishedCharacteristics = [Int: [CBCharacteristic]]()
|
|
var readCharacteristicCompletions = [Int: (Result<FlutterStandardTypedData, Error>) -> Void]()
|
|
var writeCharacteristicCompletions = [Int: (Result<Void, Error>) -> Void]()
|
|
var notifyCharacteristicCompletions = [Int: (Result<Void, Error>) -> Void]()
|
|
var readDescriptorCompletions = [Int: (Result<FlutterStandardTypedData, Error>) -> Void]()
|
|
var writeDescriptorCompletions = [Int: (Result<Void, Error>) -> Void]()
|
|
|
|
func setUp(completion: @escaping (Result<MyCentralControllerArgs, Error>) -> Void) {
|
|
do {
|
|
let unfinishedCompletion = setUpCompletion
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
centralManager.delegate = myCentralManagerDelegate
|
|
if centralManager.state == .unknown {
|
|
setUpCompletion = completion
|
|
} else {
|
|
let myStateArgs = centralManager.state.toMyArgs()
|
|
let myStateNumber = Int64(myStateArgs.rawValue)
|
|
let myArgs = MyCentralControllerArgs(myStateNumber: myStateNumber)
|
|
completion(.success(myArgs))
|
|
}
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func tearDown() throws {
|
|
centralManager.delegate = nil
|
|
if(centralManager.isScanning) {
|
|
centralManager.stopScan()
|
|
}
|
|
for peripheral in cachedPeripherals.values {
|
|
peripheral.delegate = nil
|
|
if peripheral.state != .disconnected {
|
|
centralManager.cancelPeripheralConnection(peripheral)
|
|
}
|
|
}
|
|
cachedPeripherals.removeAll()
|
|
cachedServices.removeAll()
|
|
cachedCharacteristics.removeAll()
|
|
cachedDescriptors.removeAll()
|
|
}
|
|
|
|
func startDiscovery() throws {
|
|
let options = [CBCentralManagerScanOptionAllowDuplicatesKey: true]
|
|
centralManager.scanForPeripherals(withServices: nil, options: options)
|
|
}
|
|
|
|
func stopDiscovery() throws {
|
|
centralManager.stopScan()
|
|
}
|
|
|
|
func connect(myPeripheralKey: Int64, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
let unfinishedCompletion = connectCompletions[peripheralKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
centralManager.connect(peripheral)
|
|
connectCompletions[peripheralKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func disconnect(myPeripheralKey: Int64, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
let unfinishedCompletion = disconnectCompletions[peripheralKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
centralManager.cancelPeripheralConnection(peripheral)
|
|
disconnectCompletions[peripheralKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func discoverGATT(myPeripheralKey: Int64, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
let unfinishedCompletion = discoverGattCompletions[peripheralKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
peripheral.discoverServices(nil)
|
|
discoverGattCompletions[peripheralKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func getServices(myPeripheralKey: Int64) throws -> [MyGattServiceArgs] {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
guard let services = cachedServices[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
return services.map { (key, service) in
|
|
return service.toMyArgs()
|
|
}
|
|
}
|
|
|
|
func getCharacteristics(myServiceKey: Int64) throws -> [MyGattCharacteristicArgs] {
|
|
let serviceKey = Int(myServiceKey)
|
|
guard let characteristics = cachedCharacteristics[serviceKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
return characteristics.map { (key, characteristic) in
|
|
return characteristic.toMyArgs()
|
|
}
|
|
}
|
|
|
|
func getDescriptors(myCharacteristicKey: Int64) throws -> [MyGattDescriptorArgs] {
|
|
let characteristicKey = Int(myCharacteristicKey)
|
|
guard let descriptors = cachedDescriptors[characteristicKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
return descriptors.map { (key, descriptor) in
|
|
return descriptor.toMyArgs()
|
|
}
|
|
}
|
|
|
|
func readCharacteristic(myPeripheralKey: Int64, myServiceKey: Int64, myCharacteristicKey: Int64, completion: @escaping (Result<FlutterStandardTypedData, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let serviceKey = Int(myServiceKey)
|
|
guard let characteristics = cachedCharacteristics[serviceKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let characteristicKey = Int(myCharacteristicKey)
|
|
guard let characteristic = characteristics[characteristicKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let unfinishedCompletion = readCharacteristicCompletions[characteristicKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
peripheral.readValue(for: characteristic)
|
|
readCharacteristicCompletions[characteristicKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func writeCharacteristic(myPeripheralKey: Int64, myServiceKey: Int64, myCharacteristicKey: Int64, value: FlutterStandardTypedData, myTypeNumber: Int64, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let serviceKey = Int(myServiceKey)
|
|
guard let characteristics = cachedCharacteristics[serviceKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let characteristicKey = Int(myCharacteristicKey)
|
|
guard let characteristic = characteristics[characteristicKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let data = value.data
|
|
let myTypeRawValue = Int(myTypeNumber)
|
|
guard let myTypeArgs = MyGattCharacteristicWriteTypeArgs(rawValue: myTypeRawValue) else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let type = myTypeArgs.toType()
|
|
let unfinishedCompletion = writeCharacteristicCompletions[characteristicKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
peripheral.writeValue(data, for: characteristic, type: type)
|
|
writeCharacteristicCompletions[characteristicKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func notifyCharacteristic(myPeripheralKey: Int64, myServiceKey: Int64, myCharacteristicKey: Int64, state: Bool, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let serviceKey = Int(myServiceKey)
|
|
guard let characteristics = cachedCharacteristics[serviceKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let characteristicKey = Int(myCharacteristicKey)
|
|
guard let characteristic = characteristics[characteristicKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let unfinishedCompletion = notifyCharacteristicCompletions[characteristicKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
peripheral.setNotifyValue(state, for: characteristic)
|
|
notifyCharacteristicCompletions[characteristicKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func readDescriptor(myPeripheralKey: Int64, myCharacteristicKey: Int64, myDescriptorKey: Int64, completion: @escaping (Result<FlutterStandardTypedData, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let characteristicKey = Int(myCharacteristicKey)
|
|
guard let descriptors = cachedDescriptors[characteristicKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let descriptorKey = Int(myDescriptorKey)
|
|
guard let descriptor = descriptors[descriptorKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let unfinishedCompletion = readDescriptorCompletions[descriptorKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
peripheral.readValue(for: descriptor)
|
|
readDescriptorCompletions[descriptorKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func writeDescriptor(myPeripheralKey: Int64, myCharacteristicKey: Int64, myDescriptorKey: Int64, value: FlutterStandardTypedData, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
do {
|
|
let peripheralKey = Int(myPeripheralKey)
|
|
guard let peripheral = cachedPeripherals[peripheralKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let characteristicKey = Int(myCharacteristicKey)
|
|
guard let descriptors = cachedDescriptors[characteristicKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let descriptorKey = Int(myDescriptorKey)
|
|
guard let descriptor = descriptors[descriptorKey] else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let data = value.data
|
|
let unfinishedCompletion = writeDescriptorCompletions[descriptorKey]
|
|
if unfinishedCompletion != nil {
|
|
throw MyError.illegalState
|
|
}
|
|
peripheral.writeValue(data, for: descriptor)
|
|
writeDescriptorCompletions[descriptorKey] = completion
|
|
} catch {
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
|
|
func didUpdateState(_ state: CBManagerState) {
|
|
let completion = setUpCompletion
|
|
if state != .unknown && completion != nil {
|
|
let myStateArgs = state.toMyArgs()
|
|
let myStateNumber = Int64(myStateArgs.rawValue)
|
|
let myArgs = MyCentralControllerArgs(myStateNumber: myStateNumber)
|
|
completion!(.success(myArgs))
|
|
setUpCompletion = nil
|
|
}
|
|
let myStateArgs = state.toMyArgs()
|
|
let myStateNumber = Int64(myStateArgs.rawValue)
|
|
myApi.onStateChanged(myStateNumber: myStateNumber) {}
|
|
}
|
|
|
|
|
|
func didDiscover(_ peripheral: CBPeripheral, _ advertisementData: [String : Any], _ rssiNumber: NSNumber) {
|
|
let peripheralKey = peripheral.hash
|
|
if cachedPeripherals[peripheralKey] == nil {
|
|
peripheral.delegate = myPeripheralDelegate
|
|
cachedPeripherals[peripheralKey] = peripheral
|
|
}
|
|
let myPeripheralArgs = peripheral.toMyArgs()
|
|
let rssi = rssiNumber.int64Value
|
|
let name = advertisementData[CBAdvertisementDataLocalNameKey] as? String
|
|
let rawManufacturerSpecificData = advertisementData[CBAdvertisementDataManufacturerDataKey] as? Data
|
|
var manufacturerSpecificData = [Int64: FlutterStandardTypedData]()
|
|
if rawManufacturerSpecificData != nil {
|
|
do {
|
|
guard let data = rawManufacturerSpecificData else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
guard data.count >= 2 else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
let key = Int64(data[0]) | (Int64(data[1]) << 8)
|
|
let bytes = data.count > 2 ? data[2...data.count-1] : Data()
|
|
let value = FlutterStandardTypedData(bytes: bytes)
|
|
manufacturerSpecificData[key] = value
|
|
} catch {
|
|
manufacturerSpecificData = [:]
|
|
}
|
|
}
|
|
let rawServiceUUIDs = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] ?? []
|
|
let serviceUUIDs = rawServiceUUIDs.map { uuid in uuid.uuidString }
|
|
let rawServiceData = advertisementData[CBAdvertisementDataServiceDataKey] as? [CBUUID: Data] ?? [:]
|
|
let elements = rawServiceData.map { (uuid, data) in
|
|
let key = uuid.uuidString
|
|
let value = FlutterStandardTypedData(bytes: data)
|
|
return (key, value)
|
|
}
|
|
let serviceData = [String?: FlutterStandardTypedData?](uniqueKeysWithValues: elements)
|
|
let myAdvertisementArgs = MyAdvertisementArgs(name: name, manufacturerSpecificData: manufacturerSpecificData, serviceUUIDs: serviceUUIDs, serviceData: serviceData)
|
|
myApi.onDiscovered(myPeripheralArgs: myPeripheralArgs, rssi: rssi, myAdvertisementArgs: myAdvertisementArgs) {}
|
|
}
|
|
|
|
func didConnect(_ peripheral: CBPeripheral) {
|
|
let peripheralKey = peripheral.hash
|
|
let myPeripheralKey = Int64(peripheralKey)
|
|
myApi.onPeripheralStateChanged(myPeripheralKey: myPeripheralKey, state: true) {}
|
|
guard let completion = connectCompletions.removeValue(forKey: peripheralKey) else {
|
|
return
|
|
}
|
|
completion(.success(()))
|
|
}
|
|
|
|
func didFailToConnect(_ peripheral: CBPeripheral, _ error: Error?) {
|
|
let peripheralKey = peripheral.hash
|
|
guard let completion = connectCompletions.removeValue(forKey: peripheralKey) else {
|
|
return
|
|
}
|
|
completion(.failure(error ?? MyError.unknown))
|
|
}
|
|
|
|
func didDisconnectPeripheral(_ peripheral: CBPeripheral, _ error: Error?) {
|
|
let peripheralKey = peripheral.hash
|
|
let myPeripheralKey = Int64(peripheralKey)
|
|
let discoverGattCompletion = discoverGattCompletions.removeValue(forKey: peripheralKey)
|
|
if discoverGattCompletion != nil {
|
|
didDiscoverGATT(peripheral, error ?? MyError.unknown)
|
|
}
|
|
let services = cachedServices[peripheralKey] ?? [:]
|
|
for service in services {
|
|
let characteristics = cachedCharacteristics[service.key] ?? [:]
|
|
for characteristic in characteristics {
|
|
let readCharacteristicCompletion = readCharacteristicCompletions.removeValue(forKey: characteristic.key)
|
|
let writeCharacteristicCompletion = writeCharacteristicCompletions.removeValue(forKey: characteristic.key)
|
|
if readCharacteristicCompletion != nil {
|
|
readCharacteristicCompletion!(.failure(MyError.illegalState))
|
|
}
|
|
if writeCharacteristicCompletion != nil {
|
|
writeCharacteristicCompletion!(.failure(MyError.illegalState))
|
|
}
|
|
let descriptors = cachedDescriptors[characteristic.key] ?? [:]
|
|
for descriptor in descriptors {
|
|
let readDescriptorCompletion = readDescriptorCompletions.removeValue(forKey: descriptor.key)
|
|
let writeDescriptorCompletion = writeDescriptorCompletions.removeValue(forKey: descriptor.key)
|
|
if readDescriptorCompletion != nil {
|
|
readDescriptorCompletion!(.failure(MyError.illegalState))
|
|
}
|
|
if writeDescriptorCompletion != nil {
|
|
writeDescriptorCompletion!(.failure(MyError.illegalState))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
myApi.onPeripheralStateChanged(myPeripheralKey: myPeripheralKey, state: false) {}
|
|
guard let completion = disconnectCompletions.removeValue(forKey: peripheralKey) else {
|
|
return
|
|
}
|
|
if error == nil {
|
|
completion(.success(()))
|
|
} else {
|
|
completion(.failure(error!))
|
|
}
|
|
}
|
|
|
|
|
|
func didDiscoverServices(_ peripheral: CBPeripheral, _ error: Error?) {
|
|
let peripheralKey = peripheral.hash
|
|
if error == nil {
|
|
var services = peripheral.services ?? []
|
|
if services.isEmpty {
|
|
didDiscoverGATT(peripheral, error)
|
|
} else {
|
|
let service = services.removeFirst()
|
|
unfinishedServices[peripheralKey] = services
|
|
peripheral.discoverCharacteristics(nil, for: service)
|
|
}
|
|
} else {
|
|
didDiscoverGATT(peripheral, error)
|
|
}
|
|
}
|
|
|
|
func didDiscoverCharacteristics(_ peripheral: CBPeripheral, _ service: CBService, _ error: Error?) {
|
|
let peripheralKey = peripheral.hash
|
|
if error == nil {
|
|
var characteristics = service.characteristics ?? []
|
|
if characteristics.isEmpty {
|
|
var services = unfinishedServices.removeValue(forKey: peripheralKey) ?? []
|
|
if services.isEmpty {
|
|
didDiscoverGATT(peripheral, error)
|
|
} else {
|
|
let service = services.removeFirst()
|
|
unfinishedServices[peripheralKey] = services
|
|
peripheral.discoverCharacteristics(nil, for: service)
|
|
}
|
|
} else {
|
|
let characteristic = characteristics.removeFirst()
|
|
unfinishedCharacteristics[peripheralKey] = characteristics
|
|
peripheral.discoverDescriptors(for: characteristic)
|
|
}
|
|
} else {
|
|
didDiscoverGATT(peripheral, error)
|
|
}
|
|
}
|
|
|
|
func didDiscoverDescriptors(_ peripheral: CBPeripheral, _ characteristic: CBCharacteristic, _ error: Error?) {
|
|
let peripheralKey = peripheral.hash
|
|
if error == nil {
|
|
var characteristics = unfinishedCharacteristics.removeValue(forKey: peripheralKey) ?? []
|
|
if (characteristics.isEmpty) {
|
|
var services = unfinishedServices.removeValue(forKey: peripheralKey) ?? []
|
|
if services.isEmpty {
|
|
didDiscoverGATT(peripheral, error)
|
|
} else {
|
|
let service = services.removeFirst()
|
|
unfinishedServices[peripheralKey] = services
|
|
peripheral.discoverCharacteristics(nil, for: service)
|
|
}
|
|
} else {
|
|
let characteristic = characteristics.removeFirst()
|
|
unfinishedCharacteristics[peripheralKey] = characteristics
|
|
peripheral.discoverDescriptors(for: characteristic)
|
|
}
|
|
} else {
|
|
didDiscoverGATT(peripheral, error)
|
|
}
|
|
}
|
|
|
|
private func didDiscoverGATT(_ peripheral: CBPeripheral, _ error: Error?) {
|
|
let peripheralKey = peripheral.hash
|
|
unfinishedServices.removeValue(forKey: peripheralKey)
|
|
unfinishedCharacteristics.removeValue(forKey: peripheralKey)
|
|
guard let completion = discoverGattCompletions.removeValue(forKey: peripheralKey) else {
|
|
return
|
|
}
|
|
if error == nil {
|
|
let services = peripheral.services ?? []
|
|
var cachedServices = [Int: CBService]()
|
|
for service in services {
|
|
let serviceKey = service.hash
|
|
cachedServices[serviceKey] = service
|
|
let characteristics = service.characteristics ?? []
|
|
var cachedCharacteristics = [Int: CBCharacteristic]()
|
|
for characteristic in characteristics {
|
|
let characteristicKey = characteristic.hash
|
|
cachedCharacteristics[characteristicKey] = characteristic
|
|
let descriptors = characteristic.descriptors ?? []
|
|
var cachedDescriptors = [Int: CBDescriptor]()
|
|
for descriptor in descriptors {
|
|
let descriptorKey = descriptor.hash
|
|
cachedDescriptors[descriptorKey] = descriptor
|
|
}
|
|
self.cachedDescriptors[characteristicKey] = cachedDescriptors
|
|
}
|
|
self.cachedCharacteristics[serviceKey] = cachedCharacteristics
|
|
}
|
|
self.cachedServices[peripheralKey] = cachedServices
|
|
completion(.success(()))
|
|
} else {
|
|
completion(.failure(error!))
|
|
}
|
|
}
|
|
|
|
func didUpdateCharacteristicValue(_ characteristic: CBCharacteristic, _ error: Error?) {
|
|
let characteristicKey = characteristic.hash
|
|
guard let completion = readCharacteristicCompletions.removeValue(forKey: characteristicKey) else {
|
|
let myCharacteristicKey = Int64(characteristicKey)
|
|
let rawValue = characteristic.value ?? Data()
|
|
let value = FlutterStandardTypedData(bytes: rawValue)
|
|
myApi.onCharacteristicValueChanged(myCharacteristicKey: myCharacteristicKey, value: value) {}
|
|
return
|
|
}
|
|
if error == nil {
|
|
let rawValue = characteristic.value ?? Data()
|
|
let value = FlutterStandardTypedData(bytes: rawValue)
|
|
completion(.success(value))
|
|
} else {
|
|
completion(.failure(error!))
|
|
}
|
|
}
|
|
|
|
func didWriteCharacteristicValue(_ characteristic: CBCharacteristic, _ error: Error?) {
|
|
let characteristicKey = characteristic.hash
|
|
guard let completion = writeCharacteristicCompletions.removeValue(forKey: characteristicKey) else {
|
|
return
|
|
}
|
|
if error == nil {
|
|
completion(.success(()))
|
|
} else {
|
|
completion(.failure(error!))
|
|
}
|
|
}
|
|
|
|
func didUpdateNotificationState(_ characteristic: CBCharacteristic, _ error: Error?) {
|
|
let characteristicKey = characteristic.hash
|
|
guard let completion = notifyCharacteristicCompletions.removeValue(forKey: characteristicKey) else {
|
|
return
|
|
}
|
|
if error == nil {
|
|
completion(.success(()))
|
|
} else {
|
|
completion(.failure(error!))
|
|
}
|
|
}
|
|
|
|
func didUpdateDescriptorValue(_ descriptor: CBDescriptor, _ error: Error?) {
|
|
let descriptorKey = descriptor.hash
|
|
guard let completion = readDescriptorCompletions.removeValue(forKey: descriptorKey) else {
|
|
return
|
|
}
|
|
if error == nil {
|
|
// TODO: Need to confirm wheather the corresponding descriptor type and value is correct.
|
|
let value: FlutterStandardTypedData
|
|
let rawValue = descriptor.value
|
|
do {
|
|
switch descriptor.uuid.uuidString {
|
|
case CBUUIDCharacteristicExtendedPropertiesString:
|
|
fallthrough
|
|
case CBUUIDClientCharacteristicConfigurationString:
|
|
fallthrough
|
|
case CBUUIDServerCharacteristicConfigurationString:
|
|
guard let rawNumber = rawValue as? NSNumber else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
value = FlutterStandardTypedData(bytes: rawNumber.data)
|
|
case CBUUIDCharacteristicUserDescriptionString:
|
|
fallthrough
|
|
case CBUUIDCharacteristicAggregateFormatString:
|
|
guard let rawString = rawValue as? String else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
value = FlutterStandardTypedData(bytes: rawString.data)
|
|
case CBUUIDCharacteristicFormatString:
|
|
guard let rawData = rawValue as? Data else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
value = FlutterStandardTypedData(bytes: rawData)
|
|
case CBUUIDL2CAPPSMCharacteristicString:
|
|
guard let rawU16 = rawValue as? UInt16 else {
|
|
throw MyError.illegalArgument
|
|
}
|
|
value = FlutterStandardTypedData(bytes: rawU16.data)
|
|
default:
|
|
throw MyError.illegalArgument
|
|
}
|
|
} catch {
|
|
value = FlutterStandardTypedData()
|
|
}
|
|
completion(.success((value)))
|
|
} else {
|
|
completion(.failure(error!))
|
|
}
|
|
}
|
|
|
|
func didWriteDescriptorValue(_ descriptor: CBDescriptor, _ error: Error?) {
|
|
let descriptorKey = descriptor.hash
|
|
guard let completion = writeDescriptorCompletions.removeValue(forKey: descriptorKey) else {
|
|
return
|
|
}
|
|
if error == nil {
|
|
completion(.success(()))
|
|
} else {
|
|
completion(.failure(error!))
|
|
}
|
|
}
|
|
}
|
|
|
|
extension CBManagerState {
|
|
func toMyArgs() -> MyCentralStateArgs {
|
|
switch self {
|
|
case .unauthorized:
|
|
return .unauthorized
|
|
case .poweredOff:
|
|
return .poweredOff
|
|
case .poweredOn:
|
|
return .poweredOn
|
|
default:
|
|
return .unsupported
|
|
}
|
|
}
|
|
}
|
|
|
|
extension CBPeripheral {
|
|
func toMyArgs() -> MyPeripheralArgs {
|
|
let key = Int64(hash)
|
|
let uuid = identifier.uuidString
|
|
return MyPeripheralArgs(key: key, uuid: uuid)
|
|
}
|
|
}
|
|
|
|
extension CBService {
|
|
func toMyArgs() -> MyGattServiceArgs {
|
|
let key = Int64(hash)
|
|
let uuid = uuid.uuidString
|
|
return MyGattServiceArgs(key: key, uuid: uuid)
|
|
}
|
|
}
|
|
|
|
extension CBCharacteristic {
|
|
func toMyArgs() -> MyGattCharacteristicArgs {
|
|
let key = Int64(hash)
|
|
let uuid = uuid.uuidString
|
|
let myPropertyArgses = properties.toMyArgses()
|
|
let myPropertyNumbers = myPropertyArgses.map { myPropertyArgs in Int64(myPropertyArgs.rawValue) }
|
|
return MyGattCharacteristicArgs(key: key, uuid: uuid, myPropertyNumbers: myPropertyNumbers)
|
|
}
|
|
}
|
|
|
|
extension CBDescriptor {
|
|
func toMyArgs() -> MyGattDescriptorArgs {
|
|
let key = Int64(hash)
|
|
let uuid = uuid.uuidString
|
|
return MyGattDescriptorArgs(key: key, uuid: uuid)
|
|
}
|
|
}
|
|
|
|
extension CBCharacteristicProperties {
|
|
func toMyArgses() -> [MyGattCharacteristicPropertyArgs] {
|
|
var myPropertyArgs = [MyGattCharacteristicPropertyArgs]()
|
|
if contains(.read) {
|
|
myPropertyArgs.append(.read)
|
|
}
|
|
if contains(.write) {
|
|
myPropertyArgs.append(.write)
|
|
}
|
|
if contains(.writeWithoutResponse) {
|
|
myPropertyArgs.append(.writeWithoutResponse)
|
|
}
|
|
if contains(.notify) {
|
|
myPropertyArgs.append(.notify)
|
|
}
|
|
if contains(.indicate) {
|
|
myPropertyArgs.append(.indicate)
|
|
}
|
|
return myPropertyArgs
|
|
}
|
|
}
|
|
|
|
extension MyGattCharacteristicWriteTypeArgs {
|
|
func toType() -> CBCharacteristicWriteType {
|
|
switch self {
|
|
case .withResponse:
|
|
return .withResponse
|
|
case .withoutResponse:
|
|
return .withoutResponse
|
|
}
|
|
}
|
|
}
|
|
|
|
extension NSNumber {
|
|
var data: Data {
|
|
var source = self
|
|
return Data(bytes: &source, count: MemoryLayout<NSNumber>.size)
|
|
}
|
|
}
|
|
|
|
extension String {
|
|
var data: Data {
|
|
return data(using: String.Encoding.utf8)!
|
|
}
|
|
}
|
|
|
|
extension UInt16 {
|
|
var data: Data {
|
|
var source = self
|
|
return Data(bytes: &source, count: MemoryLayout<UInt16>.size)
|
|
}
|
|
}
|