Core Bluetooth: BLE architektúra és fejlesztés iOS-en

Mi a Core Bluetooth: architektúra és összetevők

Core Bluetooth két logikai szerepre osztja a BLE vermet a Bluetooth SIG specifikáció által meghatározottak szerint. A központi eszköz szerepét (Central) a CBCentralManager osztály képviseli — elindítja a szkennelést, kapcsolatokat hoz létre és kezeli a csatlakoztatott CBPeripheral-ek listáját. A perifériás eszköz szerepét (Peripheral) a CBPeripheralManager képviseli — szolgáltatásokat és jellemzőket publikál, válaszol a központ kéréseire és értesítéseket küld. Egy iOS munkamenet egyszerre mindkét szerepben dolgozhat különböző BLE rádiókon, de a tipikus alkalmazás egy szerepet használ.

A Core Bluetooth architektúra öt kulcsfontosságú absztrakciót foglal magában. CBCentralManager kezeli az eszköz Bluetooth adapterének állapotát: poweredOn (munkára kész), poweredOff (Bluetooth kikapcsolva), unauthorized (nincs engedély), unsupported (BLE nem elérhető). CBPeripheral egy távoli BLE eszközt képvisel annak UUID-jével, nevével, RSSI-jével és GATT hierarchiájával. CBService — jellemzők logikai csoportja. CBCharacteristic — adatpont olvasáshoz/íráshoz/értesítésekhez. CBPeripheralManager egy helyi GATT szervert hoz létre periféria emulálásához.

CBCentralManager állapotok kezelik az összes BLE műveletet. Az alkalmazás indításakor a centralManagerDidUpdateState meghívódik az aktuális Bluetooth állapottal. Ha az állapot nem .poweredOn, a rendszer figyelmen kívül hagy minden BLE hívást. A fejlesztőnek ellenőriznie kell a state-et minden szkennelés és csatlakozás előtt. A .poweredOff-ról .poweredOn-ra való átmenet akkor történik, amikor a Bluetooth be van kapcsolva az iOS Beállításokban — a delegált újrahívást kap, és az alkalmazás folytathatja a szkennelést.

CBCentralManager: BLE eszközök szkennelése és csatlakoztatása

CBCentralManager — a belépési pont az összes BLE művelethez a központi eszköz oldaláról. Az inicializálás fogad egy delegáltat (CBCentralManagerDelegate) és egy DispatchQueue sort — az Apple a main queue használatát javasolja egyszerűségért vagy serial queue-t teljesítményért. Inicializálás után a keretrendszer automatikusan ellenőrzi a Bluetooth állapotot és meghívja a centralManagerDidUpdateState: — az első kötelező delegált a feldolgozáshoz.

A szkennelés a scanForPeripheralsWithServices:options: metódussal indul. Az első paraméter a szűréshez használt szolgáltatások CBUUID tömbje: ha a kívánt szolgáltatások UUID-jei ismertek, azok átadása csökkenti az energiafogyasztást és a keresési időt. Ha nil, akkor minden BLE eszköz érzékelhető a hatótávolságon belül. Az opciók közé tartozik a .allowDuplicatesKey (ugyanazon eszköz ismételt érzékelése) és a .solicitedServiceUUIDsKey (a központon publikált szolgáltatásokhoz).

import CoreBluetooth

class BLECentral: NSObject {

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

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

    // BLE szkennelés indítása
    func startScan() {
        guard centralManager.state == .poweredOn else {
            print("Bluetooth nem elérhető")
            return
        }
        // Összes eszköz szkennelése (nil = nincs szűrő)
        centralManager.scanForPeripherals(withServices: nil,
                                            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
    }

    // Szkennelés leállítása
    func stopScan() {
        centralManager.stopScan()
    }

    // Csatlakozás a kiválasztott eszközhöz
    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)")
    }
}

A BLECentral osztály bemutatja a BLE eszközök szkennelésének és csatlakoztatásának teljes ciklusát. A centralManagerDidUpdateState elindítja a szkennelést, ha a Bluetooth be van kapcsolva. A didDiscoverPeripheral összegyűjti a talált eszközöket a discoveredPeripherals tömbben deduplikációval identifier alapján. Csatlakozás után (didConnect) azonnal elindul a szolgáltatások felderítése — ez kötelező lépés bármilyen GATT művelet előtt.

