📶 Core Bluetooth

⭐ Difficulty: ⭐⭐⭐⭐ ⏱️ Est. Time: 3-4h 📂 System & Network

BLE device scanning, connection, and data communication

iOS 5+BLE 5.0

✨ Core Bluetooth?

Core Bluetooth is a framework that uses the Bluetooth Low Energy (BLE) protocol to scan, connect, and exchange data with nearby devices. You can communicate with smartwatches, fitness trackers, sensors, and IoT devices, reading and writing data through GATT services and characteristics. It operates on the Central-Peripheral architecture.

💡 Key Features: BLE Device Scanning · Peripheral Connection · GATT Service Discovery · Characteristic Read/Write · Notification Subscription · Battery-Efficient Communication · Background Operation

🔌 1. CBCentralManager Initialization

Create a manager that scans and connects BLE devices as a Central role.

BluetoothManager.swift — Central Manager Initialization

import CoreBluetooth
import SwiftUI

@Observable
class BluetoothManager: NSObject {
    private var centralManager: CBCentralManager!
    var discoveredPeripherals: [CBPeripheral] = []
    var connectedPeripheral: CBPeripheral?
    var isBluetoothOn = false
    var isScanning = false

    override init() {
        super.init()
        // Central Manager 생성
        centralManager = CBCentralManager(delegate: self, queue: nil)
    }

    // Start scanning
    func startScanning() {
        guard isBluetoothOn else {
            print("⚠️ Bluetooth가 꺼져 있습니다")
            return
        }

        discoveredPeripherals.removeAll()
        isScanning = true

        // all BLE 기기 스캔 (서비스 필터 없음)
        centralManager.scanForPeripherals(
            withServices: nil,
            options: [CBCentralManagerScanOptionAllowDuplicatesKey: false]
        )

        print("🔍 BLE 기기 Start scanning")
    }

    // 특정 서비스만 스캔
    func scanForDevices(withServices serviceUUIDs: [CBUUID]) {
        guard isBluetoothOn else { return }

        discoveredPeripherals.removeAll()
        isScanning = true

        centralManager.scanForPeripherals(withServices: serviceUUIDs, options: nil)
        print("🔍 특정 서비스 스캔: \(serviceUUIDs)")
    }

    // Stop scanning
    func stopScanning() {
        centralManager.stopScan()
        isScanning = false
        print("⏹️ Stop scanning")
    }

    // Peripheral 연결
    func connect(peripheral: CBPeripheral) {
        stopScanning()
        centralManager.connect(peripheral, options: nil)
        print("🔗 연결 시도: \(peripheral.name ?? "Unknown")")
    }

    // Connect 해제
    func disconnect() {
        guard let peripheral = connectedPeripheral else { return }
        centralManager.cancelPeripheralConnection(peripheral)
        print("❌ 연결 해제")
    }
}

📡 2. Central Manager Delegate

Handle Bluetooth state changes and device discovery.

BluetoothManager+Delegate.swift — Central Delegate

import CoreBluetooth

extension BluetoothManager: CBCentralManagerDelegate {
    // Bluetooth state change
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        switch central.state {
        case .poweredOn:
            print("✅ Bluetooth 켜짐")
            isBluetoothOn = true
        case .poweredOff:
            print("❌ Bluetooth 꺼짐")
            isBluetoothOn = false
        case .unauthorized:
            print("⚠️ Bluetooth 권한 없음")
            isBluetoothOn = false
        case .unsupported:
            print("❌ Bluetooth Not supported")
            isBluetoothOn = false
        case .resetting:
            print("🔄 Bluetooth 재설정 중")
        case .unknown:
            print("❓ Bluetooth 상태 불명")
        @unknown default:
            break
        }
    }

    // Peripheral 발견
    func centralManager(
        _ central: CBCentralManager,
        didDiscover peripheral: CBPeripheral,
        advertisementData: [String: Any],
        rssi RSSI: NSNumber
    ) {
        // 이미 발견된 기기는 추가하지 않음
        guard !discoveredPeripherals.contains(where: { $0.identifier == peripheral.identifier }) else {
            return
        }

        discoveredPeripherals.append(peripheral)

        let deviceName = peripheral.name ?? "Unknown Device"
        let signalStrength = RSSI.intValue
        print("📶 발견: \(deviceName) (RSSI: \(signalStrength)dBm)")

        // Advertisement Data 출력
        if let localName = advertisementData[CBAdvertisementDataLocalNameKey] as? String {
            print("  Local Name: \(localName)")
        }
        if let serviceUUIDs = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] {
            print("  Services: \(serviceUUIDs)")
        }
    }

    // Connection successful
    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
        print("✅ Connection successful: \(peripheral.name ?? "Unknown")")
        connectedPeripheral = peripheral
        peripheral.delegate = self

        // 서비스 탐색
        peripheral.discoverServices(nil)
    }

    // Connection failed
    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
        print("❌ Connection failed: \(error?.localizedDescription ?? "Unknown error")")
        connectedPeripheral = nil
    }

    // Connect 해제
    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
        print("❌ 연결 해제: \(peripheral.name ?? "Unknown")")
        connectedPeripheral = nil

        if let error = error {
            print("  Error: \(error.localizedDescription)")
        }
    }
}

