@mentra/bluetooth-sdk 0.1.8 → 0.1.10

package/ios/BluetoothSdkModule.swift

@@ -23,10 +23,12 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             "speaking_status",
             "battery_status",
             "wifi_status_change",
+            "wifi_scan_result",
             "hotspot_status_change",
             "hotspot_error",
             "photo_response",
             "photo_status",
+            "video_recording_status",
             "gallery_status",
             "compatible_glasses_search_stop",
             "heartbeat_sent",
@@ -34,6 +36,8 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             "swipe_volume_status",
             "switch_status",
             "rgb_led_control_response",
+            "settings_ack",
+            "version_info",
             "pair_failure",
             "audio_pairing_needed",
             "audio_connected",
@@ -56,7 +60,8 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             "send_command_to_ble",
             "receive_command_from_ble",
             "miniapp_selected",
-            "captions_tester_incident"
+            "captions_tester_incident",
+            "extraction_progress"
         )
 
         OnCreate {
@@ -241,7 +246,7 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             JSCExperiment.spawn(count: count)
         }
 
-        Function("jscKillAll") { () -> Void in
+        Function("jscKillAll") { () in
             JSCExperiment.killAll()
         }
 
@@ -253,7 +258,7 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             JSCExperiment.spawnAndMeasure(count: count, baselineMB: baselineMB)
         }
 
