Core Bluetooth: आर्किटेक्चर और iOS पर BLE डेवलपमेंट

Core Bluetooth क्या है: आर्किटेक्चर और घटक

Core Bluetooth BLE स्टैक को Bluetooth SIG विनिर्देश द्वारा परिभाषित दो तार्किक भूमिकाओं में विभाजित करता है। केंद्रीय उपकरण की भूमिका (Central) CBCentralManager क्लास द्वारा प्रस्तुत की जाती है — यह स्कैनिंग शुरू करता है, कनेक्शन स्थापित करता है, और कनेक्टेड CBPeripheral की सूची प्रबंधित करता है। परिधीय उपकरण की भूमिका (Peripheral) CBPeripheralManager द्वारा प्रस्तुत की जाती है — यह सेवाएं और विशेषताएं प्रकाशित करता है, केंद्रीय अनुरोधों का जवाब देता है, और सूचनाएं भेजता है। एक iOS सत्र विभिन्न BLE रेडियो पर एक साथ दोनों भूमिकाओं में काम कर सकता है, लेकिन विशिष्ट एप्लिकेशन एक भूमिका का उपयोग करता है।

Core Bluetooth आर्किटेक्चर में पाँच प्रमुख एब्स्ट्रैक्शन शामिल हैं। CBCentralManager उपकरण के Bluetooth एडेप्टर की स्थिति प्रबंधित करता है: poweredOn (काम करने के लिए तैयार), poweredOff (Bluetooth बंद), unauthorized (कोई अनुमति नहीं), unsupported (BLE उपलब्ध नहीं)। CBPeripheral अपने UUID, नाम, RSSI और GATT पदानुक्रम के साथ एक दूरस्थ BLE उपकरण का प्रतिनिधित्व करता है। CBService — विशेषताओं का एक तार्किक समूह। CBCharacteristic — पढ़ने/लिखने/सूचनाओं के लिए एक डेटा बिंदु। CBPeripheralManager परिधीय का अनुकरण करने के लिए एक स्थानीय GATT सर्वर बनाता है।

CBCentralManager की स्थितियाँ सभी BLE संचालन को नियंत्रित करती हैं। जब ऐप शुरू होता है, centralManagerDidUpdateState को वर्तमान Bluetooth स्थिति के साथ कॉल किया जाता है। यदि स्थिति .poweredOn नहीं है, तो सिस्टम किसी भी BLE कॉल को अनदेखा करता है। डेवलपर को प्रत्येक स्कैन और कनेक्शन से पहले स्थिति की जाँच करनी चाहिए। .poweredOff से .poweredOn में संक्रमण तब होता है जब iOS सेटिंग्स में Bluetooth चालू किया जाता है — डेलीगेट को एक बार-बार कॉल प्राप्त होता है, और ऐप स्कैनिंग फिर से शुरू कर सकता है।

CBCentralManager: BLE उपकरणों को स्कैन करना और कनेक्ट करना

CBCentralManager केंद्रीय उपकरण की ओर से सभी BLE संचालन के लिए प्रवेश बिंदु है। इनिशियलाइज़ेशन एक डेलीगेट (CBCentralManagerDelegate) और एक DispatchQueue लेता है — Apple सादगी के लिए मुख्य कतार या प्रदर्शन के लिए सीरियल कतार का उपयोग करने की सलाह देता है। इनिशियलाइज़ेशन के बाद, फ्रेमवर्क स्वचालित रूप से Bluetooth स्थिति की जाँच करता है और centralManagerDidUpdateState: को कॉल करता है — संभालने के लिए पहला अनिवार्य डेलीगेट।