🛠️ 3. Peripheral Delegate

Discover services and characteristics, and read data.

BluetoothManager+Peripheral.swift — Peripheral Delegate

import CoreBluetooth

extension BluetoothManager: CBPeripheralDelegate {
    // 서비스 발견
    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        if let error = error {
            print("❌ 서비스 발견 실패: \(error.localizedDescription)")
            return
        }

        guard let services = peripheral.services else { return }

        print("🔍 발견된 서비스: \(services.count)개")

        for service in services {
            print("  Service UUID: \(service.uuid)")
            // each 서비스의 특성 탐색
            peripheral.discoverCharacteristics(nil, for: service)
        }
    }

    // 특성 발견
    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        if let error = error {
            print("❌ 특성 발견 실패: \(error.localizedDescription)")
            return
        }

        guard let characteristics = service.characteristics else { return }

        print("🔍 서비스 \(service.uuid)의 특성: \(characteristics.count)개")

        for characteristic in characteristics {
            print("  Characteristic UUID: \(characteristic.uuid)")
            print("  Properties: \(characteristic.properties)")

            // 읽기 가능하면 읽기
            if characteristic.properties.contains(.read) {
                peripheral.readValue(for: characteristic)
            }

            // Notify 가능하면 구독
            if characteristic.properties.contains(.notify) {
                peripheral.setNotifyValue(true, for: characteristic)
                print("  📬 Notification 구독")
            }
        }
    }

    // 특성 값 읽기 완료
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("❌ 값 읽기 실패: \(error.localizedDescription)")
            return
        }

        guard let data = characteristic.value else {
            print("⚠️ 데이터 없음")
            return
        }

        print("📥 Receive data (\(characteristic.uuid)): \(data.hexString)")

        // String으로 변환 시도
        if let stringValue = String(data: data, encoding: .utf8) {
            print("  String: \(stringValue)")
        }

        // 특정 서비스별 파싱
        parseCharacteristicValue(characteristic, data: data)
    }

    // 특성 값 쓰기 완료
    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("❌ 쓰기 실패: \(error.localizedDescription)")
            return
        }

        print("✅ 쓰기 성공 (\(characteristic.uuid))")
    }

    // Notification change state
    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("❌ Notification 설정 실패: \(error.localizedDescription)")
            return
        }

        if characteristic.isNotifying {
            print("✅ Notification 활성화 (\(characteristic.uuid))")
        } else {
            print("❌ Notification 비활성화 (\(characteristic.uuid))")
        }
    }

    // 특성 값 파싱 (서비스별 처리)
    private func parseCharacteristicValue(_ characteristic: CBCharacteristic, data: Data) {
        // Heart Rate Service (0x180D)
        if characteristic.uuid == CBUUID(string: "2A37") {
            let heartRate = parseHeartRate(data)
            print("  ❤️ Heart Rate: \(heartRate) bpm")
        }
        // Battery Level (0x2A19)
        else if characteristic.uuid == CBUUID(string: "2A19") {
            if let batteryLevel = data.first {
                print("  🔋 Battery: \(batteryLevel)%")
            }
        }
    }

    // Heart Rate 데이터 파싱
    private func parseHeartRate(_ data: Data) -> Int {
        guard data.count > 1 else { return 0 }
        let flags = data[0]
        let is16Bit = (flags & 0x01) == 0x01

        if is16Bit {
            return Int(data[1]) | (Int(data[2]) << 8)
        } else {
            return Int(data[1])
        }
    }
}

// Data Extension
extension Data {
    var hexString: String {
        map { String(format: "%02X", $0) }.joined(separator: " ")
    }
}

📤 4. Writing Data

Peripheral에 데이터를 전송.

BluetoothManager+Write.swift — Data Writing

import CoreBluetooth

extension BluetoothManager {
    // 문자열 Send data
    func writeString(_ string: String, to characteristic: CBCharacteristic) {
        guard let data = string.data(using: .utf8) else {
            print("❌ 문자열 Conversion failed")
            return
        }

        writeData(data, to: characteristic)
    }

    // bytes Send data
    func writeData(_ data: Data, to characteristic: CBCharacteristic) {
        guard let peripheral = connectedPeripheral else {
            print("❌ 연결된 기기 없음")
            return
        }

        // 쓰기 가능 여부 확인
        guard characteristic.properties.contains(.write) || characteristic.properties.contains(.writeWithoutResponse) else {
            print("❌ 쓰기 불가능한 특성")
            return
        }

        // 쓰기 타입 결정
        let writeType: CBCharacteristicWriteType = characteristic.properties.contains(.write) ? .withResponse : .withoutResponse

        peripheral.writeValue(data, for: characteristic, type: writeType)
        print("📤 Send data: \(data.hexString)")
    }

