@glassly/bluetooth-sdk 0.1.0-dev.62 → 0.1.0-dev.90

package/ios/Source/controllers/R1.swift

@@ -31,22 +31,97 @@ private enum R1BLE {
     /// Name filters for scanning
     static let NAME_FILTERS = ["EVEN R1", "BCL60"]
 
-    // Init sequence config writes
-    static let CONFIG_FC = Data([0xFC])
-    static let CONFIG_11 = Data([0x11])
-
-    // BleRing1 command header (cmd, module, subCmd) for advStart
-    // From RE: BleRing1Cmd_system=0, BleRing1Module_system=0, BleRing1SubCmd_advStart=9
-    static let CMD_SYSTEM: UInt8 = 0x00
-    static let MODULE_SYSTEM: UInt8 = 0x00
-    static let SUBCMD_ADV_START: UInt8 = 0x09
-
     /// 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 {
@@ -92,6 +167,7 @@ class R1: NSObject, ControllerManager {
     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"
@@ -223,67 +299,83 @@ class R1: NSObject, ControllerManager {
         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.
-    /// Sends 0xFC and 0x11 config writes to initialize the ring.
+    /// 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")
 
-        // Write init commands to both write characteristics
-        let writeChars = [writeChar1, writeChar2].compactMap { $0 }
-        guard !writeChars.isEmpty else {
-            Bridge.log("R1: No write characteristics found, skipping init")
+        guard writeChar2 != nil else {
+            Bridge.log("R1: No channel-2 write characteristic, skipping init")
             markConnected()
             return
         }
 
-        for wc in writeChars {
-            ringPeripheral?.writeValue(R1BLE.CONFIG_FC, for: wc, type: .withoutResponse)
-        }
+        sendEusCommand(R1Eus.SUBCMD_PAIR_AUTH, payload: Data([0x01]), log: "pairAuth")
 
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
-            guard let self = self else { return }
-            for wc in writeChars {
-                self.ringPeripheral?.writeValue(R1BLE.CONFIG_11, for: wc, type: .withoutResponse)
-            }
-            self.markConnected()
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+            self?.markConnected()
         }
     }
 
-    /// Tells the ring to start advertising / connect to the glasses.
-    /// Sends BleRing1 advStart (cmd=0, module=0, subCmd=9) with the 6-byte glasses MAC as payload
-    /// to WRITE_CHAR_2 (BAE80012-…). Reverse-engineered from the Even Realities mobile app
-    /// (BleRing1CmdProto::advStart -> BleRing1CmdPublicExt.sendCmd).
+    /// 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() {
-        let glassesMac = (DeviceStore.shared.get("glasses", "bluetoothMacAddress") as? String)
+        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 glassesMac else {
+        guard let left, let leftBytes = parseMac(left) else {
             Bridge.log("R1: connectToGlasses: no glasses MAC")
             return
         }
+        let rightBytes = right.flatMap(parseMac) ?? leftBytes
 
-        guard let macBytes = parseMac(glassesMac) else {
-            Bridge.log("R1: connectToGlasses: could not parse glasses MAC")
-            return
-        }
-
-        // Cache so we can reconnect even before the glasses are scanned.
-        UserDefaults.standard.set(glassesMac, forKey: "glasses_btMacAddress")
-
-        guard let wc = writeChar2 ?? writeChar1 else {
-            Bridge.log("R1: connectToGlasses: no write characteristic")
-            return
+        // 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 = Data([R1BLE.CMD_SYSTEM, R1BLE.MODULE_SYSTEM, R1BLE.SUBCMD_ADV_START])
-        payload.append(macBytes)
-        Bridge.log("R1: advStart sent")
-        ringPeripheral?.writeValue(payload, for: wc, type: .withoutResponse)
+        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.
@@ -317,7 +409,10 @@ class R1: NSObject, ControllerManager {
         DeviceStore.shared.apply("glasses", "controllerMacAddress", mac)
 
         DeviceStore.shared.apply("glasses", "controllerConnected", true)
-        // DeviceStore.shared.apply("glasses", "controllerFullyBooted", 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()
@@ -420,7 +515,8 @@ class R1: NSObject, ControllerManager {
         batteryLevelChar = nil
         notifySubscriptionCount = 0
         initSequenceRun = false
-        ringMacAddress = nil
+        // 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)
     }
@@ -666,7 +762,7 @@ extension R1: CBCentralManagerDelegate {
             if self.isDisconnecting { return }
 
             self.resetConnectionState()
-            // self.startReconnectionTimer()
+            self.startReconnectionTimer()
         }
     }
 }