Core Bluetooth: architektura a vývoj BLE na iOS

Co je Core Bluetooth: architektura a komponenty

Core Bluetooth rozděluje zásobník BLE na dvě logické role definované specifikací Bluetooth SIG. Role centrálního zařízení (Central) je reprezentována třídou CBCentralManager — iniciuje skenování, vytváří připojení a spravuje seznam připojených CBPeripheral. Role periferního zařízení (Peripheral) je reprezentována CBPeripheralManager — publikuje služby a charakteristiky, odpovídá na požadavky centrály a odesílá oznámení. Jedna iOS relace může současně pracovat v obou rolích na různých BLE rádiích, ale typická aplikace používá jednu roli.

Architektura Core Bluetooth zahrnuje pět klíčových abstrakcí. CBCentralManager spravuje stav Bluetooth adaptéru zařízení: poweredOn (připraven k práci), poweredOff (Bluetooth vypnuto), unauthorized (bez oprávnění), unsupported (BLE nedostupné). CBPeripheral představuje vzdálené BLE zařízení s jeho UUID, názvem, RSSI a hierarchií GATT. CBService — logická skupina charakteristik. CBCharacteristic — datový bod pro čtení/zápis/oznámení. CBPeripheralManager vytváří lokální GATT server pro emulaci periferie.

Stavy CBCentralManager spravují všechny BLE operace. Při spuštění aplikace je centralManagerDidUpdateState volán s aktuálním stavem Bluetooth. Pokud stav není .poweredOn, všechny BLE volání jsou systémem ignorovány. Vývojář musí zkontrolovat state před každým skenováním a připojením. Přechod z .poweredOff na .poweredOn nastává při zapnutí Bluetooth v iOS Nastavení — delegát obdrží opakované volání a aplikace může obnovit skenování.

CBCentralManager: skenování a připojování BLE zařízení

CBCentralManager — vstupní bod pro všechny BLE operace ze strany centrálního zařízení. Inicializace přijímá delegáta (CBCentralManagerDelegate) a frontu DispatchQueue — doporučení Apple je používat main queue pro jednoduchost nebo serial queue pro výkon. Po inicializaci framework automaticky zkontroluje stav Bluetooth a zavolá centralManagerDidUpdateState: — první povinný delegát pro zpracování.

Skenování se spouští metodou scanForPeripheralsWithServices:options:. První parametr je pole CBUUID služeb pro filtrování: pokud jsou známy UUID zajímavých služeb, jejich předání snižuje spotřebu energie a dobu vyhledávání. Pokud je nil, všechna BLE zařízení v dosahu jsou detekována. Možnosti zahrnují .allowDuplicatesKey (opakovaná detekce stejného zařízení) a .solicitedServiceUUIDsKey (pro služby publikované na centrále).

import CoreBluetooth

class BLECentral: NSObject {

    private var centralManager: CBCentralManager!
    private var discoveredPeripherals: [CBPeripheral] = []

    override init() {
        super.init()
        centralManager = CBCentralManager(delegate: self, queue: .main)
    }

    // Spustit BLE skenování
    func startScan() {
        guard centralManager.state == .poweredOn else {
            print("Bluetooth nedostupné")
            return
        }
        // Skenovat všechna zařízení (nil = bez filtru)
        centralManager.scanForPeripherals(withServices: nil,
                                            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
    }

    // Zastavit skenování
    func stopScan() {
        centralManager.stopScan()
    }

    // Připojit k vybranému zařízení
    func connect(to peripheral: CBPeripheral) {
        centralManager.connect(peripheral, options: nil)
    }
}

// MARK: - CBCentralManagerDelegate
extension BLECentral: CBCentralManagerDelegate {

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            startScan()
        }
    }

    func centralManager(_ central: CBCentralManager,
                        didDiscover peripheral: CBPeripheral,
                        advertisementData: [String : Any],
                        rssi: NSNumber) {
        if !discoveredPeripherals.contains(where: { $0.identifier == peripheral.identifier }) {
            discoveredPeripherals.append(peripheral)
            print("Found devices: \(peripheral.name ?? "Unknown"), RSSI: \(rssi)")
        }
    }

    func centralManager(_ central: CBCentralManager,
                        didConnect peripheral: CBPeripheral) {
        print("Connected: \(peripheral.identifier)")
        peripheral.delegate = self
        peripheral.discoverServices(nil)
    }

    func centralManager(_ central: CBCentralManager,
                        didDisconnectPeripheral peripheral: CBPeripheral,
                        error: Error?) {
        print("Disconnected: \(peripheral.identifier)")
    }
}

Třída BLECentral demonstruje celý cyklus skenování a připojování BLE zařízení. centralManagerDidUpdateState spouští skenování, když je Bluetooth zapnutý. didDiscoverPeripheral shromažďuje nalezená zařízení v poli discoveredPeripherals s deduplikací podle identifier. Po připojení (didConnect) je okamžitě spuštěno objevování služeb — to je povinný krok před jakýmikoli operacemi GATT.

