📶 Core Bluetooth

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

BLE 기기 스캔, 연결, 데이터 통신 프레임워크

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 초기화

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)
    }

    // 스캔 시작
    func startScanning() {
        guard isBluetoothOn else {
            print("⚠️ Bluetooth가 꺼져 있습니다")
            return
        }

        discoveredPeripherals.removeAll()
        isScanning = true

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

        print("🔍 BLE 기기 스캔 시작")
    }

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

        discoveredPeripherals.removeAll()
        isScanning = true

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

    // 스캔 중지
    func stopScanning() {
        centralManager.stopScan()
        isScanning = false
        print("⏹️ 스캔 중지")
    }

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

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

📡 2. Central Manager 델리게이트

Handle Bluetooth state changes and device discovery.

BluetoothManager+Delegate.swift — Central Delegate

import CoreBluetooth

extension BluetoothManager: CBCentralManagerDelegate {
    // Bluetooth 상태 변화
    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 미지원")
            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)")
        }
    }

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

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

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

    // 연결 해제
    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 델리게이트

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)")
            // 각 서비스의 특성 탐색
            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("📥 데이터 수신 (\(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 상태 변경
    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. 데이터 쓰기

Peripheral에 데이터를 전송.

BluetoothManager+Write.swift — Data Writing

import CoreBluetooth

extension BluetoothManager {
    // 문자열 데이터 전송
    func writeString(_ string: String, to characteristic: CBCharacteristic) {
        guard let data = string.data(using: .utf8) else {
            print("❌ 문자열 변환 실패")
            return
        }

        writeData(data, to: characteristic)
    }

    // 바이트 데이터 전송
    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("📤 데이터 전송: \(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) {
                // 상태 표시
                statusHeader

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

    // 상태 헤더
    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.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 기기를 찾을 수 없습니다", 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("연결됨")
                                .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: 불필요한 스캔 중지, 연결 후 즉시 스캔 중단
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