CBPeripheral: یہ کیا ہے، طریقے اور iOS پر BLE پیریفرل کا انتظام

CBPeripheral کیا ہے: جوہر اور مقصد

CBPeripheral ایک آبجیکٹ ہے جو iOS ایپلیکیشن میں ایک دور دراز BLE ڈیوائس کی نمائندگی کرتا ہے۔ CBCentralManager کے برعکس، جو iPhone کے مقامی Bluetooth اڈاپٹر کا انتظام کرتا ہے، CBPeripheral ایک بیرونی پیریفرل ڈیوائس کا ماڈل بناتا ہے: سینسر، فٹنس ٹریکر، بیکن یا طبی آلہ۔ ہر CBPeripheral مثال میں ایک منفرد شناخت کنندہ (UUID) ہوتا ہے جو کنکشن سیشنز کے درمیان برقرار رہتا ہے — Apple سسٹم بونڈنگ کے ذریعے UUID کو ایک مخصوص ڈیوائس سے منسلک کرتا ہے۔

CBPeripheral براہ راست init کے ذریعے نہیں بنایا جاتا۔ Core Bluetooth فریم ورک دو منظرناموں میں CBPeripheral آبجیکٹ لوٹاتا ہے: جب scanForPeripheralsWithServices: کے ذریعے ڈیوائس دریافت ہوتی ہے (مندوب didDiscoverPeripheral) اور جب retrievePeripheralsWithIdentifiers: کے ذریعے پہلے سے معروف ڈیوائس سے منسلک کیا جاتا ہے۔ آبجیکٹ حاصل کرنے کے بعد، ڈویلپر CBCentralManager پر connectPeripheral: کال کرتا ہے، جس کے بعد CBPeripheral GATT آپریشنز کے لیے دستیاب ہو جاتا ہے۔

CBPeripheral لائف سائیکل چھ حالات پر مشتمل ہے: منقطع (ابتدائی)، منسلک ہو رہا ہے (connect کال کے بعد)، منسلک (didConnectPeripheral کے بعد)، دریافت کر رہا ہے (discoverServices کال کے دوران)، دریافت شدہ (خدمات حاصل کرنے کے بعد) اور منقطع کر رہا ہے (cancelPeripheralConnection کے بعد)۔ ہر حالت CBPeripheralDelegate پروٹوکول کے ذریعے ٹریک کی جاتی ہے — iOS پر کسی بھی BLE ایپلیکیشن کے لیے لازمی۔

CBPeripheral اور GATT درجہ بندی: خدمات، خصوصیات، وضاحت کنندگان

CBPeripheral تین سطحوں پر مشتمل ایک درجہ بندی GATT ساخت ذخیرہ کرتا ہے۔ بنیادی سطح CBService (خدمات) کی ایک صف ہے، ہر خدمت میں CBCharacteristic (خصوصیات) کی ایک صف ہوتی ہے، ہر خصوصیت میں CBDescriptor (وضاحت کنندگان) کی ایک صف ہوتی ہے۔ یہ ماڈل Bluetooth GATT تصریح کے مطابق ہے: خدمت ایک ڈیوائس فنکشن ہے (مثال کے طور پر، «دل کی دھڑکن کی سروس»)، خصوصیت ایک مخصوص قدر ہے (نبض 72 bpm)، وضاحت کنندہ خصوصیت کا میٹا ڈیٹا ہے (پیمائش کی اکائیاں، اطلاع ترتیب)۔

معیاری BLE خدمات Bluetooth SIG کے ذریعے رجسٹرڈ ہیں: Heart Rate Service (UUID 180D)، Battery Service (180F)، Device Information (180A)، Blood Pressure (1810)۔ کسٹم خدمات کے لیے 128-bit UUID استعمال ہوتے ہیں (مثال کے طور پر، E20A39F4-73F5-4BC4-A12F-17D1AD07A961)۔ iOS خود بخود معیاری UUID کو پہچانتا ہے اور انسانی پڑھنے کے قابل نام دکھاتا ہے؛ کسٹم UUID hex فارمیٹ میں ظاہر ہوتے ہیں۔

کنکشن کے بعد، CBPeripheral کا درجہ بندی خالی ہوتا ہے — خدمات اور خصوصیات لوڈ نہیں ہوتیں۔ ڈویلپر کو خدمات حاصل کرنے کے لیے discoverServices: کال کرنی ہوگی اور پھر ہر خدمت کے لیے discoverCharacteristics:forService: کال کرنی ہوگی۔ اگر خدمت میں شامل کردہ خدمات ہیں، تو اضافی طور پر discoverIncludedServices:forService: کال کیا جاتا ہے۔ درجہ بندی کی دریافت مکمل ہونے کے بعد ہی CBPeripheral بھر جاتا ہے اور پڑھنے اور لکھنے کے لیے دستیاب ہوتا ہے۔

