Core Bluetooth: BLE arxitekturası və iOS tətbiqlərində inkişaf

Core Bluetooth nədir: arxitektura və komponentlər

Core Bluetooth BLE stackını Bluetooth SIG spesifikasiyası ilə müəyyən edilmiş iki məntiqi roluna ayırır. Mərkəzi cihaz rolu (Central) CBCentralManager sinifi ilə təmsil olunur — skan etməni başladır, qoşulmalar yaradır və qoşulmuş CBPeripheral siyahısını idarə edir. Periferiya cihazı rolu (Peripheral) CBPeripheralManager ilə təmsil olunur — xidmətlər və xarakteristikaları dərc edir, mərkəzin sorğularına cavab verir və bildirişlər göndərir. Bir iOS sessiyası eyni anda müxtəlif BLE radiolarında hər iki rolda işləyə bilər, lakin tipik tətbiq bir roldan istifadə edir.

Core Bluetooth arxitekturası beş əsas abstraksiyanı əhatə edir. CBCentralManager cihazın Bluetooth adapterinin vəziyyətini idarə edir: poweredOn (işə hazır), poweredOff (Bluetooth söndürülüb), unauthorized (icazə yoxdur), unsupported (BLE əlçatan deyil). CBPeripheral uzaq BLE cihazını UUID, ad, RSSI və GATT iyerarxiyası ilə təmsil edir. CBService — xarakteristikaların məntiqi qrupu. CBCharacteristic — oxu/yazı/bildiriş üçün məlumat nöqtəsi. CBPeripheralManager periferiyanı emulyasiya etmək üçün lokal GATT serveri yaradır.

CBCentralManager vəziyyətləri bütün BLE əməliyyatlarını idarə edir. Tətbiq başladıqda centralManagerDidUpdateState cari Bluetooth vəziyyəti ilə çağırılır. Vəziyyət .poweredOn deyilsə, hər hansı BLE çağırışları sistem tərəfindən ignore edilir. Tərtibatçı hər skan və qoşulmadan əvvəl state-i yoxlamalıdır. .poweredOff-dan .poweredOn-a keçid iOS Parametrlərində Bluetooth açıldıqda baş verir — deleqat təkrar çağırış alır və tətbiq skan etməni bərpa edə bilər.

CBCentralManager: BLE cihazlarının skan edilməsi və qoşulması

CBCentralManager — mərkəzi cihaz tərəfindən bütün BLE əməliyyatları üçün giriş nöqtəsi. İnisializasiya deleqat (CBCentralManagerDelegate) və DispatchQueue qəbul edir — Apple sadəlik üçün main queue və ya performans üçün serial queue istifadə etməyi tövsiyə edir. İnisializasiyadan sonra framework avtomatik Bluetooth vəziyyətini yoxlayır və centralManagerDidUpdateState: — işləmək üçün ilk məcburi deleqatı çağırır.

Skan etmə scanForPeripheralsWithServices:options: metodu ilə başladılır. Birinci parametr filtrləmə üçün CBUUID xidmətlər massividir: maraq xidmətlərinin UUID-ləri məlumdursa, onların ötürülməsi enerji istehlakını və axtarış vaxtını azaldır. Nil olduqda, ərazidəki bütün BLE cihazları aşkar edilir. Seçimlərə .allowDuplicatesKey (eyni cihazın təkrar aşkarlanması) və .solicitedServiceUUIDsKey (mərkəzdə dərc olunan xidmətlər üçün) daxildir.

import CoreBluetooth

class BLECentral: NSObject {

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

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

    // BLE skanını başlat
    func startScan() {
        guard centralManager.state == .poweredOn else {
            print("Bluetooth əlçatan deyil")
            return
        }
        // Bütün cihazları skan et (nil = filtr yoxdur)
        centralManager.scanForPeripherals(withServices: nil,
                                            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
    }

    // Skanı dayandır
    func stopScan() {
        centralManager.stopScan()
    }

    // Seçilmiş cihaza qoşul
    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)")
    }
}

BLECentral sinifi BLE cihazlarının skan edilməsi və qoşulmasının tam dövrünü nümayiş etdirir. centralManagerDidUpdateState Bluetooth açıq olduqda skan etməni başladır. didDiscoverPeripheral tapılan cihazları identifier ilə deduplikasiya ilə discoveredPeripherals massivində toplayır. Qoşulduqdan sonra (didConnect) dərhal xidmətlərin aşkarlanması başladılır — bu hər hansı GATT əməliyyatından əvvəl məcburi addımdır.