CBPeripheralManager: BLE szerver létrehozása iOS-en

CBPeripheralManager — osztály a BLE perifériás eszköz emulálásához iOS-en. A periféria szerepében lévő alkalmazás publikálhatja saját szolgáltatásait és jellemzőit, fogadhat bejövő olvasási/írási kéréseket a központi eszköztől és küldhet értesítéseket. A CBPeripheralManager az iPhone által emulált BLE tartozékokhoz használatos: távirányítók, billentyűzetek, nyomkövetők, IoT átjárók.

A CBPeripheralManager életciklusa inicializálással és a CBPeripheralManagerDelegate delegálttal kezdődik. A poweredOn megerősítése után a peripheralManagerDidUpdateState:-n keresztül a szolgáltatások publikálásra kerülnek (addService:) és a reklámozás elindul (startAdvertising:). A CBAdvertisementData reklámadatok tartalmazzák a helyi nevet (CBAdvertisementDataLocalNameKey), a szolgáltatások UUID-it (CBAdvertisementDataServiceUUIDsKey) és a teljesítményszintet (CBAdvertisementDataTxPowerLevelKey). A reklámcsomag maximális mérete 31 bájt BLE 4.0 esetén, 251 bájt a BLE 5.0+ extended advertising esetén.

// BLE periféria iOS-en CBPeripheralManager segítségével
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)
    }

    // Szolgáltatás publikálása jellemzővel
    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)
    }

    // Reklámozás indítása
    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()
        }
    }

    // Olvasási kérelem kezelése
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveRead request: CBATTRequest) {
        let data = "CurrentValue".data(using: .utf8)!
        request.value = data
        peripheralManager.respond(to: request, withResult: .success)
    }

    // Írási kérelem kezelése
    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)
    }
}

A BLEPeripheral osztály létrehoz egy BLE szervert egy olyan jellemzővel, amely támogatja az olvasást, írást és értesítéseket. Inicializálás után a peripheralManagerDidUpdateState publikálja a szolgáltatást az addService:-n keresztül, majd elindítja a reklámozást a startAdvertising:-n keresztül. A didReceiveRead és didReceiveWrite kezelők válaszolnak a központi eszköztől érkező bejövő GATT kérésekre. Az értesítések küldéséhez az updateValue:forCharacteristic:onSubscribedCentrals: metódus használatos.

GATT műveletek: olvasás, írás és értesítések

GATT műveletek (Generic Attribute Profile) — az adatcsere alapja a Core Bluetooth-ban. A szolgáltatások és jellemzők felderítése után a központi eszköz háromféle műveletet végezhet: jellemző értékének olvasása, érték írása és feliratkozás értesítésekre/indikációkra. Minden művelet aszinkron, és az eredményt a megfelelő CBPeripheralDelegate delegáltan keresztül adja vissza.

Olvasás a readValueForCharacteristic: meghívásával történik. Az érték a peripheral:didUpdateValueForCharacteristic:error:-ban érkezik. Fontos: az olvasás az aktuális értéket adja vissza az eszközről, nem a gyorsítótárazottat. Ha az eszköz nem támogatja az olvasást (.read tulajdonság), a hívás hibát ad vissza. Nagy értékek esetén (nagyobb, mint MTU) a BLE automatikusan darabolja és összeállítja az adatokat GATT szinten.

Írás a writeValue:forCharacteristic:type: meghívásával történik. A BLE két írási modellt támogat: withResponse (megbízható, visszaigazolással) és withoutResponse (gyors, visszaigazolás nélkül). A CBCharacteristic.properties tulajdonság határozza meg az elérhető írási típusokat. Egyetlen írási csomag maximális méretét az MTU korlátozza: 23 bájt BLE 4.0 esetén (20 bájt hasznos adat + 3 bájt fejléc), akár 247 bájt BLE 5.0 esetén extended MTU-val (MTU 251).

Értesítések a setNotifyValue:true forCharacteristic: meghívásával aktiválhatók. Feliratkozás után a periféria automatikusan frissítéseket küld a peripheral:didUpdateValueForCharacteristic:-n keresztül, amikor a jellemző értéke változik. Az értesítések kikapcsolásához a setNotifyValue:false forCharacteristic: hívható meg. A Core Bluetooth automatikusan kezeli a CCCD leírót a periférián.