سروس اور خصوصیت کی دریافت: طریقے اور مندوب

دریافت CBPeripheral کی GATT ساخت کی دریافت کسی بھی پڑھنے یا لکھنے کے آپریشن سے پہلے ایک لازمی مرحلہ ہے۔ discoverServices: طریقہ تمام ڈیوائس خدمات کی ایک غیر متزامن تلاش شروع کرتا ہے۔ اگر nil پاس کیا جاتا ہے، تو تمام خدمات دریافت ہوتی ہیں؛ اگر CBUUID کی ایک صف پاس کی جاتی ہے — صرف مخصوص UUID والی خدمات (وقت کی اصلاح)۔ نتیجہ مندوب peripheral:didDiscoverServices: پر آتا ہے — CBPeripheral آبجیکٹ اپنی services خصوصیت کو CBService کی صف سے بھرتا ہے۔

خدمات حاصل کرنے کے بعد، ہر CBService کے لیے discoverCharacteristics:forService: کال کرنا ضروری ہے۔ اسی طرح، nil — تمام خصوصیات، CBUUID کی صف — صرف مخصوص کردہ۔ نتیجہ: peripheral:didDiscoverCharacteristicsForService:error:۔ اس مرحلے پر، CBCharacteristic خصوصیات حاصل کرتا ہے (properties: .read، .write، .notify، .indicate) جو اجازت شدہ آپریشنز کی وضاحت کرتی ہیں۔

import CoreBluetooth

extension BLEViewController: CBPeripheralDelegate {

    // 1. Service discovery
    func peripheral(_ peripheral: CBPeripheral,
                     didDiscoverServices error: Error?) {
        guard let services = peripheral.services else { return }

        for service in services {
            // Request characteristics for each service
            peripheral.discoverCharacteristics(nil, for: service)
        }
    }

    // 2. Characteristic discovery
    func peripheral(_ peripheral: CBPeripheral,
                     didDiscoverCharacteristicsFor service: CBService,
                     error: Error?) {
        guard let characteristics = service.characteristics else { return }

        for characteristic in characteristics {
            if characteristic.properties.contains(.read) {
                peripheral.readValue(for: characteristic)
            }
            if characteristic.properties.contains(.notify) {
                peripheral.setNotifyValue(true, for: characteristic)
            }
        }
    }

    // 3. Read value
    func peripheral(_ peripheral: CBPeripheral,
                     didUpdateValueFor characteristic: CBCharacteristic,
                     error: Error?) {
        guard let data = characteristic.value,
              let value = String(data: data, encoding: .utf8)
        else { return }
        print("Characteristic value: \(value)")
    }
}

مثال میں، CBPeripheralDelegate تین لازمی دریافت طریقوں کو نافذ کرتا ہے۔ didDiscoverServices تمام ملنے والی خدمات پر تکرار کرتا ہے اور خصوصیات کی درخواست کرتا ہے۔ didDiscoverCharacteristicsForService ہر خصوصیت کی خصوصیات کو چیک کرتا ہے: .read کے لیے readValue کال کرتا ہے، .notify کے لیے setNotifyValue(true) کال کرتا ہے۔ didUpdateValueForCharacteristic طریقہ Data فارمیٹ میں اصل قدر وصول کرتا ہے۔

خصوصیات کا پڑھنا اور لکھنا: withResponse اور withoutResponse

اقدار پڑھنا CBCharacteristic کی قدریں readValueForCharacteristic: طریقہ استعمال کرتے ہوئے پڑھی جاتی ہیں۔ نتیجہ غیر متزامن طور پر peripheral:didUpdateValueForCharacteristic:error: پر آتا ہے۔ اہم: ڈیوائس پر کیش شدہ قدر ہو سکتی ہے (دریافت کے فوراً بعد characteristic.value دستیاب ہے)، لیکن موجودہ ڈیٹا حاصل کرنے کے لیے readValue کال لازمی ہے۔ iOS توانائی کی بچت کے لیے اقدار کو کیش کر سکتا ہے — readValue کیش کو تازہ کرتا ہے۔

اقدار لکھنا writeValue:forCharacteristic:type: طریقہ استعمال کرتے ہوئے کیا جاتا ہے۔ پیرامیٹر type لکھنے کی قسم کا تعین کرتا ہے: .withResponse (CBCharacteristicWriteWithResponse) — ڈیوائس didWriteValueForCharacteristic کے ذریعے تحریر کی تصدیق کرتی ہے؛ .withoutResponse (CBCharacteristicWriteWithoutResponse) — تصدیق کے بغیر تحریر، زیادہ سے زیادہ رفتار لیکن ترسیل کی کوئی ضمانت نہیں۔ BLE تصریح MTU (زیادہ سے زیادہ ترسیلی اکائی) کو محدود کرتی ہے: BLE 4.0 کے لیے 23 بائٹس تک، BLE 5.0+ کے لیے 251 بائٹس تک۔ MTU سے بڑے ڈیٹا کے لیے ایپلیکیشن سطح پر ٹکڑے کرنا ضروری ہے۔

