Core Bluetooth: iOS'ta BLE mimarisi ve geliştirme

Core Bluetooth Nedir: Mimari ve Bileşenler

Core Bluetooth, BLE yığınını Bluetooth SIG spesifikasyonu tarafından tanımlanan iki mantıksal role ayırır. Merkezi cihaz rolü (Central), CBCentralManager sınıfı tarafından temsil edilir — taramayı başlatır, bağlantılar kurar ve bağlı CBPeripheral'ların listesini yönetir. Çevre birim cihaz rolü (Peripheral), CBPeripheralManager tarafından temsil edilir — hizmetleri ve özellikleri yayınlar, merkezi isteklere yanıt verir ve bildirimler gönderir. Tek bir iOS oturumu, farklı BLE radyolarında aynı anda her iki rolü de çalıştırabilir, ancak tipik bir uygulama tek bir rol kullanır.

Core Bluetooth mimarisi beş temel soyutlama içerir. CBCentralManager cihazın Bluetooth adaptör durumunu yönetir: poweredOn (çalışmaya hazır), poweredOff (Bluetooth devre dışı), unauthorized (izin yok), unsupported (BLE kullanılamıyor). CBPeripheral UUID'si, adı, RSSI'si ve GATT hiyerarşisi ile uzaktaki bir BLE cihazını temsil eder. CBService — özelliklerin mantıksal bir grubu. CBCharacteristic — okuma/yazma/bildirimler için bir veri noktası. CBPeripheralManager bir çevre birimini öykünmek için yerel bir GATT sunucusu oluşturur.

CBCentralManager Durumları tüm BLE işlemlerini kontrol eder. Uygulama başladığında, centralManagerDidUpdateState mevcut Bluetooth durumuyla çağrılır. Durum .poweredOn değilse, sistem tüm BLE çağrılarını yok sayar. Geliştirici her tarama ve bağlantıdan önce durumu kontrol etmelidir. .poweredOff'tan .poweredOn'a geçiş, iOS Ayarları'nda Bluetooth etkinleştirildiğinde gerçekleşir — temsilci tekrarlanan bir çağrı alır ve uygulama taramaya devam edebilir.

CBCentralManager: BLE Cihazlarını Tarama ve Bağlama

CBCentralManager, merkezi cihaz tarafındaki tüm BLE işlemleri için giriş noktasıdır. Başlatma, bir temsilci (CBCentralManagerDelegate) ve bir DispatchQueue alır — Apple, basitlik için ana kuyruğu veya performans için seri kuyruğu kullanmayı önerir. Başlatmadan sonra, çerçeve otomatik olarak Bluetooth durumunu kontrol eder ve centralManagerDidUpdateState:'i çağırır — işlenmesi gereken ilk zorunlu temsilci.

Tarama, scanForPeripheralsWithServices:options: yöntemiyle başlar. İlk parametre, filtreleme için bir CBUUID hizmetleri dizisidir: istenen hizmetlerin UUID'leri biliniyorsa, bunları iletmek güç tüketimini ve arama süresini azaltır. Nil ise, menzildeki tüm BLE cihazları keşfedilir. Seçenekler arasında .allowDuplicatesKey (aynı cihazın tekrarlanan keşfi) ve .solicitedServiceUUIDsKey (merkezde yayınlanan hizmetler için) bulunur.

import CoreBluetooth

class BLECentral: NSObject {

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

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

