Core Bluetooth: BLE arxitekturasi va iOS-da ishlab chiqish

Core Bluetooth nima: arxitektura va komponentlar

Core Bluetooth BLE stackini Bluetooth SIG spetsifikatsiyasi bilan belgilangan ikkita mantiqiy rolga ajratadi. Markaziy qurilma roli (Central) CBCentralManager sinfi bilan ifodalanadi — skanerlashni boshlaydi, ulanishlarni o'rnatadi va ulangan CBPeripheral ro'yxatini boshqaradi. Periferik qurilma roli (Peripheral) CBPeripheralManager bilan ifodalanadi — xizmatlar va xarakteristikalarni nashr etadi, markazning so'rovlariga javob beradi va bildirishnomalar yuboradi. Bitta iOS sessiyasi bir vaqtning o'zida turli BLE radiolarida ikkala rolda ishlashi mumkin, ammo odatdagi ilova bitta roldan foydalanadi.

Core Bluetooth arxitekturasi beshta asosiy abstraksiyani o'z ichiga oladi. CBCentralManager qurilmaning Bluetooth adapteri holatini boshqaradi: poweredOn (ishga tayyor), poweredOff (Bluetooth o'chirilgan), unauthorized (ruxsat yo'q), unsupported (BLE mavjud emas). CBPeripheral uzoq BLE qurilmasini uning UUID, nom, RSSI va GATT ierarxiyasi bilan ifodalaydi. CBService — xarakteristikalarning mantiqiy guruhi. CBCharacteristic — o'qish/yozish/bildirishnomalar uchun ma'lumot nuqtasi. CBPeripheralManager periferiyani emulyatsiya qilish uchun mahalliy GATT serverini yaratadi.

CBCentralManager holatlari barcha BLE operatsiyalarini boshqaradi. Ilova ishga tushganda, centralManagerDidUpdateState joriy Bluetooth holati bilan chaqiriladi. Agar holat .poweredOn bo'lmasa, har qanday BLE chaqiruvlari tizim tomonidan inkor etiladi. Dasturchi har bir skanerlash va ulanishdan oldin state ni tekshirishi kerak. .poweredOff dan .poweredOn ga o'tish iOS Sozlamalarida Bluetooth yoqilganda sodir bo'ladi — delegat qayta chaqiruv oladi va ilova skanerlashni davom ettirishi mumkin.

CBCentralManager: BLE qurilmalarini skanerlash va ulash

CBCentralManager — markaziy qurilma tomonidan barcha BLE operatsiyalari uchun kirish nuqtasi. Inisializatsiya delegat (CBCentralManagerDelegate) va DispatchQueue navbatini qabul qiladi — Apple soddalik uchun main queue yoki samaradorlik uchun serial queue dan foydalanishni tavsiya qiladi. Inisializatsiyadan so'ng, framework avtomatik ravishda Bluetooth holatini tekshiradi va centralManagerDidUpdateState: — ishlov berish uchun birinchi majburiy delegatni chaqiradi.

Skanerlash scanForPeripheralsWithServices:options: metodi bilan boshlanadi. Birinchi parametr filtrlash uchun CBUUID xizmatlar massividir: agar qiziqish xizmatlarining UUID lari ma'lum bo'lsa, ularni uzatish energiya sarfini va qidirish vaqtini kamaytiradi. Agar nil bo'lsa, hududdagi barcha BLE qurilmalari aniqlanadi. Variantlarga .allowDuplicatesKey (bir xil qurilmani qayta aniqlash) va .solicitedServiceUUIDsKey (markazda nashr etilgan xizmatlar uchun) kiradi.

import CoreBluetooth

class BLECentral: NSObject {

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

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

    // BLE skanerlashni boshlash
    func startScan() {
        guard centralManager.state == .poweredOn else {
            print("Bluetooth mavjud emas")
            return
        }
        // Barcha qurilmalarni skanerlash (nil = filtr yo'q)
        centralManager.scanForPeripherals(withServices: nil,
                                            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
    }

    // Skanerlashni to'xtatish
    func stopScan() {
        centralManager.stopScan()
    }

    // Tanlangan qurilmaga ulanish
    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 sinfi BLE qurilmalarini skanerlash va ulashning to'liq siklini namoyish etadi. centralManagerDidUpdateState Bluetooth yoqilganida skanerlashni boshlaydi. didDiscoverPeripheral topilgan qurilmalarni identifier bo'yicha deduplikatsiya bilan discoveredPeripherals massivida to'playdi. Ulangandan so'ng (didConnect), darhol xizmatlarni aniqlash boshlanadi — bu har qanday GATT operatsiyalaridan oldin majburiy qadamdir.

CBPeripheralManager: iOS da BLE serverini yaratish

CBPeripheralManager — iOS da BLE periferik qurilmasini emulyatsiya qilish uchun sinf. Periferiya rolidagi ilova o'z xizmatlari va xarakteristikalarini nashr etishi, markaziy qurilmadan kiruvchi o'qish/yozish so'rovlarini qabul qilishi va bildirishnomalar yuborishi mumkin. CBPeripheralManager iPhone tomonidan emulyatsiya qilinadigan BLE aksessuarlari uchun ishlatiladi: pultlar, klaviaturalar, trekerlar, IoT shlyuzlari.

CBPeripheralManager ning hayot sikli inisializatsiya va CBPeripheralManagerDelegate delegati bilan boshlanadi. peripheralManagerDidUpdateState: orqali poweredOn tasdiqlangandan so'ng, xizmatlar nashr etiladi (addService:) va reklama boshlanadi (startAdvertising:). CBAdvertisementData reklama ma'lumotlariga mahalliy nom (CBAdvertisementDataLocalNameKey), xizmat UUID lari (CBAdvertisementDataServiceUUIDsKey) va quvvat darajasi (CBAdvertisementDataTxPowerLevelKey) kiradi. BLE 4.0 uchun maksimal reklama paketi hajmi 31 bayt, BLE 5.0+ extended advertising uchun 251 bayt.

// CBPeripheralManager orqali iOS da BLE periferiyasi
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 bilan xizmatni nashr etish
    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)
    }

    // Reklamani boshlash
    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()
        }
    }

    // O'qish so'rovini boshqarish
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveRead request: CBATTRequest) {
        let data = "CurrentValue".data(using: .utf8)!
        request.value = data
        peripheralManager.respond(to: request, withResult: .success)
    }

    // Yozish so'rovini boshqarish
    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 sinfi o'qish, yozish va bildirishnomalarni qo'llab-quvvatlaydigan bitta xarakteristika bilan BLE serverini yaratadi. Inisializatsiyadan so'ng, peripheralManagerDidUpdateState addService: orqali xizmatni nashr etadi, so'ngra startAdvertising: orqali reklamani boshlaydi. didReceiveRead va didReceiveWrite ishlovchilari markaziy qurilmadan kiruvchi GATT so'rovlariga javob beradi. Bildirishnomalarni yuborish uchun updateValue:forCharacteristic:onSubscribedCentrals: metodi ishlatiladi.

