CBCentralManager i iOS — vad är det, BLE-hantering och Core Bluetooth

Vad är CBCentralManager?

CBCentralManager — är huvudklassen i Core Bluetooth för att implementera Central-rollen i BLE-arkitekturen på iOS. Den hanterar hela livscykeln för en BLE-anslutning: från skanning av annonserande enheter till dataöverföring och frånkoppling. CBCentralManager arbetar asynkront via delegaten CBCentralManagerDelegate, som meddelar appen om händelser i Bluetooth-stacken.

Initiering av CBCentralManager startar state restoration-processen: hanteraren kontrollerar Bluetooth-status på enheten och återställer tidigare anslutningar om appen stängdes. Initieringsprocessen kan ta 50 till 500 ms beroende på Bluetooth-status. Appen måste vänta på anropet centralManagerDidUpdateState innan några BLE-operationer påbörjas.

Arkitekturen i Core Bluetooth är byggd på mönstret Delegation: CBCentralManager delegerar händelsehantering (enhetsupptäckt, anslutning, fel) till protokollet CBCentralManagerDelegate. För arbete med en specifik Peripheral används protokollet CBPeripheralDelegate, som meddelar om upptäckt av tjänster, egenskaper och mottagning av data. Denna asynkrona modell säkerställer icke-blockerande UI-drift.

CBCentralManager-tillstånd

CBCentralManager går igenom flera tillstånd som avgör om BLE-stacken är tillgänglig för arbete. Tillståndet överförs via delegaten: centralManagerDidUpdateState(_:). Utvecklaren måste hantera alla tillstånd — inte bara poweredOn, utan även fall när Bluetooth är avstängt eller inte tillgängligt.

Unauthorized state blir allt vanligare från iOS 13+. Från och med denna version måste appen ha tillståndet NSBluetoothAlwaysUsageDescription i Info.plist. Utan det går den centrala hanteraren över till .unauthorized och skanning är omöjlig. Användaren kan när som helst ändra tillståndet i Inställningar > Integritet > Bluetooth.

Skanning av BLE-enheter

scanForPeripherals(withServices:options:) — huvudmetoden för att starta skanning. Parametern withServices tar emot en array av tjänsters UUID för filtrering: om nil skickas kommer alla enheter att upptäckas, vilket avsevärt ökar energiförbrukningen. Det rekommenderas att alltid filtrera efter UUID för de tjänster som appen behöver. Skanningsalternativ inkluderar CBCentralManagerScanOptionAllowDuplicatesKey (upprepade meddelanden om samma enhet).

import CoreBluetooth

class BLEController: NSObject,
    CBCentralManagerDelegate {

    private var centralManager: CBCentralManager!

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

    func startScanning() {
        let serviceUUID =
            CBUUID("180F") // Batteritjänst

        centralManager.scanForPeripherals(
            withServices: [serviceUUID],
            options: [
                CBCentralManagerScanOptionAllowDuplicatesKey: false
            ]
        )
    }
}

När en enhet upptäcks anropas centralManager(_:didDiscover:advertisementData:rssi:). Parametern advertisementData innehåller en fullständig ordbok över annonseringspaketets data, inklusive enhetens namn (CBAdvertisementDataLocalNameKey), tjänsters UUID (CBAdvertisementDataServiceUUIDsKey) och tillverkar data (CBAdvertisementDataManufacturerDataKey). RSSI — signalstyrka i dBm, tillgänglig vid upptäcktstillfället.

Anslutning till Peripheral

connect(_:options:) — metod för att upprätta en BLE-anslutning med en upptäckt Peripheral. Efter anropet connect försöker iOS ansluta till enheten. Lyckad anslutning bekräftas av centralManager(_:didConnect:), fel av centralManager(_:didFailToConnect:error:). Anslutningsalternativ inkluderar CBConnectPeripheralOptionNotifyOnConnectionKey, CBConnectPeripheralOptionNotifyOnDisconnectionKey och CBConnectPeripheralOptionNotifyOnNotificationKey för bakgrundsmeddelanden.

// Anslut till BLE-enhet
func connectToPeripheral(
    _ peripheral: CBPeripheral
) {
    centralManager.connect(peripheral, options: nil)

    // Ställ in delegat för Peripheral
    peripheral.delegate = self
}

// Delegat: lyckad anslutning
func centralManager(
    _ central: CBCentralManager,
    didConnect peripheral: CBPeripheral
) {
    print("Ansluten till " +
          "\(peripheral.name ?? "unknown")")

    // Starta tjänstupptäckt
    peripheral.discoverServices(nil)
}