    // BLE taramasını başlat
    func startScan() {
        guard centralManager.state == .poweredOn else {
            print("Bluetooth kullanılamıyor")
            return
        }
        // Tüm cihazları tara (nil = filtre yok)
        centralManager.scanForPeripherals(withServices: nil,
                                            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
    }

    // Taramayı durdur
    func stopScan() {
        centralManager.stopScan()
    }

    // Seçili cihaza bağlan
    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 sınıfı, BLE cihaz tarama ve bağlantının tam döngüsünü gösterir. centralManagerDidUpdateState, Bluetooth etkin olduğunda taramayı başlatır. didDiscoverPeripheral, identifier'a göre yinelenenleri kaldırarak bulunan cihazları discoveredPeripherals dizisinde toplar. Bağlantıdan (didConnect) sonra, hizmet keşfi hemen başlar — bu, herhangi bir GATT işleminden önce zorunlu bir adımdır.

CBPeripheralManager: iOS'ta BLE Sunucusu Oluşturma

CBPeripheralManager, iOS'ta bir BLE çevre birim cihazını öykünmek için kullanılan sınıftır. Çevre birim rolündeki bir uygulama, hizmetlerini ve özelliklerini yayınlayabilir, merkezi bir cihazdan gelen okuma/yazma isteklerini kabul edebilir ve bildirimler gönderebilir. CBPeripheralManager, iPhone tarafından öykünülen BLE aksesuarları için kullanılır: uzaktan kumandalar, klavyeler, izleyiciler, IoT ağ geçitleri.

CBPeripheralManager'ın yaşam döngüsü, başlatma ve CBPeripheralManagerDelegate ile başlar. peripheralManagerDidUpdateState: aracılığıyla poweredOn onayı alındıktan sonra, hizmetler yayınlanır (addService:) ve reklam başlatılır (startAdvertising:). Reklam verileri CBAdvertisementData, yerel adı (CBAdvertisementDataLocalNameKey), hizmet UUID'lerini (CBAdvertisementDataServiceUUIDsKey) ve iletim gücü seviyesini (CBAdvertisementDataTxPowerLevelKey) içerir. Maksimum reklam paketi boyutu BLE 4.0 için 31 bayt, extended advertising BLE 5.0+ için 251 bayttır.

// CBPeripheralManager ile iOS'ta BLE çevre birimi
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)
    }

    // Özellikle hizmeti yayınla
    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()
        }
    }

    // Okuma isteğini işle
    func peripheralManager(_ peripheral: CBPeripheralManager,
                        didReceiveRead request: CBATTRequest) {
        let data = "CurrentValue".data(using: .utf8)!
        request.value = data
        peripheralManager.respond(to: request, withResult: .success)
    }

    // Yazma isteğini işle
    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 sınıfı, okuma, yazma ve bildirimleri destekleyen tek bir özellikle bir BLE sunucusu oluşturur. Başlatmadan sonra, peripheralManagerDidUpdateState addService: aracılığıyla hizmeti yayınlar, ardından startAdvertising: aracılığıyla reklamı başlatır. didReceiveRead ve didReceiveWrite işleyicileri, merkezi cihazdan gelen GATT isteklerine yanıt verir. Bildirim göndermek için updateValue:forCharacteristic:onSubscribedCentrals: yöntemi kullanılır.

GATT İşlemleri: Okuma, Yazma ve Bildirimler

GATT işlemleri (Generic Attribute Profile), Core Bluetooth'ta veri alışverişinin temelidir. Hizmet ve özellik keşfinden sonra, merkezi cihaz üç tür işlem gerçekleştirebilir: bir özellik değerini okuma, bir değer yazma ve bildirimlere/indikasyonlara abone olma. Her işlem eşzamansızdır ve sonucu ilgili CBPeripheralDelegate geri çağrımı aracılığıyla döndürür.

