@mentra/bluetooth-sdk 0.1.8 → 0.1.10

package/ios/Source/sgcs/MentraLive.swift

@@ -15,6 +15,7 @@
 import Combine
 import CoreBluetooth
 import Foundation
+import ImageIO
 import UIKit
 
 // MARK: - Supporting Types
@@ -68,7 +69,9 @@ class BlePhotoUploadService {
         imageData: Data,
         requestId: String,
         webhookUrl: String,
-        authToken: String?
+        authToken: String?,
+        onSuccess: ((String, String) -> Void)? = nil,
+        onError: ((String, String) -> Void)? = nil
     ) {
         Task {
             do {
@@ -76,32 +79,11 @@ class BlePhotoUploadService {
                     "\(TAG): Processing BLE photo for upload. Image size: \(imageData.count) bytes"
                 )
 
-                // 1. Decode image (AVIF or JPEG) to UIImage
-                guard let image = decodeImage(imageData: imageData) else {
-                    throw NSError(
-                        domain: "BlePhotoUpload",
-                        code: -1,
-                        userInfo: [NSLocalizedDescriptionKey: "Failed to decode image data"]
-                    )
-                }
-
-                Bridge.log(
-                    "\(TAG): Decoded image to bitmap: \(Int(image.size.width))x\(Int(image.size.height))"
-                )
-
-                // 2. Convert to JPEG for upload (in case it was AVIF)
-                guard let jpegData = image.jpegData(compressionQuality: 0.9) else {
-                    throw NSError(
-                        domain: "BlePhotoUpload",
-                        code: -2,
-                        userInfo: [NSLocalizedDescriptionKey: "Failed to convert image to JPEG"]
-                    )
-                }
-
+                let jpegData = try convertToJpegPreservingExif(imageData: imageData)
                 Bridge.log("\(TAG): Converted to JPEG for upload. Size: \(jpegData.count) bytes")
 
-                // 3. Upload to webhook
-                try await uploadToWebhook(
+                // Upload to webhook
+                let responseBody = try await uploadToWebhook(
                     jpegData: jpegData,
                     requestId: requestId,
                     webhookUrl: webhookUrl,
@@ -109,43 +91,313 @@ class BlePhotoUploadService {
                 )
 
                 Bridge.log("\(TAG): Photo uploaded successfully for requestId: \(requestId)")
-
-                //        DispatchQueue.main.async {
-                //          callback.onSuccess(requestId: requestId)
-                //        }
+                onSuccess?(requestId, responseBody)
 
             } catch {
                 Bridge.log(
                     "\(TAG): Error processing BLE photo for requestId: \(requestId), error: \(error)"
                 )
+                onError?(requestId, error.localizedDescription)
+            }
+        }
+    }
+
+    private static func convertToJpegPreservingExif(imageData: Data) throws -> Data {
+        logIncomingImageDiagnostics(imageData: imageData)
+        let imuJson = readImuJsonFromImageData(imageData)
+
+        guard let image = decodeImage(imageData: imageData) else {
+            throw NSError(
+                domain: "BlePhotoUpload",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to decode image data"]
+            )
+        }
+
+        Bridge.log(
+            "\(TAG): Decoded image to bitmap: \(Int(image.size.width))x\(Int(image.size.height))"
+        )
+
+        guard var jpegData = image.jpegData(compressionQuality: 0.9) else {
+            throw NSError(
+                domain: "BlePhotoUpload",
+                code: -2,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to convert image to JPEG"]
+            )
+        }
+
+        if let imuJson, !imuJson.isEmpty {
+            jpegData = try writeImuJsonToJpegData(jpegData, imuJson: imuJson)
+            Bridge.log("\(TAG): Re-attached IMU EXIF UserComment on output JPEG (\(imuJson.count) chars)")
+        } else {
+            let rawHasExif = containsExifMarker(in: imageData)
+            Bridge.log(
+                "\(TAG): No IMU from ImageIO (container=\(describeContainer(imageData)), rawHasExifMarker=\(rawHasExif))"
+            )
+        }
+
+        return jpegData
+    }
+
+    private static func logIncomingImageDiagnostics(imageData: Data) {
+        Bridge.log(
+            "\(TAG): BLE image diagnostics: size=\(imageData.count) bytes, container=\(describeContainer(imageData)), rawHasExifMarker=\(containsExifMarker(in: imageData))"
+        )
+    }
+
+    private static func describeContainer(_ data: Data) -> String {
+        let bytes = [UInt8](data.prefix(12))
+        if bytes.count >= 2, bytes[0] == 0xFF, bytes[1] == 0xD8 { return "jpeg" }
+        if bytes.count >= 12, bytes[4] == 0x66, bytes[5] == 0x74, bytes[6] == 0x79, bytes[7] == 0x70 {
+            let brand = String(bytes: bytes[8..<12], encoding: .ascii) ?? "?"
+            return "iso_bmff/ftyp=\(brand)"
+        }
+        return "unknown"
+    }
 
-                //        DispatchQueue.main.async {
-                //          callback.onError(requestId: requestId, error: error.localizedDescription)
-                //        }
+    private static func containsExifMarker(in data: Data) -> Bool {
+        let marker: [UInt8] = [0x45, 0x78, 0x69, 0x66, 0, 0]
+        let bytes = [UInt8](data)
+        guard bytes.count >= marker.count else { return false }
+        for i in 0...(bytes.count - marker.count) {
+            if Array(bytes[i..<(i + marker.count)]) == marker { return true }
+        }
+        return false
+    }
+
+    private static func readImuJsonFromImageData(_ imageData: Data) -> String? {
+        // Primary: ImageIO EXIF (works for JPEG and well-formed AVIF)
+        if let source = CGImageSourceCreateWithData(imageData as CFData, nil),
+            let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any]
+        {
+            let exif = properties[kCGImagePropertyExifDictionary as String] as? [String: Any]
+            let userComment = exif?[kCGImagePropertyExifUserComment as String] as? String
+            let tiff = properties[kCGImagePropertyTIFFDictionary as String] as? [String: Any]
+            let description = tiff?[kCGImagePropertyTIFFImageDescription as String] as? String
+            Bridge.log(
+                "\(TAG): ImageIO EXIF UserComment=\(describeExifAttribute(userComment)), ImageDescription=\(describeExifAttribute(description))"
+            )
+            if let userComment, !userComment.isEmpty { return userComment }
+            if let description, !description.isEmpty { return description }
+        } else {
+            Bridge.log("\(TAG): ImageIO: could not read properties")
+        }
+
+        // Fallback: raw TIFF scan for AVIFs where ImageIO doesn't expose the embedded Exif block
+        if containsExifMarker(in: imageData) {
+            if let tiffResult = readImuJsonFromTiff(imageData) {
+                Bridge.log("\(TAG): Read IMU UserComment via TIFF scan (\(tiffResult.count) chars)")
+                return tiffResult
+            }
+        }
+        return nil
+    }
+
+    /// Scans raw bytes for the {@code Exif\0\0} TIFF header and reads UserComment (0x9286).
+    private static func readImuJsonFromTiff(_ data: Data) -> String? {
+        let bytes = [UInt8](data)
+        let marker: [UInt8] = [0x45, 0x78, 0x69, 0x66, 0, 0]
+        var searchFrom = 0
+        while searchFrom <= bytes.count - marker.count {
+            guard let exifOff = findBytes(marker, in: bytes, from: searchFrom) else { break }
+            let tiff = exifOff + 6
+            guard tiff + 8 <= bytes.count else { break }
+            let littleEndian = bytes[tiff] == 0x49 && bytes[tiff + 1] == 0x49
+            let bigEndian = bytes[tiff] == 0x4D && bytes[tiff + 1] == 0x4D
+            guard littleEndian || bigEndian else { searchFrom = exifOff + 1; continue }
+            let magic = readU16(bytes, at: tiff + 2, le: littleEndian)
+            guard magic == 0x002A else { searchFrom = exifOff + 1; continue }
+            let ifd0Off = Int(readU32(bytes, at: tiff + 4, le: littleEndian))
+            if let result = readTagFromIfd(
+                bytes, tiff: tiff, ifdOff: tiff + ifd0Off, tag: 0x9286, le: littleEndian)
+            {
+                return result
             }
+            searchFrom = exifOff + 1
         }
+        return nil
+    }
+
+    private static func readTagFromIfd(
+        _ bytes: [UInt8], tiff: Int, ifdOff: Int, tag: UInt16, le: Bool
+    ) -> String? {
+        guard ifdOff + 2 <= bytes.count else { return nil }
+        let count = Int(readU16(bytes, at: ifdOff, le: le))
+        var off = ifdOff + 2
+        for _ in 0..<count {
+            guard off + 12 <= bytes.count else { break }
+            let entryTag = readU16(bytes, at: off, le: le)
+            let type = readU16(bytes, at: off + 2, le: le)
+            let valueCount = Int(readU32(bytes, at: off + 4, le: le))
+            if entryTag == tag {
+                let byteLen = valueCount
+                let valueOff: Int
+                if byteLen > 4 {
+                    valueOff = tiff + Int(readU32(bytes, at: off + 8, le: le))
+                } else {
+                    valueOff = off + 8
+                }
+                // UserComment starts with 8-byte charset prefix
+                let startOff = (tag == 0x9286 && byteLen > 8) ? valueOff + 8 : valueOff
+                let len = (tag == 0x9286 && byteLen > 8) ? byteLen - 8 : byteLen
+                guard startOff + len <= bytes.count else { return nil }
+                return String(bytes: Array(bytes[startOff..<startOff + len]), encoding: .utf8)?
+                    .trimmingCharacters(in: .init(charactersIn: "\0"))
+            }
+            // Follow Exif IFD pointer
+            if entryTag == 0x8769, type == 4 {
+                let subOff = tiff + Int(readU32(bytes, at: off + 8, le: le))
+                if let r = readTagFromIfd(bytes, tiff: tiff, ifdOff: subOff, tag: tag, le: le) {
+                    return r
+                }
+            }
+            off += 12
+        }
+        return nil
+    }
+
+    private static func findBytes(_ needle: [UInt8], in haystack: [UInt8], from: Int) -> Int? {
+        guard haystack.count >= needle.count else { return nil }
+        for i in from...(haystack.count - needle.count) {
+            if Array(haystack[i..<i + needle.count]) == needle { return i }
+        }
+        return nil
+    }
+
+    private static func readU16(_ bytes: [UInt8], at off: Int, le: Bool) -> UInt16 {
+        let a = UInt16(bytes[off]), b = UInt16(bytes[off + 1])
+        return le ? a | (b << 8) : (a << 8) | b
+    }
+
+    private static func readU32(_ bytes: [UInt8], at off: Int, le: Bool) -> UInt32 {
+        let a = UInt32(bytes[off]), b = UInt32(bytes[off + 1]),
+            c = UInt32(bytes[off + 2]), d = UInt32(bytes[off + 3])
+        return le ? a | (b << 8) | (c << 16) | (d << 24) : (a << 24) | (b << 16) | (c << 8) | d
+    }
+
+    private static func describeExifAttribute(_ value: String?) -> String {
+        guard let value else { return "null" }
+        if value.isEmpty { return "empty" }
+        let preview = value.count > 80 ? String(value.prefix(80)) + "…" : value
+        return "len=\(value.count) preview=\"\(preview)\""
+    }
+
+    private static func writeImuJsonToJpegData(_ jpegData: Data, imuJson: String) throws -> Data {
+        guard let source = CGImageSourceCreateWithData(jpegData as CFData, nil),
+            let imageType = CGImageSourceGetType(source),
+            let cgImage = CGImageSourceCreateImageAtIndex(source, 0, nil)
+        else {
+            throw PhotoUploadError.decodingFailed
+        }
+
+        let output = NSMutableData()
+        guard let destination = CGImageDestinationCreateWithData(
+            output, imageType, 1, nil
+        ) else {
+            throw PhotoUploadError.decodingFailed
+        }
+
+        var properties =
+            (CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any]) ?? [:]
+        var exif =
+            (properties[kCGImagePropertyExifDictionary as String] as? [String: Any]) ?? [:]
+        exif[kCGImagePropertyExifUserComment as String] = imuJson
+        properties[kCGImagePropertyExifDictionary as String] = exif
+
+        CGImageDestinationAddImage(destination, cgImage, properties as CFDictionary)
+        guard CGImageDestinationFinalize(destination) else {
+            throw PhotoUploadError.decodingFailed
+        }
+        return output as Data
     }
 
     /**
-     * Decode image data (AVIF or JPEG) to UIImage
+     * Decode image data (AVIF or JPEG) to UIImage.
+     * AVIF arriving from glasses has a TIFF EXIF block appended to {@code mdat}; iOS ImageIO
+     * rejects those bytes the same way Android does. Strip the Exif tail before decoding.
      */
     private static func decodeImage(imageData: Data) -> UIImage? {
-        // First try standard UIImage decoding (works for JPEG, PNG, etc)
-        if let image = UIImage(data: imageData) {
+        let isAvif = isAvifData(imageData)
+        var decodeData = imageData
+        if isAvif && containsExifMarker(in: imageData) {
+            let stripped = stripAvifExifTail(imageData)
+            if stripped.count < imageData.count {
+                Bridge.log(
+                    "\(TAG): Stripped Exif metadata item for decode: \(imageData.count) -> \(stripped.count) bytes"
+                )
+                decodeData = stripped
+            }
+        }
+
+        if let image = UIImage(data: decodeData) {
             return image
         }
 
-        // If that fails, try AVIF decoding
-        // Note: AVIF support requires iOS 16+ or a third-party library
-        if #available(iOS 16.0, *) {
-            // iOS 16+ has native AVIF support
-            return UIImage(data: imageData)
-        } else {
-            // For older iOS versions, you would need to integrate a third-party
-            // AVIF decoder library like libavif
-            Bridge.log("\(TAG): AVIF decoding not supported on this iOS version")
-            return nil
+        if isAvif {
+            if #available(iOS 16.0, *) {
+                return UIImage(data: decodeData)
+            } else {
+                Bridge.log("\(TAG): AVIF decoding not supported on iOS < 16")
+                return nil
+            }
+        }
+        return nil
+    }
+
+    private static func isAvifData(_ data: Data) -> Bool {
+        let bytes = [UInt8](data.prefix(12))
+        return bytes.count >= 12
+            && bytes[4] == 0x66 && bytes[5] == 0x74 && bytes[6] == 0x79 && bytes[7] == 0x70
+            && bytes[8] == 0x61 && bytes[9] == 0x76 && bytes[10] == 0x69 && bytes[11] == 0x66
+    }
+
+    /// Truncates the {@code mdat} box at the {@code Exif\0\0} marker, removing the TIFF EXIF
+    /// block that the glasses encoder appends. Returns original data unchanged on any parse error.
+    private static func stripAvifExifTail(_ data: Data) -> Data {
+        let bytes = [UInt8](data)
+        let marker: [UInt8] = [0x45, 0x78, 0x69, 0x66, 0, 0]
+
+        // Find last Exif marker
+        var lastExif = -1
+        for i in 0...(bytes.count - marker.count) {
+            if Array(bytes[i..<i + marker.count]) == marker { lastExif = i }
+        }
+        guard lastExif >= 0 else { return data }
+
+        // Walk top-level boxes to find mdat
+        var off = 0
+        while off + 8 <= bytes.count {
+            let boxSize = Int(readU32BE(bytes, at: off))
+            guard boxSize >= 8, off + boxSize <= bytes.count else { break }
+            let boxType = String(bytes: Array(bytes[off + 4..<off + 8]), encoding: .ascii) ?? ""
+            if boxType == "mdat" {
+                let payloadStart = off + 8
+                let payloadEnd = off + boxSize
+                guard lastExif >= payloadStart, lastExif < payloadEnd else { break }
+                let newPayloadLen = lastExif - payloadStart
+                guard newPayloadLen > 0 else { break }
+
+                var result = Data()
+                // Everything up to mdat header
+                result.append(contentsOf: bytes[0..<off])
+                // New mdat box header with updated size
+                let newMdatSize = UInt32(8 + newPayloadLen)
+                result.append(UInt8((newMdatSize >> 24) & 0xFF))
+                result.append(UInt8((newMdatSize >> 16) & 0xFF))
+                result.append(UInt8((newMdatSize >> 8) & 0xFF))
+                result.append(UInt8(newMdatSize & 0xFF))
+                result.append(contentsOf: [0x6D, 0x64, 0x61, 0x74]) // "mdat"
+                result.append(contentsOf: bytes[payloadStart..<payloadStart + newPayloadLen])
+                return result
+            }
+            off += boxSize
         }
+        return data
+    }
+
+    private static func readU32BE(_ bytes: [UInt8], at off: Int) -> UInt32 {
+        UInt32(bytes[off]) << 24 | UInt32(bytes[off + 1]) << 16
+            | UInt32(bytes[off + 2]) << 8 | UInt32(bytes[off + 3])
     }
 
     private static func uploadToWebhook(
@@ -153,10 +405,10 @@ class BlePhotoUploadService {
         requestId: String,
         webhookUrl: String,
         authToken: String?
-    ) async throws {
+    ) async throws -> String {
         guard let url = URL(string: webhookUrl) else {
             Bridge.log("LIVE: Invalid webhook URL: \(webhookUrl)")
-            return
+            throw PhotoUploadError.uploadFailed("Invalid webhook URL")
         }
 
         var request = URLRequest(url: url)
@@ -220,6 +472,7 @@ class BlePhotoUploadService {
             }
 
             print("LIVE: Upload successful. Response code: \(httpResponse.statusCode)")
+            return String(data: data, encoding: .utf8) ?? ""
 
         } catch {
             if error is PhotoUploadError {
@@ -546,31 +799,36 @@ private final class BleIncidentLogRelayEntry {
 // MARK: - CBCentralManagerDelegate
 
 extension MentraLive: CBCentralManagerDelegate {
-    func centralManagerDidUpdateState(_ central: CBCentralManager) {
-        switch central.state {
-        case .poweredOn:
-            Bridge.log("LIVE: Bluetooth powered on")
-            // If we have a saved device, try to reconnect
-            if let savedDeviceName = UserDefaults.standard.string(forKey: PREFS_DEVICE_NAME),
-               !savedDeviceName.isEmpty
-            {
-                startScan()
-            }
+    // CoreBluetooth delivers these callbacks on `bluetoothQueue`; hop back before touching MainActor state.
+    nonisolated func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        let state = central.state
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            switch state {
+            case .poweredOn:
+                Bridge.log("LIVE: Bluetooth powered on")
+                // If we have a saved device, try to reconnect
+                if let savedDeviceName = UserDefaults.standard.string(forKey: PREFS_DEVICE_NAME),
+                   !savedDeviceName.isEmpty
+                {
+                    self.startScan()
+                }
 
-        case .poweredOff:
-            Bridge.log("LIVE: Bluetooth is powered off")
-            updateConnectionState(ConnTypes.DISCONNECTED)
+            case .poweredOff:
+                Bridge.log("LIVE: Bluetooth is powered off")
+                self.updateConnectionState(ConnTypes.DISCONNECTED)
 
-        case .unauthorized:
-            Bridge.log("LIVE: Bluetooth is unauthorized")
-            updateConnectionState(ConnTypes.DISCONNECTED)
+            case .unauthorized:
+                Bridge.log("LIVE: Bluetooth is unauthorized")
+                self.updateConnectionState(ConnTypes.DISCONNECTED)
 
-        case .unsupported:
-            Bridge.log("LIVE: Bluetooth is unsupported")
-            updateConnectionState(ConnTypes.DISCONNECTED)
+            case .unsupported:
+                Bridge.log("LIVE: Bluetooth is unsupported")
+                self.updateConnectionState(ConnTypes.DISCONNECTED)
 
-        default:
-            Bridge.log("LIVE: Bluetooth state: \(central.state.rawValue)")
+            default:
+                Bridge.log("LIVE: Bluetooth state: \(state.rawValue)")
+            }
         }
     }
 
@@ -602,79 +860,89 @@ extension MentraLive: CBCentralManagerDelegate {
         }
     }
 
-    func centralManager(
+    nonisolated func centralManager(
         _: CBCentralManager, didDiscover peripheral: CBPeripheral,
         advertisementData _: [String: Any], rssi: NSNumber
     ) {
-        handleDiscoveredPeripheral(peripheral, rssi: rssi)
+        DispatchQueue.main.async { [weak self] in
+            self?.handleDiscoveredPeripheral(peripheral, rssi: rssi)
+        }
     }
 
-    func centralManager(_: CBCentralManager, didConnect peripheral: CBPeripheral) {
-        Bridge.log("Connected to GATT server, discovering services...")
+    nonisolated func centralManager(_: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            Bridge.log("Connected to GATT server, discovering services...")
 
-        stopConnectionTimeout()
-        isConnecting = false
-        connectedPeripheral = peripheral
+            self.stopConnectionTimeout()
+            self.isConnecting = false
+            self.connectedPeripheral = peripheral
 
-        // Save device name and address for future reconnection
-        if let name = peripheral.name {
-            UserDefaults.standard.set(name, forKey: PREFS_DEVICE_NAME)
-            Bridge.log("Saved device name for future reconnection: \(name)")
-            DeviceStore.shared.apply("glasses", "bluetoothName", name)
-        }
-        // Persist peripheral UUID so DeviceManager can sync it to RN settings
-        DeviceStore.shared.apply("bluetooth", "device_address", peripheral.identifier.uuidString)
+            // Save device name and address for future reconnection
+            if let name = peripheral.name {
+                UserDefaults.standard.set(name, forKey: PREFS_DEVICE_NAME)
+                Bridge.log("Saved device name for future reconnection: \(name)")
+                DeviceStore.shared.apply("glasses", "bluetoothName", name)
+            }
+            // Persist peripheral UUID so DeviceManager can sync it to RN settings
+            DeviceStore.shared.apply("bluetooth", "device_address", peripheral.identifier.uuidString)
 
-        // Audio Pairing: Setup Bluetooth audio after BLE connection
-        if let deviceName = peripheral.name {
-            Bridge.log("BLE connection established, setting up audio...")
-            // setupAudioPairing(deviceName: deviceName)
-        }
+            // Audio Pairing: Setup Bluetooth audio after BLE connection
+            if let deviceName = peripheral.name {
+                Bridge.log("BLE connection established, setting up audio...")
+                // setupAudioPairing(deviceName: deviceName)
+            }
 
-        // Discover services
-        peripheral.discoverServices([SERVICE_UUID])
+            // Discover services
+            peripheral.discoverServices([SERVICE_UUID])
 
-        // Reset reconnect attempts
-        reconnectAttempts = 0
+            // Reset reconnect attempts
+            self.reconnectAttempts = 0
+        }
     }
 
-    func centralManager(
+    nonisolated func centralManager(
         _: CBCentralManager, didDisconnectPeripheral _: CBPeripheral, error _: Error?
     ) {
-        Bridge.log("LIVE: Disconnected from GATT server")
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            Bridge.log("LIVE: Disconnected from GATT server")
 
-        isConnecting = false
+            self.isConnecting = false
 
-        connectedPeripheral = nil
-        fullyBooted = false
-        connected = false
-        updateConnectionState(ConnTypes.DISCONNECTED)
-        rgbLedAuthorityClaimed = false
+            self.connectedPeripheral = nil
+            self.fullyBooted = false
+            self.connected = false
+            self.updateConnectionState(ConnTypes.DISCONNECTED)
+            self.rgbLedAuthorityClaimed = false
 
-        stopAllTimers()
+            self.stopAllTimers()
 
-        // Clean up characteristics
-        txCharacteristic = nil
-        rxCharacteristic = nil
+            // Clean up characteristics
+            self.txCharacteristic = nil
+            self.rxCharacteristic = nil
 
-        // Attempt reconnection if not killed
-        if !isKilled {
-            handleReconnection()
+            // Attempt reconnection if not killed
+            if !self.isKilled {
+                self.handleReconnection()
+            }
         }
     }
 
-    func centralManager(_: CBCentralManager, didFailToConnect _: CBPeripheral, error: Error?) {
-        Bridge.log(
-            "LIVE: Failed to connect to peripheral: \(error?.localizedDescription ?? "Unknown error")"
-        )
+    nonisolated func centralManager(_: CBCentralManager, didFailToConnect _: CBPeripheral, error: Error?) {
+        let errorDescription = error?.localizedDescription ?? "Unknown error"
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            Bridge.log("LIVE: Failed to connect to peripheral: \(errorDescription)")
 
-        stopConnectionTimeout()
-        isConnecting = false
-        connectedPeripheral = nil
-        updateConnectionState(ConnTypes.DISCONNECTED)
+            self.stopConnectionTimeout()
+            self.isConnecting = false
+            self.connectedPeripheral = nil
+            self.updateConnectionState(ConnTypes.DISCONNECTED)
 
-        if !isKilled {
-            handleReconnection()
+            if !self.isKilled {
+                self.handleReconnection()
+            }
         }
     }
 }
@@ -682,201 +950,228 @@ extension MentraLive: CBCentralManagerDelegate {
 // MARK: - CBPeripheralDelegate
 
 extension MentraLive: CBPeripheralDelegate {
-    func peripheral(_: CBPeripheral, didReadRSSI RSSI: NSNumber, error: Error?) {
-        signalStrengthReadInFlight = false
-        if let error {
-            Bridge.log("LIVE: Error reading RSSI: \(error.localizedDescription)")
-        } else {
-            updateSignalStrength(Int(truncating: RSSI))
+    nonisolated func peripheral(_: CBPeripheral, didReadRSSI RSSI: NSNumber, error: Error?) {
+        let errorDescription = error?.localizedDescription
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.signalStrengthReadInFlight = false
+            if let errorDescription {
+                Bridge.log("LIVE: Error reading RSSI: \(errorDescription)")
+            } else {
+                self.updateSignalStrength(Int(truncating: RSSI))
+            }
         }
     }
 
-    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
-        if let error {
-            Bridge.log("LIVE: Error discovering services: \(error.localizedDescription)")
-            centralManager?.cancelPeripheralConnection(peripheral)
-            return
-        }
+    nonisolated func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        let errorDescription = error?.localizedDescription
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            if let errorDescription {
+                Bridge.log("LIVE: Error discovering services: \(errorDescription)")
+                self.centralManager?.cancelPeripheralConnection(peripheral)
+                return
+            }
 
-        guard let services = peripheral.services else { return }
+            guard let services = peripheral.services else { return }
 
-        for service in services where service.uuid == SERVICE_UUID {
-            Bridge.log("LIVE: Found UART service, discovering characteristics...")
-            peripheral.discoverCharacteristics(
-                [
-                    TX_CHAR_UUID, RX_CHAR_UUID, FILE_READ_UUID, FILE_WRITE_UUID, LC3_READ_UUID,
-                    LC3_WRITE_UUID,
-                ], for: service
-            )
+            for service in services where service.uuid == SERVICE_UUID {
+                Bridge.log("LIVE: Found UART service, discovering characteristics...")
+                peripheral.discoverCharacteristics(
+                    [
+                        TX_CHAR_UUID, RX_CHAR_UUID, FILE_READ_UUID, FILE_WRITE_UUID, LC3_READ_UUID,
+                        LC3_WRITE_UUID,
+                    ], for: service
+                )
+            }
         }
     }
 
-    func peripheral(
+    nonisolated func peripheral(
         _ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?
     ) {
-        if let error {
-            Bridge.log("LIVE: Error discovering characteristics: \(error.localizedDescription)")
-            centralManager?.cancelPeripheralConnection(peripheral)
-            return
-        }
+        let errorDescription = error?.localizedDescription
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            if let errorDescription {
+                Bridge.log("LIVE: Error discovering characteristics: \(errorDescription)")
+                self.centralManager?.cancelPeripheralConnection(peripheral)
+                return
+            }
 
-        guard let characteristics = service.characteristics else { return }
-
-        for characteristic in characteristics {
-            // Log characteristic properties for debugging
-            let props = characteristic.properties
-            let propsStr = [
-                props.contains(.notify) ? "NOTIFY" : nil,
-                props.contains(.indicate) ? "INDICATE" : nil,
-                props.contains(.read) ? "READ" : nil,
-                props.contains(.write) ? "WRITE" : nil,
-                props.contains(.writeWithoutResponse) ? "WRITE_NO_RESPONSE" : nil,
-            ].compactMap { $0 }.joined(separator: " ")
-            Bridge.log("📋 Characteristic \(characteristic.uuid): properties=[\(propsStr)]")
-
-            if characteristic.uuid == TX_CHAR_UUID {
-                txCharacteristic = characteristic
-                Bridge.log("LIVE: ✅ Found TX characteristic")
-            } else if characteristic.uuid == RX_CHAR_UUID {
-                rxCharacteristic = characteristic
-                Bridge.log(
-                    "LIVE: ✅ Found RX characteristic - hasNotify=\(props.contains(.notify)), hasIndicate=\(props.contains(.indicate))"
-                )
-            } else if characteristic.uuid == FILE_READ_UUID {
-                fileReadCharacteristic = characteristic
-                Bridge.log("LIVE: 📁 Found FILE_READ characteristic (72FF)!")
-            } else if characteristic.uuid == FILE_WRITE_UUID {
-                fileWriteCharacteristic = characteristic
-                Bridge.log("LIVE: 📁 Found FILE_WRITE characteristic (73FF)!")
-            } else if characteristic.uuid == LC3_READ_UUID {
-                lc3ReadCharacteristic = characteristic
-                Bridge.log("LIVE: 🎤 Found LC3_READ characteristic (audio input)!")
-            } else if characteristic.uuid == LC3_WRITE_UUID {
-                lc3WriteCharacteristic = characteristic
-                Bridge.log("LIVE: 🎤 Found LC3_WRITE characteristic (audio output)!")
+            guard let characteristics = service.characteristics else { return }
+
+            for characteristic in characteristics {
+                // Log characteristic properties for debugging
+                let props = characteristic.properties
+                let propsStr = [
+                    props.contains(.notify) ? "NOTIFY" : nil,
+                    props.contains(.indicate) ? "INDICATE" : nil,
+                    props.contains(.read) ? "READ" : nil,
+                    props.contains(.write) ? "WRITE" : nil,
+                    props.contains(.writeWithoutResponse) ? "WRITE_NO_RESPONSE" : nil,
+                ].compactMap { $0 }.joined(separator: " ")
+                Bridge.log("📋 Characteristic \(characteristic.uuid): properties=[\(propsStr)]")
+
+                if characteristic.uuid == TX_CHAR_UUID {
+                    self.txCharacteristic = characteristic
+                    Bridge.log("LIVE: ✅ Found TX characteristic")
+                } else if characteristic.uuid == RX_CHAR_UUID {
+                    self.rxCharacteristic = characteristic
+                    Bridge.log(
+                        "LIVE: ✅ Found RX characteristic - hasNotify=\(props.contains(.notify)), hasIndicate=\(props.contains(.indicate))"
+                    )
+                } else if characteristic.uuid == FILE_READ_UUID {
+                    self.fileReadCharacteristic = characteristic
+                    Bridge.log("LIVE: 📁 Found FILE_READ characteristic (72FF)!")
+                } else if characteristic.uuid == FILE_WRITE_UUID {
+                    self.fileWriteCharacteristic = characteristic
+                    Bridge.log("LIVE: 📁 Found FILE_WRITE characteristic (73FF)!")
+                } else if characteristic.uuid == LC3_READ_UUID {
+                    self.lc3ReadCharacteristic = characteristic
+                    Bridge.log("LIVE: 🎤 Found LC3_READ characteristic (audio input)!")
+                } else if characteristic.uuid == LC3_WRITE_UUID {
+                    self.lc3WriteCharacteristic = characteristic
+                    Bridge.log("LIVE: 🎤 Found LC3_WRITE characteristic (audio output)!")
+                }
             }
-        }
 
-        // Check if we have both characteristics
-        if let tx = txCharacteristic, let rx = rxCharacteristic {
-            Bridge.log("LIVE: ✅ Both TX and RX characteristics found - BLE connection ready")
-            Bridge.log("LIVE: 🔄 Waiting for glasses SOC to become ready...")
+            // Check if we have both characteristics
+            if self.txCharacteristic != nil, let rx = self.rxCharacteristic {
+                Bridge.log("LIVE: ✅ Both TX and RX characteristics found - BLE connection ready")
+                Bridge.log("LIVE: 🔄 Waiting for glasses SOC to become ready...")
 
-            // Don't set connected=true here - wait for SOC to be ready (fullyBooted=true)
-            // DeviceStore handles connected state based on fullyBooted
+                // Don't set connected=true here - wait for SOC to be ready (fullyBooted=true)
+                // DeviceStore handles connected state based on fullyBooted
 
-            // Keep state as connecting until glasses are ready
-            updateConnectionState(ConnTypes.CONNECTING)
+                // Keep state as connecting until glasses are ready
+                self.updateConnectionState(ConnTypes.CONNECTING)
 
-            let withResponseMtu = peripheral.maximumWriteValueLength(for: .withResponse) + 3
-            let withoutResponseMtu = peripheral.maximumWriteValueLength(for: .withoutResponse) + 3
-            currentMtu = max(23, min(withResponseMtu, withoutResponseMtu))
-            Bridge.log(
-                "LIVE: Current MTU estimate: withResponse=\(withResponseMtu), withoutResponse=\(withoutResponseMtu), selected=\(currentMtu)"
-            )
+                let withResponseMtu = peripheral.maximumWriteValueLength(for: .withResponse) + 3
+                let withoutResponseMtu = peripheral.maximumWriteValueLength(for: .withoutResponse) + 3
+                self.currentMtu = max(23, min(withResponseMtu, withoutResponseMtu))
+                Bridge.log(
+                    "LIVE: Current MTU estimate: withResponse=\(withResponseMtu), withoutResponse=\(withoutResponseMtu), selected=\(self.currentMtu)"
+                )
 
-            // Enable notifications on RX characteristic
-            peripheral.setNotifyValue(true, for: rx)
+                // Enable notifications on RX characteristic
+                peripheral.setNotifyValue(true, for: rx)
 
-            // Enable notifications on file characteristics if available
-            if let fileRead = fileReadCharacteristic {
-                peripheral.setNotifyValue(true, for: fileRead)
-            }
+                // Enable notifications on file characteristics if available
+                if let fileRead = self.fileReadCharacteristic {
+                    peripheral.setNotifyValue(true, for: fileRead)
+                }
 
-            // Enable notifications on LC3 audio characteristic if device supports it
-            if supportsLC3Audio, let lc3Read = lc3ReadCharacteristic {
-                peripheral.setNotifyValue(true, for: lc3Read)
-                Bridge.log("LIVE: 🎤 Enabled LC3 audio notifications")
-            }
+                // Enable notifications on LC3 audio characteristic if device supports it
+                if self.supportsLC3Audio, let lc3Read = self.lc3ReadCharacteristic {
+                    peripheral.setNotifyValue(true, for: lc3Read)
+                    Bridge.log("LIVE: 🎤 Enabled LC3 audio notifications")
+                }
 
-            // Start readiness check loop
-            startSignalStrengthPolling()
-            startReadinessCheckLoop()
-        } else {
-            Bridge.log("LIVE: Required BLE characteristics not found")
-            if txCharacteristic == nil {
-                Bridge.log("LIVE: TX characteristic not found")
-            }
-            if rxCharacteristic == nil {
-                Bridge.log("LIVE: RX characteristic not found")
+                // Start readiness check loop
+                self.startSignalStrengthPolling()
+                self.startReadinessCheckLoop()
+            } else {
+                Bridge.log("LIVE: Required BLE characteristics not found")
+                if self.txCharacteristic == nil {
+                    Bridge.log("LIVE: TX characteristic not found")
+                }
+                if self.rxCharacteristic == nil {
+                    Bridge.log("LIVE: RX characteristic not found")
+                }
+                self.centralManager?.cancelPeripheralConnection(peripheral)
             }
-            centralManager?.cancelPeripheralConnection(peripheral)
         }
     }
 
-    func peripheral(
+    nonisolated func peripheral(
         _: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?
     ) {
-        // Bridge.log("LIVE: DEBUG: didUpdateValueFor CALLED - characteristic: \(characteristic.uuid), dataSize: \(characteristic.value?.count ?? 0)")
-        // Log raw hex for debugging glasses_ready issue
-        if let data = characteristic.value {
-            let hexString = data.prefix(50).map { String(format: "%02X ", $0) }.joined()
-            // Bridge.log("LIVE: DEBUG: RAW HEX (first 50): \(hexString)")
-        }
-        if let error {
-            Bridge.log(
-                "LIVE: Error updating value for characteristic: \(error.localizedDescription)"
-            )
-            return
-        }
+        let uuid = characteristic.uuid
+        let data = characteristic.value
+        let errorDescription = error?.localizedDescription
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            // Bridge.log("LIVE: DEBUG: didUpdateValueFor CALLED - characteristic: \(uuid), dataSize: \(data?.count ?? 0)")
+            // Log raw hex for debugging glasses_ready issue
+            if let data {
+                let hexString = data.prefix(50).map { String(format: "%02X ", $0) }.joined()
+                _ = hexString
+                // Bridge.log("LIVE: DEBUG: RAW HEX (first 50): \(hexString)")
+            }
+            if let errorDescription {
+                Bridge.log("LIVE: Error updating value for characteristic: \(errorDescription)")
+                return
+            }
 
-        guard let data = characteristic.value else {
-            Bridge.log("LIVE: Characteristic value is nil")
-            return
-        }
+            guard let data else {
+                Bridge.log("LIVE: Characteristic value is nil")
+                return
+            }
 
-        let threadId = Thread.current.hash
-        let uuid = characteristic.uuid
+            let threadId = Thread.current.hash
+            _ = threadId
 
-        // Bridge.log("Thread-\(threadId): 🎉 didUpdateValueFor CALLBACK TRIGGERED! Characteristic: \(uuid)")
-        // if uuid == RX_CHAR_UUID {
-        //   Bridge.log("Thread-\(threadId): 🎯 RECEIVED DATA ON RX CHARACTERISTIC (Peripheral's TX)")
-        // } else if uuid == TX_CHAR_UUID {
-        //   Bridge.log("Thread-\(threadId): 🎯 RECEIVED DATA ON TX CHARACTERISTIC (Peripheral's RX)")
-        // }
-        // Bridge.log("Thread-\(threadId): 🔍 Processing received data - \(data.count) bytes")
+            // Bridge.log("Thread-\(threadId): 🎉 didUpdateValueFor CALLBACK TRIGGERED! Characteristic: \(uuid)")
+            // if uuid == RX_CHAR_UUID {
+            //   Bridge.log("Thread-\(threadId): 🎯 RECEIVED DATA ON RX CHARACTERISTIC (Peripheral's TX)")
+            // } else if uuid == TX_CHAR_UUID {
+            //   Bridge.log("Thread-\(threadId): 🎯 RECEIVED DATA ON TX CHARACTERISTIC (Peripheral's RX)")
+            // }
+            // Bridge.log("Thread-\(threadId): 🔍 Processing received data - \(data.count) bytes")
 
-        // Handle LC3 audio data separately (dedicated characteristic for LC3-capable devices)
-        if uuid == LC3_READ_UUID && supportsLC3Audio {
-            // Bridge.log("LIVE: Received data on LC3_READ characteristic (audio input)")
-            processLc3AudioPacket(data)
-            return
-        }
+            // Handle LC3 audio data separately (dedicated characteristic for LC3-capable devices)
+            if uuid == LC3_READ_UUID && self.supportsLC3Audio {
+                // Bridge.log("LIVE: Received data on LC3_READ characteristic (audio input)")
+                self.processLc3AudioPacket(data)
+                return
+            }
 
-        // Handle regular data (JSON messages, file transfers, etc.)
-        processReceivedData(data)
+            // Handle regular data (JSON messages, file transfers, etc.)
+            self.processReceivedData(data)
+        }
     }
 
-    func peripheral(_: CBPeripheral, didWriteValueFor _: CBCharacteristic, error: Error?) {
-        if let error {
-            Bridge.log("LIVE: Error writing characteristic: \(error.localizedDescription)")
-        } else {
-            Bridge.log("LIVE: Characteristic write successful")
+    nonisolated func peripheral(_: CBPeripheral, didWriteValueFor _: CBCharacteristic, error: Error?) {
+        let errorDescription = error?.localizedDescription
+        DispatchQueue.main.async {
+            if let errorDescription {
+                Bridge.log("LIVE: Error writing characteristic: \(errorDescription)")
+            } else {
+                Bridge.log("LIVE: Characteristic write successful")
+            }
         }
     }
 
-    func peripheral(
+    nonisolated func peripheral(
         _: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic,
         error: Error?
     ) {
-        if let error {
-            Bridge.log("LIVE: Error updating notification state: \(error.localizedDescription)")
-        } else {
-            Bridge.log(
-                "Notification state updated for \(characteristic.uuid): \(characteristic.isNotifying ? "ON" : "OFF")"
-            )
+        let uuid = characteristic.uuid
+        let isNotifying = characteristic.isNotifying
+        let errorDescription = error?.localizedDescription
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            if let errorDescription {
+                Bridge.log("LIVE: Error updating notification state: \(errorDescription)")
+            } else {
+                Bridge.log("Notification state updated for \(uuid): \(isNotifying ? "ON" : "OFF")")
 
-            if characteristic.uuid == RX_CHAR_UUID, characteristic.isNotifying {
-                Bridge.log("LIVE: 🔔 Ready to receive data via notifications")
+                if uuid == self.RX_CHAR_UUID, isNotifying {
+                    Bridge.log("LIVE: 🔔 Ready to receive data via notifications")
+                }
             }
         }
     }
 
-    func peripheralDidUpdateRSSI(_ peripheral: CBPeripheral, error: Error?) {
-        if let error {
-            Bridge.log("LIVE: Error reading RSSI: \(error.localizedDescription)")
-        } else {
-            Bridge.log("LIVE: RSSI: \(peripheral.readRSSI())")
+    nonisolated func peripheralDidUpdateRSSI(_ peripheral: CBPeripheral, error: Error?) {
+        let errorDescription = error?.localizedDescription
+        DispatchQueue.main.async {
+            if let errorDescription {
+                Bridge.log("LIVE: Error reading RSSI: \(errorDescription)")
+            } else {
+                Bridge.log("LIVE: RSSI: \(peripheral.readRSSI())")
+            }
         }
     }
 }
@@ -918,6 +1213,7 @@ class MentraLive: NSObject, SGCManager {
         // a previous pairing into the next one (would otherwise surface as wrong overall_percent
         // or stale lastBesOtaProgress on the next OTA).
         if state == ConnTypes.DISCONNECTED {
+            incomingChunkReassembler.clear()
             stopSignalStrengthPolling()
             DeviceStore.shared.apply("glasses", "signalStrength", -1)
             DeviceStore.shared.apply("glasses", "signalStrengthUpdatedAt", 0)
@@ -929,7 +1225,7 @@ class MentraLive: NSObject, SGCManager {
     func setSilentMode(_: Bool) {}
     func exit() {}
     func showDashboard() {}
-    func displayBitmap(base64ImageData _: String) async -> Bool {
+    func displayBitmap(base64ImageData _: String, x _: Int32? = nil, y _: Int32? = nil, width _: Int32? = nil, height _: Int32? = nil) async -> Bool {
         return true
     }
 
@@ -1317,10 +1613,10 @@ class MentraLive: NSObject, SGCManager {
 
     func requestPhoto(
         _ requestId: String, appId: String, size: String?, webhookUrl: String?, authToken: String?,
-        compress: String?, flash: Bool, sound: Bool, exposureTimeNs: Double?, iso: Int?
+        compress: String?, flash: Bool, save: Bool, sound: Bool, exposureTimeNs: Double?, iso: Int?
     ) {
         Bridge.log(
-            "LIVE: PHOTO PIPELINE [5/6] requestPhoto() entry requestId=\(requestId) appId=\(appId) flash=\(flash) sound=\(sound) iso=\(iso.map { String($0) } ?? "auto")"
+            "LIVE: PHOTO PIPELINE [5/6] requestPhoto() entry requestId=\(requestId) appId=\(appId) flash=\(flash) save=\(save) sound=\(sound) iso=\(iso.map { String($0) } ?? "auto")"
         )
 
         var json: [String: Any] = [
@@ -1366,6 +1662,7 @@ class MentraLive: NSObject, SGCManager {
         json["compress"] = compress ?? "none"
 
         json["flash"] = flash
+        json["save"] = save
         json["sound"] = sound
 
         if let e = exposureTimeNs, e.isFinite, e > 0, e <= Double(Int64.max) {
@@ -1838,7 +2135,8 @@ class MentraLive: NSObject, SGCManager {
             updateBatteryStatus(level: level, isCharging: isCharging)
 
         case "voice_activity_detection_status":
-            let enabled = json["voiceActivityDetectionEnabled"] as? Bool ?? true
+            let enabled = json["voiceActivityDetectionEnabled"] as? Bool
+                ?? BluetoothSdkDefaults.voiceActivityDetectionEnabled
             handleVoiceActivityDetectionStatus(enabled: enabled)
 
         case "speaking_status":
@@ -1870,21 +2168,34 @@ class MentraLive: NSObject, SGCManager {
         case "stream_status":
             emitRtmpStreamStatus(json)
 
+        case "video_recording_status":
+            emitVideoRecordingStatus(json)
+
         case "photo_status":
             emitPhotoStatus(json)
 
+        case "photo_response":
+            emitPhotoResponse(json)
+
         case "gallery_status":
             let photoCount = json["photos"] as? Int ?? 0
             let videoCount = json["videos"] as? Int ?? 0
             let totalCount = json["total"] as? Int ?? 0
             let totalSize = json["total_size"] as? Int64 ?? 0
             let hasContent = json["has_content"] as? Bool ?? false
+            let cameraBusy = Self.galleryCameraBusy(json)
+            let cameraBusyReason = Self.galleryCameraBusyReason(json)
             handleGalleryStatus(
                 photoCount: photoCount, videoCount: videoCount,
                 totalCount: totalCount, totalSize: totalSize,
-                hasContent: hasContent
+                hasContent: hasContent,
+                cameraBusy: cameraBusy,
+                cameraBusyReason: cameraBusyReason
             )
 
+        case "settings_ack":
+            emitSettingsAck(json)
+
         case "button_press":
             handleButtonPress(json)
 
@@ -2035,6 +2346,7 @@ class MentraLive: NSObject, SGCManager {
 
             Bridge.log("LIVE: 📱 OTA status - step \(osCurrentStep)/\(osTotalSteps) \(osPhase) \(osStatus) \(osOverallPercent)%")
 
+            let glassesTimeMs = (json["glasses_time_ms"] as? NSNumber)?.int64Value ?? 0
             Bridge.sendOtaStatus(
                 sessionId: osSessionId,
                 totalSteps: osTotalSteps,
@@ -2044,7 +2356,8 @@ class MentraLive: NSObject, SGCManager {
                 stepPercent: osStepPercent,
                 overallPercent: osOverallPercent,
                 status: osStatus,
-                errorMessage: osErrorMessage
+                errorMessage: osErrorMessage,
+                glassesTimeMs: glassesTimeMs > 0 ? glassesTimeMs : nil
             )
 
         case "ota_progress":
@@ -2125,12 +2438,11 @@ class MentraLive: NSObject, SGCManager {
                 if let bluetoothMacAddress = fields["bt_mac_address"] as? String {
                     DeviceStore.shared.apply("glasses", "bluetoothMacAddress", bluetoothMacAddress)
                 }
+                if let systemTimeMs = fields["system_time_ms"] as? NSNumber {
+                    DeviceStore.shared.apply("glasses", "systemTimeMs", systemTimeMs.int64Value)
+                }
 
-                // Send fields immediately to RN - no waiting for other chunks
-                // All fields including mtk_fw_version are forwarded to RN
-                // Bridge.sendTypedMessage("version_info", body: fields)
-
-                // Bridge.log("LIVE: Processed version_info fields and sent to RN")
+                Bridge.sendVersionInfo(fields)
             } else {
                 Bridge.log("Unhandled message type: \(type)")
             }
@@ -2461,6 +2773,17 @@ class MentraLive: NSObject, SGCManager {
         sendJson(json, wakeUp: true)
     }
 
+    func sendSetSystemTime(_ timestampMs: Int64) {
+        Bridge.log("LIVE: ⏰ Sending set_system_time: \(timestampMs)")
+
+        let json: [String: Any] = [
+            "type": "set_system_time",
+            "timestamp_ms": timestampMs,
+        ]
+
+        sendJson(json, wakeUp: true)
+    }
+
     func sendUserEmailToGlasses(_ email: String) {
         Bridge.log("LIVE: Sending user email to glasses for crash reporting")
 
@@ -2536,13 +2859,20 @@ class MentraLive: NSObject, SGCManager {
 
     func sendGalleryMode() {
         let active = DeviceStore.shared.get("bluetooth", "gallery_mode") as! Bool
+        sendGalleryMode(requestId: nil, active: active)
+    }
+
+    func sendGalleryMode(requestId: String?, active: Bool) {
         Bridge.log("LIVE: 📸 Sending gallery mode active to glasses: \(active)")
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "save_in_gallery_mode",
             "active": active,
             "timestamp": Int(Date().timeIntervalSince1970 * 1000),
         ]
+        if let requestId, !requestId.isEmpty {
+            json["request_id"] = requestId
+        }
 
         sendJson(json, wakeUp: true)
     }
@@ -2572,6 +2902,17 @@ class MentraLive: NSObject, SGCManager {
         sendJson(json, wakeUp: true)
     }
 
+    func sendOtaRetryVersionCheck() {
+        Bridge.log("LIVE: ⏰ Sending ota_retry_version_check command to glasses")
+
+        let json: [String: Any] = [
+            "type": "ota_retry_version_check",
+            "timestamp": Int(Date().timeIntervalSince1970 * 1000),
+        ]
+
+        sendJson(json, wakeUp: true)
+    }
+
     func keepAwake() {
         Bridge.log("LIVE: 📱 Sending keep_awake command to glasses")
 
@@ -2644,7 +2985,8 @@ class MentraLive: NSObject, SGCManager {
             networks = networksNeoArray
         }
 
-        Bridge.updateWifiScanResults(networks)
+        let scanComplete = json["scan_complete"] as? Bool ?? json["scanComplete"] as? Bool ?? false
+        Bridge.updateWifiScanResults(networks, scanComplete: scanComplete)
     }
 
     private func handleButtonPress(_ json: [String: Any]) {
@@ -3226,7 +3568,53 @@ class MentraLive: NSObject, SGCManager {
         BlePhotoUploadService.processAndUploadPhoto(
             imageData: imageData, requestId: transfer.requestId, webhookUrl: transfer.webhookUrl,
             authToken: transfer.authToken
-        )
+        ) { [weak self] requestId, responseBody in
+            self?.sendPhotoTerminalSuccessResponse(
+                requestId: requestId,
+                uploadUrl: transfer.webhookUrl,
+                responseBody: responseBody
+            )
+        } onError: { requestId, error in
+            Bridge.sendPhotoError(
+                requestId: requestId,
+                errorCode: "PHONE_UPLOAD_FAILED",
+                errorMessage: "BLE photo upload failed: \(error)"
+            )
+        }
+    }
+
+    private func sendPhotoTerminalSuccessResponse(
+        requestId: String,
+        uploadUrl: String,
+        responseBody: String
+    ) {
+        var event: [String: Any] = [
+            "type": "photo_response",
+            "state": "success",
+            "success": true,
+            "requestId": requestId,
+            "uploadUrl": uploadUrl,
+            "timestamp": Int(Date().timeIntervalSince1970 * 1000),
+        ]
+        copyPhotoUploadResponseMetadata(into: &event, responseBody: responseBody)
+        Bridge.sendPhotoResponse(event)
+    }
+
+    private func copyPhotoUploadResponseMetadata(
+        into event: inout [String: Any],
+        responseBody: String
+    ) {
+        guard !responseBody.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+            let data = responseBody.data(using: .utf8),
+            let response = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return
+        }
+        for key in ["photoUrl", "statusUrl", "mimeType", "contentType", "bytes", "size"] {
+            if let value = response[key], !(value is NSNull) {
+                event[key] = value
+            }
+        }
     }
 
     private func sendAckToGlasses(messageId: Int) {
@@ -3305,8 +3693,12 @@ class MentraLive: NSObject, SGCManager {
 
                     // Create chunks
                     let chunks = MessageChunker.createChunks(
-                        originalJson: jsonString, messageId: messageId
+                        originalJson: jsonString, messageId: messageId, wakeUp: wakeUp
                     )
+                    guard !chunks.isEmpty else {
+                        Bridge.log("LIVE: Failed to create BLE chunks within K900 packet limit")
+                        return
+                    }
                     Bridge.log("LIVE: Sending \(chunks.count) chunks")
 
                     // Send each chunk
@@ -3661,24 +4053,55 @@ class MentraLive: NSObject, SGCManager {
 
     private func handleGalleryStatus(
         photoCount: Int, videoCount: Int, totalCount: Int,
-        totalSize: Int64, hasContent: Bool
+        totalSize: Int64, hasContent: Bool, cameraBusy: Bool,
+        cameraBusyReason: String?
     ) {
         Bridge.log(
             "LIVE: 📸 Received gallery status - photos: \(photoCount), videos: \(videoCount), total size: \(totalSize) bytes"
         )
 
         // Emit gallery status event like other status events
-        let eventBody =
+        var eventBody =
             [
+                "type": "gallery_status",
                 "photos": photoCount,
                 "videos": videoCount,
                 "total": totalCount,
                 "totalSize": totalSize,
                 "hasContent": hasContent,
+                "cameraBusy": cameraBusy,
             ] as [String: Any]
+        if let cameraBusyReason, !cameraBusyReason.isEmpty {
+            eventBody["cameraBusyReason"] = cameraBusyReason
+        }
         Bridge.sendTypedMessage("gallery_status", body: eventBody)
     }
 
+    private static func galleryCameraBusy(_ json: [String: Any]) -> Bool {
+        if let busy = json["cameraBusy"] as? Bool {
+            return busy
+        }
+        if let busy = json["camera_busy"] as? Bool {
+            return busy
+        }
+        if let reason = json["camera_busy"] as? String {
+            let normalized = reason.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+            return !normalized.isEmpty && normalized != "false"
+        }
+        return false
+    }
+
+    private static func galleryCameraBusyReason(_ json: [String: Any]) -> String? {
+        if let reason = json["cameraBusyReason"] as? String, !reason.isEmpty {
+            return reason
+        }
+        if let reason = json["camera_busy"] as? String {
+            let normalized = reason.trimmingCharacters(in: .whitespacesAndNewlines)
+            return normalized.isEmpty || normalized.lowercased() == "false" ? nil : normalized
+        }
+        return nil
+    }
+
     // MARK: - Timers
 
     private func startHeartbeat() {
@@ -3921,6 +4344,10 @@ class MentraLive: NSObject, SGCManager {
         Bridge.sendPhotoStatus(json)
     }
 
+    private func emitPhotoResponse(_ json: [String: Any]) {
+        Bridge.sendPhotoResponse(json)
+    }
+
     private func emitButtonPress(buttonId: String, pressType: String, timestamp: Int64) {
         let eventBody: [String: Any] = [
             "device_model": "Mentra Live",
@@ -3946,7 +4373,7 @@ class MentraLive: NSObject, SGCManager {
             "bt_mac_address": bluetoothMacAddress,
         ]
 
-        Bridge.sendTypedMessage("version_info", body: eventBody)
+        Bridge.sendVersionInfo(eventBody)
     }
 
     private func emitKeepAliveAck(_ json: [String: Any]) {
@@ -3972,6 +4399,7 @@ class MentraLive: NSObject, SGCManager {
 
         // Stop all timers
         stopAllTimers()
+        incomingChunkReassembler.clear()
 
         // Disconnect BLE
         if let peripheral = connectedPeripheral {
@@ -4544,6 +4972,50 @@ extension MentraLive {
         return Int64(Date().timeIntervalSince1970 * 1000)
     }
 
+    private func emitSettingsAck(_ json: [String: Any]) {
+        var body = json
+        if let requestId = body["request_id"], body["requestId"] == nil {
+            body["requestId"] = requestId
+        }
+        if let roiPosition = body["roi_position"], body["roiPosition"] == nil {
+            body["roiPosition"] = roiPosition
+        }
+        if let errorCode = body["error_code"], body["errorCode"] == nil {
+            body["errorCode"] = errorCode
+        }
+        if let errorMessage = body["error_message"], body["errorMessage"] == nil {
+            body["errorMessage"] = errorMessage
+        }
+        if let hardwareApplied = body["hardware_applied"], body["hardwareApplied"] == nil {
+            body["hardwareApplied"] = hardwareApplied
+        }
+        body.removeValue(forKey: "request_id")
+        body.removeValue(forKey: "roi_position")
+        body.removeValue(forKey: "error_code")
+        body.removeValue(forKey: "error_message")
+        body.removeValue(forKey: "hardware_applied")
+        if body["timestamp"] == nil {
+            body["timestamp"] = Int64(Date().timeIntervalSince1970 * 1000)
+        }
+        Bridge.sendSettingsAck(body)
+    }
+
+    private func emitVideoRecordingStatus(_ json: [String: Any]) {
+        var body = json
+        if let requestId = body["request_id"], body["requestId"] == nil {
+            body["requestId"] = requestId
+        }
+        if let details = body["error_details"], body["details"] == nil {
+            body["details"] = details
+        }
+        body.removeValue(forKey: "request_id")
+        body.removeValue(forKey: "error_details")
+        if body["timestamp"] == nil {
+            body["timestamp"] = Int64(Date().timeIntervalSince1970 * 1000)
+        }
+        Bridge.sendVideoRecordingStatus(body)
+    }
+
     /**
      * Check if a JSON string is already properly formatted for K900 protocol
      */
@@ -4624,7 +5096,8 @@ extension MentraLive {
     }
 
     func sendVoiceActivityDetectionSetting() {
-        let enabled = DeviceStore.shared.get("bluetooth", "voice_activity_detection_enabled") as? Bool ?? true
+        let enabled = DeviceStore.shared.get("bluetooth", "voice_activity_detection_enabled") as? Bool
+            ?? BluetoothSdkDefaults.voiceActivityDetectionEnabled
         Bridge.log("LIVE: 🎤 Sending Voice Activity Detection setting to glasses: \(enabled)")
 
         guard connectedPeripheral != nil, txCharacteristic != nil else {
@@ -4672,28 +5145,37 @@ extension MentraLive {
         let finalHeight = height > 0 ? height : 720
         let finalFps = fps > 0 ? fps : 30
 
-        Bridge.log(
-            "Sending button video recording settings: \(finalWidth)x\(finalHeight)@\(finalFps)fps"
-        )
+        sendButtonVideoRecordingSettings(requestId: nil, width: finalWidth, height: finalHeight, fps: finalFps)
+    }
+
+    func sendButtonVideoRecordingSettings(requestId: String?, width: Int, height: Int, fps: Int) {
+        Bridge.log("Sending button video recording settings: \(width)x\(height)@\(fps)fps")
 
         guard connectionState == ConnTypes.CONNECTED else {
             Bridge.log("Cannot send button video recording settings - not connected")
             return
         }
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "button_video_recording_setting",
             "params": [
-                "width": finalWidth,
-                "height": finalHeight,
-                "fps": finalFps,
+                "width": width,
+                "height": height,
+                "fps": fps,
             ],
         ]
+        if let requestId, !requestId.isEmpty {
+            json["request_id"] = requestId
+        }
         sendJson(json, wakeUp: true)
     }
 
     func sendButtonMaxRecordingTime() {
         let maxTime = DeviceStore.shared.get("bluetooth", "button_max_recording_time") as? Int ?? 10
+        sendButtonMaxRecordingTime(requestId: nil, minutes: maxTime)
+    }
+
+    func sendButtonMaxRecordingTime(requestId: String?, minutes maxTime: Int) {
         Bridge.log("Sending button max recording time: \(maxTime) minutes")
 
         guard connectionState == ConnTypes.CONNECTED else {
@@ -4701,16 +5183,22 @@ extension MentraLive {
             return
         }
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "button_max_recording_time",
             "minutes": maxTime,
         ]
+        if let requestId, !requestId.isEmpty {
+            json["request_id"] = requestId
+        }
         sendJson(json, wakeUp: true)
     }
 
     func sendButtonPhotoSettings() {
         let size = DeviceStore.shared.get("bluetooth", "button_photo_size") as! String
+        sendButtonPhotoSettings(requestId: nil, size: size)
+    }
 
+    func sendButtonPhotoSettings(requestId: String?, size: String) {
         Bridge.log("Sending button photo setting: \(size)")
 
         guard connectionState == ConnTypes.CONNECTED else {
@@ -4718,16 +5206,22 @@ extension MentraLive {
             return
         }
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "button_photo_setting",
             "size": size,
         ]
+        if let requestId, !requestId.isEmpty {
+            json["request_id"] = requestId
+        }
         sendJson(json, wakeUp: true)
     }
 
     func sendButtonCameraLedSetting() {
         let enabled = DeviceStore.shared.get("bluetooth", "button_camera_led") as! Bool
+        sendButtonCameraLedSetting(requestId: nil, enabled: enabled)
+    }
 
+    func sendButtonCameraLedSetting(requestId: String?, enabled: Bool) {
         Bridge.log("Sending button camera LED setting: \(enabled)")
 
         guard connectionState == ConnTypes.CONNECTED else {
@@ -4735,10 +5229,13 @@ extension MentraLive {
             return
         }
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "button_camera_led",
             "enabled": enabled,
         ]
+        if let requestId, !requestId.isEmpty {
+            json["request_id"] = requestId
+        }
         sendJson(json, wakeUp: true)
     }
 
@@ -4746,7 +5243,10 @@ extension MentraLive {
         let settings = DeviceStore.shared.get("bluetooth", "camera_fov") as? [String: Any] ?? ["fov": 118, "roi_position": 0]
         let fov = settings["fov"] as? Int ?? 118
         let roiPosition = settings["roi_position"] as? Int ?? 0
+        sendCameraFovSetting(requestId: nil, fov: fov, roiPosition: roiPosition)
+    }
 
+    func sendCameraFovSetting(requestId: String?, fov: Int, roiPosition: Int) {
         Bridge.log("Sending camera FOV setting: fov=\(fov), roiPosition=\(roiPosition)")
 
         guard connectionState == ConnTypes.CONNECTED else {
@@ -4754,13 +5254,16 @@ extension MentraLive {
             return
         }
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "camera_fov_setting",
             "params": [
                 "fov": fov,
                 "roi_position": roiPosition,
             ],
         ]
+        if let requestId, !requestId.isEmpty {
+            json["request_id"] = requestId
+        }
         sendJson(json, wakeUp: true)
     }
 
@@ -4773,20 +5276,7 @@ extension MentraLive {
     // MARK: - SGCManager Protocol Compliance
 
     func sendButtonMaxRecordingTime(_ minutes: Int) {
-        let maxTime = minutes
-
-        Bridge.log("Sending button max recording time: \(maxTime) minutes")
-
-        guard connectionState == ConnTypes.CONNECTED else {
-            Bridge.log("Cannot send button max recording time - not connected")
-            return
-        }
-
-        let json: [String: Any] = [
-            "type": "button_max_recording_time",
-            "minutes": maxTime,
-        ]
-        sendJson(json, wakeUp: true)
+        sendButtonMaxRecordingTime(requestId: nil, minutes: minutes)
     }
 
     func startVideoRecording(
@@ -4809,13 +5299,16 @@ extension MentraLive {
             "sound": sound,
         ]
 
-        // Add video settings if provided
-        if width > 0, height > 0 {
-            json["settings"] = [
-                "width": width,
-                "height": height,
-                "fps": fps > 0 ? fps : 30,
-            ]
+        // Add video settings when any field is overridden. Each field is sent
+        // only when > 0; the glasses merge the missing fields onto their saved
+        // button-video defaults, so a partial override (e.g. fps-only) still
+        // takes effect instead of being dropped here.
+        if width > 0 || height > 0 || fps > 0 {
+            var settings: [String: Any] = [:]
+            if width > 0 { settings["width"] = width }
+            if height > 0 { settings["height"] = height }
+            if fps > 0 { settings["fps"] = fps }
+            json["settings"] = settings
         }
         sendJson(json)
     }