@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.2.1

package/ios/Source/sgcs/G2ConnectionSession.swift

@@ -0,0 +1,101 @@
+import Foundation
+
+/// Readiness belongs to an authenticated pair and a completed initialization attempt, never to
+/// a gesture from one arm. A generation retires asynchronous setup when either arm is lost.
+struct G2ConnectionSession {
+    enum Side: String, CaseIterable {
+        case left = "L"
+        case right = "R"
+    }
+
+    private(set) var generation: UInt64 = 0
+    private var initialized: Set<Side> = []
+    private var authenticatedSides: Set<Side> = []
+    private var authStarted = false
+    private var setupComplete = false
+
+    var isReady: Bool {
+        initialized.count == 2 && authenticatedSides.count == 2 && setupComplete
+    }
+
+    func needsRecovery(attempt: UInt64) -> Bool {
+        generation == attempt && !isReady
+    }
+
+    mutating func initialize(_ side: Side) {
+        initialized.insert(side)
+    }
+
+    mutating func beginAuthentication() -> UInt64? {
+        guard initialized.count == 2, !authStarted else { return nil }
+        authStarted = true
+        return generation
+    }
+
+    mutating func authenticated(_ side: Side, success: Bool) {
+        guard authStarted else { return }
+        if success { authenticatedSides.insert(side) }
+        else { authenticatedSides.remove(side) }
+    }
+
+    mutating func completeSetup(generation: UInt64) {
+        guard self.generation == generation, authStarted else { return }
+        setupComplete = true
+    }
+
+    mutating func reset() {
+        generation &+= 1
+        initialized.removeAll()
+        authenticatedSides.removeAll()
+        authStarted = false
+        setupComplete = false
+    }
+}
+
+enum G2ConnectionTarget {
+    /// A serial-scoped cached UUID identifies an arm even without a new advertisement. Nearby
+    /// arms can share the G2_32 name fragment; only an advertisement's serial can select an
+    /// uncached arm. Never fall back to names alone or another pair's cached identifiers.
+    static func side(
+        identifier: UUID, name: String?, advertisedSerial: String?, searchID: String,
+        leftUUID: UUID?, rightUUID: UUID?
+    ) -> G2ConnectionSession.Side? {
+        guard !searchID.isEmpty, searchID != "NOT_SET" else { return nil }
+        if identifier == leftUUID, identifier == rightUUID { return nil }
+        if identifier == leftUUID { return .left }
+        if identifier == rightUUID { return .right }
+        guard let advertisedSerial, advertisedSerial.contains(searchID), let name else { return nil }
+        if name.contains("_L_") { return .left }
+        if name.contains("_R_") { return .right }
+        return nil
+    }
+}
+
+/// Normal pairing connects the arms sequentially. Surface a missing arm only after the
+/// same partial link has persisted for three seconds, using monotonic time.
+struct G2PartialConnection {
+    static let noticeDelay: TimeInterval = 3
+    private(set) var missingSide: G2ConnectionSession.Side?
+    private var partialSince: TimeInterval = 0
+
+    mutating func update(leftConnected: Bool, rightConnected: Bool, now: TimeInterval) {
+        let missing: G2ConnectionSession.Side? = leftConnected == rightConnected
+            ? nil : (leftConnected ? .right : .left)
+        if missing != missingSide {
+            missingSide = missing
+            partialSince = now
+        }
+    }
+
+    func visibleMissingSide(now: TimeInterval) -> G2ConnectionSession.Side? {
+        now - partialSince >= Self.noticeDelay ? missingSide : nil
+    }
+
+    var timeoutError: String {
+        switch missingSide {
+        case .left: "errors:g2LeftArmUnavailable"
+        case .right: "errors:g2RightArmUnavailable"
+        case nil: "errors:g2ConnectionTimedOut"
+        }
+    }
+}

package/ios/Source/sgcs/Mach1.swift