-        Function("jscRunBenchmark") { () -> Void in
+        Function("jscRunBenchmark") { () in
             JSCExperiment.runBenchmark()
         }
 
@@ -268,26 +273,39 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
         // MARK: - WiFi Commands
 
         AsyncFunction("requestWifiScan") {
-            await MainActor.run {
-                self.bluetoothSdk().requestWifiScan()
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.requestWifiScan().map(\.dictionary)
         }
 
         AsyncFunction("sendWifiCredentials") { (ssid: String, password: String) in
-            await MainActor.run {
-                self.bluetoothSdk().sendWifiCredentials(ssid: ssid, password: password)
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.sendWifiCredentials(ssid: ssid, password: password).values
         }
 
         AsyncFunction("forgetWifiNetwork") { (ssid: String) in
-            await MainActor.run {
-                self.bluetoothSdk().forgetWifiNetwork(ssid: ssid)
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.forgetWifiNetwork(ssid: ssid).values
         }
 
         AsyncFunction("setHotspotState") { (enabled: Bool) in
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.setHotspotState(enabled: enabled).values
+        }
+
+        AsyncFunction("setSystemTime") { (timestampMs: Double) in
+            let maxTimestamp = Double(Int64.max).nextDown
+            guard timestampMs.isFinite,
+                  timestampMs >= Double(Int64.min),
+                  timestampMs <= maxTimestamp
+            else {
+                throw BluetoothError(
+                    code: "invalid_timestamp",
+                    message: "setSystemTime timestampMs must be a finite Int64 millisecond timestamp."
+                )
+            }
+            let timestamp = Int64(timestampMs)
             await MainActor.run {
-                self.bluetoothSdk().setHotspotState(enabled: enabled)
+                self.bluetoothSdk().setSystemTime(timestampMs: timestamp)
             }
         }
 
@@ -295,7 +313,7 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
 
         AsyncFunction("setGalleryModeEnabled") { (enabled: Bool) in
             let sdk = await MainActor.run { self.bluetoothSdk() }
-            try await sdk.setGalleryModeEnabled(enabled)
+            return try await sdk.setGalleryModeEnabled(enabled).values
         }
 
         AsyncFunction("setVoiceActivityDetectionEnabled") { (enabled: Bool) in
@@ -303,10 +321,38 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             try await sdk.setVoiceActivityDetectionEnabled(enabled)
         }
 
+        AsyncFunction("setButtonPhotoSettings") { (size: String) in
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.setButtonPhotoSettings(size: ButtonPhotoSize(rawValue: size) ?? .medium).values
+        }
+
+        AsyncFunction("setButtonVideoRecordingSettings") { (width: Int, height: Int, fps: Int) in
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.setButtonVideoRecordingSettings(width: width, height: height, fps: fps).values
+        }
+
+        AsyncFunction("setButtonCameraLed") { (enabled: Bool) in
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.setButtonCameraLed(enabled: enabled).values
+        }
+
+        AsyncFunction("setButtonMaxRecordingTime") { (minutes: Int) in
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.setButtonMaxRecordingTime(minutes: minutes).values
+        }
+
+        AsyncFunction("setCameraFov") { (fov: [String: Any]) in
+            let value = intValue(fov["fov"]) ?? CameraFov.defaultFov
+            let roiPosition = CameraRoiPosition.from(
+                rawValue: intValue(fov["roiPosition"]) ?? intValue(fov["roi_position"])
+            )
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.setCameraFov(CameraFov(fov: value, roiPosition: roiPosition)).values
+        }
+
         AsyncFunction("queryGalleryStatus") {
-            await MainActor.run {
-                self.bluetoothSdk().queryGalleryStatus()
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.queryGalleryStatus().values
         }
 
         AsyncFunction("requestPhoto") { (params: [String: Any]) in
@@ -320,6 +366,7 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             let authToken = params["authToken"] as? String ?? ""
             let compress = params["compress"] as? String ?? "none"
             let flash = params["flash"] as? Bool ?? true
+            let save = params["save"] as? Bool ?? params["saveToGallery"] as? Bool ?? false
             let sound = params["sound"] as? Bool ?? true
             let exposureTimeNs: Double?
             switch params["exposureTimeNs"] {
@@ -337,7 +384,8 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             case let value as Int:
                 iso = value > 0 ? value : nil
             case let value as Double:
-                iso = value.isFinite && value > 0 ? Int(value) : nil
+                // Guard against Int(Double) trapping on out-of-range values.
+                iso = (value.isFinite && value > 0 && value < Double(Int.max)) ? Int(value) : nil
             case let value as NSNumber:
                 let intValue = value.intValue
                 iso = intValue > 0 ? intValue : nil
@@ -345,44 +393,46 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
                 iso = nil
             }
 
-            await MainActor.run {
-                self.bluetoothSdk().requestPhoto(
-                    PhotoRequest(
-                        requestId: requestId,
-                        appId: appId,
-                        size: PhotoSize(rawValue: size) ?? .medium,
-                        webhookUrl: webhookUrl,
-                        authToken: authToken,
-                        compress: PhotoCompression(rawValue: compress),
-                        flash: flash,
-                        sound: sound,
-                        exposureTimeNs: exposureTimeNs,
-                        iso: iso
-                    )
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.requestPhoto(
+                PhotoRequest(
+                    requestId: requestId,
+                    appId: appId,
+                    size: PhotoSize(rawValue: size) ?? .medium,
+                    webhookUrl: webhookUrl,
+                    authToken: authToken,
+                    compress: PhotoCompression(rawValue: compress),
+                    flash: flash,
+                    save: save,
+                    sound: sound,
+                    exposureTimeNs: exposureTimeNs,
+                    iso: iso
                 )
-            }
+            ).values
         }
 
         // MARK: - OTA Commands
 
         AsyncFunction("sendOtaStart") {
-            await MainActor.run {
-                self.bluetoothSdk().sendOtaStart()
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.sendOtaStart().values
         }
 
         AsyncFunction("sendOtaQueryStatus") {
-            await MainActor.run {
-                self.bluetoothSdk().sendOtaQueryStatus()
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.sendOtaQueryStatus().values
+        }
+
+        AsyncFunction("retryOtaVersionCheck") {
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.retryOtaVersionCheck().values
         }
 
         // MARK: - Version Info Commands
 
         AsyncFunction("requestVersionInfo") {
-            await MainActor.run {
-                self.bluetoothSdk().requestVersionInfo()
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.requestVersionInfo().dictionary
         }
 
         // MARK: - Power Control Commands
@@ -401,37 +451,43 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
 
         // MARK: - Video Recording Commands
 
-        AsyncFunction("startVideoRecording") { (requestId: String, save: Bool, sound: Bool) in
-            await MainActor.run {
-                self.bluetoothSdk().startVideoRecording(
-                    VideoRecordingRequest(requestId: requestId, save: save, sound: sound)
-                )
+        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.
+            func dim(_ key: String) -> Int {
+                (settings?[key] as? NSNumber)?.intValue ?? 0
             }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.startVideoRecording(
+                VideoRecordingRequest(
+                    requestId: requestId, save: save, sound: sound,
+                    width: dim("width"), height: dim("height"), fps: dim("fps")
+                )
+            ).values
         }
 
         AsyncFunction("stopVideoRecording") { (requestId: String) in
-            await MainActor.run {
-                self.bluetoothSdk().stopVideoRecording(requestId: requestId)
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.stopVideoRecording(requestId: requestId).values
         }
 
         // MARK: - Stream Commands
 
         AsyncFunction("startStream") { (params: [String: Any]) in
-            await MainActor.run {
-                self.bluetoothSdk().startStream(StreamRequest(values: params))
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.startStream(StreamRequest(values: params)).values
         }
 
         AsyncFunction("stopStream") {
-            await MainActor.run {
-                self.bluetoothSdk().stopStream()
-            }
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.stopStream().values
         }
 
-        AsyncFunction("sendCloudStreamKeepAlive") { (params: [String: Any]) in
+        AsyncFunction("sendExternallyManagedStreamKeepAlive") { (params: [String: Any]) in
             await MainActor.run {
-                self.bluetoothSdk().sendCloudStreamKeepAlive(StreamKeepAliveRequest(values: params))
+                self.bluetoothSdk().sendExternallyManagedStreamKeepAlive(StreamKeepAliveRequest(values: params))
             }
         }
 
@@ -458,19 +514,18 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
                 requestId: String, packageName: String?, action: String, color: String?,
                 onDurationMs: Int, offDurationMs: Int, count: Int
             ) in
-            await MainActor.run {
-                self.bluetoothSdk().rgbLedControl(
-                    RgbLedRequest(
-                        requestId: requestId,
-                        packageName: packageName,
-                        action: RgbLedAction(rawValue: action) ?? .off,
-                        color: color.flatMap(RgbLedColor.init(rawValue:)),
-                        onDurationMs: onDurationMs,
-                        offDurationMs: offDurationMs,
-                        count: count
-                    )
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.rgbLedControl(
+                RgbLedRequest(
+                    requestId: requestId,
+                    packageName: packageName,
+                    action: RgbLedAction(rawValue: action) ?? .off,
+                    color: color.flatMap(RgbLedColor.init(rawValue:)),
+                    onDurationMs: onDurationMs,
+                    offDurationMs: offDurationMs,
+                    count: count
                 )
-            }
+            ).values
         }
 
         // MARK: - Microphone Commands
@@ -525,6 +580,39 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
         AsyncFunction("extractTarBz2") { (sourcePath: String, destinationPath: String) -> Bool in
             return STTTools.extractTarBz2(sourcePath: sourcePath, destinationPath: destinationPath)
         }
+
+        // MARK: - TTS Model Management
+
+        AsyncFunction("setTtsModelDetails") { (path: String, languageCode: String) in
+            TTSTools.setTtsModelDetails(path, languageCode)
+        }
+
+        AsyncFunction("getTtsModelPath") { () -> String in
+            return TTSTools.getTtsModelPath()
+        }
+
+        AsyncFunction("getTtsModelLanguage") { () -> String in
+            return TTSTools.getTtsModelLanguage()
+        }
+
+        AsyncFunction("checkTtsModelAvailable") { () -> Bool in
+            return TTSTools.checkTTSModelAvailable()
+        }
+
+        AsyncFunction("validateTtsModel") { (path: String) -> Bool in
+            return TTSTools.validateTTSModel(path)
+        }
+
+        AsyncFunction("generateTtsAudio") {
+            (text: String, modelPath: String, outputPath: String, speakerId: Int, speed: Double) -> Bool in
+            return TTSTools.generateTtsAudio(
+                text: text,
+                modelPath: modelPath,
+                outputPath: outputPath,
+                speakerId: speakerId,
+                speed: speed
+            )
+        }
     }
 
     @MainActor
@@ -610,10 +698,26 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             sendEvent("photo_response", response.values)
         case let .photoStatus(status):
             sendEvent("photo_status", status.values)
+        case let .videoRecordingStatus(status):
+            sendEvent("video_recording_status", status.values)
+        case let .rgbLedControlResponse(response):
+            sendEvent("rgb_led_control_response", response.values)
         case let .streamStatus(status):
             sendEvent("stream_status", status.values)
         case let .keepAliveAck(ack):
             sendEvent("keep_alive_ack", ack.values)
+        case let .otaUpdateAvailable(event):
+            sendEvent("ota_update_available", event.values)
+        case let .otaStartAck(event):
+            sendEvent("ota_start_ack", event.values)
+        case let .otaStatus(event):
+            sendEvent("ota_status", event.values)
+        case let .settingsAck(event):
+            sendEvent("settings_ack", event.values)
+        case let .versionInfo(event):
+            var values = event.dictionary
+            values["type"] = "version_info"
+            sendEvent("version_info", values)
         case let .localTranscription(transcription):
             sendEvent("local_transcription", transcription.values)
         case let .raw(name, values):