GATT operatsiyalari: o'qish, yozish va bildirishnomalar

GATT operatsiyalari (Generic Attribute Profile) — Core Bluetooth da ma'lumot almashishning asosi. Xizmatlar va xarakteristikalar aniqlangandan so'ng, markaziy qurilma uch turdagi operatsiyalarni bajarishi mumkin: xarakteristika qiymatini o'qish, qiymatni yozish va bildirishnomalarga/indikatsiyalarga obuna bo'lish. Har bir operatsiya asinxrondir va natijani tegishli CBPeripheralDelegate delegati orqali qaytaradi.

O'qish readValueForCharacteristic: chaqiruvi bilan amalga oshiriladi. Qiymat peripheral:didUpdateValueForCharacteristic:error: bilan keladi. Muhim: o'qish qurilmadan joriy qiymatni qaytaradi, keshlanganini emas. Agar qurilma o'qishni qo'llab-quvvatlamasa (.read xususiyati), chaqiruv xato qaytaradi. Katta qiymatlar uchun (MTU dan katta), BLE avtomatik ravishda GATT darajasida ma'lumotni parchalaydi va birlashtiradi.

Yozish writeValue:forCharacteristic:type: bilan amalga oshiriladi. BLE ikkita yozish modelini qo'llab-quvvatlaydi: withResponse (ishonchli, tasdiqlash bilan) va withoutResponse (tez, tasdiqlashsiz). CBCharacteristic.properties xususiyati mavjud yozish turlarini aniqlaydi. Bitta yozish paketining maksimal hajmi MTU bilan cheklangan: BLE 4.0 uchun 23 bayt (20 bayt foydali ma'lumot + 3 bayt sarlavha), BLE 5.0 uchun extended MTU bilan 247 baytgacha (MTU 251).