// Delegat: anslutningsfel
func centralManager(
    _ central: CBCentralManager,
    didFailToConnect peripheral: CBPeripheral,
    error: Error?
) {
    print("Connection failed: 
          \(error?.localizedDescription ?? "")")
}

Anslutningstimeout på iOS är 30 sekunder. Om enheten inte svarar på anslutningsbegäran inom denna tid anropas didFailToConnect. Faktorer som påverkar timeouter: avstånd till enheten, störningar, om enheten för närvarande annonserar. Innan anslutning, se till att enheten är i connectable advertising-läge (ADV_IND, inte ADV_NONCONN_IND).

Upptäckt av tjänster och egenskaper

Efter anslutning måste tjänster (discoverServices) och egenskaper (discoverCharacteristics) för Peripheral upptäckas. Detta är ett obligatoriskt steg innan läsning eller skrivning av data. Processen är asynkron: discoverServices returnerar resultat via peripheral(_:didDiscoverServices:), och discoverCharacteristics via peripheral(_:didDiscoverCharacteristicsFor:error:).

Det rekommenderas att skicka en array av intressanta UUID till discoverServices, inte nil. Filtrering påskyndar upptäckten och sparar energi. Om tjänsten inte hittas rapporterar iOS en tom array. Efter upptäckt av egenskaper kan deras värden läsas (readValue), prenumerera på meddelanden (setNotifyValue) eller skriva data (writeValue).

En viktig detalj: MTU förhandlas automatiskt efter anslutning. För att få aktuell MTU, använd peripheral.maximumWriteValueLength(for: .withResponse) eller .withoutResponse. I iOS är maximal MTU 512 byte för BLE 5.0-enheter. Om du behöver överföra data större än MTU, implementera fragmentering på applikationsnivå.

Bakgrundsskanning och iOS-begränsningar

Bakgrundsskanning av BLE-enheter på iOS kräver speciell konfiguration. Core Bluetooth stöder bakgrundskörning, men med betydande begränsningar. För bakgrundsarbete krävs: aktivera bluetooth-central i Background Modes i projektets Capabilities, initiera CBCentralManager med alternativet CBCentralManagerOptionRestoreIdentifierKey för state restoration, och hantera händelser från den centrala hanteraren vid övergång till bakgrunden.

BLE-begränsningar i bakgrunden på iOS: scanForPeripherals utan UUID-filtrering fungerar inte i bakgrunden. Appen måste ange specifika tjänsters UUID för skanning. iOS kan fördröja leverans av BLE-händelser på obestämd tid. Core Bluetooth återupptar automatiskt skanning vid upptäckt av en matchande enhet, även om appen är i bakgrunden. Timeout för bakgrundsskanning: iOS kan stoppa skanning efter 10–30 minuter för att spara energi.

State Restoration — Core Bluetooth-mekanismen som möjliggör återställning av BLE-anslutningar efter omstart av appen eller iOS-omstart. För användning: ange CBCentralManagerOptionRestoreIdentifierKey vid initiering, implementera centralManager(_:willRestoreState:) i delegaten och återställ listan över anslutna Peripherals från den skickade ordboken. State Restoration är en kritisk funktionalitet för BLE-appar som fungerar i bakgrunden, till exempel fitnessspårare eller medicinska enheter.

Felhantering och återställning av anslutning

CBCentralManager genererar fel i flera scenarier: anslutning misslyckades (didFailToConnect), anslutning bruten (didDisconnectPeripheral), egenskap inte tillgänglig för läsning/skrivning (didWriteValue error). Alla Core Bluetooth-fel returneras via Error-objektet med domänen CBErrorDomain. De vanligaste koderna: CBErrorConnectionTimeout (0x04), CBErrorPeripheralDisconnected (0x07), CBErrorOperationNotSupported (0x0A).

Strategi för återställning av anslutning: vid mottagning av didDisconnectPeripheral, kontrollera felkoden. Om felet är CBErrorConnectionTimeout eller CBErrorPeripheralDisconnected — schemalägg automatisk återanslutning efter 1–5 sekunder. Om felet är CBErrorOperationNotSupported — logga och försök inte upprepa operationen. För kritiska anslutningar (medicinska enheter) använd exponential backoff med maxintervall på 60 sekunder.

// Hantera frånkoppling med automatisk återanslutning
func centralManager(
    _ central: CBCentralManager,
    didDisconnectPeripheral peripheral: CBPeripheral,
    error: Error?
) {
    guard let error = error else {
        return // Förväntad frånkoppling
    }

    print("Disconnected: \(error.localizedDescription)")

    // Automatisk återanslutning
    if shouldAutoReconnect {
        DispatchQueue.main.asyncAfter(
            deadline: .now() + reconnectDelay
        ) {
            central.connect(peripheral)
        }
    }
}

Vid utveckling av en pålitlig BLE-app på iOS, beakta: Core Bluetooth garanterar inte leverans av alla paket vid svag signal. För pålitlig överföring, använd writeType .withResponse (bekräftad skrivning) och prenumerera på meddelanden (setNotifyValue) för att ta emot data från Peripheral. För en fellogg för att diagnostisera anslutningsproblem i produktion.