CBPeripheralManager: iOS-da BLE serverinin yaradılması

CBPeripheralManager — iOS-da BLE periferiya cihazını emulyasiya etmək üçün sinif. Periferiya rolunda tətbiq öz xidmətlərini və xarakteristikalarını dərc edə, mərkəzi cihazdan daxil olan oxu/yazı sorğularını qəbul edə və bildirişlər göndərə bilər. CBPeripheralManager iPhone tərəfindən emulyasiya edilən BLE aksessuarları üçün istifadə olunur: pultlar, klaviaturalar, trekerlər, IoT şlüzləri.

CBPeripheralManager-ın həyat dövrü inisializasiya və CBPeripheralManagerDelegate deleqatı ilə başlayır. peripheralManagerDidUpdateState: vasitəsilə poweredOn təsdiqləndikdən sonra xidmətlər dərc edilir (addService:) və reklam başladılır (startAdvertising:). CBAdvertisementData reklam məlumatlarına lokal ad (CBAdvertisementDataLocalNameKey), xidmət UUID-ləri (CBAdvertisementDataServiceUUIDsKey) və güc səviyyəsi (CBAdvertisementDataTxPowerLevelKey) daxildir. BLE 4.0 üçün maksimum reklam paketi ölçüsü 31 bayt, BLE 5.0+ extended advertising üçün 251 baytdır.

// CBPeripheralManager vasitəsilə iOS-da BLE periferiyası
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)
    }

    // Xarakteristika ilə xidməti dərc et
    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)
    }

    // Reklamı başlat
    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()
        }
    }

    // Oxu sorğusunu idarə et
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveRead request: CBATTRequest) {
        let data = "CurrentValue".data(using: .utf8)!
        request.value = data
        peripheralManager.respond(to: request, withResult: .success)
    }

    // Yazı sorğusunu idarə et
    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)
    }
}

BLEPeripheral sinifi oxu, yazı və bildirişləri dəstəkləyən bir xarakteristika ilə BLE serveri yaradır. İnisializasiyadan sonra peripheralManagerDidUpdateState addService: vasitəsilə xidməti dərc edir, sonra startAdvertising: vasitəsilə reklamı başladır. didReceiveRead və didReceiveWrite işləyiciləri mərkəzi cihazdan daxil olan GATT sorğularına cavab verir. Bildirişləri göndərmək üçün updateValue:forCharacteristic:onSubscribedCentrals: metodu istifadə olunur.

GATT əməliyyatları: oxu, yazı və bildirişlər

GATT əməliyyatları (Generic Attribute Profile) — Core Bluetooth-da məlumat mübadiləsinin əsası. Xidmətlər və xarakteristikalar aşkar edildikdən sonra mərkəzi cihaz üç tip əməliyyat yerinə yetirə bilər: xarakteristikanın qiymətinin oxunması, qiymətin yazılması və bildirişlərə/indikasiyalara abunə olma. Hər əməliyyat asinxrondur və nəticəni müvafiq CBPeripheralDelegate deleqatı vasitəsilə qaytarır.

Oxu readValueForCharacteristic: çağırışı ilə yerinə yetirilir. Qiymət peripheral:didUpdateValueForCharacteristic:error: ilə gəlir. Əhəmiyyətli: oxu cihazdan cari qiyməti qaytarır, keşləşdirilmişi yox. Əgər cihaz oxumanı dəstəkləmirsə (.read xüsusiyyəti), çağırış xəta qaytaracaq. Böyük qiymətlər üçün (MTU-dan böyük) BLE avtomatik olaraq GATT səviyyəsində məlumatı parçalayır və birləşdirir.

Yazı writeValue:forCharacteristic:type: ilə yerinə yetirilir. BLE iki yazı modelini dəstəkləyir: withResponse (etibarlı, təsdiqləmə ilə) və withoutResponse (sürətli, təsdiqləməsiz). CBCharacteristic.properties xüsusiyyəti mövcud yazı tiplərini müəyyən edir. Tək yazı paketinin maksimum ölçüsü MTU ilə məhdudlaşır: BLE 4.0 üçün 23 bayt (20 bayt faydalı məlumat + 3 bayt başlıq), BLE 5.0 üçün extended MTU ilə 247 bayta qədər (MTU 251).

Bildirişlər setNotifyValue:true forCharacteristic: çağırışı ilə aktivləşdirilir. Abunəlikdən sonra periferiya xarakteristikanın qiyməti hər dəfə dəyişdikdə peripheral:didUpdateValueForCharacteristic: vasitəsilə avtomatik yeniləmələr göndərir. Bildirişləri söndürmək üçün setNotifyValue:false forCharacteristic: çağırılır. Core Bluetooth periferiyada CCCD deskriptorunu avtomatik idarə edir.