Bildirishnomalar setNotifyValue:true forCharacteristic: chaqiruvi bilan faollashtiriladi. Obunadan so'ng, periferiya xarakteristika qiymati har o'zgarganda peripheral:didUpdateValueForCharacteristic: orqali avtomatik yangilanishlarni yuboradi. Bildirishnomalarni o'chirish uchun setNotifyValue:false forCharacteristic: chaqiriladi. Core Bluetooth periferiyada CCCD deskriptorini avtomatik boshqaradi.

Core Bluetooth fon rejimi va State Restoration

Fon rejimi Core Bluetooth BLE ilovasiga fonda skanerlashni davom ettirish, ulanishlarni saqlash va bildirishnomalarni olish imkonini beradi. Faollashtirish uchun talab qilinadi: Xcode da capability “Uses Bluetooth LE accessories” ni yoqish (Info.plist → Required background modes → App communicates using Core Bluetooth) va UIBackgroundModes ga „bluetooth-central” kalitini qo'shish. Periferiya roli uchun — „bluetooth-peripheral”.

State Restoration — iOS tizimi tomonidan ilova qayta ishga tushirilgandan so'ng BLE ulanishlari holatini tiklash uchun Core Bluetooth mexanizmi. Fon rejimi faollashtirilganda va CBCentralManager yoki CBPeripheralManager inisializatsiyasida restoreIdentifier ko'rsatilganda, iOS ilova tugaganda BLE stacki holatini saqlaydi va keyingi ishga tushirishda uni tiklaydi. Delegat centralManager:willRestoreState: saqlangan CBPeripheral va kutayotgan ulanishlar bilan lug'at oladi.

// State Restoration bilan Core Bluetooth konfiguratsiyasi
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 {

    // Qayta ishga tushirishdan so'ng holatni tiklash
    func centralManager(_ central: CBCentralManager,
                        willRestoreState dict: [String : Any]) {
        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]
            as? [CBPeripheral] {
            for peripheral in peripherals {
                peripheral.delegate = self
                // GATT aniqlashni tiklash
                peripheral.discoverServices(nil)
            }
        }
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            print("Tiklashdan so'ng Bluetooth tayyor")
        }
    }
}

BLECentralWithRestoration konfiguratsiyasida CBCentralManagerOptionRestoreIdentifierKey kaliti holatni saqlashni faollashtiradi. Agar ilova iOS tomonidan tugatilgan bo'lsa (masalan, xotira yetishmasligi sababli), keyingi ishga tushirishda centralManager:willRestoreState: avval ulangan CBPeripheral ro'yxatini oladi. Ilova delegatlarni tiklaydi va xizmatlarni qayta aniqlashni amalga oshiradi — foydalanuvchi ulanish uzilganini sezmaydi. State Restoration bo'lmasa, ilova tugaganda barcha BLE sessiyalari yo'qoladi.

Swift da BLE ilovasi namunasi: markaz va periferiya

To'liq misol Swift da BLE ilovasi markaziy va periferik qurilmalarni bitta loyihada birlashtiradi. Ilova ikki rejimda ishlashi mumkin: BLE qurilmalarini aniqlash va ulanish (Central) yoki BLE aksessuarini emulyatsiya qilish (Peripheral). Quyida ishga tushirishda rolni tanlaydigan umumiy BLE menejeri bilan arxitektura keltirilgan.

// Markaz va periferiya uchun universal BLE menejeri
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)
        }
    }

    // Markaziy qurilma: skanerlash
    func scanForDevices() {
        centralManager?.scanForPeripherals(withServices: nil, options: nil)
    }

    // Periferik qurilma: reklama
    func advertiseService() {
        let data: [String: Any] = [
            CBAdvertisementDataServiceUUIDsKey: [advertisedServiceUUID]
        ]
        peripheralManager?.startAdvertising(data)
    }
}

// Ishga tushirishda foydalanish
let isCentral = UserDefaults.standard.bool(forKey: "isCentral")
let manager = BLEManager(role: isCentral ? .central : .peripheral)

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

BLEManager menejeri inisializatsiyada rolni tanlaydi va tegishli Manager (CBCentralManager yoki CBPeripheralManager) yaratadi. Rol bayrog'i UserDefaults da saqlanishi yoki konfiguratsiya serveri orqali uzatilishi mumkin. Bunday yondashuv BLE ilovasiga foydalanish stsenariysiga moslashish imkonini beradi: savdo nuqtasida iPhone to'lov terminallarini skanerlash uchun markaz sifatida, IoT shlyuzida esa sensorlardan ma'lumot yig'ish uchun periferiya sifatida ishlaydi.