CBPeripheralManager: vytvoření BLE serveru na iOS

CBPeripheralManager — třída pro emulaci BLE periferního zařízení na iOS. Aplikace v roli periferie může publikovat své vlastní služby a charakteristiky, přijímat příchozí požadavky na čtení/zápis od centrálního zařízení a odesílat oznámení. CBPeripheralManager se používá pro BLE příslušenství emulované iPhone: dálkové ovladače, klávesnice, trackery, IoT brány.

Životní cyklus CBPeripheralManager začíná inicializací a delegátem CBPeripheralManagerDelegate. Po potvrzení poweredOn prostřednictvím peripheralManagerDidUpdateState: jsou služby publikovány (addService:) a reklama je spuštěna (startAdvertising:). Reklamní data CBAdvertisementData zahrnují místní název (CBAdvertisementDataLocalNameKey), UUID služeb (CBAdvertisementDataServiceUUIDsKey) a úroveň výkonu (CBAdvertisementDataTxPowerLevelKey). Maximální velikost reklamního paketu je 31 bajtů pro BLE 4.0, 251 bajtů pro extended advertising BLE 5.0+.

// BLE periferie na iOS přes CBPeripheralManager
class BLEPeripheral: NSObject {

    private var peripheralManager: CBPeripheralManager!

    let serviceUUID = CBUUID(string: "1234")
    let characteristicUUID = CBUUID(string: "5678")

    override init() {
        super.init()
        peripheralManager = CBPeripheralManager(delegate: self, queue: .main)
    }

    // Publikovat službu s charakteristikou
    func setupService() {
        let characteristic = CBMutableCharacteristic(
            type: characteristicUUID,
            properties: [.read, .write, .notify],
            value: nil,
            permissions: [.readable, .writeable]
        )
        let service = CBMutableService(type: serviceUUID, primary: true)
        service.characteristics = [characteristic]
        peripheralManager.add(service)
    }

    // Spustit reklamu
    func startAdvertising() {
        let advertisementData: [String: Any] = [
            CBAdvertisementDataLocalNameKey: "My BLE Device",
            CBAdvertisementDataServiceUUIDsKey: [serviceUUID]
        ]
        peripheralManager.startAdvertising(advertisementData)
    }
}

// MARK: - CBPeripheralManagerDelegate
extension BLEPeripheral: CBPeripheralManagerDelegate {

    func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
        if peripheral.state == .poweredOn {
            setupService()
        }
    }

    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didAdd service: CBService,
                        error: Error?) {
        if error == nil {
            startAdvertising()
        }
    }

    // Zpracovat požadavek na čtení
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveRead request: CBATTRequest) {
        let data = "CurrentValue".data(using: .utf8)!
        request.value = data
        peripheralManager.respond(to: request, withResult: .success)
    }

    // Zpracovat požadavek na zápis
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveWrite requests: [CBATTRequest]) {
        for request in requests {
            if let value = request.value {
                print("Write: \(value)")
            }
        }
        peripheralManager.respond(to: requests.first!, withResult: .success)
    }
}

Třída BLEPeripheral vytváří BLE server s jednou charakteristikou podporující čtení, zápis a oznámení. Po inicializaci peripheralManagerDidUpdateState publikuje službu prostřednictvím addService:, poté spouští reklamu prostřednictvím startAdvertising:. Handlery didReceiveRead a didReceiveWrite reagují na příchozí GATT požadavky od centrálního zařízení. Pro odesílání oznámení se používá metoda updateValue:forCharacteristic:onSubscribedCentrals:.

Operace GATT: čtení, zápis a oznámení

Operace GATT (Generic Attribute Profile) — základ výměny dat v Core Bluetooth. Po objevení služeb a charakteristik může centrální zařízení provádět tři typy operací: čtení hodnoty charakteristiky, zápis hodnoty a přihlášení k odběru oznámení/indikací. Každá operace je asynchronní a vrací výsledek prostřednictvím příslušného delegáta CBPeripheralDelegate.

Čtení se provádí voláním readValueForCharacteristic:. Hodnota přichází v peripheral:didUpdateValueForCharacteristic:error:. Důležité: čtení vrací aktuální hodnotu ze zařízení, ne kešovanou. Pokud zařízení nepodporuje čtení (vlastnost .read), volání vrátí chybu. Pro velké hodnoty (větší než MTU) BLE automaticky fragmentuje a sestavuje data na úrovni GATT.

Zápis se provádí voláním writeValue:forCharacteristic:type:. BLE podporuje dva modely zápisu: withResponse (spolehlivý, s potvrzením) a withoutResponse (rychlý, bez potvrzení). Vlastnost CBCharacteristic.properties určuje dostupné typy zápisu. Maximální velikost jednoho zápisového paketu je omezena MTU: 23 bajtů pro BLE 4.0 (20 bajtů užitečných dat + 3 bajty hlavičky), až 247 bajtů pro BLE 5.0 s extended MTU (MTU 251).