// CBPeripheral characteristic read and write
class BLEService {

    private let peripheral: CBPeripheral
    private let serviceUUID = CBUUID(string: "180D")
    private let charUUID = CBUUID(string: "2A37")

    init(peripheral: CBPeripheral) {
        self.peripheral = peripheral
    }

    // Read with response
    func readHeartRate() {
        guard let service = peripheral.services?.first(where: { $0.uuid == serviceUUID }),
              let characteristic = service.characteristics?.first(where: { $0.uuid == charUUID })
        else { return }
        peripheral.readValue(for: characteristic)
    }

    // Write with response (withResponse)
    func writeWithResponse(data: Data) {
        guard let characteristic = findCharacteristic() else { return }
        peripheral.writeValue(data, for: characteristic,
                             type: .withResponse)
    }

    // Write without response (withoutResponse)
    // Max throughput, no delivery guarantee
    func writeWithoutResponse(data: Data) {
        guard let characteristic = findCharacteristic() else { return }
        peripheral.writeValue(data, for: characteristic,
                             type: .withoutResponse)
    }

    private func findCharacteristic() -> CBCharacteristic? {
        return peripheral.services?
            .flatMap { $0.characteristics ?? [] }
            .first(where: { $0.uuid == charUUID })
    }
}

تحریر کی قسم withResponse یا withoutResponse کا انتخاب اعتماد کی ضروریات پر منحصر ہے۔ کمانڈز کے لیے (لائٹ آن کریں، تالا کھولیں) withResponse استعمال کریں — ترسیل کی ضمانت اہم ہے۔ اسٹریمنگ ڈیٹا (نبض، درجہ حرارت) کے لیے withoutResponse استعمال کریں — ایک پیکٹ کا کھو جانا غیر اہم ہے۔ BLE ڈیوائس صرف ایک تحریر کی قسم کو سپورٹ کر سکتی ہے — characteristic.properties.contains(.write) اور .writeWithoutResponse خصوصیت کو چیک کریں۔

setNotifyValue کے ذریعے BLE اطلاعات کی سبسکرپشن

اطلاعات ایک BLE طریقہ کار ہے جس میں پیریفرل ڈیوائس مرکزی ڈیوائس کو خصوصیت کی قدریں غیر متزامن طور پر بھیجتی ہے، مرکزی کی طرف سے مسلسل پولنگ کے بغیر۔ CBPeripheral setNotifyValue:forCharacteristic: طریقہ کے ذریعے سبسکرپشن کو فعال کرتا ہے۔ سبسکرپشن فعال ہونے کے بعد، iOS خود بخود پیریفرل پر CCCD (کلائنٹ خصوصیت ترتیب وضاحت کنندہ) میں لکھتا ہے، اور ڈیوائس قدر تبدیل ہونے پر اپ ڈیٹس بھیجنا شروع کر دیتی ہے۔

اشاروں کے برعکس، اطلاعات کو مرکزی ڈیوائس سے تصدیق کی ضرورت نہیں ہوتی — پیکٹ بھیجا جاتا ہے اور بھلا دیا جاتا ہے۔ یہ زیادہ سے زیادہ تھرو پٹ فراہم کرتا ہے، لیکن پیکٹ کھو سکتے ہیں۔ اشاروں کو پروٹوکول سطح (L2CAP) پر تصدیق کی ضرورت ہوتی ہے — زیادہ قابل اعتماد لیکن سست۔ CBCharacteristic کی properties خصوصیت بالکل بتاتی ہے کہ کون سا موڈ سپورٹ ہے: .notify، .indicate یا دونوں۔

جب CBPeripheral منقطع ہوتا ہے (منقطع، حد سے باہر)، تمام فعال سبسکرپشنز خود بخود ری سیٹ ہو جاتی ہیں۔ دوبارہ کنکشن پر، ہر خصوصیت کے لیے دوبارہ setNotifyValue:true کال کرنا ضروری ہے۔ iOS جب ایپلیکیشن پیش منظر چھوڑتی ہے تو بھی سبسکرپشنز کھو دیتا ہے (اگر پس منظر موڈ فعال نہ ہو) — پس منظر میں کام کرنے کے لیے Info.plist میں “Uses Bluetooth LE accessories” کی صلاحیت کو فعال کرنا ضروری ہے۔

// CBPeripheral notification subscription management
class NotificationManager: NSObject {

    private var peripheral: CBPeripheral?
    private var subscribedCharacteristics: Set<CBUUID> = []

