@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.3.0-beta.942

package/ios/Source/sgcs/MentraLiveFileTransferSession.swift

@@ -0,0 +1,137 @@
+import Foundation
+
+struct MentraLiveFileTransferSession {
+    let fileName: String
+    let fileSize: Int // NOTE: May be "fake" (inflated) due to BES firmware workaround
+    let dynamicPayload: Bool
+    var actualPackSize: Int = 0 // Actual pack size from first received packet
+    var totalPackets: Int
+    var expectedNextPacket: Int = 0
+    var receivedPackets: [Int: Data] = [:]
+    let startTime: Date
+    var isComplete: Bool = false
+    var isAnnounced: Bool = false
+
+    /// BES2700 firmware hardcodes FILE_PACK_SIZE=400 when calculating totalPack.
+    /// Android glasses "lie" about fileSize to make BES expect correct packet count.
+    private static let BES_HARDCODED_PACK_SIZE = 400
+
+    init(fileName: String, fileSize: Int, announcedPackets: Int? = nil, flags: UInt16 = 0) {
+        self.fileName = fileName
+        self.fileSize = fileSize
+        dynamicPayload = (flags & 0x0002) != 0
+        let computedPackets =
+            (fileSize + K900ProtocolUtils.FILE_PACK_SIZE - 1) / K900ProtocolUtils.FILE_PACK_SIZE
+        if let announced = announcedPackets, announced > 0 {
+            totalPackets = announced
+            isAnnounced = true
+        } else {
+            totalPackets = computedPackets
+            isAnnounced = false
+        }
+        startTime = Date()
+    }
+
+    mutating func updateAnnouncedPackets(_ announced: Int) {
+        guard announced > 0 else { return }
+        totalPackets = announced
+        isAnnounced = true
+        if expectedNextPacket >= totalPackets {
+            expectedNextPacket = min(expectedNextPacket, max(totalPackets - 1, 0))
+        }
+    }
+
+    /// Recalculate total packets based on actual pack size from received packet.
+    /// Dynamic headers carry the true byte count. Only legacy small packs use inflated sizes.
+    mutating func recalculateTotalPackets(actualPackSize: Int) {
+        guard actualPackSize > 0, actualPackSize <= K900ProtocolUtils.FILE_PACK_SIZE else { return }
+
+        self.actualPackSize = actualPackSize
+
+        // Detect BES lie: if fileSize is exact multiple of 400, glasses used the lie strategy
+        let isBesLie = !dynamicPayload
+            && (fileSize % Self.BES_HARDCODED_PACK_SIZE == 0)
+            && (actualPackSize < Self.BES_HARDCODED_PACK_SIZE)
+
+        let newTotalPackets: Int
+        if isBesLie {
+            // BES lie detected: totalPackets = fileSize / 400
+            newTotalPackets = fileSize / Self.BES_HARDCODED_PACK_SIZE
+            Bridge.log(
+                "📦 BES Lie detected! fakeFileSize=\(fileSize), totalPackets=\(newTotalPackets), actualPackSize=\(actualPackSize)"
+            )
+        } else {
+            // Normal case: calculate based on actual pack size
+            newTotalPackets = (fileSize + actualPackSize - 1) / actualPackSize
+        }
+
+        if newTotalPackets != totalPackets {
+            Bridge.log(
+                "📦 Recalculating totalPackets: \(totalPackets) -> \(newTotalPackets) (packSize=\(actualPackSize), fileSize=\(fileSize))"
+            )
+            totalPackets = newTotalPackets
+        }
+    }
+
+    mutating func addPacket(_ index: Int, data: Data) -> Bool {
+        guard index >= 0 else { return false }
+
+        // On first packet, recalculate total packets only when we do not already
+        // have an authoritative pack size from protocol metadata.
+        if receivedPackets.isEmpty && actualPackSize == 0 && !data.isEmpty {
+            recalculateTotalPackets(actualPackSize: data.count)
+        }
+
+        guard index < totalPackets else { return false }
+        if dynamicPayload {
+            let expectedSize = min(actualPackSize, fileSize - index * actualPackSize)
+            guard expectedSize > 0, data.count == expectedSize else { return false }
+        }
+
+        guard receivedPackets[index] == nil else {
+            return false
+        }
+
+        receivedPackets[index] = data
+
+        while receivedPackets[expectedNextPacket] != nil, expectedNextPacket < totalPackets {
+            expectedNextPacket += 1
+        }
+
+        isComplete = (receivedPackets.count == totalPackets)
+        return true
+    }
+
+    func isFinalPacket(_ index: Int) -> Bool {
+        index == totalPackets - 1
+    }
+
+    func missingPacketIndices() -> [Int] {
+        guard totalPackets > receivedPackets.count else { return [] }
+        return (0 ..< totalPackets).compactMap { receivedPackets[$0] == nil ? $0 : nil }
+    }
+
+    /// Assemble file from received packets.
+    /// NOTE: Calculates actual file size from received data, NOT from header fileSize,
+    /// because fileSize may be "fake" (inflated) due to BES firmware workaround.
+    func assembleFile() -> Data? {
+        guard isComplete else { return nil }
+
+        // Calculate actual file size by summing all received packet sizes
+        let actualFileSize = receivedPackets.values.reduce(0) { $0 + $1.count }
+
+        Bridge.log(
+            "📦 Assembling file: headerFileSize=\(fileSize), actualFileSize=\(actualFileSize), totalPackets=\(totalPackets)"
+        )
+
+        var fileData = Data(capacity: actualFileSize)
+
+        for i in 0 ..< totalPackets {
+            if let packet = receivedPackets[i] {
+                fileData.append(packet)
+            }
+        }
+
+        return fileData
+    }
+}

