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

package/ios/Source/sgcs/MentraLive.swift

@@ -677,145 +677,13 @@ enum K900ProtocolUtils {
     }
 }
 
-private struct FileTransferSession {
-    let fileName: String
-    let fileSize: Int // NOTE: May be "fake" (inflated) due to BES firmware workaround
-    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) {
-        self.fileName = fileName
-        self.fileSize = fileSize
-        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.
-    /// Detects BES lie: if fileSize is multiple of 400 but actual pack size differs.
-    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 =
-            (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)
-        }
-
-        if index >= totalPackets {
-            totalPackets = index + 1
-        }
-
-        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
-    }
-}
-
 private struct BlePhotoTransfer {
     var isThumbnail = false
     let bleImgId: String
     let requestId: String
     let webhookUrl: String
     var authToken: String?
-    var session: FileTransferSession?
+    var session: MentraLiveFileTransferSession?
     let phoneStartTime: Date
     var bleTransferStartTime: Date?
     var glassesCompressionDurationMs: Int64 = 0
@@ -838,7 +706,7 @@ private final class BleIncidentLogRelayEntry {
     let incidentId: String
     let apiBaseUrl: String
     let kind: BleIncidentLogRelayKind
-    var session: FileTransferSession?
+    var session: MentraLiveFileTransferSession?
 
     init(
         fileBaseKey: String, incidentId: String, apiBaseUrl: String, kind: BleIncidentLogRelayKind
@@ -994,6 +862,7 @@ extension MentraLive: CBCentralManagerDelegate {
             Bridge.log("Connected to GATT server, discovering services...")
 
             self.stopConnectionTimeout()
+            self.clearPendingReconnectTracking()
             self.isConnecting = false
             self.connectingPeripheral = nil
             self.connectedPeripheral = peripheral
@@ -1048,6 +917,7 @@ extension MentraLive: CBCentralManagerDelegate {
                 return
             }
             self.connectingPeripheral = nil
+            self.clearPendingReconnectTracking()
             Bridge.log("LIVE: Disconnected from GATT server")
 
             self.isConnecting = false
@@ -1077,8 +947,9 @@ extension MentraLive: CBCentralManagerDelegate {
                 return
             }
 
-            // Attempt reconnection if not killed
-            if !self.isKilled {
+            // Prefer a pending direct reconnect: it is the only path iOS completes while the
+            // app is suspended. Fall back to the scan backoff when it does not apply.
+            if !self.isKilled, !self.reconnectDirectly(to: peripheral) {
                 self.handleReconnection()
             }
         }
@@ -1098,6 +969,7 @@ extension MentraLive: CBCentralManagerDelegate {
             Bridge.log("LIVE: Failed to connect to peripheral: \(errorDescription)")
 
             self.stopConnectionTimeout()
+            self.clearPendingReconnectTracking()
             self.isConnecting = false
             self.closeL2capFileChannel()
             self.connectedPeripheral = nil
@@ -1414,6 +1286,7 @@ class MentraLive: NSObject, SGCManager {
     private let BLOCK_AUDIO_DUPLEX = false
     private static let voiceActivityDetectionSwitchType = 8
     private static let loudnessGateSwitchType = 10
+    private static let autoPowerOffSwitchType = 11
     private func pairingAdvertisement(
         _ advertisementData: [String: Any]
     ) -> MentraLivePairingAdvertisement? {
@@ -1601,7 +1474,7 @@ class MentraLive: NSObject, SGCManager {
     // NEW: File transfer properties
     private var fileReadCharacteristic: CBCharacteristic?
     private var fileWriteCharacteristic: CBCharacteristic?
-    private var activeFileTransfers = [String: FileTransferSession]()
+    private var activeFileTransfers = [String: MentraLiveFileTransferSession]()
     private var blePhotoTransfers = [String: BlePhotoTransfer]()
     private var bleIncidentLogRelays = [String: BleIncidentLogRelayEntry]()
     private var l2capFileChannel: MentraLiveL2capChannel?
@@ -1777,6 +1650,10 @@ class MentraLive: NSObject, SGCManager {
     private static let glassesMediaVolumeTimeoutSec: TimeInterval = 2.0
 
     private var connectionTimeoutTimer: Timer?
+    /// Peripheral of an armed pending reconnect (see `reconnectDirectly`).
+    private var pendingReconnectPeripheral: CBPeripheral?
+    private var pendingReconnect = MentraLivePendingReconnect()
+    private var pendingReconnectSettleWorkItem: DispatchWorkItem?
     private var reconnectionWorkItem: DispatchWorkItem?
     private var requiresAncs = true
 
@@ -1844,6 +1721,7 @@ class MentraLive: NSObject, SGCManager {
 
             // clear the saved device name:
             UserDefaults.standard.set("", forKey: PREFS_DEVICE_NAME)
+            cancelPendingReconnect(reason: "discovery")
 
             manualDiscoveryActive = true
             startScan()
@@ -1856,6 +1734,7 @@ class MentraLive: NSObject, SGCManager {
     }
 
     private func enterPairingYield(windowMs: Int) {
+        cancelPendingReconnect(reason: "pairing_yield")
         pairingYieldActive = true
         pairingYieldAwaitingReclaim = false
         pairingYieldEndWorkItem?.cancel()
@@ -1936,6 +1815,7 @@ class MentraLive: NSObject, SGCManager {
             return
         }
         Bridge.log("connectById: \(deviceName)")
+        cancelPendingReconnect(reason: "connect_by_id")
         // Save the device name for future reconnection
         UserDefaults.standard.set(deviceName, forKey: PREFS_DEVICE_NAME)
 
@@ -2488,15 +2368,59 @@ class MentraLive: NSObject, SGCManager {
         }
         Bridge.log("LIVE: Connecting to device: \(peripheral.identifier.uuidString)")
 
+        // A timed attempt supersedes any pending reconnect: withdraw one aimed at other
+        // glasses, and drop tracking for this one so its settle timer cannot touch this attempt.
+        if let pending = pendingReconnectPeripheral, pending !== peripheral {
+            cancelPendingReconnect(reason: "superseded")
+        } else {
+            clearPendingReconnectTracking()
+        }
+
         isConnecting = true
         updateConnectionState(ConnTypes.CONNECTING)
         connectingPeripheral = peripheral
         connectedPeripheral = peripheral
-        peripheral.delegate = self
 
         // Set connection timeout
         startConnectionTimeout()
 
+        issueConnect(peripheral)
+    }
+
+    /// Re-arms a pending connection to the glasses that just dropped. Unlike `connectToDevice`,
+    /// it sets no timeout: CoreBluetooth keeps the request open until the glasses advertise
+    /// again (for example after a BES firmware reset), completes it in the background and wakes
+    /// the app. Discovery, connect-by-id, pairing yield and `destroy()` cancel it through
+    /// `cancelPendingReconnect`. Returns false when the policy does not apply, so the caller can
+    /// fall back to scanning.
+    private func reconnectDirectly(to peripheral: CBPeripheral) -> Bool {
+        guard let centralManager,
+              MentraLiveConnectionAttemptPolicy.shouldReconnectDirectly(
+                  isKilled: isKilled,
+                  pairingYieldActive: pairingYieldActive,
+                  bluetoothPoweredOn: centralManager.state == .poweredOn,
+                  peripheralName: peripheral.name,
+                  savedDeviceName: UserDefaults.standard.string(forKey: PREFS_DEVICE_NAME)
+              )
+        else {
+            return false
+        }
+        Bridge.log(
+            "LIVE: Pending direct reconnect to \(peripheral.identifier.uuidString) (no timeout, completes in background)"
+        )
+        isConnecting = true
+        updateConnectionState(ConnTypes.CONNECTING)
+        connectingPeripheral = peripheral
+        connectedPeripheral = peripheral
+        pendingReconnectPeripheral = peripheral
+        issueConnect(peripheral)
+        schedulePendingReconnectSettle(attempt: pendingReconnect.arm())
+        return true
+    }
+
+    /// The single CoreBluetooth connect call, shared by user-initiated and pending reconnects.
+    private func issueConnect(_ peripheral: CBPeripheral) {
+        peripheral.delegate = self
         #if os(macOS)
             centralManager?.connect(peripheral, options: nil)
         #else
@@ -2511,6 +2435,58 @@ class MentraLive: NSObject, SGCManager {
         #endif
     }
 
+    /// A pending connect never times out, so the glasses may simply never return (battery
+    /// dead, left behind). After the old scan backoff's span, report DISCONNECTED like that
+    /// backoff did, but keep the request armed: iOS still completes it whenever the glasses
+    /// advertise, and `didConnect` accepts it through `connectingPeripheral`.
+    private func schedulePendingReconnectSettle(attempt: Int) {
+        pendingReconnectSettleWorkItem?.cancel()
+        let work = DispatchWorkItem { [weak self] in
+            // Only the attempt that armed this timer may settle state; a failure, fallback
+            // connect or re-arm clears or replaces it.
+            guard let self, self.pendingReconnect.owns(attempt),
+                  self.connectionState != ConnTypes.CONNECTED
+            else { return }
+            Bridge.log("LIVE: Glasses still unreachable; reporting disconnected, pending reconnect stays armed")
+            self.pendingReconnectSettleWorkItem = nil
+            self.isConnecting = false
+            self.connectedPeripheral = nil
+            self.updateConnectionState(ConnTypes.DISCONNECTED)
+        }
+        pendingReconnectSettleWorkItem = work
+        DispatchQueue.main.asyncAfter(
+            deadline: .now() + .milliseconds(MentraLiveConnectionAttemptPolicy.pendingReconnectSettleMs),
+            execute: work
+        )
+    }
+
+    /// Stops tracking a pending reconnect after it connected; no CoreBluetooth call needed.
+    private func clearPendingReconnectTracking() {
+        pendingReconnectSettleWorkItem?.cancel()
+        pendingReconnectSettleWorkItem = nil
+        pendingReconnect.clear()
+        pendingReconnectPeripheral = nil
+    }
+
+    /// Withdraws a pending reconnect before the user retargets (discovery, connect-by-id,
+    /// pairing yield) or tears down, so iOS cannot later complete it to the previous glasses.
+    private func cancelPendingReconnect(reason: String) {
+        guard let peripheral = pendingReconnectPeripheral else {
+            clearPendingReconnectTracking()
+            return
+        }
+        clearPendingReconnectTracking()
+        Bridge.log("LIVE: Cancelling pending reconnect to \(peripheral.identifier.uuidString) (\(reason))")
+        if connectingPeripheral === peripheral {
+            connectingPeripheral = nil
+        }
+        if connectedPeripheral === peripheral, connectionState != ConnTypes.CONNECTED {
+            connectedPeripheral = nil
+        }
+        isConnecting = false
+        centralManager?.cancelPeripheralConnection(peripheral)
+    }
+
     /// Opt the firmware into ANCS only after iOS has authorized this accessory.
     /// Old firmware safely ignores the command, while new firmware stays inert
     /// for old mobile clients that never send it.
@@ -2638,7 +2614,8 @@ class MentraLive: NSObject, SGCManager {
                 // The reader thread keeps draining the stream (and returning CoC credits)
                 // while the existing transfer state remains serialized on the main actor.
                 DispatchQueue.main.async {
-                    self?.processReceivedData(frame)
+                    guard let self, self.l2capFileChannelId == channelId else { return }
+                    self.processReceivedData(frame)
                 }
             },
             onClose: { [weak self] in
@@ -2665,7 +2642,7 @@ class MentraLive: NSObject, SGCManager {
 
     // MARK: - Data Processing
 
-    // Internal so native integration tests can replay the actual BLE receive path.
+    /// Internal so native integration tests can replay the actual BLE receive path.
     func processReceivedData(_ data: Data) {
         guard data.count > 0 else { return }
 
@@ -3015,7 +2992,9 @@ class MentraLive: NSObject, SGCManager {
 
         case "stream_controller_probe":
             if let response = StreamControllerProbe.response(json) {
-                sendJson(response)
+                // BES buffers non-waking commands when MTK enters standby, even while
+                // its streaming CPU lease is held. The current probe needs a live reply.
+                sendJson(response, wakeUp: true)
             }
 
         case "pong":
@@ -3440,10 +3419,13 @@ class MentraLive: NSObject, SGCManager {
             if let body = k900ParseBody(json["B"]) {
                 let switchType = k900JsonInt(body, "type") ?? -1
                 let switchValue = k900JsonInt(body, "switch") ?? -1
+                // K900 replies carry result in "S"; 0 is RC_SUCCESS.
+                let resultCode = k900JsonInt(json, "S") ?? -1
                 handleSwitchStatus(
                     switchType: switchType,
                     value: switchValue,
-                    timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+                    timestamp: Int64(Date().timeIntervalSince1970 * 1000),
+                    resultCode: resultCode
                 )
             }
 
@@ -3459,7 +3441,14 @@ class MentraLive: NSObject, SGCManager {
 
         case "sr_wrst":
             if let body = k900ParseBody(json["B"]) {
-                Bridge.sendWearState(worn: (k900JsonInt(body, "on") ?? 0) != 0)
+                Bridge.sendWearState(
+                    worn: (k900JsonInt(body, "on") ?? 0) != 0,
+                    elapsedMs: k900JsonInt(body, "elapsed_ms"),
+                    timeoutMs: k900JsonInt(body, "timeout_ms"),
+                    enabled: body["enabled"] == nil ? nil : (k900JsonInt(body, "enabled") ?? 0) != 0,
+                    armed: body["armed"] == nil ? nil : (k900JsonInt(body, "armed") ?? 0) != 0,
+                    inhibited: body["inhibited"] == nil ? nil : (k900JsonInt(body, "inhibited") ?? 0) != 0
+                )
             }
 
         case "sr_micrms":
@@ -4148,7 +4137,7 @@ class MentraLive: NSObject, SGCManager {
             activeFileTransfers.removeValue(forKey: fileName)
         }
 
-        var session = FileTransferSession(
+        var session = MentraLiveFileTransferSession(
             fileName: fileName, fileSize: fileSize, announcedPackets: totalPackets
         )
         session.isAnnounced = true
@@ -4158,7 +4147,7 @@ class MentraLive: NSObject, SGCManager {
         if var bleTransfer = blePhotoTransfers[bleImgId] {
             var bleSession =
                 bleTransfer.session
-                    ?? FileTransferSession(
+                    ?? MentraLiveFileTransferSession(
                         fileName: fileName, fileSize: fileSize, announcedPackets: totalPackets
                     )
             bleSession.updateAnnouncedPackets(totalPackets)
@@ -4251,8 +4240,8 @@ class MentraLive: NSObject, SGCManager {
 
             if incidentRelay.session == nil {
                 activeFileTransfers.removeValue(forKey: packetInfo.fileName)
-                var session = FileTransferSession(
-                    fileName: packetInfo.fileName, fileSize: Int(packetInfo.fileSize)
+                var session = MentraLiveFileTransferSession(
+                    fileName: packetInfo.fileName, fileSize: Int(packetInfo.fileSize), flags: packetInfo.flags
                 )
                 session.recalculateTotalPackets(actualPackSize: Int(packetInfo.packSize))
                 incidentRelay.session = session
@@ -4303,10 +4292,11 @@ class MentraLive: NSObject, SGCManager {
 
             // Get or create session for this transfer
             if photoTransfer.session == nil {
-                var session = FileTransferSession(
+                var session = MentraLiveFileTransferSession(
                     fileName: packetInfo.fileName,
-                    fileSize: Int(packetInfo.fileSize)
+                    fileSize: Int(packetInfo.fileSize), flags: packetInfo.flags
                 )
+                session.recalculateTotalPackets(actualPackSize: Int(packetInfo.packSize))
                 photoTransfer.session = session
                 blePhotoTransfers[bleImgId] = photoTransfer
                 Bridge.log(
@@ -4379,9 +4369,10 @@ class MentraLive: NSObject, SGCManager {
         var session = activeFileTransfers[packetInfo.fileName]
         if session == nil {
             // New file transfer
-            session = FileTransferSession(
-                fileName: packetInfo.fileName, fileSize: Int(packetInfo.fileSize)
+            session = MentraLiveFileTransferSession(
+                fileName: packetInfo.fileName, fileSize: Int(packetInfo.fileSize), flags: packetInfo.flags
             )
+            session?.recalculateTotalPackets(actualPackSize: Int(packetInfo.packSize))
             activeFileTransfers[packetInfo.fileName] = session
 
             Bridge.log(
@@ -5273,7 +5264,8 @@ class MentraLive: NSObject, SGCManager {
         if let requestId {
             json["request_id"] = requestId
         }
-        sendJson(json)
+        // Wake ASG so the version request and its response can finish after idle.
+        sendJson(json, wakeUp: true)
     }
 
     private func sendCoreTokenToAsgClient() {
@@ -5523,8 +5515,17 @@ class MentraLive: NSObject, SGCManager {
         Bridge.sendSpeakingStatus(speaking)
     }
 
-    private func handleSwitchStatus(switchType: Int, value: Int, timestamp: Int64) {
+    private func handleSwitchStatus(
+        switchType: Int, value: Int, timestamp: Int64, resultCode: Int = -1
+    ) {
         Bridge.sendSwitchStatus(switchType: switchType, value: value, timestamp: timestamp)
+        if switchType == Self.autoPowerOffSwitchType {
+            let ok = resultCode == 0
+            Bridge.log(
+                "LIVE: 🔋 auto power-off sr_swit reply type=\(switchType) switch=\(value)"
+                    + " result=\(resultCode) ok=\(ok)"
+            )
+        }
         if switchType == Self.voiceActivityDetectionSwitchType, value == 0 || value == 1 {
             handleVoiceActivityDetectionStatus(enabled: value == 1)
         }
@@ -5999,6 +6000,7 @@ class MentraLive: NSObject, SGCManager {
         closeL2capFileChannel()
 
         // Disconnect BLE
+        cancelPendingReconnect(reason: "destroy")
         if let peripheral = connectedPeripheral {
             centralManager?.cancelPeripheralConnection(peripheral)
         }
@@ -6874,6 +6876,9 @@ extension MentraLive {
         // Send glasses-side loudness / Barrier gate setting.
         sendLoudnessGateSetting()
 
+        // Send glasses-side auto power-off setting.
+        sendAutoPowerOffSetting()
+
         // Send mic tuning. With nothing authorized this sends a reset, which is
         // what returns a freshly connected pair of glasses to stock behaviour.
         sendMicTuningSetting()
@@ -7100,6 +7105,46 @@ extension MentraLive {
         }
     }
 
+    func sendAutoPowerOffSetting() {
+        let enabled = DeviceStore.shared.get("bluetooth", "auto_power_off_enabled") as? Bool
+            ?? BluetoothSdkDefaults.autoPowerOffEnabled
+        Bridge.log(
+            "LIVE: 🔋 Sending auto power-off setting to glasses: enabled=\(enabled)"
+                + " (cs_swit type=\(Self.autoPowerOffSwitchType))"
+        )
+
+        guard connectedPeripheral != nil, txCharacteristic != nil else {
+            Bridge.log("LIVE: Cannot send auto power-off setting - BLE write path not ready")
+            return
+        }
+
+        do {
+            let bodyData = try JSONSerialization.data(withJSONObject: [
+                "type": Self.autoPowerOffSwitchType,
+                "switch": enabled ? 1 : 0,
+            ])
+            guard let bodyString = String(data: bodyData, encoding: .utf8) else {
+                Bridge.log("LIVE: Failed to encode auto power-off payload")
+                return
+            }
+            let command: [String: Any] = [
+                "C": "cs_swit",
+                "V": 1,
+                "B": bodyString,
+            ]
+            if !sendRawK900Command(command, wakeUp: true) {
+                Bridge.log("LIVE: Failed to send auto power-off setting command")
+            } else {
+                Bridge.log(
+                    "LIVE: 🔋 Queued auto power-off cs_swit type=\(Self.autoPowerOffSwitchType)"
+                        + " switch=\(enabled ? 1 : 0)"
+                )
+            }
+        } catch {
+            Bridge.log("LIVE: Error encoding auto power-off payload: \(error)")
+        }
+    }
+
     func sendButtonVideoRecordingSettings() {
         let settings =
             DeviceStore.shared.get("bluetooth", "button_video_settings") as? [String: Any] ?? [
@@ -7418,7 +7463,7 @@ extension MentraLive {
             if fps > 0 { settings["fps"] = fps }
             json["settings"] = settings
         }
-        sendJson(json)
+        sendJson(json, wakeUp: true)
     }
 
     func stopVideoRecording(requestId: String) {
@@ -7433,7 +7478,7 @@ extension MentraLive {
         sendJson([
             "type": "get_video_recording_status",
             "requestId": requestId,
-        ])
+        ], wakeUp: true)
     }
 
     func stopVideoRecording(requestId: String, webhookUrl: String?, authToken: String?) {
@@ -7458,7 +7503,7 @@ extension MentraLive {
         if let authToken, !authToken.isEmpty {
             json["authToken"] = authToken
         }
-        sendJson(json)
+        sendJson(json, wakeUp: true)
     }
 }