स्कैनिंग scanForPeripheralsWithServices:options: विधि से शुरू होती है। पहला पैरामीटर फ़िल्टर करने के लिए CBUUID सेवाओं की एक सरणी है: यदि वांछित सेवाओं के UUID ज्ञात हैं, तो उन्हें पास करने से बिजली की खपत और खोज समय कम हो जाता है। यदि nil है, तो रेंज में सभी BLE उपकरण खोजे जाते हैं। विकल्पों में .allowDuplicatesKey (एक ही उपकरण की बार-बार खोज) और .solicitedServiceUUIDsKey (केंद्रीय पर प्रकाशित सेवाओं के लिए) शामिल हैं।

import CoreBluetooth

class BLECentral: NSObject {

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

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

    // BLE स्कैनिंग शुरू करें
    func startScan() {
        guard centralManager.state == .poweredOn else {
            print("Bluetooth उपलब्ध नहीं")
            return
        }
        // सभी उपकरणों को स्कैन करें (nil = कोई फ़िल्टर नहीं)
        centralManager.scanForPeripherals(withServices: nil,
                                            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
    }

    // स्कैनिंग बंद करें
    func stopScan() {
        centralManager.stopScan()
    }

    // चयनित उपकरण से कनेक्ट करें
    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 क्लास BLE उपकरण स्कैनिंग और कनेक्शन के पूर्ण चक्र को प्रदर्शित करता है। centralManagerDidUpdateState Bluetooth सक्षम होने पर स्कैनिंग शुरू करता है। didDiscoverPeripheral पाए गए उपकरणों को identifier द्वारा डिडुप्लिकेशन के साथ discoveredPeripherals सरणी में एकत्र करता है। कनेक्शन (didConnect) के बाद, सेवा खोज तुरंत शुरू होती है — यह किसी भी GATT संचालन से पहले एक अनिवार्य कदम है।

CBPeripheralManager: iOS पर BLE सर्वर बनाना

CBPeripheralManager iOS पर BLE परिधीय उपकरण का अनुकरण करने के लिए क्लास है। परिधीय भूमिका में एक ऐप अपनी सेवाएं और विशेषताएं प्रकाशित कर सकता है, केंद्रीय उपकरण से आने वाले पढ़ने/लिखने के अनुरोधों को स्वीकार कर सकता है, और सूचनाएं भेज सकता है। CBPeripheralManager का उपयोग iPhone द्वारा अनुकरण किए जाने वाले BLE एक्सेसरीज़ के लिए किया जाता है: रिमोट, कीबोर्ड, ट्रैकर, IoT गेटवे।

CBPeripheralManager का जीवनचक्र इनिशियलाइज़ेशन और CBPeripheralManagerDelegate के साथ शुरू होता है। peripheralManagerDidUpdateState: के माध्यम से poweredOn की पुष्टि प्राप्त करने के बाद, सेवाएं प्रकाशित की जाती हैं (addService:) और विज्ञापन शुरू होता है (startAdvertising:)। विज्ञापन डेटा CBAdvertisementData में स्थानीय नाम (CBAdvertisementDataLocalNameKey), सेवा UUID (CBAdvertisementDataServiceUUIDsKey), और ट्रांसमिट पावर स्तर (CBAdvertisementDataTxPowerLevelKey) शामिल है। अधिकतम विज्ञापन पैकेट आकार BLE 4.0 के लिए 31 बाइट्स, विस्तारित विज्ञापन BLE 5.0+ के लिए 251 बाइट्स है।

// CBPeripheralManager के माध्यम से iOS पर BLE परिधीय
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)
    }

    // विशेषता के साथ सेवा प्रकाशित करें
    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)
    }

    // विज्ञापन शुरू करें
    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()
        }
    }

    // पढ़ने के अनुरोध को संभालें
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveRead request: CBATTRequest) {
        let data = "CurrentValue".data(using: .utf8)!
        request.value = data
        peripheralManager.respond(to: request, withResult: .success)
    }

    // लिखने के अनुरोध को संभालें
    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 क्लास पढ़ने, लिखने और सूचनाओं का समर्थन करने वाली एक विशेषता के साथ BLE सर्वर बनाता है। इनिशियलाइज़ेशन के बाद, peripheralManagerDidUpdateState addService: के माध्यम से सेवा प्रकाशित करता है, फिर startAdvertising: के माध्यम से विज्ञापन शुरू करता है। didReceiveRead और didReceiveWrite हैंडलर केंद्रीय उपकरण से आने वाले GATT अनुरोधों का जवाब देते हैं। सूचनाएं भेजने के लिए updateValue:forCharacteristic:onSubscribedCentrals: विधि का उपयोग किया जाता है।