Core Bluetooth háttérmód és State Restoration

Háttérmód A Core Bluetooth lehetővé teszi a BLE alkalmazás számára, hogy továbbra is szkenneljen, kapcsolatokat tartson fenn és értesítéseket fogadjon, miközben háttérben van. Az aktiváláshoz szükséges: kapcsolja be a „Uses Bluetooth LE accessories” capability-t az Xcode-ban (Info.plist → Required background modes → App communicates using Core Bluetooth) és adja hozzá a „bluetooth-central” kulcsot az UIBackgroundModes-hoz. A periféria szerephez — „bluetooth-peripheral”.

State Restoration — a Core Bluetooth mechanizmusa a BLE kapcsolatok állapotának helyreállítására az alkalmazás iOS rendszer általi újraindítása után. A háttérmód aktiválásakor és a restoreIdentifier megadásakor a CBCentralManager vagy CBPeripheralManager inicializálásában, az iOS elmenti a BLE verem állapotát az alkalmazás befejezésekor, és visszaállítja azt a következő indításkor. A centralManager:willRestoreState: delegált egy szótárt kap a mentett CBPeripheral-ekkel és függőben lévő kapcsolatokkal.

// Core Bluetooth konfiguráció State Restoration-nel
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 {

    // Állapot visszaállítása újraindítás után
    func centralManager(_ central: CBCentralManager,
                        willRestoreState dict: [String : Any]) {
        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]
            as? [CBPeripheral] {
            for peripheral in peripherals {
                peripheral.delegate = self
                // GATT felderítés visszaállítása
                peripheral.discoverServices(nil)
            }
        }
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            print("Bluetooth kész a visszaállítás után")
        }
    }
}

A BLECentralWithRestoration konfigurációban a CBCentralManagerOptionRestoreIdentifierKey kulcs aktiválja az állapot mentését. Ha az alkalmazást az iOS befejezte (pl. memóriahiány miatt), a következő indításkor a centralManager:willRestoreState: megkapja a korábban csatlakoztatott CBPeripheral-ek listáját. Az alkalmazás visszaállítja a delegáltakat és újra elvégzi a szolgáltatások felderítését — a felhasználó nem észleli a kapcsolat megszakadását. State Restoration nélkül minden BLE munkamenet elveszik az alkalmazás befejezésekor.

BLE alkalmazás példa Swift-ben: központ és periféria

Teljes példa BLE alkalmazásra Swift-ben, amely egyesíti a központi és perifériás eszközt egy projektben. Az alkalmazás két módban működhet: BLE eszközök érzékelése és csatlakozás (Central) vagy BLE tartozék emulálása (Peripheral). Az alábbiakban bemutatjuk az architektúrát egy közös BLE menedzserrel, amely induláskor kiválasztja a szerepet.

// Univerzális BLE menedzser központhoz és perifériához
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)
        }
    }

    // Központi eszköz: szkennelés
    func scanForDevices() {
        centralManager?.scanForPeripherals(withServices: nil, options: nil)
    }

    // Perifériás eszköz: reklámozás
    func advertiseService() {
        let data: [String: Any] = [
            CBAdvertisementDataServiceUUIDsKey: [advertisedServiceUUID]
        ]
        peripheralManager?.startAdvertising(data)
    }
}

// Használat induláskor
let isCentral = UserDefaults.standard.bool(forKey: "isCentral")
let manager = BLEManager(role: isCentral ? .central : .peripheral)

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

A BLEManager menedzser inicializáláskor kiválasztja a szerepet, és létrehozza a megfelelő Menedzsert (CBCentralManager vagy CBPeripheralManager). A szerep jelzője tárolható a UserDefaults-ban vagy továbbítható konfigurációs szerveren keresztül. Ez a megközelítés lehetővé teszi a BLE alkalmazás számára, hogy alkalmazkodjon a használati forgatókönyvhöz: értékesítési ponton az iPhone központként működik a fizetési terminálok szkenneléséhez, IoT átjárón — perifériaként az érzékelőktől származó adatok gyűjtéséhez.