Oznámení se aktivují voláním setNotifyValue:true forCharacteristic:. Po přihlášení k odběru periferie automaticky odesílá aktualizace prostřednictvím peripheral:didUpdateValueForCharacteristic: pokaždé, když se hodnota charakteristiky změní. Pro deaktivaci oznámení se volá setNotifyValue:false forCharacteristic:. Core Bluetooth automaticky spravuje CCCD deskriptor na periferii.

Režim na pozadí Core Bluetooth a State Restoration

Režim na pozadí Core Bluetooth umožňuje BLE aplikaci pokračovat ve skenování, udržovat připojení a přijímat oznámení na pozadí. Pro aktivaci je vyžadováno: zapněte capability „Uses Bluetooth LE accessories” v Xcode (Info.plist → Required background modes → App communicates using Core Bluetooth) a přidejte klíč „bluetooth-central” do UIBackgroundModes. Pro periferní roli — „bluetooth-peripheral”.

State Restoration — mechanismus Core Bluetooth pro obnovení stavu BLE připojení po restartu aplikace systémem iOS. Při aktivaci režimu na pozadí a zadání restoreIdentifier při inicializaci CBCentralManager nebo CBPeripheralManager, iOS ukládá stav zásobníku BLE při ukončení aplikace a obnovuje jej při příštím spuštění. Delegát centralManager:willRestoreState: obdrží slovník s uloženými CBPeripheral a čekajícími připojeními.

// Konfigurace Core Bluetooth s State Restoration
class BLECentralWithRestoration: NSObject {

    let restoreIdentifier = "com.app.blecentral"
    private var centralManager: CBCentralManager!

    override init() {
        super.init()
        let options: [String: Any] = [
            CBCentralManagerOptionRestoreIdentifierKey: restoreIdentifier,
            CBCentralManagerOptionShowPowerAlertKey: true
        ]
        centralManager = CBCentralManager(delegate: self,
                                          queue: nil,
                                          options: options)
    }
}

extension BLECentralWithRestoration: CBCentralManagerDelegate {

    // Obnovit stav po restartu
    func centralManager(_ central: CBCentralManager,
                        willRestoreState dict: [String : Any]) {
        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]
            as? [CBPeripheral] {
            for peripheral in peripherals {
                peripheral.delegate = self
                // Obnovit GATT objevování
                peripheral.discoverServices(nil)
            }
        }
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            print("Bluetooth připraven po obnovení")
        }
    }
}

V konfiguraci BLECentralWithRestoration klíč CBCentralManagerOptionRestoreIdentifierKey aktivuje ukládání stavu. Pokud byla aplikace ukončena iOS (např. kvůli nedostatku paměti), při příštím spuštění centralManager:willRestoreState: obdrží seznam dříve připojených CBPeripheral. Aplikace obnoví delegáty a provede znovuobjevení služeb — uživatel nezaznamená přerušení připojení. Bez State Restoration jsou všechny BLE relace ztraceny při ukončení aplikace.

Příklad BLE aplikace ve Swift: centrála a periferie

Plný příklad BLE aplikace ve Swift kombinuje centrální a periferní zařízení v jednom projektu. Aplikace může pracovat ve dvou režimech: detekovat a připojovat se k BLE zařízením (Central) nebo emulovat BLE příslušenství (Peripheral). Níže je uvedena architektura se společným BLE správcem, který vybírá roli při spuštění.

// Univerzální BLE správce pro centrálu a periferii
class BLEManager {

    enum Role {
        case central
        case peripheral
    }

    private let role: Role
    private var centralManager: CBCentralManager?
    private var peripheralManager: CBPeripheralManager?
    let advertisedServiceUUID = CBUUID(string: "A001")

    init(role: Role) {
        self.role = role
        switch role {
        case .central:
            centralManager = CBCentralManager(delegate: nil, queue: .main)
        case .peripheral:
            peripheralManager = CBPeripheralManager(delegate: nil, queue: .main)
        }
    }

    // Centrální zařízení: skenování
    func scanForDevices() {
        centralManager?.scanForPeripherals(withServices: nil, options: nil)
    }

    // Periferní zařízení: reklama
    func advertiseService() {
        let data: [String: Any] = [
            CBAdvertisementDataServiceUUIDsKey: [advertisedServiceUUID]
        ]
        peripheralManager?.startAdvertising(data)
    }
}

// Použití při spuštění
let isCentral = UserDefaults.standard.bool(forKey: "isCentral")
let manager = BLEManager(role: isCentral ? .central : .peripheral)

if isCentral {
    manager.scanForDevices()
} else {
    manager.advertiseService()
}

Správce BLEManager vybírá roli při inicializaci a vytváří odpovídající Manager (CBCentralManager nebo CBPeripheralManager). Příznak role může být uložen v UserDefaults nebo předán prostřednictvím konfiguračního serveru. Tento přístup umožňuje BLE aplikaci přizpůsobit se scénáři použití: na prodejním místě iPhone funguje jako centrála pro skenování platebních terminálů, na IoT bráně — jako periferie pro sběr dat ze senzorů.