@glassly/bluetooth-sdk 0.1.0-dev.100

package/ios/Source/controllers/R1.swift

@@ -0,0 +1,925 @@
+//
+//  R1.swift
+//  Glassly_Manager
+//
+//  Even Realities R1 Smart Ring controller
+//  Protocol reverse-engineered from BTSnoop captures and firmware analysis
+//
+
+import Combine
+import CoreBluetooth
+import Foundation
+
+// MARK: - R1 BLE Constants
+
+private enum R1BLE {
+    /// Ring custom service
+    static let SERVICE_UUID = CBUUID(string: "BAE80001-4F05-4503-8E65-3AF1F7329D1F")
+
+    // Channel 1
+    static let WRITE_CHAR_1 = CBUUID(string: "BAE80010-4F05-4503-8E65-3AF1F7329D1F")
+    static let NOTIFY_CHAR_1 = CBUUID(string: "BAE80011-4F05-4503-8E65-3AF1F7329D1F")
+
+    // Channel 2
+    static let WRITE_CHAR_2 = CBUUID(string: "BAE80012-4F05-4503-8E65-3AF1F7329D1F")
+    static let NOTIFY_CHAR_2 = CBUUID(string: "BAE80013-4F05-4503-8E65-3AF1F7329D1F")
+
+    // Standard battery service (ring may expose this)
+    static let BATTERY_SERVICE = CBUUID(string: "180F")
+    static let BATTERY_LEVEL_CHAR = CBUUID(string: "2A19")
+
+    /// Name filters for scanning
+    static let NAME_FILTERS = ["EVEN R1", "BCL60"]
+
+    /// Gesture protocol marker
+    static let GESTURE_MARKER: UInt8 = 0xFF
+
+    static let SCAN_TIMEOUT: TimeInterval = 15.0
+}
+
+// MARK: - EUS transport encoder (phone → ring, channel 2)
+
+/// Recovered firmware contract (openCFW r1/ research): every phone→ring packet
+/// is a 12-byte "model" header
+///   [version, module, moduleVersion, serial LE16, status, command, subcommand,
+///    totalLength LE16, crc16 LE16]
+/// followed by the payload, where the phone-direction CRC-16 (CCITT rounds,
+/// init 0xFFFF) runs over the compact bytes [0,1,2,3,5,6,7,8,0x00] and then
+/// continues over the payload bytes. The model is carried on channel 2 inside
+/// a fragment train [sequence, crc32 LE32, ≤239 bytes]; the CRC-32 (poly
+/// 0x1EDC6F41, MSB-first, zero seed, no final xor) covers the whole model and
+/// sequence 0 terminates the train — all our packets fit a single fragment.
+private enum R1Eus {
+    static let VERSION: UInt8 = 100
+    static let MODULE_SYSTEM: UInt8 = 0x01
+    static let MODULE_VERSION: UInt8 = 100
+    /// status bit 0x02 marks a SET; advStart requires it
+    static let STATUS_SET: UInt8 = 0x02
+
+    /// system subcommand 0x08: payload [0x01] claims the phone role; the ring
+    /// requests link encryption/bonding in response
+    static let SUBCMD_PAIR_AUTH: UInt8 = 0x08
+    /// system subcommand 0x0A: 12-byte payload = two 6-byte glasses arm MACs;
+    /// the ring stores both targets and fast-advertises for them
+    static let SUBCMD_ADV_START: UInt8 = 0x0A
+
+    private static func crc16Step(_ crc: UInt16, _ byte: UInt8) -> UInt16 {
+        var c = (crc >> 8) | (crc << 8)
+        c ^= UInt16(byte)
+        c ^= (c & 0x00FF) >> 4
+        c ^= c << 12
+        c ^= (c & 0x00FF) << 5
+        return c
+    }
+
+    private static func phoneCrc16(header: [UInt8], payload: Data) -> UInt16 {
+        var crc: UInt16 = 0xFFFF
+        // compact header: bytes 0-3 and 5-8, then a zero placeholder
+        for b in [header[0], header[1], header[2], header[3], header[5], header[6], header[7], header[8], 0] {
+            crc = crc16Step(crc, b)
+        }
+        for b in payload {
+            crc = crc16Step(crc, b)
+        }
+        return crc
+    }
+
+    private static func crc32(_ data: Data) -> UInt32 {
+        var crc: UInt32 = 0
+        for byte in data {
+            crc ^= UInt32(byte) << 24
+            for _ in 0 ..< 8 {
+                crc = (crc & 0x8000_0000) != 0 ? (crc << 1) ^ 0x1EDC_6F41 : crc << 1
+            }
+        }
+        return crc
+    }
+
+    /// Build one single-fragment system-module command packet.
+    static func frame(subcommand: UInt8, status: UInt8, serial: UInt16, payload: Data) -> Data {
+        let length = UInt16(12 + payload.count)
+        var header: [UInt8] = [
+            VERSION, MODULE_SYSTEM, MODULE_VERSION,
+            UInt8(serial & 0xFF), UInt8(serial >> 8),
+            status, 0x00, subcommand,
+            UInt8(length & 0xFF), UInt8(length >> 8),
+            0, 0,
+        ]
+        let crc16 = phoneCrc16(header: header, payload: payload)
+        header[10] = UInt8(crc16 & 0xFF)
+        header[11] = UInt8(crc16 >> 8)
+        var model = Data(header)
+        model.append(payload)
+
+        let outer = crc32(model)
+        var packet = Data([0x00]) // sequence 0: single-fragment train
+        packet.append(UInt8(outer & 0xFF))
+        packet.append(UInt8((outer >> 8) & 0xFF))
+        packet.append(UInt8((outer >> 16) & 0xFF))
+        packet.append(UInt8((outer >> 24) & 0xFF))
+        packet.append(model)
+        return packet
+    }
+}
+
+// MARK: - R1 Gesture Types
+
+private enum R1Gesture: String {
+    case hold
+    case singleTap = "single_tap"
+    case doubleTap = "double_tap"
+    case swipeUp = "swipe_up"
+    case swipeDown = "swipe_down"
+
+    /// Parse gesture from notification data: [0xFF, type, param]
+    static func parse(from data: Data) -> R1Gesture? {
+        guard data.count >= 3, data[0] == R1BLE.GESTURE_MARKER else { return nil }
+        switch data[1] {
+        case 0x03:
+            return .hold
+        case 0x04:
+            return data[2] == 0x01 ? .singleTap : data[2] == 0x02 ? .doubleTap : nil
+        case 0x05:
+            return data[2] < 0x80 ? .swipeUp : .swipeDown
+        default:
+            return nil
+        }
+    }
+}
+
+// MARK: - R1 Controller
+
+@MainActor
+class R1: NSObject, ControllerManager {
+    var type = ControllerTypes.R1
+    let hasMic = false // R1 ring has no microphone
+
+    // Connection state
+    private var centralManager: CBCentralManager?
+    private var ringPeripheral: CBPeripheral?
+    private var isDisconnecting = false
+
+    // BLE characteristics
+    private var writeChar1: CBCharacteristic?
+    private var notifyChar1: CBCharacteristic?
+    private var writeChar2: CBCharacteristic?
+    private var notifyChar2: CBCharacteristic?
+    private var batteryLevelChar: CBCharacteristic?
+    private var notifySubscriptionCount = 0
+    private var initSequenceRun = false
+    private var eusSerial: UInt16 = 0
+
+    /// Device search
+    var DEVICE_SEARCH_ID = "NOT_SET"
+
+    /// persisted state for ease of reconnection / background connection:
+    /// we could store these elsewhere to be like other settings / state, but in practice they will only ever be set and used here
+    /// Stored UUID for background reconnection
+    private var ringUUID: UUID? {
+        get { UserDefaults.standard.string(forKey: "r1_ringUUID").flatMap { UUID(uuidString: $0) } }
+        set {
+            if let v = newValue {
+                UserDefaults.standard.set(v.uuidString, forKey: "r1_ringUUID")
+            } else {
+                UserDefaults.standard.removeObject(forKey: "r1_ringUUID")
+            }
+        }
+    }
+
+    /// maps peripheral.name to 6-byte ring MAC address:
+    private var ringMacAddressMap: [String: Data] {
+        get {
+            UserDefaults.standard.dictionary(forKey: "r1_ringMacAddressMap") as? [String: Data]
+                ?? [:]
+        }
+        set { UserDefaults.standard.set(newValue, forKey: "r1_ringMacAddressMap") }
+    }
+
+    private var ringMacAddress: String? {
+        get { UserDefaults.standard.string(forKey: "r1_ringMacAddress") }
+        set { UserDefaults.standard.set(newValue, forKey: "r1_ringMacAddress") }
+    }
+
+    /// Reconnection
+    private let reconnectionManager = R1ReconnectionManager()
+
+    /// Battery
+    @Published private var _batteryLevel: Int = -1 {
+        didSet {
+            if _batteryLevel != oldValue && _batteryLevel >= 0 {
+                DeviceStore.shared.apply("glasses", "controllerBatteryLevel", _batteryLevel)
+                // Bridge.sendBatteryStatus(level: _batteryLevel, charging: isCharging)
+            }
+        }
+    }
+
+    private var isCharging = false
+
+    /// Heartbeat
+    private var heartbeatTimer: Timer?
+
+    static let _bluetoothQueue = DispatchQueue(label: "BluetoothR1", qos: .userInitiated)
+
+    // MARK: - Init
+
+    override init() {
+        super.init()
+    }
+
+    deinit {
+        centralManager?.delegate = nil
+        ringPeripheral?.delegate = nil
+    }
+
+    // MARK: - BLE Scanning
+
+    @discardableResult
+    private func startScan() -> Bool {
+        Bridge.log("R1: startScan()")
+        if centralManager == nil {
+            centralManager = CBCentralManager(
+                delegate: self, queue: R1._bluetoothQueue,
+                options: [CBCentralManagerOptionShowPowerAlertKey: 0]
+            )
+        }
+
+        isDisconnecting = false
+        guard centralManager!.state == .poweredOn else {
+            Bridge.log("R1: Bluetooth not powered on")
+            return false
+        }
+
+        // Try UUID-based reconnection first
+        if connectByUUID() {
+            return true
+        }
+
+        centralManager!.scanForPeripherals(
+            withServices: nil,
+            options: [
+                CBCentralManagerScanOptionAllowDuplicatesKey: false,
+            ]
+        )
+        return true
+    }
+
+    func stopScan() {
+        centralManager?.stopScan()
+    }
+
+    private func connectByUUID() -> Bool {
+        // don't do this if we don't have a search id set:
+        if DEVICE_SEARCH_ID == "NOT_SET" || DEVICE_SEARCH_ID.isEmpty {
+            Bridge.log("R1: 🔵 No DEVICE_SEARCH_ID set, skipping connect by UUID")
+            return false
+        }
+        guard let uuid = ringUUID else { return false }
+        guard let ringMac = ringMacAddress else { return false }
+        guard let peripheral = centralManager?.retrievePeripherals(withIdentifiers: [uuid]).first
+        else { return false }
+
+        ringPeripheral = peripheral
+        peripheral.delegate = self
+        centralManager?.connect(peripheral, options: nil)
+        Bridge.log("R1: Reconnecting by UUID to \(peripheral.name ?? "ring")")
+        return true
+    }
+
+    private func matchesNameFilter(_ name: String?) -> Bool {
+        guard let name = name else { return false }
+        return R1BLE.NAME_FILTERS.contains(where: { name.contains($0) })
+    }
+
+    /// Extract a device identifier from the ring name (e.g. "EVEN R1_CEC5BA" -> "CEC5BA")
+    private func extractRingId(_ name: String) -> String? {
+        if let range = name.range(of: "R1_") {
+            let id = String(name[range.upperBound...])
+            return id.isEmpty ? nil : id
+        }
+        return nil
+    }
+
+    // MARK: - EUS commands
+
+    private func nextEusSerial() -> UInt16 {
+        eusSerial &+= 1
+        if eusSerial == 0 { eusSerial = 1 }
+        return eusSerial
+    }
+
+    /// EUS system commands go to WRITE_CHAR_2 only — channel 2 is the framed
+    /// transport; channel 1 speaks the separate legacy protocol.
+    private func sendEusCommand(_ subcommand: UInt8, payload: Data, log: String) {
+        guard let wc = writeChar2 else {
+            Bridge.log("R1: \(log): no channel-2 write characteristic")
+            return
+        }
+        let packet = R1Eus.frame(
+            subcommand: subcommand, status: R1Eus.STATUS_SET,
+            serial: nextEusSerial(), payload: payload
+        )
+        ringPeripheral?.writeValue(packet, for: wc, type: .withoutResponse)
+        Bridge.log("R1: \(log) sent (\(packet.count) bytes)")
+    }
+
+    // MARK: - Init Sequence
+
+    /// Runs after notify subscriptions are confirmed: claim the phone role,
+    /// then mark the phone link ready.
+    private func runInitSequence() {
+        guard !initSequenceRun else { return }
+        initSequenceRun = true
+
+        Bridge.log("R1: Running init sequence")
+
+        guard writeChar2 != nil else {
+            Bridge.log("R1: No channel-2 write characteristic, skipping init")
+            markConnected()
+            return
+        }
+
+        sendEusCommand(R1Eus.SUBCMD_PAIR_AUTH, payload: Data([0x01]), log: "pairAuth")
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+            self?.markConnected()
+        }
+    }
+
+    /// Tells the ring which glasses may connect to it: EUS advStart whose
+    /// 12-byte payload is the two glasses arm MACs. The ring stores both
+    /// targets, fast-advertises while a glasses role is open, and accepts a
+    /// connection from either arm. With only one arm MAC known it is sent for
+    /// both targets — the ring matches against either slot.
+    private func connectToGlasses() {
+        func stored(_ key: String) -> String? {
+            guard let value = DeviceStore.shared.get("glasses", key) as? String, !value.isEmpty else { return nil }
+            return value
+        }
+        let left = stored("leftMacAddress")
+            ?? stored("bluetoothMacAddress")
+            ?? UserDefaults.standard.string(forKey: "glasses_btMacAddress")
+        let right = stored("rightMacAddress")
+            ?? UserDefaults.standard.string(forKey: "glasses_btMacAddressRight")
+
+        guard let left, let leftBytes = parseMac(left) else {
+            Bridge.log("R1: connectToGlasses: no glasses MAC")
+            return
+        }
+        let rightBytes = right.flatMap(parseMac) ?? leftBytes
+
+        // Cache so we can re-send even before the glasses are next scanned.
+        UserDefaults.standard.set(left, forKey: "glasses_btMacAddress")
+        if let right {
+            UserDefaults.standard.set(right, forKey: "glasses_btMacAddressRight")
+        }
+
+        var payload = leftBytes
+        payload.append(rightBytes)
+        sendEusCommand(R1Eus.SUBCMD_ADV_START, payload: payload, log: "advStart")
+    }
+
+    /// Parse a MAC string like "AA:BB:CC:DD:EE:FF" or "AABBCCDDEEFF" into 6 raw bytes.
+    private func parseMac(_ s: String) -> Data? {
+        let cleaned = s.replacingOccurrences(of: ":", with: "")
+            .replacingOccurrences(of: "-", with: "")
+        guard cleaned.count == 12 else { return nil }
+        var out = Data(); out.reserveCapacity(6)
+        var idx = cleaned.startIndex
+        for _ in 0 ..< 6 {
+            let next = cleaned.index(idx, offsetBy: 2)
+            guard let byte = UInt8(cleaned[idx ..< next], radix: 16) else { return nil }
+            out.append(byte)
+            idx = next
+        }
+        return out
+    }
+
+    private func markConnected() {
+        Task { await reconnectionManager.stop() }
+        Bridge.log("R1: Ring connected")
+
+        if let name = ringPeripheral?.name, let id = extractRingId(name) {
+            DeviceStore.shared.apply("bluetooth", "controller_device_name", id)
+        }
+
+        guard let mac = ringMacAddress else {
+            Bridge.log("R1: No ring MAC address found")
+            return
+        }
+        DeviceStore.shared.apply("glasses", "controllerMacAddress", mac)
+
+        DeviceStore.shared.apply("glasses", "controllerConnected", true)
+        // The phone link owns these flags: a ready phone link IS pairing
+        // success (fires handleControllerReady). The glasses link is layered
+        // on afterwards via advStart + RING_CONNECT_INFO.
+        DeviceStore.shared.apply("glasses", "controllerFullyBooted", true)
+
+        // tell the ring to connect to the glasses if we have it's mac address:
+        connectToGlasses()
+
+        // after a second, connect the glasses to the controller if needed:
+        Task {
+            try? await Task.sleep(nanoseconds: 1_000_000_000)
+            await DeviceManager.shared.sgc?.connectController()
+        }
+
+        startHeartbeat()
+    }
+
+    // MARK: - Heartbeat
+
+    private func startHeartbeat() {
+        heartbeatTimer?.invalidate()
+        // Simple keepalive: re-read battery every 30 seconds
+        heartbeatTimer = Timer.scheduledTimer(withTimeInterval: 30.0, repeats: true) {
+            [weak self] _ in
+            DispatchQueue.main.async {
+                guard let self = self, DeviceStore.shared.get("glasses", "controllerConnected") as? Bool ?? false else { return }
+                // Read battery if we have the standard battery char
+                if let char = self.batteryLevelChar {
+                    self.ringPeripheral?.readValue(for: char)
+                }
+            }
+        }
+    }
+
+    private func stopHeartbeat() {
+        heartbeatTimer?.invalidate()
+        heartbeatTimer = nil
+    }
+
+    // MARK: - Incoming Data Handling
+
+    private func handleNotification(from characteristic: CBCharacteristic, data: Data) {
+        let hex = data.map { String(format: "%02X", $0) }.joined(separator: " ")
+        Bridge.log("R1: \(String(characteristic.uuid.uuidString.suffix(4))) -> \(hex)")
+
+        let timestamp = Int64(Date().timeIntervalSince1970 * 1000)
+
+        // Gesture: [0xFF, type, param]
+        if data.count >= 3, data[0] == R1BLE.GESTURE_MARKER {
+            if let gesture = R1Gesture.parse(from: data) {
+                Bridge.log("R1: Gesture: \(gesture.rawValue)")
+                Bridge.sendTouchEvent(
+                    deviceModel: ControllerTypes.R1,
+                    gestureName: gesture.rawValue,
+                    timestamp: timestamp
+                )
+            } else {
+                Bridge.log(
+                    "R1: Unknown gesture type=0x\(String(format: "%02X", data[1])) param=0x\(String(format: "%02X", data[2]))"
+                )
+            }
+            return
+        }
+
+        // Battery: 2 bytes, first byte is percentage
+        if data.count == 2, data[0] <= 100 {
+            _batteryLevel = Int(data[0])
+            Bridge.log("R1: Battery: \(data[0])%")
+            return
+        }
+
+        // State: single byte (0x01=ready, 0x00=menu)
+        if data.count == 1 {
+            let state = data[0] == 0x01 ? "ready" : data[0] == 0x00 ? "menu" : "unknown(\(data[0]))"
+            Bridge.log("R1: State: \(state)")
+            return
+        }
+
+        // Longer data: check for embedded gesture marker
+        if data.count > 3, let ffIndex = data.firstIndex(of: R1BLE.GESTURE_MARKER),
+           ffIndex + 2 < data.count
+        {
+            let gestureData = Data(data[ffIndex ... ffIndex + 2])
+            if let gesture = R1Gesture.parse(from: gestureData) {
+                Bridge.log("R1: Embedded gesture: \(gesture.rawValue)")
+                Bridge.sendTouchEvent(
+                    deviceModel: ControllerTypes.R1,
+                    gestureName: gesture.rawValue,
+                    timestamp: timestamp
+                )
+                return
+            }
+        }
+    }
+
+    // MARK: - Connection State Reset
+
+    private func resetConnectionState() {
+        ringPeripheral = nil
+        writeChar1 = nil
+        notifyChar1 = nil
+        writeChar2 = nil
+        notifyChar2 = nil
+        batteryLevelChar = nil
+        notifySubscriptionCount = 0
+        initSequenceRun = false
+        // ringMacAddress/ringUUID persist across disconnects so reconnection
+        // can find the ring again; only forget() clears them.
+        DeviceStore.shared.apply("glasses", "controllerConnected", false)
+        DeviceStore.shared.apply("glasses", "controllerFullyBooted", false)
+    }
+
+    // MARK: - Reconnection
+
+    private func startReconnectionTimer() {
+        Task {
+            await reconnectionManager.start { [weak self] in
+                guard let self else { return false }
+                if await MainActor.run(body: { DeviceStore.shared.get("glasses", "controllerConnected") as? Bool ?? false }) {
+                    return true // already connected
+                }
+                Bridge.log("R1: Attempting reconnection...")
+                await MainActor.run { self.startScan() }
+                return false // keep trying
+            }
+        }
+    }
+
+    // MARK: - ControllerManager Protocol
+
+    func findCompatibleDevices() {
+        Bridge.log("R1: findCompatibleDevices()")
+        DEVICE_SEARCH_ID = "NOT_SET"
+        startScan()
+    }
+
+    func connectById(_ id: String) {
+        Bridge.log("R1: connectById(\(id))")
+        DEVICE_SEARCH_ID = id
+        startScan()
+    }
+
+    func disconnect() {
+        Bridge.log("R1: disconnect()")
+        isDisconnecting = true
+        stopHeartbeat()
+        Task { await reconnectionManager.stop() }
+
+        if let peripheral = ringPeripheral {
+            centralManager?.cancelPeripheralConnection(peripheral)
+        }
+        resetConnectionState()
+    }
+
+    func forget() {
+        disconnect()
+        ringUUID = nil
+        ringMacAddress = nil
+        DEVICE_SEARCH_ID = "NOT_SET"
+        centralManager?.delegate = nil
+    }
+
+    func cleanup() {
+        disconnect()
+    }
+
+    func getConnectedBluetoothName() -> String? {
+        return ringPeripheral?.name
+    }
+
+    func ping() {
+        if let char = batteryLevelChar {
+            ringPeripheral?.readValue(for: char)
+        }
+    }
+
+    func getBatteryStatus() {
+        if let char = batteryLevelChar {
+            ringPeripheral?.readValue(for: char)
+        }
+    }
+
+    // MARK: - No-op implementations (ring has no display/camera/wifi/mic)
+
+    func sendIncidentId(_: String, apiBaseUrl _: String?) {}
+    func setMicEnabled(_: Bool) {}
+    func sortMicRanking(list: [String]) -> [String] {
+        return list
+    }
+
+    func sendJson(_: [String: Any], wakeUp _: Bool, requireAck _: Bool) {}
+    func requestPhoto(_: PhotoRequest) {}
+    func startVideoRecording(requestId _: String, save _: Bool, sound _: Bool) {}
+    func stopVideoRecording(requestId _: String) {}
+    func startStream(_: [String: Any]) {}
+    func stopStream() {}
+    func sendStreamKeepAlive(_: [String: Any]) {}
+    func sendButtonPhotoSettings() {}
+    func sendButtonVideoRecordingSettings() {}
+    func sendButtonMaxRecordingTime() {}
+    func setBrightness(_: Int, autoMode _: Bool) {}
+    func clearDisplay() {}
+    func sendTextWall(_: String) {}
+    func sendDoubleTextWall(_: String, _: String) {}
+    func displayBitmap(base64ImageData _: String, x _: Int32? = nil, y _: Int32? = nil, width _: Int32? = nil, height _: Int32? = nil) async -> Bool {
+        return false
+    }
+
+    func showDashboard() {}
+    func setDashboardPosition(_: Int, _: Int) {}
+    func setHeadUpAngle(_: Int) {}
+    func setSilentMode(_: Bool) {}
+    func exit() {}
+    func sendShutdown() {
+        disconnect()
+    }
+
+    func sendReboot() {}
+    func sendRgbLedControl(
+        requestId _: String, packageName _: String?, action _: String, color _: String?, onDurationMs _: Int,
+        offDurationMs _: Int, count _: Int
+    ) {}
+    func requestWifiScan() {}
+    func sendWifiCredentials(_: String, _: String) {}
+    func forgetWifiNetwork(_: String) {}
+    func sendHotspotState(_: Bool) {}
+    func sendOtaStart(otaVersionUrl: String?) {}
+    func sendOtaQueryStatus() {}
+    func sendUserEmailToGlasses(_: String) {}
+    func queryGalleryStatus() {}
+    func sendGalleryMode() {}
+    func requestVersionInfo() {}
+}
+
+// MARK: - CBCentralManagerDelegate
+
+extension R1: CBCentralManagerDelegate {
+    nonisolated func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        let state = central.state
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            Bridge.log("R1: Bluetooth state: \(state.rawValue)")
+            if state == .poweredOn {
+                _ = self.startScan()
+            }
+        }
+    }
+
+    nonisolated func centralManager(
+        _ central: CBCentralManager,
+        didDiscover peripheral: CBPeripheral,
+        advertisementData: [String: Any],
+        rssi RSSI: NSNumber
+    ) {
+        let name = peripheral.name ?? advertisementData[CBAdvertisementDataLocalNameKey] as? String
+        let mfgData = advertisementData[CBAdvertisementDataManufacturerDataKey] as? Data
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            guard self.matchesNameFilter(name) else { return }
+
+            Bridge.log(
+                "R1: Discovered: \(name ?? "?") (RSSI: \(RSSI)) mfgData: \(mfgData?.map { String(format: "%02X", $0) }.joined(separator: " ") ?? "none")"
+            )
+
+            // Extract ring MAC from manufacturer data if available and store to a map name:mac
+            if let mfgData = mfgData {
+                Bridge.log(
+                    "R1: mfgData: \(mfgData.map { String(format: "%02X", $0) }.joined(separator: " "))"
+                )
+                if mfgData.count >= 6 {
+                    self.ringMacAddressMap[name ?? ""] = Data(mfgData.suffix(6))
+                }
+            }
+
+            // Emit discovered device
+            if let name = name, let id = self.extractRingId(name) {
+                Bridge.sendDiscoveredDevice(ControllerTypes.R1, id)
+            }
+
+            // If scan-only mode, don't auto-connect
+            guard self.DEVICE_SEARCH_ID != "NOT_SET" else { return }
+
+            // If search ID is specific, check it matches the ring name/id
+            if let name = name, let id = self.extractRingId(name),
+               self.DEVICE_SEARCH_ID != id && !name.contains(self.DEVICE_SEARCH_ID)
+            {
+                return
+            }
+
+            if self.ringPeripheral == nil {
+                self.ringPeripheral = peripheral
+                peripheral.delegate = self
+                central.connect(peripheral, options: nil)
+                self.stopScan()
+                Bridge.log("R1: Connecting to \(name ?? "ring")")
+            }
+        }
+    }
+
+    nonisolated func centralManager(
+        _: CBCentralManager, didConnect peripheral: CBPeripheral
+    ) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            Bridge.log("R1: Connected to \(peripheral.name ?? "ring")")
+
+            self.ringUUID = peripheral.identifier
+
+            guard let name = peripheral.name, let mac = self.ringMacAddressMap[name] else {
+                Bridge.log("R1: No MAC stored in map found for \(peripheral.name ?? "ring")")
+                // stop the scan, disconnect, remove the uuid, and try again as we need the mac address to connect:
+                self.disconnect()
+                self.ringUUID = nil
+                // we are still searching!:
+                DeviceStore.shared.apply("glasses", "controllerConnected", false)
+                DeviceStore.shared.apply("glasses", "controllerFullyBooted", false)
+                DeviceStore.shared.apply("glasses", "controllerSearching", true)
+                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                    self.startScan()
+                }
+                return
+            }
+
+            self.ringMacAddress = mac.map { String(format: "%02X", $0) }.joined(separator: ":")
+
+            // Discover all services
+            peripheral.discoverServices(nil)
+        }
+    }
+
+    nonisolated func centralManager(
+        _: CBCentralManager, didFailToConnect _: CBPeripheral, error: Error?
+    ) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            Bridge.log("R1: Failed to connect: \(error?.localizedDescription ?? "unknown")")
+            self.resetConnectionState()
+        }
+    }
+
+    nonisolated func centralManager(
+        _: CBCentralManager, didDisconnectPeripheral _: CBPeripheral, error: Error?
+    ) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            Bridge.log("R1: Disconnected: \(error?.localizedDescription ?? "clean")")
+
+            self.stopHeartbeat()
+
+            if self.isDisconnecting { return }
+
+            self.resetConnectionState()
+            self.startReconnectionTimer()
+        }
+    }
+}
+
+// MARK: - CBPeripheralDelegate
+
+extension R1: CBPeripheralDelegate {
+    nonisolated func peripheral(_ peripheral: CBPeripheral, didDiscoverServices _: Error?) {
+        guard let services = peripheral.services else { return }
+        for service in services {
+            // Discover ALL characteristics on every service
+            peripheral.discoverCharacteristics(nil, for: service)
+        }
+    }
+
+    nonisolated func peripheral(
+        _ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error _: Error?
+    ) {
+        guard let characteristics = service.characteristics else { return }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            for char in characteristics {
+                Bridge.log("R1: char discovered: \(char.uuid)")
+                let props = char.properties
+                var propStr: [String] = []
+                if props.contains(.read) { propStr.append("read") }
+                if props.contains(.write) { propStr.append("write") }
+                if props.contains(.writeWithoutResponse) { propStr.append("writeNoResp") }
+                if props.contains(.notify) { propStr.append("notify") }
+                if props.contains(.indicate) { propStr.append("indicate") }
+                Bridge.log("R1: char \(char.uuid) props=[\(propStr.joined(separator: ","))]")
+
+                // Store known characteristics
+                switch char.uuid {
+                case R1BLE.WRITE_CHAR_1:
+                    self.writeChar1 = char
+                case R1BLE.NOTIFY_CHAR_1:
+                    self.notifyChar1 = char
+                case R1BLE.WRITE_CHAR_2:
+                    self.writeChar2 = char
+                case R1BLE.NOTIFY_CHAR_2:
+                    self.notifyChar2 = char
+                case R1BLE.BATTERY_LEVEL_CHAR:
+                    self.batteryLevelChar = char
+                default:
+                    break
+                }
+
+                // Subscribe to any notify/indicate characteristic
+                if props.contains(.notify) || props.contains(.indicate) {
+                    peripheral.setNotifyValue(true, for: char)
+                }
+
+                // Read any readable characteristic (triggers pairing if encrypted)
+                if props.contains(.read) {
+                    peripheral.readValue(for: char)
+                }
+            }
+        }
+    }
+
+    nonisolated func peripheral(
+        _: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic,
+        error: Error?
+    ) {
+        Bridge.log("R1: didUpdateNotificationStateFor: \(characteristic.uuid)")
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            if let error = error {
+                Bridge.log(
+                    "R1: Notify error on \(characteristic.uuid): \(error.localizedDescription)"
+                )
+                return
+            }
+            Bridge.log("R1: Notify enabled on \(characteristic.uuid)")
+
+            self.notifySubscriptionCount += 1
+
+            // Run init after subscribing to at least 2 notify characteristics
+            if self.notifySubscriptionCount >= 2 && !self.initSequenceRun {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+                    self?.runInitSequence()
+                }
+            }
+        }
+    }
+
+    nonisolated func peripheral(
+        _: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic,
+        error: Error?
+    ) {
+        Bridge.log("R1: didUpdateValueFor1: \(characteristic.uuid)")
+        guard let data = characteristic.value, !data.isEmpty, error == nil else { return }
+        Bridge.log("R1: didUpdateValueFor: \(characteristic.uuid) data: \(data.hexEncodedString())")
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            // Standard battery service
+            if characteristic.uuid == R1BLE.BATTERY_LEVEL_CHAR {
+                self._batteryLevel = Int(data[0])
+                Bridge.log("R1: Battery (std): \(data[0])%")
+                return
+            }
+
+            self.handleNotification(from: characteristic, data: data)
+        }
+    }
+
+    nonisolated func peripheral(
+        _: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?
+    ) {
+        Bridge.log("R1: didWriteValueFor: \(characteristic.uuid)")
+        if let error = error {
+            DispatchQueue.main.async {
+                Bridge.log(
+                    "R1: Write error on \(characteristic.uuid): \(error.localizedDescription)"
+                )
+            }
+        }
+    }
+}
+
+// MARK: - R1 Reconnection Manager
+
+actor R1ReconnectionManager {
+    private var task: Task<Void, Never>?
+    private let intervalSeconds: TimeInterval
+    private var attempts = 0
+    private let maxAttempts: Int
+
+    init(intervalSeconds: TimeInterval = 30, maxAttempts: Int = -1) {
+        self.intervalSeconds = intervalSeconds
+        self.maxAttempts = maxAttempts
+    }
+
+    func start(onAttempt: @escaping @Sendable () async -> Bool) {
+        stop()
+        attempts = 0
+        task = Task {
+            while !Task.isCancelled {
+                try? await Task.sleep(nanoseconds: UInt64(intervalSeconds * 1_000_000_000))
+                if Task.isCancelled { break }
+                attempts += 1
+                if maxAttempts > 0, attempts > maxAttempts { break }
+                let done = await onAttempt()
+                if done { break }
+            }
+        }
+    }
+
+    func stop() {
+        task?.cancel()
+        task = nil
+        attempts = 0
+    }
+}