Core Bluetooth

import CoreBluetooth
final class BluetoothManager: NSObject, CBCentralManagerDelegate {    private var centralManager: CBCentralManager!    private var discoveredPeripheral: CBPeripheral?
    override init() {        super.init()        centralManager = CBCentralManager(delegate: self, queue: nil)    }
    func centralManagerDidUpdateState(_ central: CBCentralManager) {        guard central.state == .poweredOn else { return }        startScanning()    }}

let heartRateServiceUUID = CBUUID(string: "180D")
func startScanning() {    centralManager.scanForPeripherals(        withServices: [heartRateServiceUUID],        options: [CBCentralManagerScanOptionAllowDuplicatesKey: false]    )}
func centralManager(    _ central: CBCentralManager,    didDiscover peripheral: CBPeripheral,    advertisementData: [String: Any],    rssi RSSI: NSNumber) {    guard RSSI.intValue > -70 else { return } // Filter weak signals
    // IMPORTANT: Retain the peripheral -- it will be deallocated otherwise    discoveredPeripheral = peripheral    centralManager.stopScan()    centralManager.connect(peripheral, options: nil)}

func centralManager(    _ central: CBCentralManager,    didConnect peripheral: CBPeripheral) {    peripheral.delegate = self    peripheral.discoverServices([heartRateServiceUUID])}
func centralManager(    _ central: CBCentralManager,    didDisconnectPeripheral peripheral: CBPeripheral,    timestamp: CFAbsoluteTime,    isReconnecting: Bool,    error: Error?) {    if isReconnecting {        // System is automatically reconnecting        return    }    // Handle disconnection -- optionally reconnect    discoveredPeripheral = nil}

extension BluetoothManager: CBPeripheralDelegate {    func peripheral(        _ peripheral: CBPeripheral,        didDiscoverServices error: Error?    ) {        guard let services = peripheral.services else { return }        for service in services {            peripheral.discoverCharacteristics(nil, for: service)        }    }
    func peripheral(        _ peripheral: CBPeripheral,        didDiscoverCharacteristicsFor service: CBService,        error: Error?    ) {        guard let characteristics = service.characteristics else { return }        for characteristic in characteristics {            if characteristic.properties.contains(.notify) {                peripheral.setNotifyValue(true, for: characteristic)            }            if characteristic.properties.contains(.read) {                peripheral.readValue(for: characteristic)            }        }    }}

func peripheral(    _ peripheral: CBPeripheral,    didUpdateValueFor characteristic: CBCharacteristic,    error: Error?) {    guard let data = characteristic.value else { return }
    switch characteristic.uuid {    case CBUUID(string: "2A37"):        if let heartRate = parseHeartRate(data) {            print("Heart rate: \(heartRate) bpm")        }    case CBUUID(string: "2A19"):        let batteryLevel = data.first.map { Int($0) } ?? 0        print("Battery: \(batteryLevel)%")    default:        break    }}
private func parseHeartRate(_ data: Data) -> Int? {    guard data.count >= 2 else { return nil }    let flags = data[0]    let is16Bit = (flags & 0x01) != 0    if is16Bit {        guard data.count >= 3 else { return nil }        return Int(data[1]) | (Int(data[2]) << 8)    } else {        return Int(data[1])    }}

func writeValue(_ data: Data, to characteristic: CBCharacteristic,                on peripheral: CBPeripheral,                preferResponse: Bool = true) {    let type: CBCharacteristicWriteType    if preferResponse, characteristic.properties.contains(.write) {        type = .withResponse    } else if characteristic.properties.contains(.writeWithoutResponse),              peripheral.canSendWriteWithoutResponse {        type = .withoutResponse    } else if characteristic.properties.contains(.write) {        type = .withResponse    } else {        return    }
    guard data.count <= peripheral.maximumWriteValueLength(for: type) else { return }    peripheral.writeValue(data, for: characteristic, type: type)}
// Confirmation callback for .withResponse writes.func peripheral(    _ peripheral: CBPeripheral,    didWriteValueFor characteristic: CBCharacteristic,    error: Error?) {    if let error {        print("Write failed: \(error.localizedDescription)")    }}
// Resume queued .withoutResponse writes here.func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {}

// Subscribeperipheral.setNotifyValue(true, for: characteristic)
// Unsubscribeperipheral.setNotifyValue(false, for: characteristic)
// Confirmationfunc peripheral(    _ peripheral: CBPeripheral,    didUpdateNotificationStateFor characteristic: CBCharacteristic,    error: Error?) {    if characteristic.isNotifying {        print("Now receiving notifications for \(characteristic.uuid)")    }}

final class BLEPeripheralManager: NSObject, CBPeripheralManagerDelegate {    private var peripheralManager: CBPeripheralManager!    private let serviceUUID = CBUUID(string: "12345678-1234-1234-1234-123456789ABC")    private let charUUID = CBUUID(string: "12345678-1234-1234-1234-123456789ABD")
    override init() {        super.init()        peripheralManager = CBPeripheralManager(delegate: self, queue: nil)    }
    func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {        guard peripheral.state == .poweredOn else { return }        setupService()    }
    private func setupService() {        let characteristic = CBMutableCharacteristic(            type: charUUID,            properties: [.read, .notify],            value: nil,            permissions: [.readable]        )
        let service = CBMutableService(type: serviceUUID, primary: true)        service.characteristics = [characteristic]        peripheralManager.add(service)    }
    func peripheralManager(        _ peripheral: CBPeripheralManager,        didAdd service: CBService,        error: Error?    ) {        guard error == nil else { return }        peripheralManager.startAdvertising([            CBAdvertisementDataServiceUUIDsKey: [serviceUUID],            CBAdvertisementDataLocalNameKey: "MyDevice"        ])    }}

// 1. Create with a restoration identifiercentralManager = CBCentralManager(    delegate: self,    queue: nil,    options: [CBCentralManagerOptionRestoreIdentifierKey: "myCentral"])
// 2. Implement the restoration delegate methodfunc centralManager(    _ central: CBCentralManager,    willRestoreState dict: [String: Any]) {    if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]        as? [CBPeripheral] {        for peripheral in peripherals {            // Re-assign delegate and retain            peripheral.delegate = self            discoveredPeripheral = peripheral        }    }    let restoredServices = dict[CBCentralManagerRestoredStateScanServicesKey]        as? [CBUUID]    let restoredOptions = dict[CBCentralManagerRestoredStateScanOptionsKey]        as? [String: Any]    // Resume scanning with restoredServices/restoredOptions if still needed.}

peripheralManager = CBPeripheralManager(    delegate: self,    queue: nil,    options: [CBPeripheralManagerOptionRestoreIdentifierKey: "myPeripheral"])
func peripheralManager(    _ peripheral: CBPeripheralManager,    willRestoreState dict: [String: Any]) {    let services = dict[CBPeripheralManagerRestoredStateServicesKey]        as? [CBMutableService]    let advertisement = dict[CBPeripheralManagerRestoredStateAdvertisementDataKey]        as? [String: Any]    // Reconnect app state to restored services/advertisement as needed.}