Core Bluetooth: arkitektura at pag-develop ng BLE sa iOS

Ano ang Core Bluetooth: arkitektura at mga bahagi

Core Bluetooth ay hinahati ang BLE stack sa dalawang lohikal na papel na tinukoy ng Bluetooth SIG specification. Ang papel ng sentral na device (Central) ay kinakatawan ng klase na CBCentralManager — nagpapasimula ng pag-scan, gumagawa ng mga koneksyon at namamahala sa listahan ng mga konektadong CBPeripheral. Ang papel ng peripheral na device (Peripheral) ay kinakatawan ng CBPeripheralManager — nag-publish ng mga serbisyo at katangian, tumutugon sa mga kahilingan ng sentral at nagpapadala ng mga notification. Ang isang iOS session ay maaaring sabay na gumana sa parehong papel sa iba't ibang BLE radio, ngunit ang tipikal na app ay gumagamit ng isang papel.

Ang arkitektura ng Core Bluetooth ay may kasamang limang pangunahing abstraction. CBCentralManager ay namamahala sa estado ng Bluetooth adapter ng device: poweredOn (handa na), poweredOff (naka-off ang Bluetooth), unauthorized (walang pahintulot), unsupported (hindi available ang BLE). CBPeripheral ay kumakatawan sa isang malayuang BLE device kasama ang UUID, pangalan, RSSI at GATT hierarchy nito. CBService — lohikal na grupo ng mga katangian. CBCharacteristic — punto ng datos para sa pagbasa/pagsulat/notification. CBPeripheralManager ay gumagawa ng lokal na GATT server para sa emulation ng peripheral.

Mga estado ng CBCentralManager ay namamahala sa lahat ng BLE operation. Sa pagsisimula ng app, ang centralManagerDidUpdateState ay tinatawag kasama ang kasalukuyang estado ng Bluetooth. Kung ang estado ay hindi .poweredOn, ang anumang BLE na tawag ay hindi papansinin ng system. Dapat suriin ng developer ang state bago ang bawat pag-scan at koneksyon. Ang paglipat mula sa .poweredOff patungong .poweredOn ay nangyayari kapag ang Bluetooth ay naka-on sa iOS Settings — ang delegate ay makakatanggap ng paulit-ulit na tawag at ang app ay maaaring magpatuloy sa pag-scan.

CBCentralManager: pag-scan at pagkonekta ng mga BLE device

CBCentralManager — entry point para sa lahat ng BLE operation mula sa sentral na device. Ang inisyalisasyon ay tumatanggap ng delegate (CBCentralManagerDelegate) at isang DispatchQueue queue — rekomendasyon ng Apple na gamitin ang main queue para sa pagiging simple o serial queue para sa performance. Pagkatapos ng inisyalisasyon, awtomatikong sinusuri ng framework ang estado ng Bluetooth at tinatawag ang centralManagerDidUpdateState: — ang unang mandatoryong delegate para sa pagproseso.

Ang pag-scan ay sinisimulan sa pamamagitan ng pamamaraang scanForPeripheralsWithServices:options:. Ang unang parameter ay isang array ng CBUUID ng mga serbisyo para sa pag-filter: kung ang mga UUID ng mga kawili-wiling serbisyo ay alam, ang pagpapasa sa mga ito ay nakakabawas ng konsumo ng kuryente at oras ng paghahanap. Kung nil, lahat ng BLE device sa saklaw ay matutukoy. Kasama sa mga opsyon ang .allowDuplicatesKey (paulit-ulit na pagtuklas ng parehong device) at .solicitedServiceUUIDsKey (para sa mga serbisyong nai-publish sa sentral).

import CoreBluetooth

class BLECentral: NSObject {

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

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

    // Simulan ang BLE scanning
    func startScan() {
        guard centralManager.state == .poweredOn else {
            print("Hindi available ang Bluetooth")
            return
        }
        // I-scan ang lahat ng device (nil = walang filter)
        centralManager.scanForPeripherals(withServices: nil,
                                            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
    }

    // Itigil ang pag-scan
    func stopScan() {
        centralManager.stopScan()
    }

    // Kumonekta sa napiling device
    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)")
    }
}

Ang klase na BLECentral ay nagpapakita ng kumpletong cycle ng pag-scan at pagkonekta ng mga BLE device. Sinisimulan ng centralManagerDidUpdateState ang pag-scan kapag naka-on ang Bluetooth. Kinokolekta ng didDiscoverPeripheral ang mga natagpuang device sa array na discoveredPeripherals na may deduplikasyon ayon sa identifier. Pagkatapos ng koneksyon (didConnect), agad na sisimulan ang discovery ng mga serbisyo — ito ay mandatoryong hakbang bago ang anumang GATT operation.