Okuma: readValueForCharacteristic: çağrılarak gerçekleştirilir. Değer peripheral:didUpdateValueForCharacteristic:error: içinde gelir. Önemli: okuma, cihazdan geçerli değeri döndürür, önbelleğe alınmış bir değeri değil. Cihaz okumayı desteklemiyorsa (.read özelliği), çağrı bir hata döndürür. Büyük değerler (MTU'dan büyük) için BLE, GATT düzeyinde verileri otomatik olarak parçalar ve yeniden birleştirir.

Yazma: writeValue:forCharacteristic:type: çağrılarak gerçekleştirilir. BLE iki yazma modelini destekler: withResponse (güvenilir, onaylı) ve withoutResponse (hızlı, onaysız). CBCharacteristic.properties özelliği, kullanılabilir yazma türlerini tanımlar. Tek bir yazma paketinin maksimum boyutu MTU ile sınırlıdır: BLE 4.0 için 23 bayt (20 bayt yük + 3 bayt başlık), genişletilmiş MTU (MTU 251) ile BLE 5.0+ için 247 bayta kadar.

Bildirimler: setNotifyValue:true forCharacteristic: çağrılarak etkinleştirilir. Abonelikten sonra, çevre birim, özellik değeri her değiştiğinde peripheral:didUpdateValueForCharacteristic: aracılığıyla otomatik olarak güncellemeler gönderir. Bildirimleri devre dışı bırakmak için setNotifyValue:false forCharacteristic: çağrılır. Core Bluetooth, çevre birimde CCCD tanımlayıcısını otomatik olarak yönetir.

Core Bluetooth Arka Plan Modu ve State Restoration

Arka plan modu, Core Bluetooth'ta BLE uygulamalarının arka plandayken taramaya devam etmesine, bağlantıları sürdürmesine ve bildirimler almasına olanak tanır. Etkinleştirmek için Xcode'da “Uses Bluetooth LE accessories” yeteneğini etkinleştirin (Info.plist → Required background modes → App communicates using Core Bluetooth) ve UIBackgroundModes'a “bluetooth-central” anahtarını ekleyin. Çevre birim rolü için — “bluetooth-peripheral”.

State Restoration, iOS tarafından uygulama yeniden başlatıldıktan sonra BLE bağlantılarının durumunu geri yüklemek için Core Bluetooth'un bir mekanizmasıdır. Arka plan modu etkinken ve CBCentralManager veya CBPeripheralManager başlatmasında bir restoreIdentifier belirtildiğinde, iOS uygulama sonlandığında BLE yığını durumunu kaydeder ve bir sonraki başlatmada geri yükler. Temsilci centralManager:willRestoreState:, kaydedilmiş CBPeripheral'lar ve bekleyen bağlantılarla bir sözlük alır.

// State Restoration ile Core Bluetooth yapılandırması
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 {

    // Yeniden başlatmadan sonra durumu geri yükle
    func centralManager(_ central: CBCentralManager,
                        willRestoreState dict: [String : Any]) {
        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey]
            as? [CBPeripheral] {
            for peripheral in peripherals {
                peripheral.delegate = self
                // GATT keşfini geri yükle
                peripheral.discoverServices(nil)
            }
        }
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            print("Geri yüklemeden sonra Bluetooth hazır")
        }
    }
}

BLECentralWithRestoration yapılandırmasında, CBCentralManagerOptionRestoreIdentifierKey anahtarı durum korumayı etkinleştirir. Uygulama iOS tarafından sonlandırıldıysa (örneğin, bellek baskısı nedeniyle), bir sonraki başlatmada centralManager:willRestoreState: daha önce bağlanmış CBPeripheral'ların bir listesini alır. Uygulama temsilcileri geri yükler ve hizmetleri yeniden keşfeder — kullanıcı bağlantı kesintisini fark etmez. State Restoration olmadan, uygulama sonlandığında tüm BLE oturumları kaybolur.

Swift'te BLE Uygulama Örneği: Merkezi ve Çevre Birim

Tam bir örnek Swift'teki BLE uygulaması, tek bir projede hem merkezi hem de çevre birim cihazları birleştirir. Uygulama iki modda çalışabilir: BLE cihazlarını keşfetme ve bağlanma (Merkezi) veya bir BLE aksesuarını öykünme (Çevre Birim). Aşağıda, başlangıçta rolü seçen ortak bir BLE yöneticisiyle bir mimari gösterilmiştir.

// Merkezi ve çevre birim için evrensel BLE yöneticisi
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)
        }
    }

    // Merkezi cihaz: tarama
    func scanForDevices() {
        centralManager?.scanForPeripherals(withServices: nil, options: nil)
    }

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

// Başlangıçta kullanım
let isCentral = UserDefaults.standard.bool(forKey: "isCentral")
let manager = BLEManager(role: isCentral ? .central : .peripheral)

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

BLEManager, başlatmada rolü seçer ve ilgili Yöneticiyi (CBCentralManager veya CBPeripheralManager) oluşturur. Rol bayrağı UserDefaults'ta saklanabilir veya bir yapılandırma sunucusu aracılığıyla iletilebilir. Bu yaklaşım, BLE uygulamasının kullanım durumuna uyum sağlamasına olanak tanır: bir satış noktasında iPhone, ödeme terminallerini taramak için merkezi olarak çalışır; bir IoT ağ geçidinde — sensörlerden veri toplamak için çevre birim olarak.