    // LED 제어 예제
    func toggleLED(characteristic: CBCharacteristic, isOn: Bool) {
        let command: UInt8 = isOn ? 0x01 : 0x00
        let data = Data([command])
        writeData(data, to: characteristic)
    }
}

📱 5. SwiftUI Integration

BLE 스캐너 UI implementation.

BLEScannerView.swift — BLE Scanner UI

import SwiftUI
import CoreBluetooth

struct BLEScannerView: View {
    @State private var bluetoothManager = BluetoothManager()

    var body: some View {
        NavigationStack {
            VStack(spacing: 0) {
                // Status 표시
                statusHeader

                // 기기 목록
                if bluetoothManager.discoveredPeripherals.isEmpty {
                    emptyState
                } else {
                    deviceList
                }
            }
            .navigationTitle("BLE 스캐너")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    scanButton
                }
            }
        }
    }

    // Status 헤더
    private var statusHeader: some View {
        VStack(spacing: 8) {
            HStack {
                Circle()
                    .fill(bluetoothManager.isBluetoothOn ? Color.green : Color.red)
                    .frame(width: 12, height: 12)

                Text(bluetoothManager.isBluetoothOn ? "Bluetooth 활성" : "Bluetooth 비활성")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)

                Spacer()

                if bluetoothManager.isScanning {
                    ProgressView()
                        .controlSize(.small)
                    Text("스캔 중...")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
            }
            .padding()

            if let connected = bluetoothManager.connectedPeripheral {
                HStack {
                    Image(systemName: "checkmark.circle.fill")
                        .foregroundStyle(.green)
                    Text("Connected: \(connected.name ?? "Unknown")")
                        .font(.subheadline)
                    Spacer()
                    Button("연결 해제") {
                        bluetoothManager.disconnect()
                    }
                    .font(.caption)
                    .buttonStyle(.bordered)
                }
                .padding(.horizontal)
                .padding(.bottom)
            }
        }
        .background(Color(.systemGroupedBackground))
    }

    // 스캔 버튼
    private var scanButton: some View {
        Button {
            if bluetoothManager.isScanning {
                bluetoothManager.stopScanning()
            } else {
                bluetoothManager.startScanning()
            }
        } label: {
            Image(systemName: bluetoothManager.isScanning ? "stop.circle" : "arrow.clockwise")
        }
        .disabled(!bluetoothManager.isBluetoothOn)
    }

    // 빈 상태
    private var emptyState: some View {
        ContentUnavailableView {
            Label("BLE 기기를 Not found", systemImage: "antenna.radiowaves.left.and.right.slash")
        } description: {
            Text("스캔 버튼을 눌러 주변 BLE 기기를 검색하세요")
        }
    }

    // 기기 목록
    private var deviceList: some View {
        List(bluetoothManager.discoveredPeripherals, id: \.identifier) { peripheral in
            Button {
                bluetoothManager.connect(peripheral: peripheral)
            } label: {
                HStack {
                    VStack(alignment: .leading, spacing: 4) {
                        Text(peripheral.name ?? "Unknown Device")
                            .font(.headline)

                        Text(peripheral.identifier.uuidString)
                            .font(.caption)
                            .foregroundStyle(.secondary)

                        if peripheral.state == .connected {
                            Text("Connected")
                                .font(.caption2)
                                .foregroundStyle(.green)
                        }
                    }

                    Spacer()

                    Image(systemName: "chevron.right")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
            }
            .disabled(peripheral.state == .connected)
        }
    }
}

💡 HIG Guidelines

Permission Request: Add NSBluetoothAlwaysUsageDescription to Info.plist
Battery Efficiency: 불필요한 Stop scanning, 연결 후 즉시 스캔 중단
Background: Add bluetooth-central background mode to Info.plist
사용자 피드백: 스캔 상태와 연결 상태를 명확히 표시
Error Handling: Provide appropriate guidance for connection failures, Bluetooth off, etc.

🎯 Practical Usage

Fitness Apps: 심박수 센서, 스마트워치 연동
IoT Control: Smart home device control
의료 기기: 혈압계, 혈당계 데이터 수집
위치 비콘: iBeacon 기반 근접 마케팅
게임 컨트롤러: BLE 게임패드 연동

📚 Learn More

⚡️ Performance Tips: 스캔 시 allowDuplicatesKey to false to reduce battery consumption. Filter by specific service UUIDs to find target devices faster. Always stop scanning after connecting.

📎 Apple Official Resources

📘 Documentation 💻 Sample Code 🎬 WWDC Sessions