CBPeripheralManager: paggawa ng BLE server sa iOS

CBPeripheralManager — klase para sa emulation ng BLE peripheral device sa iOS. Ang app sa papel ng peripheral ay maaaring mag-publish ng sarili nitong mga serbisyo at katangian, tumanggap ng mga papasok na kahilingan sa pagbasa/pagsulat mula sa sentral na device at magpadala ng mga notification. Ang CBPeripheralManager ay ginagamit para sa mga BLE accessory na na-emulate ng iPhone: mga remote, keyboard, tracker, IoT gateway.

Ang life cycle ng CBPeripheralManager ay nagsisimula sa inisyalisasyon at delegate na CBPeripheralManagerDelegate. Pagkatapos ng kumpirmasyon ng poweredOn sa pamamagitan ng peripheralManagerDidUpdateState:, ang mga serbisyo ay nai-publish (addService:) at ang advertising ay sinisimulan (startAdvertising:). Ang datos ng advertising na CBAdvertisementData ay may kasamang lokal na pangalan (CBAdvertisementDataLocalNameKey), mga UUID ng serbisyo (CBAdvertisementDataServiceUUIDsKey) at antas ng lakas (CBAdvertisementDataTxPowerLevelKey). Ang maximum na laki ng advertising packet ay 31 bytes para sa BLE 4.0, 251 bytes para sa extended advertising BLE 5.0+.

// BLE peripheral sa iOS sa pamamagitan ng 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)
    }

    // I-publish ang serbisyo na may katangian
    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)
    }

    // Simulan ang advertising
    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()
        }
    }

    // Pangasiwaan ang kahilingan sa pagbasa
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveRead request: CBATTRequest) {
        let data = "CurrentValue".data(using: .utf8)!
        request.value = data
        peripheralManager.respond(to: request, withResult: .success)
    }

    // Pangasiwaan ang kahilingan sa pagsulat
    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)
    }
}

Ang klase na BLEPeripheral ay gumagawa ng BLE server na may isang katangian na sumusuporta sa pagbasa, pagsulat at mga notification. Pagkatapos ng inisyalisasyon, ang peripheralManagerDidUpdateState ay nag-publish ng serbisyo sa pamamagitan ng addService:, pagkatapos ay sinisimulan ang advertising sa pamamagitan ng startAdvertising:. Ang mga handler na didReceiveRead at didReceiveWrite ay tumutugon sa mga papasok na GATT na kahilingan mula sa sentral na device. Para sa pagpapadala ng mga notification, ginagamit ang pamamaraang updateValue:forCharacteristic:onSubscribedCentrals:.

Mga operasyon ng GATT: pagbasa, pagsulat at notification

Mga operasyon ng GATT (Generic Attribute Profile) — batayan ng pagpapalitan ng datos sa Core Bluetooth. Pagkatapos ng discovery ng mga serbisyo at katangian, ang sentral na device ay maaaring magsagawa ng tatlong uri ng operasyon: pagbasa ng halaga ng katangian, pagsulat ng halaga at pag-subscribe sa mga notification/indikasyon. Ang bawat operasyon ay asynchronous at nagbabalik ng resulta sa pamamagitan ng kaukulang CBPeripheralDelegate delegate.

Pagbasa ay isinasagawa sa pamamagitan ng pagtawag sa readValueForCharacteristic:. Ang halaga ay dumarating sa peripheral:didUpdateValueForCharacteristic:error:. Mahalaga: ang pagbasa ay nagbabalik ng kasalukuyang halaga mula sa device, hindi naka-cache. Kung hindi sinusuportahan ng device ang pagbasa (property na .read), ang tawag ay magbabalik ng error. Para sa malalaking halaga (mas malaki sa MTU), awtomatikong hinahati at binubuo ng BLE ang datos sa antas ng GATT.

Pagsulat ay isinasagawa sa pamamagitan ng writeValue:forCharacteristic:type:. Sinusuportahan ng BLE ang dalawang modelo ng pagsulat: withResponse (maaasahan, may kumpirmasyon) at withoutResponse (mabilis, walang kumpirmasyon). Ang property na CBCharacteristic.properties ay tumutukoy sa mga available na uri ng pagsulat. Ang maximum na laki ng isang write packet ay limitado ng MTU: 23 bytes para sa BLE 4.0 (20 bytes na kapaki-pakinabang na datos + 3 bytes na header), hanggang 247 bytes para sa BLE 5.0 na may extended MTU (MTU 251).

