@mentra/bluetooth-sdk 0.1.10 → 0.1.12

package/ios/BluetoothSdkModule.swift

@@ -18,6 +18,9 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             "glasses_not_ready",
             "button_press",
             "touch_event",
+            "accel_event",
+            "CompassHeadingEvent",
+            "CompassCalibrationEvent",
             "head_up",
             "voice_activity_detection_status",
             "speaking_status",
@@ -29,6 +32,8 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             "photo_response",
             "photo_status",
             "video_recording_status",
+            "media_success",
+            "media_error",
             "gallery_status",
             "compatible_glasses_search_stop",
             "heartbeat_sent",
@@ -453,9 +458,9 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
 
         AsyncFunction("startVideoRecording") {
             (requestId: String, save: Bool, sound: Bool, settings: [String: Any]?) in
-            // Optional per-recording {width,height,fps}. Absent fields stay 0, which
-            // the glasses treat as "use the saved button-video default". JS numbers
-            // arrive as Double across the bridge, so coerce to Int.
+            /// Optional per-recording {width,height,fps}. Absent fields stay 0, which
+            /// the glasses treat as "use the saved button-video default". JS numbers
+            /// arrive as Double across the bridge, so coerce to Int.
             func dim(_ key: String) -> Int {
                 (settings?[key] as? NSNumber)?.intValue ?? 0
             }
@@ -463,14 +468,20 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             return try await sdk.startVideoRecording(
                 VideoRecordingRequest(
                     requestId: requestId, save: save, sound: sound,
-                    width: dim("width"), height: dim("height"), fps: dim("fps")
+                    width: dim("width"), height: dim("height"), fps: dim("fps"),
+                    maxRecordingTimeMinutes: dim("maxRecordingTimeMinutes")
                 )
             ).values
         }
 
-        AsyncFunction("stopVideoRecording") { (requestId: String) in
+        // webhookUrl/authToken are supplied at stop (not start) so the token is
+        // fresh when the upload runs. Empty/nil webhook = keep on device.
+        AsyncFunction("stopVideoRecording") {
+            (requestId: String, webhookUrl: String?, authToken: String?) in
             let sdk = await MainActor.run { self.bluetoothSdk() }
-            return try await sdk.stopVideoRecording(requestId: requestId).values
+            return try await sdk.stopVideoRecording(
+                requestId: requestId, webhookUrl: webhookUrl, authToken: authToken
+            ).values
         }
 
         // MARK: - Stream Commands
@@ -621,7 +632,11 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             return sdk
         }
 
-        let sdk = MentraBluetoothSDK()
+        let sdk = MentraBluetoothSDK(
+            configuration: MentraBluetoothSDKConfiguration(
+                analytics: BluetoothSdkAnalyticsConfiguration().withSurface("react_native")
+            )
+        )
         sdk.delegate = self
         self.sdk = sdk
         return sdk
@@ -700,6 +715,8 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             sendEvent("photo_status", status.values)
         case let .videoRecordingStatus(status):
             sendEvent("video_recording_status", status.values)
+        case let .mediaUpload(event):
+            sendEvent(event.type, event.values)
         case let .rgbLedControlResponse(response):
             sendEvent("rgb_led_control_response", response.values)
         case let .streamStatus(status):

package/ios/Source/BluetoothSdkDefaults.swift

@@ -2,5 +2,32 @@ import Foundation
 
 /// Defaults for the public Bluetooth SDK surface.
 enum BluetoothSdkDefaults {
+    static var sdkVersion: String? {
+        packageVersion(from: sdkBundle)
+    }
+
     static let voiceActivityDetectionEnabled = false
+
+    private static var sdkBundle: Bundle {
+        #if SWIFT_PACKAGE
+            Bundle.module
+        #else
+            Bundle(for: BluetoothSdkBundleToken.self)
+        #endif
+    }
+
+    private static func packageVersion(from bundle: Bundle) -> String? {
+        let version = bundle.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+        let build = bundle.object(forInfoDictionaryKey: "CFBundleVersion") as? String
+
+        for candidate in [version, build] {
+            if let candidate, !candidate.isEmpty, candidate != "1.0" {
+                return candidate
+            }
+        }
+
+        return nil
+    }
 }