Core Bluetooth fon rejimi və State Restoration

Fon rejimi Core Bluetooth BLE tətbiqinə fonda skan etməyə, qoşulmaları saxlamağa və bildirişlər almağa davam etməyə imkan verir. Aktivasiya üçün tələb olunur: Xcode-da capability “Uses Bluetooth LE accessories”-i aktivləşdirmək (Info.plist → Required background modes → App communicates using Core Bluetooth) və UIBackgroundModes-a „bluetooth-central” açarını əlavə etmək. Periferiya rolu üçün — „bluetooth-peripheral”.

State Restoration — iOS sistemi tərəfindən tətbiq yenidən başladıldıqdan sonra BLE qoşulmalarının vəziyyətini bərpa etmək üçün Core Bluetooth mexanizmi. Fon rejimi aktivləşdirildikdə və CBCentralManager və ya CBPeripheralManager-in inisializasiyasında restoreIdentifier göstərildikdə, iOS tətbiq başa çatdıqda BLE stackının vəziyyətini saxlayır və növbəti başlanğıcda onu bərpa edir. Deleqat centralManager:willRestoreState: saxlanmış CBPeripheral və gözləyən qoşulmalarla lüğət alır.

// State Restoration ilə Core Bluetooth konfiqurasiyası
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 {

    // Yenidən başlatmadan sonra vəziyyəti bərpa et
    func centralManager(_ central: CBCentralManager,
                        willRestoreState dict: [String : Any]) {
        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]
            as? [CBPeripheral] {
            for peripheral in peripherals {
                peripheral.delegate = self
                // GATT aşkarlanmasını bərpa et
                peripheral.discoverServices(nil)
            }
        }
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            print("Bərpadan sonra Bluetooth hazırdır")
        }
    }
}

BLECentralWithRestoration konfiqurasiyasında CBCentralManagerOptionRestoreIdentifierKey açarı vəziyyətin saxlanmasını aktivləşdirir. Əgər tətbiq iOS tərəfindən başa çatdırılıbsa (məsələn, yaddaş çatışmazlığı səbəbindən), növbəti başlanğıcda centralManager:willRestoreState: əvvəllər qoşulmuş CBPeripheral siyahısını alır. Tətbiq deleqatları bərpa edir və xidmətlərin təkrar aşkarlanmasını yerinə yetirir — istifadəçi qoşulmanın kəsildiyini hiss etmir. State Restoration olmadan, tətbiq başa çatdıqda bütün BLE sessiyaları itirilir.

Swift-də BLE tətbiqi nümunəsi: mərkəz və periferiya

Tam nümunə Swift-də BLE tətbiqi mərkəzi və periferiya cihazlarını bir layihədə birləşdirir. Tətbiq iki rejimdə işləyə bilər: BLE cihazlarını aşkar etmək və qoşulmaq (Central) və ya BLE aksessuarını emulyasiya etmək (Peripheral). Aşağıda başlanğıcda rolu seçən ümumi BLE meneceri ilə arxitektura təqdim olunur.

// Mərkəz və periferiya üçün universal BLE meneceri
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)
        }
    }

    // Mərkəzi cihaz: skan etmə
    func scanForDevices() {
        centralManager?.scanForPeripherals(withServices: nil, options: nil)
    }

    // Periferiya cihazı: reklam
    func advertiseService() {
        let data: [String: Any] = [
            CBAdvertisementDataServiceUUIDsKey: [advertisedServiceUUID]
        ]
        peripheralManager?.startAdvertising(data)
    }
}

// Başlanğıcda istifadə
let isCentral = UserDefaults.standard.bool(forKey: "isCentral")
let manager = BLEManager(role: isCentral ? .central : .peripheral)

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

BLEManager meneceri inisializasiyada rolu seçir və müvafiq Manager (CBCentralManager və ya CBPeripheralManager) yaradır. Rol bayrağı UserDefaults-da saxlanıla və ya konfiqurasiya serveri vasitəsilə ötürülə bilər. Bu yanaşma BLE tətbiqinə istifadə ssenarisinə uyğunlaşmağa imkan verir: satış nöqtəsində iPhone ödəniş terminallarını skan etmək üçün mərkəz kimi, IoT şlüzündə isə sensorlardan məlumat toplamaq üçün periferiya kimi işləyir.