@mentra/bluetooth-sdk 0.1.10 → 0.1.12

package/ios/Source/camera/CameraModels.swift

@@ -11,6 +11,7 @@ public enum ButtonPhotoSize: String {
     case small
     case medium
     case large
+    case max
 }
 
 public enum PhotoCompression: String {
@@ -228,9 +229,12 @@ public struct VideoRecordingRequest {
     public let width: Int
     public let height: Int
     public let fps: Int
+    // Optional auto-stop timer in minutes; 0 = record until stopped/interrupted.
+    public let maxRecordingTimeMinutes: Int
 
     public init(
-        requestId: String, save: Bool, sound: Bool, width: Int = 0, height: Int = 0, fps: Int = 0
+        requestId: String, save: Bool, sound: Bool, width: Int = 0, height: Int = 0, fps: Int = 0,
+        maxRecordingTimeMinutes: Int = 0
     ) {
         self.requestId = requestId
         self.save = save
@@ -238,6 +242,7 @@ public struct VideoRecordingRequest {
         self.width = width
         self.height = height
         self.fps = fps
+        self.maxRecordingTimeMinutes = maxRecordingTimeMinutes
     }
 }
 
@@ -279,6 +284,50 @@ public struct VideoRecordingStatusEvent: CustomStringConvertible {
     }
 }
 
+public struct MediaUploadEvent: CustomStringConvertible {
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        self.values = values
+    }
+
+    public var type: String {
+        stringValue(values, "type") ?? ""
+    }
+
+    public var requestId: String {
+        stringValue(values, "requestId") ?? ""
+    }
+
+    public var mediaUrl: String? {
+        stringValue(values, "mediaUrl")
+    }
+
+    public var errorMessage: String? {
+        stringValue(values, "errorMessage")
+    }
+
+    public var mediaType: Int? {
+        intValue(values["mediaType"])
+    }
+
+    public var timestamp: Int {
+        intValue(values["timestamp"]) ?? Int(Date().timeIntervalSince1970 * 1000)
+    }
+
+    public var isSuccess: Bool {
+        type == "media_success"
+    }
+
+    public var isVideo: Bool {
+        mediaType == 2
+    }
+
+    public var description: String {
+        "MediaUploadEvent(requestId: \(requestId), type: \(type), mediaType: \(mediaType ?? -1))"
+    }
+}
+
 public enum PhotoResponse: CustomStringConvertible, Equatable {
     public enum State: String {
         case success

package/ios/Source/events/BluetoothEvents.swift

@@ -244,6 +244,7 @@ public enum BluetoothEvent: CustomStringConvertible {
     case photoResponse(PhotoResponseEvent)
     case photoStatus(PhotoStatusEvent)
     case videoRecordingStatus(VideoRecordingStatusEvent)
+    case mediaUpload(MediaUploadEvent)
     case rgbLedControlResponse(RgbLedControlResponseEvent)
     case streamStatus(StreamStatusEvent)
     case keepAliveAck(KeepAliveAckEvent)
@@ -277,6 +278,8 @@ public enum BluetoothEvent: CustomStringConvertible {
             event.description
         case let .videoRecordingStatus(event):
             event.description
+        case let .mediaUpload(event):
+            event.description
         case let .rgbLedControlResponse(event):
             event.description
         case let .streamStatus(event):

package/ios/Source/internal/BluetoothAvailability.swift

@@ -6,6 +6,7 @@ final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
 
     private var centralManager: CBCentralManager?
     private var state: CBManagerState = .unknown
+    private var listeners: [UUID: (CBManagerState) -> Void] = [:]
 
     override private init() {
         super.init()
@@ -19,6 +20,25 @@ final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
 
     func centralManagerDidUpdateState(_ central: CBCentralManager) {
         state = central.state
+        for listener in Array(listeners.values) {
+            listener(state)
+        }
+    }
+
+    @discardableResult
+    func addStateListener(_ listener: @escaping (CBManagerState) -> Void) -> UUID {
+        // `listeners` is unsynchronized; it is only safe because the central
+        // manager queue is `.main` and all callers are main-thread bound.
+        dispatchPrecondition(condition: .onQueue(.main))
+        let id = UUID()
+        listeners[id] = listener
+        listener(state)
+        return id
+    }
+
+    func removeStateListener(_ id: UUID) {
+        dispatchPrecondition(condition: .onQueue(.main))
+        listeners[id] = nil
     }
 
     func requirePoweredOn(operation: String) throws {

package/ios/Source/internal/BluetoothSdkAnalytics.swift

@@ -0,0 +1,160 @@
+import Foundation
+
+public struct BluetoothSdkAnalyticsConfiguration {
+    public static let disabled = BluetoothSdkAnalyticsConfiguration(enabled: false)
+
+    public let enabled: Bool
+    let surface: String
+
+    public init(enabled: Bool = true) {
+        self.enabled = enabled
+        surface = "ios"
+    }
+
+    var isReady: Bool {
+        enabled
+    }
+
+    func withSurface(_ surface: String) -> BluetoothSdkAnalyticsConfiguration {
+        BluetoothSdkAnalyticsConfiguration(
+            enabled: enabled,
+            surface: surface
+        )
+    }
+
+    private init(
+        enabled: Bool,
+        surface: String
+    ) {
+        self.enabled = enabled
+        self.surface = surface
+    }
+}
+
+final class BluetoothSdkAnalytics {
+    private static let defaultPostHogApiKey = "phc_FCweXVAxVgU7wZK4Fk3okOx4RmyNqVHJf62YpZSfJt5"
+    private static let defaultPostHogHost = "https://us.i.posthog.com"
+    private let stateQueue = DispatchQueue(label: "com.mentra.bluetoothsdk.analytics.state")
+    private let transportQueue = DispatchQueue(label: "com.mentra.bluetoothsdk.analytics.transport")
+    private let configuration: BluetoothSdkAnalyticsConfiguration
+    private var startedCaptured = false
+    private var lastConnected = false
+
+    init(configuration: BluetoothSdkAnalyticsConfiguration) {
+        self.configuration = configuration.resolvedForApp()
+    }
+
+    func initializeGlassesStatus(_ status: GlassesStatus) {
+        stateQueue.sync {
+            lastConnected = status.analyticsConnected
+        }
+    }
+
+    func captureStarted() {
+        stateQueue.sync {
+            captureStartedLocked()
+        }
+    }
+
+    private func captureStartedLocked() {
+        guard !startedCaptured, configuration.isReady else { return }
+        startedCaptured = true
+        capture(
+            event: "bluetooth_sdk_started",
+            properties: ["event_kind": "sdk_started"],
+            configuration: configuration
+        )
+    }
+
+    func observeGlassesStatus(_ status: GlassesStatus) {
+        stateQueue.sync {
+            let isConnected = status.analyticsConnected
+            let wasConnected = lastConnected
+            lastConnected = isConnected
+            guard configuration.isReady else { return }
+            if isConnected, !wasConnected {
+                var properties: [String: Any] = [
+                    "event_kind": "glasses_connected",
+                    "fully_booted": status.fullyBooted,
+                ]
+                if !status.deviceModel.isEmpty {
+                    properties["glasses_model"] = status.deviceModel
+                }
+                capture(event: "bluetooth_sdk_glasses_connected", properties: properties, configuration: configuration)
+            }
+        }
+    }
+
+    private func capture(
+        event: String,
+        properties: [String: Any],
+        configuration activeConfiguration: BluetoothSdkAnalyticsConfiguration
+    ) {
+        guard activeConfiguration.isReady else { return }
+
+        transportQueue.async {
+            let payload: [String: Any] = [
+                "api_key": Self.defaultPostHogApiKey,
+                "event": event,
+                "distinct_id": self.distinctId(),
+                "properties": self.baseProperties(configuration: activeConfiguration).merging(properties) { _, new in new },
+            ]
+            guard let body = try? JSONSerialization.data(withJSONObject: payload) else { return }
+            guard let captureURL = self.captureURL() else { return }
+            var request = URLRequest(url: captureURL)
+            request.httpMethod = "POST"
+            request.timeoutInterval = 4
+            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            request.httpBody = body
+            URLSession.shared.dataTask(with: request).resume()
+        }
+    }
+
+    private func baseProperties(configuration: BluetoothSdkAnalyticsConfiguration) -> [String: Any] {
+        var properties: [String: Any] = [
+            "$process_person_profile": false,
+            "event_source": "mentra_bluetooth_sdk",
+            "sdk_platform": "ios",
+            "sdk_surface": configuration.surface,
+            "app_bundle_identifier": Bundle.main.bundleIdentifier ?? "",
+            "os_platform": "ios",
+            "os_version": ProcessInfo.processInfo.operatingSystemVersionString,
+        ]
+        if let sdkVersion = BluetoothSdkDefaults.sdkVersion {
+            properties["sdk_version"] = sdkVersion
+        }
+        return properties
+    }
+
+    private func distinctId() -> String {
+        let key = "mentra_bluetooth_sdk_analytics_distinct_id"
+        if let existing = UserDefaults.standard.string(forKey: key), !existing.isEmpty {
+            return existing
+        }
+        let generated = "mentra-bt-sdk-\(UUID().uuidString)"
+        UserDefaults.standard.set(generated, forKey: key)
+        return generated
+    }
+
+    private func captureURL() -> URL? {
+        let normalized = Self.defaultPostHogHost.trimmingCharacters(in: .whitespacesAndNewlines).trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        return URL(string: "\(normalized)/i/v0/e/")
+    }
+}
+
+private extension GlassesStatus {
+    var analyticsConnected: Bool {
+        connectionState.isConnected || connected || fullyBooted
+    }
+}
+
+private extension BluetoothSdkAnalyticsConfiguration {
+    func resolvedForApp() -> BluetoothSdkAnalyticsConfiguration {
+        let disabledByApp = Bundle.main.object(forInfoDictionaryKey: "MentraBluetoothSdkAnalyticsDisabled") as? Bool == true
+
+        return BluetoothSdkAnalyticsConfiguration(
+            enabled: enabled && !disabledByApp,
+            surface: surface
+        )
+    }
+}

package/ios/Source/sgcs/G1.swift

@@ -786,7 +786,7 @@ class G1: NSObject, SGCManager {
         //    }
     }
 
-    func sendTextWall(_ text: String) {
+    func sendTextWall(_ text: String) async {
         let chunks = textHelper.createTextWallChunks(text)
         queueChunks(chunks, sleepAfterMs: 10)
     }
@@ -799,7 +799,7 @@ class G1: NSObject, SGCManager {
         }
     }
 
-    func sendDoubleTextWall(_ top: String, _ bottom: String) {
+    func sendDoubleTextWall(_ top: String, _ bottom: String) async {
         let chunks = textHelper.createDoubleTextWallChunks(textTop: top, textBottom: bottom)
         queueChunks(chunks, sleepAfterMs: 10)
 
@@ -1886,7 +1886,7 @@ extension G1 {
 
     func clearDisplay() {
         Bridge.log("G1: clearDisplay() - Using space")
-        sendTextWall(" ")
+        Task { await sendTextWall(" ") }
     }
 
     /// Create a simple test BMP pattern in hex format