GATT संचालन: पढ़ना, लिखना और सूचनाएं

GATT संचालन (Generic Attribute Profile) Core Bluetooth में डेटा आदान-प्रदान की नींव हैं। सेवा और विशेषता खोज के बाद, केंद्रीय उपकरण तीन प्रकार के संचालन कर सकता है: विशेषता मान पढ़ना, मान लिखना, और सूचनाओं/संकेतों की सदस्यता लेना। प्रत्येक संचालन अतुल्यकालिक है और संबंधित CBPeripheralDelegate कॉलबैक के माध्यम से परिणाम लौटाता है।

पढ़ना: readValueForCharacteristic: को कॉल करके किया जाता है। मान peripheral:didUpdateValueForCharacteristic:error: में आता है। महत्वपूर्ण: पढ़ना उपकरण से वर्तमान मान लौटाता है, कैश किया हुआ नहीं। यदि उपकरण पढ़ने का समर्थन नहीं करता (.read प्रॉपर्टी), तो कॉल एक त्रुटि लौटाएगा। बड़े मानों (MTU से बड़े) के लिए, BLE स्वचालित रूप से GATT स्तर पर डेटा को खंडित और पुनः एकत्रित करता है।

लिखना: writeValue:forCharacteristic:type: को कॉल करके किया जाता है। BLE दो लेखन मॉडल का समर्थन करता है: withResponse (विश्वसनीय, पुष्टिकरण के साथ) और withoutResponse (तेज़, बिना पुष्टिकरण के)। CBCharacteristic.properties प्रॉपर्टी उपलब्ध लेखन प्रकारों को परिभाषित करती है। एकल लेखन पैकेट का अधिकतम आकार MTU द्वारा सीमित है: BLE 4.0 के लिए 23 बाइट्स (20 बाइट्स पेलोड + 3 बाइट्स हेडर), विस्तारित MTU के साथ BLE 5.0 के लिए 247 बाइट्स (MTU 251) तक।

सूचनाएं: setNotifyValue:true forCharacteristic: को कॉल करके सक्रिय की जाती हैं। सदस्यता के बाद, परिधीय स्वचालित रूप से peripheral:didUpdateValueForCharacteristic: के माध्यम से अपडेट भेजता है जब भी विशेषता मान बदलता है। सूचनाओं को अक्षम करने के लिए, setNotifyValue:false forCharacteristic: को कॉल किया जाता है। Core Bluetooth स्वचालित रूप से परिधीय पर CCCD डिस्क्रिप्टर का प्रबंधन करता है।

Core Bluetooth पृष्ठभूमि मोड और State Restoration

पृष्ठभूमि मोड Core Bluetooth में BLE ऐप्स को पृष्ठभूमि में रहते हुए स्कैनिंग जारी रखने, कनेक्शन बनाए रखने और सूचनाएं प्राप्त करने की अनुमति देता है। इसे सक्रिय करने के लिए, Xcode में “Uses Bluetooth LE accessories” क्षमता सक्षम करें (Info.plist → Required background modes → App communicates using Core Bluetooth) और UIBackgroundModes में “bluetooth-central” कुंजी जोड़ें। परिधीय भूमिका के लिए — “bluetooth-peripheral”.