+
+private final class BluetoothSdkBundleToken {}

package/ios/Source/Bridge.swift

@@ -251,6 +251,16 @@ class Bridge {
         Bridge.sendTypedMessage("touch_event", body: body)
     }
 
+    static func sendAccelEvent(x: Float, y: Float, z: Float, timestamp: Int64) {
+        let body: [String: Any] = [
+            "x": x,
+            "y": y,
+            "z": z,
+            "timestamp": timestamp,
+        ]
+        Bridge.sendTypedMessage("accel_event", body: body)
+    }
+
     static func sendSwipeVolumeStatus(enabled: Bool, timestamp: Int64) {
         let body: [String: Any] = [
             "enabled": enabled,
@@ -293,6 +303,12 @@ class Bridge {
         Bridge.sendTypedMessage("video_recording_status", body: body)
     }
 
+    static func sendMediaUploadEvent(type: String, values: [String: Any]) {
+        var body = values
+        body["type"] = type
+        Bridge.sendTypedMessage(type, body: body)
+    }
+
     static func sendVersionInfo(_ values: [String: Any]) {
         var body: [String: Any] = [
             "type": "version_info",

package/ios/Source/DeviceManager.swift

@@ -241,6 +241,7 @@ struct ViewState {
         get { DeviceStore.shared.get("bluetooth", "shouldSendBootingMessage") as? Bool ?? true }
         set { DeviceStore.shared.apply("bluetooth", "shouldSendBootingMessage", newValue) }
     }
+
     private var lastSystemTimeSyncConnectionKey = ""
 
     private var systemMicUnavailable: Bool {
@@ -564,7 +565,7 @@ struct ViewState {
             // Check if we've completed all cycles
             if cycles >= totalCycles {
                 // End animation with final message
-                sgc?.sendTextWall("                  /// MentraOS Connected \\\\\\")
+                Task { await sgc?.sendTextWall("                  /// MentraOS Connected \\\\\\") }
                 animationQueue.asyncAfter(deadline: .now() + 1.0) {
                     self.sgc?.clearDisplay()
                 }
@@ -574,7 +575,7 @@ struct ViewState {
             // Display current animation frame
             let frameText =
                 "                    \(arrowFrames[frameIndex]) MentraOS Booting \(arrowFrames[frameIndex])"
-            sgc?.sendTextWall(frameText)
+            Task { await sgc?.sendTextWall(frameText) }
 
             // Move to next frame
             frameIndex = (frameIndex + 1) % arrowFrames.count
@@ -692,20 +693,20 @@ struct ViewState {
             switch layoutType {
             case "text_wall":
                 let text = currentViewState.text
-                sgc?.sendTextWall(text)
+                await sgc?.sendTextWall(text)
             case "double_text_wall":
                 let topText = currentViewState.topText
                 let bottomText = currentViewState.bottomText
-                sgc?.sendDoubleTextWall(topText, bottomText)
+                await sgc?.sendDoubleTextWall(topText, bottomText)
             case "reference_card":
-                sgc?.sendTextWall(currentViewState.title + "\n\n" + currentViewState.text)
+                await sgc?.sendTextWall(currentViewState.title + "\n\n" + currentViewState.text)
             case "bitmap_view":
-                Bridge.log("MAN: Processing bitmap_view layout")
+                // Bridge.log("MAN: Processing bitmap_view layout")
                 guard let data = currentViewState.data else {
                     Bridge.log("MAN: ERROR: bitmap_view missing data field")
                     return
                 }
-                Bridge.log("MAN: Processing bitmap_view with base64 data, length: \(data.count)")
+                // Bridge.log("MAN: Processing bitmap_view with base64 data, length: \(data.count)")
                 await sgc?.displayBitmap(
                     base64ImageData: data,
                     x: currentViewState.bmpX,
@@ -890,11 +891,24 @@ struct ViewState {
 
         let connectionKey = "\(sgc.type):\(deviceName)"
         syncSystemTimeOnceForConnection(sgc, connectionKey: connectionKey)
+        
+        // re-apply display height/depth after reconnection
+        DispatchQueue.main.asyncAfter(deadline: .now() + 2) { [weak self] in
+            // Re-read the current sgc rather than capturing the connect-time instance: the user may
+            // have disconnected or switched glasses during the 2s window, and we must not push to a
+            // stale/torn-down connection.
+            guard let sgc = self?.sgc else { return }
+            let h = DeviceStore.shared.get("bluetooth", "dashboard_height") as? Int ?? 4
+            // Fall back to the canonical default (2), matching DeviceStore — not 1.
+            let rawDepth = DeviceStore.shared.get("bluetooth", "dashboard_depth") as? Int ?? 2
+            let d = min(max(rawDepth, 1), 4)
+            sgc.setDashboardPosition(h, d)
+        }
 
         // Show welcome message on first connect for all display glasses
         if shouldSendBootingMessage {
             Task {
-                sgc.sendTextWall("// MentraOS Connected")
+                await sgc.sendTextWall("// MentraOS Connected")
                 try? await Task.sleep(nanoseconds: 3_000_000_000) // 1 second
                 sgc.clearDisplay()
             }
@@ -920,17 +934,6 @@ struct ViewState {
         Bridge.saveSetting("device_name", deviceName)
         Bridge.saveSetting("device_address", deviceAddress)
 
-        // Re-apply display height after reconnection
-        let h = DeviceStore.shared.get("bluetooth", "dashboard_height") as? Int ?? 4
-#if !SWIFT_PACKAGE || MENTRA_FEATURE_NEX
-        let d = NexDashboardDisplayWire.clampDepthFromStore(
-            DeviceStore.shared.get("bluetooth", "dashboard_depth")
-        )
-#else
-        let rawDepth = DeviceStore.shared.get("bluetooth", "dashboard_depth") as? Int ?? 1
-        let d = min(max(rawDepth, 1), 4)
-#endif
-        sgc.setDashboardPosition(h, d)
     }
 
     private func syncSystemTimeOnceForConnection(_ sgc: SGCManager, connectionKey: String) {
@@ -1006,7 +1009,7 @@ struct ViewState {
         }
 
         Bridge.log("MAN: Displaying text: \(text)")
-        sgc?.sendTextWall(text)
+        Task { await sgc?.sendTextWall(text) }
     }
 
     func displayEvent(_ event: [String: Any]) {
@@ -1096,7 +1099,7 @@ struct ViewState {
     }
 
     func showNotificationsPanel() {
-        sgc?.showNotificationsPanel()
+        Task { await sgc?.showNotificationsPanel() }
     }
 
     func ping() {
@@ -1235,20 +1238,22 @@ struct ViewState {
 
     func startVideoRecording(
         _ requestId: String, _ save: Bool, _ sound: Bool, _ width: Int = 0, _ height: Int = 0,
-        _ fps: Int = 0
+        _ fps: Int = 0, _ maxRecordingTimeMinutes: Int = 0
     ) {
         Bridge.log(
-            "MAN: onStartVideoRecording: requestId=\(requestId), save=\(save), flash=true, sound=\(sound), resolution=\(width)x\(height)@\(fps)fps"
+            "MAN: onStartVideoRecording: requestId=\(requestId), save=\(save), flash=true, sound=\(sound), resolution=\(width)x\(height)@\(fps)fps, maxRecordingTimeMinutes=\(maxRecordingTimeMinutes)"
         )
         sgc?.startVideoRecording(
             requestId: requestId, save: save, flash: true, sound: sound, width: width, height: height,
-            fps: fps
+            fps: fps, maxRecordingTimeMinutes: maxRecordingTimeMinutes
         )
     }
 
-    func stopVideoRecording(_ requestId: String) {
-        Bridge.log("MAN: onStopVideoRecording: requestId=\(requestId)")
-        sgc?.stopVideoRecording(requestId: requestId)
+    func stopVideoRecording(_ requestId: String, _ webhookUrl: String?, _ authToken: String?) {
+        Bridge.log(
+            "MAN: onStopVideoRecording: requestId=\(requestId), webhook=\((webhookUrl?.isEmpty ?? true) ? "none" : "set")"
+        )
+        sgc?.stopVideoRecording(requestId: requestId, webhookUrl: webhookUrl, authToken: authToken)
     }
 
     func setMicState() {
@@ -1447,6 +1452,7 @@ struct ViewState {
         DeviceStore.shared.apply("glasses", "deviceModel", "")
         DeviceStore.shared.apply("glasses", "fullyBooted", false)
         DeviceStore.shared.apply("glasses", "connected", false)
+        DeviceStore.shared.apply("glasses", "connectionState", ConnTypes.DISCONNECTED)
         DeviceStore.shared.apply("glasses", "voiceActivityDetectionEnabled", BluetoothSdkDefaults.voiceActivityDetectionEnabled)
         // disconnect the controller as well:
         searchingController = false

package/ios/Source/DeviceStore.swift

@@ -84,6 +84,7 @@ class DeviceStore {
         store.set("bluetooth", "dashboard_height", 4)
         store.set("bluetooth", "dashboard_depth", 2)
         store.set("bluetooth", "head_up_angle", 30)
+        store.set("bluetooth", "imu_enabled", false)
         store.set("bluetooth", "contextual_dashboard", true)
         store.set("bluetooth", "gallery_mode", true)
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.voiceActivityDetectionEnabled)
@@ -186,7 +187,7 @@ class DeviceStore {
             let auto = store.get("bluetooth", "auto_brightness") as? Bool ?? true
             Task {
                 DeviceManager.shared.sgc?.setBrightness(b, autoMode: auto)
-                DeviceManager.shared.sgc?.sendTextWall("Set brightness to \(b)%")
+                await DeviceManager.shared.sgc?.sendTextWall("Set brightness to \(b)%")
                 try? await Task.sleep(nanoseconds: 800_000_000) // 0.8 seconds
                 DeviceManager.shared.sgc?.clearDisplay()
             }
@@ -198,7 +199,7 @@ class DeviceStore {
             Task {
                 DeviceManager.shared.sgc?.setBrightness(b, autoMode: auto)
                 if autoBrightnessChanged {
-                    DeviceManager.shared.sgc?.sendTextWall(
+                    await DeviceManager.shared.sgc?.sendTextWall(
                         auto ? "Enabled auto brightness" : "Disabled auto brightness"
                     )
                     try? await Task.sleep(nanoseconds: 800_000_000) // 0.8 seconds
@@ -217,6 +218,11 @@ class DeviceStore {
                 DeviceManager.shared.sgc?.setHeadUpAngle(angle)
             }
 
+        case ("bluetooth", "imu_enabled"):
+            if let enabled = value as? Bool {
+                Task { await DeviceManager.shared.sgc?.setImuEnabled(enabled) }
+            }
+
         case ("bluetooth", "menu_apps"):
             if let items = value as? [[String: Any]] {
                 DeviceManager.shared.sgc?.setDashboardMenu(items)

package/ios/Source/MentraBluetoothSDK.swift

@@ -81,10 +81,14 @@ private final class PendingHotspotStatusRequest {
 private final class PendingVideoRecordingRequest {
     let expectedStatus: String
     let pending: PendingResponse<VideoRecordingStatusEvent>
+    let waitForUpload: Bool
+    var stoppedEvent: VideoRecordingStatusEvent?
+    var uploadSucceeded = false
 
-    init(expectedStatus: String, pending: PendingResponse<VideoRecordingStatusEvent>) {
+    init(expectedStatus: String, pending: PendingResponse<VideoRecordingStatusEvent>, waitForUpload: Bool = false) {
         self.expectedStatus = expectedStatus
         self.pending = pending
+        self.waitForUpload = waitForUpload
     }
 }
 
@@ -147,13 +151,18 @@ public final class MentraBluetoothSDK {
 
     private let configuration: MentraBluetoothSDKConfiguration
     private var discoveredDeviceNames = Set<String>()
+    private var bluetoothAvailabilityListenerId: UUID?
+    private var shouldRestoreGlassesOnBluetoothRestore = false
+    private var shouldRestoreControllerOnBluetoothRestore = false
     private var bridgeEventSinkId: String?
     private var storeListenerId: String?
     private let defaultDeviceKeys: Set<String> = ["default_wearable", "device_name", "device_address"]
+    private let videoUploadStopTimeoutMs = 10 * 60 * 1000
     private var suppressDefaultDeviceEvents = false
     private var defaultDeviceApplyGeneration = 0
     private var activeScanSessions: [UUID: ActiveScanSession] = [:]
     private var activeStreamKeepAlive: ActiveStreamKeepAlive?
+    private let analytics: BluetoothSdkAnalytics
     private var pendingPhotoRequests: [String: PendingResponse<PhotoResponseEvent>] = [:]
     private var pendingVideoRecordingRequests: [String: PendingVideoRecordingRequest] = [:]
     private var pendingRgbLedRequests: [String: PendingResponse<RgbLedControlResponseEvent>] = [:]
@@ -170,7 +179,12 @@ public final class MentraBluetoothSDK {
 
     public init(configuration: MentraBluetoothSDKConfiguration = .default) {
         self.configuration = configuration
-        _ = BluetoothAvailability.shared
+        analytics = BluetoothSdkAnalytics(configuration: configuration.analytics)
+        bluetoothAvailabilityListenerId = BluetoothAvailability.shared.addStateListener { [weak self] state in
+            Task { @MainActor [weak self] in
+                self?.handleBluetoothAvailability(state)
+            }
+        }
         bridgeEventSinkId = Bridge.addEventSink { [weak self] eventName, data in
             Task { @MainActor [weak self] in
                 self?.dispatchBridgeEvent(eventName, data)
@@ -181,6 +195,8 @@ public final class MentraBluetoothSDK {
                 self?.dispatchStoreUpdate(category, changes)
             }
         }
+        analytics.initializeGlassesStatus(glassesStatus)
+        analytics.captureStarted()
     }
 
     public var state: MentraBluetoothState {
@@ -211,6 +227,15 @@ public final class MentraBluetoothSDK {
         currentDefaultDevice()
     }
 
+    private func requireGlassesConnected(operation: String) throws {
+        guard glassesStatus.connected else {
+            throw BluetoothError(
+                code: "glasses_not_connected",
+                message: "Cannot \(operation) because glasses are not connected."
+            )
+        }
+    }
+
     public func getDefaultDevice() -> Device? {
         currentDefaultDevice()
     }
@@ -296,6 +321,7 @@ public final class MentraBluetoothSDK {
     }
 
     public func connect(to device: Device, options: ConnectOptions = ConnectOptions()) throws {
+        clearBluetoothRestoreIntent()
         if device.model != .simulated {
             try BluetoothAvailability.shared.requirePoweredOn(operation: "connect to glasses")
         }
@@ -315,6 +341,7 @@ public final class MentraBluetoothSDK {
     }
 
     public func connectDefault(options: ConnectOptions = ConnectOptions()) throws {
+        clearBluetoothRestoreIntent()
         guard let device = currentDefaultDevice() else {
             throw BluetoothError(
                 code: "default_device_missing",
@@ -331,18 +358,22 @@ public final class MentraBluetoothSDK {
     }
 
     public func cancelConnectionAttempt() {
+        clearBluetoothRestoreIntent()
         DeviceManager.shared.disconnect()
     }
 
     func connectSimulated() {
+        clearBluetoothRestoreIntent()
         DeviceManager.shared.connectSimulated()
     }
 
     public func disconnect() {
+        clearBluetoothRestoreIntent()
         DeviceManager.shared.disconnect()
     }
 
     public func forget() {
+        clearBluetoothRestoreIntent()
         DeviceManager.shared.forget()
     }
 
@@ -806,6 +837,7 @@ public final class MentraBluetoothSDK {
         guard !request.requestId.isEmpty else {
             throw BluetoothError(code: "missing_request_id", message: "requestId is required to start video recording.")
         }
+        try requireGlassesConnected(operation: "start video recording")
         let pending = PendingResponse<VideoRecordingStatusEvent>(
             operation: "start video recording \(request.requestId)"
         )
@@ -825,7 +857,8 @@ public final class MentraBluetoothSDK {
             request.sound,
             request.width,
             request.height,
-            request.fps
+            request.fps,
+            request.maxRecordingTimeMinutes
         )
         do {
             let event = try await pending.wait()
@@ -837,10 +870,13 @@ public final class MentraBluetoothSDK {
         }
     }
 
-    public func stopVideoRecording(requestId: String) async throws -> VideoRecordingStatusEvent {
+    public func stopVideoRecording(
+        requestId: String, webhookUrl: String? = nil, authToken: String? = nil
+    ) async throws -> VideoRecordingStatusEvent {
         guard !requestId.isEmpty else {
             throw BluetoothError(code: "missing_request_id", message: "requestId is required to stop video recording.")
         }
+        try requireGlassesConnected(operation: "stop video recording")
         let pending = PendingResponse<VideoRecordingStatusEvent>(operation: "stop video recording \(requestId)")
         guard pendingVideoRecordingRequests[requestId] == nil else {
             throw BluetoothError(
@@ -848,13 +884,16 @@ public final class MentraBluetoothSDK {
                 message: "A video recording command is already waiting for requestId \(requestId)."
             )
         }
+        let waitForUpload = !(webhookUrl?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ?? true)
         pendingVideoRecordingRequests[requestId] = PendingVideoRecordingRequest(
             expectedStatus: "recording_stopped",
-            pending: pending
+            pending: pending,
+            waitForUpload: waitForUpload
         )
-        DeviceManager.shared.stopVideoRecording(requestId)
+        DeviceManager.shared.stopVideoRecording(requestId, webhookUrl, authToken)
         do {
-            let event = try await pending.wait()
+            let timeoutMs = waitForUpload ? videoUploadStopTimeoutMs : 15_000
+            let event = try await pending.wait(timeoutMs: timeoutMs)
             pendingVideoRecordingRequests.removeValue(forKey: requestId)
             return event
         } catch {
@@ -971,6 +1010,10 @@ public final class MentraBluetoothSDK {
 
     public func invalidate() {
         stopStreamKeepAliveMonitor()
+        if let bluetoothAvailabilityListenerId {
+            BluetoothAvailability.shared.removeStateListener(bluetoothAvailabilityListenerId)
+            self.bluetoothAvailabilityListenerId = nil
+        }
         if let bridgeEventSinkId {
             Bridge.removeEventSink(bridgeEventSinkId)
             self.bridgeEventSinkId = nil
@@ -982,6 +1025,83 @@ public final class MentraBluetoothSDK {
         delegate = nil
     }
 
+    private func handleBluetoothAvailability(_ state: CBManagerState) {
+        switch state {
+        case .poweredOff, .resetting, .unauthorized, .unsupported:
+            handleBluetoothUnavailable()
+        case .poweredOn:
+            handleBluetoothRestored()
+        case .unknown:
+            break
+        @unknown default:
+            handleBluetoothUnavailable()
+        }
+    }
+
+    private func handleBluetoothUnavailable() {
+        cancelActiveScanSessions(reason: .cancelled)
+        clearBluetoothDiscoveryState()
+        disconnectActiveConnections()
+    }
+
+    private func disconnectActiveConnections() {
+        if glassesStatus.controllerConnected {
+            DeviceManager.shared.disconnectController()
+            shouldRestoreControllerOnBluetoothRestore = true
+        }
+        if glassesStatus.deviceModel == DeviceTypes.SIMULATED
+            || DeviceManager.shared.sgc?.type.contains(DeviceTypes.SIMULATED) == true
+        {
+            return
+        }
+        if glassesStatus.connected || glassesStatus.connectionState != .disconnected {
+            DeviceManager.shared.disconnect()
+            shouldRestoreGlassesOnBluetoothRestore = true
+        }
+    }
+
+    /// Reconnect only what `handleBluetoothUnavailable` tore down, never a
+    /// connection the user closed themselves (explicit connect/disconnect
+    /// calls clear the restore intent).
+    private func handleBluetoothRestored() {
+        let restoreGlasses = shouldRestoreGlassesOnBluetoothRestore
+        let restoreController = shouldRestoreControllerOnBluetoothRestore
+        clearBluetoothRestoreIntent()
+
+        if restoreGlasses, !glassesStatus.connected, glassesStatus.connectionState == .disconnected {
+            DeviceManager.shared.connectDefault() // also restores the controller
+        } else if restoreController, !glassesStatus.controllerConnected {
+            DeviceManager.shared.connectDefaultController()
+        }
+    }
+
+    private func clearBluetoothRestoreIntent() {
+        shouldRestoreGlassesOnBluetoothRestore = false
+        shouldRestoreControllerOnBluetoothRestore = false
+    }
+
+    private func clearBluetoothDiscoveryState() {
+        discoveredDeviceNames.removeAll()
+        DeviceStore.shared.apply(ObservableStore.bluetoothCategory, "searching", false)
+        DeviceStore.shared.apply(ObservableStore.bluetoothCategory, "searchingController", false)
+        DeviceStore.shared.apply(ObservableStore.bluetoothCategory, "searchResults", [] as [[String: Any]])
+    }
+
+    private func cancelActiveScanSessions(reason: ScanStopReason) {
+        let ids = Array(activeScanSessions.keys)
+        guard !ids.isEmpty else {
+            if bluetoothStatus.searching || bluetoothStatus.searchingController {
+                stopScan(reason: reason)
+            }
+            return
+        }
+        for (index, id) in ids.enumerated() {
+            // Stop the underlying scan once (first session); the rest only
+            // complete their callbacks.
+            finishScanSession(id, reason: reason, shouldStopScan: index == 0)
+        }
+    }
+
     private func startStreamKeepAliveMonitor(streamId: String, intervalSeconds requestedIntervalSeconds: Int) {
         let intervalSeconds = requestedIntervalSeconds > 0 ? requestedIntervalSeconds : 5
         let tracker = ActiveStreamKeepAlive(streamId: streamId, intervalSeconds: intervalSeconds)
@@ -1162,7 +1282,14 @@ public final class MentraBluetoothSDK {
         guard let request = pendingVideoRecordingRequests[event.requestId] else { return }
         if event.success {
             if event.status == request.expectedStatus {
-                request.pending.resolve(event)
+                if request.waitForUpload {
+                    request.stoppedEvent = event
+                    if request.uploadSucceeded {
+                        request.pending.resolve(event)
+                    }
+                } else {
+                    request.pending.resolve(event)
+                }
             }
         } else {
             request.pending.reject(
@@ -1174,6 +1301,26 @@ public final class MentraBluetoothSDK {
         }
     }
 
+    private func handleMediaUploadForRequests(_ event: MediaUploadEvent) {
+        guard event.isVideo, let request = pendingVideoRecordingRequests[event.requestId], request.waitForUpload else {
+            return
+        }
+        if event.isSuccess {
+            if let stoppedEvent = request.stoppedEvent {
+                request.pending.resolve(stoppedEvent)
+            } else {
+                request.uploadSucceeded = true
+            }
+        } else {
+            request.pending.reject(
+                BluetoothError(
+                    code: "video_upload_failed",
+                    message: event.errorMessage ?? "Video upload failed."
+                )
+            )
+        }
+    }
+
     private func handleRgbLedResponseForRequests(_ event: RgbLedControlResponseEvent) {
         guard let pending = pendingRgbLedRequests[event.requestId] else { return }
         if event.state == "success" {
@@ -1273,6 +1420,7 @@ public final class MentraBluetoothSDK {
     private func dispatchStoreUpdate(_ category: String, _ changes: [String: Any]) {
         switch ObservableStore.normalizeCategory(category) {
         case "glasses":
+            analytics.observeGlassesStatus(glassesStatus)
             let nextState = state
             delegate?.mentraBluetoothSDK(self, didUpdate: nextState)
             delegate?.mentraBluetoothSDK(self, didUpdateGlasses: nextState.glasses)
@@ -1424,6 +1572,10 @@ public final class MentraBluetoothSDK {
             let event = VideoRecordingStatusEvent(values: data)
             handleVideoRecordingStatusForRequests(event)
             delegate?.mentraBluetoothSDK(self, didReceive: .videoRecordingStatus(event))
+        case "media_success", "media_error":
+            let event = MediaUploadEvent(values: data)
+            handleMediaUploadForRequests(event)
+            delegate?.mentraBluetoothSDK(self, didReceive: .mediaUpload(event))
         case "rgb_led_control_response":
             let event = RgbLedControlResponseEvent(values: data)
             handleRgbLedResponseForRequests(event)