    // Subscribe to notifications for all .notify characteristics
    func subscribeToAllNotifications(peripheral: CBPeripheral) {
        self.peripheral = peripheral

        guard let services = peripheral.services else { return }

        for service in services {
            guard let characteristics = service.characteristics else { continue }

            for characteristic in characteristics {
                if characteristic.properties.contains(.notify)
                    || characteristic.properties.contains(.indicate) {
                    peripheral.setNotifyValue(true, for: characteristic)
                    subscribedCharacteristics.insert(characteristic.uuid)
                }
            }
        }
    }

    // Unsubscribe from all notifications
    func unsubscribeFromAll() {
        guard let peripheral = peripheral else { return }
        guard let services = peripheral.services else { return }

        for service in services {
            guard let characteristics = service.characteristics else { continue }

            for characteristic in characteristics {
                if subscribedCharacteristics.contains(characteristic.uuid) {
                    peripheral.setNotifyValue(false, for: characteristic)
                }
            }
        }
        subscribedCharacteristics.removeAll()
    }

    // Notification handler
    func peripheral(_ peripheral: CBPeripheral,
                     didUpdateNotificationStateFor characteristic: CBCharacteristic,
                     error: Error?) {
        if characteristic.isNotifying {
            print("Subscription active: \(characteristic.uuid)")
        } else {
            print("Subscription inactive: \(characteristic.uuid)")
        }
    }
}

NotificationManager CBPeripheral اطلاعات کی مناسب ہینڈلنگ کو ظاہر کرتا ہے۔ subscribeToAllNotifications تمام خدمات اور خصوصیات پر تکرار کرتا ہے، .notify اور .indicate کو فعال کرتا ہے۔ subscribedCharacteristics مناسب ان سبسکرائب کرنے کے لیے فعال سبسکرپشنز کو ٹریک کرتا ہے۔ didUpdateNotificationStateForCharacteristic characteristic.isNotifying خصوصیت کے ذریعے کامیاب سبسکرپشن حالت کی تبدیلی کی تصدیق کرتا ہے۔

Swift میں مکمل CBPeripheral مثال

مکمل ورک فلو CBPeripheral کے ساتھ شامل ہے: CBCentralManager سے آبجیکٹ حاصل کرنا، کنکشن، دریافت، پڑھنا/لکھنا، اطلاع سبسکرپشن اور منقطع کرنا۔ نیچے دی گئی مثال BLEConnection کلاس کو نافذ کرتی ہے جو جدید async/await API (iOS 15+) کا استعمال کرتے ہوئے Swift میں مکمل BLE پیریفرل لائف سائیکل کا انتظام کرتی ہے۔

import CoreBluetooth

// Full CBPeripheral management example with async/await
class BLEConnection: NSObject {

    private let centralManager: CBCentralManager
    private var peripheral: CBPeripheral?
    private var continuation: CheckedContinuation<Void, Error>?

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

    // 1. Connect to peripheral
    func connect(to peripheral: CBPeripheral) async throws {
        self.peripheral = peripheral
        peripheral.delegate = self
        centralManager.connect(peripheral, options: nil)

        try await withCheckedThrowingContinuation { continuation in
            self.continuation = continuation
        }
    }

    // 2. Discovery  
    func discoverServices() async throws {
        guard let peripheral = peripheral else {
            throw BLEError.notConnected
        }
        peripheral.discoverServices(nil)
        try await withCheckedThrowingContinuation { continuation in
            self.continuation = continuation
        }
    }
}

// 3.  CBCentralManager
extension BLEConnection: CBCentralManagerDelegate {
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        // Handle Bluetooth device state
    }

    func centralManager(_ central: CBCentralManager,
                        didConnect peripheral: CBPeripheral) {
        continuation?.resume()
        continuation = nil
    }

    func centralManager(_ central: CBCentralManager,
                        didFailToConnect peripheral: CBPeripheral,
                        error: Error?) {
        continuation?.resume(throwing: error ?? BLEError.connectionFailed)
        continuation = nil
    }
}

enum BLEError: Error {
    case notConnected
    case connectionFailed
    case serviceNotFound
    case characteristicNotFound
}

BLEConnection کلاس CheckedContinuation کے ذریعے Swift Concurrency (async/await) استعمال کرتی ہے — Core Bluetooth کے مندوب پر مبنی API کے ساتھ کام کرنے کے لیے ایک جدید پیٹرن۔ connect(to:) didConnectPeripheral کے ذریعے کنکشن کی تصدیق کا انتظار کرتا ہے، discoverServices() — didDiscoverServices کے ذریعے۔ یہ طریقہ نیسٹڈ مندوبین کو ختم کرتا ہے اور BLE کوڈ کو لکیری اور پڑھنے کے قابل بناتا ہے۔ BLEError کے ذریعے غلطی کا انتظام تمام عام BLE کنکشن ناکامی کے منظرناموں کو کور کرتا ہے۔