State Restoration iOS द्वारा ऐप पुनरारंभ के बाद BLE कनेक्शन की स्थिति को पुनर्स्थापित करने के लिए Core Bluetooth का एक तंत्र है। जब पृष्ठभूमि मोड सक्रिय है और CBCentralManager या CBPeripheralManager इनिशियलाइज़ेशन में restoreIdentifier निर्दिष्ट किया गया है, iOS ऐप समाप्त होने पर BLE स्टैक स्थिति को सहेजता है और अगले लॉन्च पर इसे पुनर्स्थापित करता है। डेलीगेट centralManager:willRestoreState: सहेजे गए CBPeripheral और लंबित कनेक्शनों के साथ एक शब्दकोश प्राप्त करता है।

// State Restoration के साथ Core Bluetooth कॉन्फ़िगरेशन
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 {

    // पुनरारंभ के बाद स्थिति पुनर्स्थापित करें
    func centralManager(_ central: CBCentralManager,
                        willRestoreState dict: [String : Any]) {
        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]
            as? [CBPeripheral] {
            for peripheral in peripherals {
                peripheral.delegate = self
                // GATT खोज पुनर्स्थापित करें
                peripheral.discoverServices(nil)
            }
        }
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            print("पुनर्स्थापना के बाद Bluetooth तैयार")
        }
    }
}

BLECentralWithRestoration कॉन्फ़िगरेशन में, CBCentralManagerOptionRestoreIdentifierKey कुंजी स्थिति संरक्षण को सक्षम करती है। यदि ऐप iOS द्वारा समाप्त कर दिया गया था (जैसे, मेमोरी दबाव के कारण), अगले लॉन्च पर centralManager:willRestoreState: पहले से कनेक्टेड CBPeripheral की एक सूची प्राप्त करता है। ऐप डेलीगेट को पुनर्स्थापित करता है और सेवा पुनः खोज करता है — उपयोगकर्ता कनेक्शन में रुकावट नहीं देखता है। State Restoration के बिना, ऐप समाप्त होने पर सभी BLE सत्र खो जाते हैं।

Swift में BLE ऐप का उदाहरण: केंद्रीय और परिधीय

एक पूर्ण उदाहरण Swift में BLE ऐप का जो एक प्रोजेक्ट में केंद्रीय और परिधीय दोनों उपकरणों को जोड़ता है। ऐप दो मोड में काम कर सकता है: BLE उपकरणों को खोजें और कनेक्ट करें (केंद्रीय) या BLE एक्सेसरी का अनुकरण करें (परिधीय)। नीचे एक सामान्य BLE मैनेजर के साथ एक आर्किटेक्चर है जो स्टार्टअप पर भूमिका चुनता है।

// केंद्रीय और परिधीय के लिए यूनिवर्सल BLE मैनेजर
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)
        }
    }

    // केंद्रीय उपकरण: स्कैनिंग
    func scanForDevices() {
        centralManager?.scanForPeripherals(withServices: nil, options: nil)
    }

    // परिधीय उपकरण: विज्ञापन
    func advertiseService() {
        let data: [String: Any] = [
            CBAdvertisementDataServiceUUIDsKey: [advertisedServiceUUID]
        ]
        peripheralManager?.startAdvertising(data)
    }
}

// स्टार्टअप पर उपयोग
let isCentral = UserDefaults.standard.bool(forKey: "isCentral")
let manager = BLEManager(role: isCentral ? .central : .peripheral)

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

BLEManager इनिशियलाइज़ेशन पर भूमिका चुनता है और संबंधित Manager (CBCentralManager या CBPeripheralManager) बनाता है। भूमिका फ़्लैग को UserDefaults में संग्रहीत या कॉन्फ़िगरेशन सर्वर के माध्यम से पारित किया जा सकता है। यह दृष्टिकोण BLE ऐप को उपयोग के मामले के अनुकूल होने की अनुमति देता है: बिक्री के बिंदु पर, iPhone भुगतान टर्मिनलों को स्कैन करने के लिए केंद्रीय के रूप में काम करता है; IoT गेटवे पर — सेंसर से डेटा एकत्र करने के लिए परिधीय के रूप में।