package/ios/Source/sgcs/MentraLivePairingAdvertisement.swift

@@ -61,4 +61,51 @@ enum MentraLiveConnectionAttemptPolicy {
     ) -> Bool {
         !pairingYieldActive && matchesActiveAttempt
     }
+
+    /// How long a pending reconnect reports CONNECTING before settling to DISCONNECTED. Matches
+    /// the span of the scan backoff it replaces (1+2+4+8+16 s, then 30 s × 5 attempts).
+    static let pendingReconnectSettleMs = 181_000
+
+    /// Whether an unexpected link loss should re-arm a pending connection to the same
+    /// peripheral. iOS completes a pending `connect` whenever the glasses advertise again,
+    /// even while the app is suspended (phone locked), and wakes the app to handle it. A scan
+    /// without service filters returns nothing in the background, and the backoff timers that
+    /// drive it stop while the app is suspended, so the scan path alone never reconnects there.
+    static func shouldReconnectDirectly(
+        isKilled: Bool,
+        pairingYieldActive: Bool,
+        bluetoothPoweredOn: Bool,
+        peripheralName: String?,
+        savedDeviceName: String?
+    ) -> Bool {
+        guard !isKilled, !pairingYieldActive, bluetoothPoweredOn,
+              let peripheralName, !peripheralName.isEmpty,
+              let savedDeviceName
+        else {
+            return false
+        }
+        return peripheralName == savedDeviceName
+    }
+}
+
+/// Ownership of the one armed pending reconnect. Each arm returns a new attempt number, so a
+/// timer captured for an earlier attempt can tell it no longer owns the connection state after
+/// a failure, a fallback connect or a re-arm.
+struct MentraLivePendingReconnect {
+    private(set) var attempt = 0
+    private(set) var isArmed = false
+
+    mutating func arm() -> Int {
+        attempt += 1
+        isArmed = true
+        return attempt
+    }
+
+    mutating func clear() {
+        isArmed = false
+    }
+
+    func owns(_ candidate: Int) -> Bool {
+        isArmed && candidate == attempt
+    }
 }

package/ios/Source/sgcs/MentraNex.swift

@@ -994,7 +994,7 @@ class MentraNexSGC: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate, SG
         // global "last" one. peripheralToConnectName == nil means an auto-reconnect with no
         // specific target, so the cached device is exactly what we want — keep using it.)
         if let targetName = peripheralToConnectName,
-           !(peripheralToConnect.name?.contains(targetName) ?? false)
+           peripheralToConnect.name != targetName
         {
             Bridge.log(
                 "NEX-CONN: 🔵 Stored UUID is '\(peripheralToConnect.name ?? "unnamed")' but target is '\(targetName)'. Skipping UUID fast-path; will scan for the target."
@@ -1088,7 +1088,7 @@ class MentraNexSGC: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate, SG
             ])
             if let targetName = peripheralToConnectName,
                let existingPeripheral = connectedPeripherals.first(where: {
-                   $0.name?.contains(targetName) == true
+                   $0.name == targetName
                })
             {
                 Bridge.log(
@@ -2724,35 +2724,12 @@ class MentraNexSGC: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate, SG
         // Always emit the discovered device for the UI list
         emitDiscoveredDevice(deviceName)
 
-        // Auto-connect logic based on target or saved device (from Java MentraNexSGC)
-        var shouldConnect = false
-        var connectionReason = ""
-
-        // Check if this matches our target device name for connection
-        if let targetName = peripheralToConnectName, deviceName.contains(targetName) {
-            shouldConnect = true
-            connectionReason = "Target device name match: \(targetName)"
-        }
-        // During a user-initiated discovery scan, only list devices — never auto-connect a
-        // saved/preferred device, so the user can pick a different one.
-        else if isDiscoveryScan {
-            shouldConnect = false
-        }
-        // Check if this matches our saved device for reconnection
-        else if let savedName = savedDeviceName, deviceName == savedName {
-            shouldConnect = true
-            connectionReason = "Saved device reconnection: \(savedName)"
-        }
-        // Check if this matches preferred device ID
-        else if let preferredId = preferredDeviceId {
-            if let extractedId = extractDeviceId(from: deviceName), extractedId == preferredId {
-                shouldConnect = true
-                connectionReason = "Preferred device ID match: \(preferredId)"
-            }
-        }
-
-        if shouldConnect {
-            connectToFoundDevice(peripheral, reason: connectionReason)
+        if NexConnectionTarget.shouldConnect(
+            name: deviceName, target: peripheralToConnectName, discoveryOnly: isDiscoveryScan,
+            savedName: savedDeviceName, preferredID: preferredDeviceId,
+            discoveredID: extractDeviceId(from: deviceName)
+        ) {
+            connectToFoundDevice(peripheral, reason: "Selected target or saved reconnect identity")
         }
     }
 

package/ios/Source/sgcs/NexConnectionTarget.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+enum NexConnectionTarget {
+    static func shouldConnect(
+        name: String, target: String?, discoveryOnly: Bool,
+        savedName: String?, preferredID: String?, discoveredID: String?
+    ) -> Bool {
+        guard !discoveryOnly else { return false }
+        // An explicit selection is authoritative even when it does not match.
+        // Saved-device fallbacks are only for reconnecting without a selection.
+        if let target { return !target.isEmpty && name == target }
+        if let savedName, !savedName.isEmpty, name == savedName { return true }
+        return preferredID != nil && preferredID == discoveredID
+    }
+}