Mga notification ay isinaaktibo sa pamamagitan ng pagtawag sa setNotifyValue:true forCharacteristic:. Pagkatapos ng subscription, awtomatikong nagpapadala ang peripheral ng mga update sa pamamagitan ng peripheral:didUpdateValueForCharacteristic: sa tuwing nagbabago ang halaga ng katangian. Para sa pag-disable ng mga notification, tinatawag ang setNotifyValue:false forCharacteristic:. Awtomatikong pinamamahalaan ng Core Bluetooth ang CCCD descriptor sa peripheral.

Background mode ng Core Bluetooth at State Restoration

Background mode ng Core Bluetooth ay nagpapahintulot sa BLE app na magpatuloy sa pag-scan, mapanatili ang mga koneksyon at makatanggap ng mga notification habang nasa background. Para sa pag-activate kinakailangan: i-on ang capability na “Uses Bluetooth LE accessories” sa Xcode (Info.plist → Required background modes → App communicates using Core Bluetooth) at idagdag ang key na „bluetooth-central” sa UIBackgroundModes. Para sa peripheral na papel — „bluetooth-peripheral”.

State Restoration — mekanismo ng Core Bluetooth para sa pagpapanumbalik ng estado ng mga BLE connection pagkatapos ng pag-restart ng app ng iOS system. Kapag na-activate ang background mode at tinukoy ang restoreIdentifier sa inisyalisasyon ng CBCentralManager o CBPeripheralManager, iniimbak ng iOS ang estado ng BLE stack sa pagtatapos ng app at pinapanumbalik ito sa susunod na pagsisimula. Ang delegate na centralManager:willRestoreState: ay tumatanggap ng diksyunaryo na may mga naka-save na CBPeripheral at mga nakabinbing koneksyon.

// Core Bluetooth configuration na may 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 {

    // I-restore ang estado pagkatapos ng restart
    func centralManager(_ central: CBCentralManager,
                        willRestoreState dict: [String : Any]) {
        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]
            as? [CBPeripheral] {
            for peripheral in peripherals {
                peripheral.delegate = self
                // I-restore ang GATT discovery
                peripheral.discoverServices(nil)
            }
        }
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            print("BLE handa pagkatapos ng restoration")
        }
    }
}

Sa configuration na BLECentralWithRestoration, ang key na CBCentralManagerOptionRestoreIdentifierKey ay nag-a-activate ng pag-save ng estado. Kung ang app ay natapos ng iOS (halimbawa, dahil sa kakulangan ng memorya), sa susunod na pagsisimula ang centralManager:willRestoreState: ay tumatanggap ng listahan ng mga dating konektadong CBPeripheral. Pinapanumbalik ng app ang mga delegate at nagsasagawa ng muling discovery ng mga serbisyo — hindi napapansin ng user ang pagkagambala ng koneksyon. Kung walang State Restoration, lahat ng BLE session ay nawawala sa pagtatapos ng app.

Halimbawa ng BLE app sa Swift: sentral at peripheral

Kumpletong halimbawa ng BLE app sa Swift ay pinagsasama ang sentral at peripheral na device sa isang proyekto. Ang app ay maaaring gumana sa dalawang mode: tuklasin at kumonekta sa mga BLE device (Central) o tularan ang isang BLE accessory (Peripheral). Sa ibaba ay ipinakita ang arkitektura na may pinagsamang BLE manager na pumipili ng papel sa pagsisimula.

// Universal BLE manager para sa sentral at peripheral
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)
        }
    }

    // Sentral na device: pag-scan
    func scanForDevices() {
        centralManager?.scanForPeripherals(withServices: nil, options: nil)
    }

    // Peripheral na device: advertising
    func advertiseService() {
        let data: [String: Any] = [
            CBAdvertisementDataServiceUUIDsKey: [advertisedServiceUUID]
        ]
        peripheralManager?.startAdvertising(data)
    }
}

// Paggamit sa pagsisimula
let isCentral = UserDefaults.standard.bool(forKey: "isCentral")
let manager = BLEManager(role: isCentral ? .central : .peripheral)

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

Ang manager na BLEManager ay pumipili ng papel sa inisyalisasyon at gumagawa ng kaukulang Manager (CBCentralManager o CBPeripheralManager). Ang flag ng papel ay maaaring i-imbak sa UserDefaults o ipasa sa pamamagitan ng configuration server. Ang pamamaraang ito ay nagpapahintulot sa BLE app na umangkop sa sitwasyon ng paggamit: sa punto ng pagbebenta, ang iPhone ay gumagana bilang sentral para sa pag-scan ng mga terminal ng pagbabayad, sa IoT gateway — bilang peripheral para sa pagkolekta ng datos mula sa mga sensor.