@@ -133,6 +133,15 @@ class Mach1: UltraliteBaseViewController, SGCManager {
 
     /// Store discovered peripherals by their identifier
     private var discoveredPeripherals: [String: CBPeripheral] = [:]
+    private var selectedPeripheralID: String?
+
+    private var currentDeviceMatchesSelection: Bool {
+        guard let selectedPeripheralID else { return true }
+        let currentDevice = UltraliteManager.shared.currentDevice
+        return VuzixConnectionTarget.matches(
+            name: currentDevice?.peripheral?.name ?? currentDevice?.getName(), target: selectedPeripheralID
+        )
+    }
 
     private var textHandle: Int?
     private var tapTextHandle: Int?
@@ -146,6 +155,7 @@ class Mach1: UltraliteBaseViewController, SGCManager {
         if setupDone { return }
         isConnectedListener = BondListener(listener: { [weak self] value in
             guard let self else { return }
+            guard !value || self.currentDeviceMatchesSelection else { return }
             Bridge.log("MACH1: isConnectedListener: \(value)")
 
             if value {
@@ -171,6 +181,7 @@ class Mach1: UltraliteBaseViewController, SGCManager {
 
         batteryLevelListener = BondListener(listener: { [weak self] value in
             guard let self else { return }
+            guard self.currentDeviceMatchesSelection else { return }
             Bridge.log("MACH1: batteryLevelListener: \(value)")
             batteryLevel = value
             DeviceStore.shared.apply("glasses", "batteryLevel", value)
@@ -238,23 +249,22 @@ class Mach1: UltraliteBaseViewController, SGCManager {
 
         // Extract the ID from the device name if it contains brackets
         // e.g., "Vuzix Z100 [f1b87c]" -> "f1b87c"
-        var peripheralId = id
-        if let deviceId = id.split(separator: "[").last?.split(separator: "]").first {
-            peripheralId = String(deviceId)
-        }
+        let peripheralId = VuzixConnectionTarget.identifier(id)
+        selectedPeripheralID = peripheralId
 
         let isLinked = UltraliteManager.shared.isLinked.value
         let currentDevice = UltraliteManager.shared.currentDevice
         let isConnected =
             isLinked && currentDevice != nil && currentDevice!.isPaired
                 && currentDevice!.isConnected.value
-        let peripheral = discoveredPeripherals[peripheralId] ?? currentDevice?.peripheral
+        let matchesSelection = currentDeviceMatchesSelection
+        let peripheral = discoveredPeripherals[peripheralId] ?? (matchesSelection ? currentDevice?.peripheral : nil)
 
         // Bind listeners to get notified when device connects
         UltraliteManager.shared.currentDevice?.isConnected.bind(listener: isConnectedListener!)
         UltraliteManager.shared.currentDevice?.batteryLevel.bind(listener: batteryLevelListener!)
 
-        if isConnected {
+        if isConnected && matchesSelection {
             // Already connected, request control now
             let gotControl = currentDevice?.requestControl(
                 layout: UltraliteSDK.Ultralite.Layout.textBottomLeftAlign, timeout: 0,
@@ -266,7 +276,7 @@ class Mach1: UltraliteBaseViewController, SGCManager {
             return
         }
 
-        if !isLinked {
+        if !isLinked || !matchesSelection {
             if peripheral == nil {
                 Bridge.log("Mach1Manager: No peripheral found or stored with ID: \(peripheralId)")
                 CONNECTING_DEVICE = peripheralId
@@ -279,6 +289,8 @@ class Mach1: UltraliteBaseViewController, SGCManager {
             UltraliteManager.shared.stopScan()
             CONNECTING_DEVICE = ""
 
+            // Replace the SDK link only after finding the explicitly selected device.
+            if isLinked { UltraliteManager.shared.unlink() }
             UltraliteManager.shared.link(device: peripheral!, callback: linked)
             UltraliteManager.shared.currentDevice?.isConnected.bind(listener: isConnectedListener!)
             UltraliteManager.shared.currentDevice?.batteryLevel.bind(