@mentra/bluetooth-sdk 0.1.10 → 0.1.12

package/README.md

@@ -150,6 +150,55 @@ uses a CoreBluetooth identifier when available, and the SDK falls back to
 platform reports RSSI, so picker UI should handle `undefined` and avoid
 reordering rows just because RSSI metadata arrives later.
 
+## Mentra SDK Usage Analytics
+
+The SDK sends two anonymous usage events to Mentra's PostHog project by default
+so Mentra can understand SDK adoption and successful glasses connections:
+
+- `bluetooth_sdk_started`: sent once per app runtime after the native SDK starts.
+- `bluetooth_sdk_glasses_connected`: sent when SDK status transitions from not connected to connected.
+
+Analytics delivery is fire-and-forget: events are submitted asynchronously, do
+not block Bluetooth SDK behavior, and are not retried if delivery fails.
+
+React Native / Expo apps can disable these events before SDK startup through
+the config plugin:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      [
+        "@mentra/bluetooth-sdk",
+        {
+          "analytics": false
+        }
+      ]
+    ]
+  }
+}
+```
+
+Native Android apps can pass `BluetoothSdkAnalyticsConfig.disabled()` in
+`MentraBluetoothSdkConfig` or add
+`com.mentra.bluetoothsdk.analytics.disabled=true` as application metadata.
+Native iOS apps can pass `.disabled` in `MentraBluetoothSDKConfiguration` or set
+`MentraBluetoothSdkAnalyticsDisabled` to `true` in `Info.plist`.
+
+Mentra's PostHog project API key is embedded in the SDK as a public analytics
+write token, not a private PostHog personal API key. Apps do not configure the
+analytics destination; these SDK usage events are always sent to Mentra's
+PostHog project unless analytics are disabled.
+
+Captured properties are limited to non-sensitive SDK/app metadata:
+`event_source`, `sdk_platform`, `sdk_surface`, `sdk_version`, the app package or
+bundle identifier, OS platform/version, `event_kind`, and for connection events
+only `fully_booted` plus a glasses model value when the SDK knows it. The SDK
+does not upload BLE MAC addresses, CoreBluetooth identifiers, serial numbers,
+Bluetooth device names, user ids, tokens, Wi-Fi credentials, microphone data,
+photos, or transcripts. PostHog receives a locally generated anonymous SDK
+install id as `distinct_id`, and events include `$process_person_profile: false`.
+
 ## React Hooks
 
 React Native apps can import optional lifecycle helpers from the `react`
@@ -274,7 +323,7 @@ React Native narrows returned values to success shapes where the raw listener ev
 | --- | --- | --- |
 | `requestPhoto(...)` | Terminal `PhotoSuccessResponseEvent` with `state: "success"` after capture and delivery finish. `uploadUrl` is always present; webhook JSON metadata such as `photoUrl`, `statusUrl`, `contentType`, or `fileSizeBytes` is included when the receiver returns it. | Rejects when raw `photo_response.state === "error"`, the SDK cannot send the command, or the terminal photo response times out. |
 | `startVideoRecording(...)` | `VideoRecordingStartedStatusEvent` with `success: true` and `status: "recording_started"`. | Rejects on `success: false` statuses such as `already_recording`, send failure, or timeout. |
-| `stopVideoRecording(...)` | `VideoRecordingStoppedStatusEvent` with `success: true` and `status: "recording_stopped"`. | Rejects on `success: false` statuses such as `not_recording`, send failure, or timeout. |
+| `stopVideoRecording(...)` | `VideoRecordingStoppedStatusEvent` with `success: true` and `status: "recording_stopped"`. When a webhook URL is supplied, resolves after the video upload succeeds. | Rejects on `success: false` statuses such as `not_recording`, webhook upload failure, send failure, or timeout. |
 | `rgbLedControl(...)` | `RgbLedControlSuccessResponseEvent` with `state: "success"`. | Rejects when raw `rgb_led_control_response.state === "error"` or the response times out. |
 | `checkForOtaUpdate()` / `retryOtaVersionCheck()` | `OtaQueryResult`, either `ota_update_available` or current `ota_status`. | Rejects on command transport timeout/failure. A returned `ota_status.status === "failed"` is glasses OTA state, not a command rejection. |
 
@@ -332,7 +381,7 @@ For one-shot manual capture tuning, pass `exposureTimeNs` and `iso` together. `e
 
 Use `setCameraFov({fov, roiPosition})` to configure Mentra Live camera field of view and crop position. FOV is clamped to 62-118 degrees; ROI position is `"center"`, `"bottom"`, or `"top"`. You can also call `setCameraFov({preset: "narrow" | "standard" | "wide"})`; presets map to 82, 102, and 118 degrees with center ROI. The returned `CameraFovResult` resolves only after the ASG client reports that the setting was applied to camera hardware after the restart cooldown, and the promise rejects if the glasses report an error, persist the setting without hardware application, or time out. Raw `settings_ack` events remain available through `addListener("settings_ack", ...)` for diagnostic fields such as `hardwareApplied`. Treat FOV as a framing/ROI control; output resolution and effective detail can vary by capture path, firmware, and camera mode.
 
-`startVideoRecording(...)` and `stopVideoRecording(...)` resolve from successful ASG `video_recording_status` events only when the status matches the requested operation (`recording_started` or `recording_stopped`) and reject when the ASG reports `success: false`. Raw `video_recording_status` events remain available through listeners, including `recording_status` query events with `data.recording`.
+`startVideoRecording(...)` resolves from the ASG `video_recording_status` event whose status is `recording_started`. `stopVideoRecording(...)` without a webhook resolves from `recording_stopped`; with a webhook it waits for `recording_stopped` plus a video `media_success`, and rejects on `media_error`. Raw `video_recording_status`, `media_success`, and `media_error` events remain available through listeners.
 
 ## Streaming
 
@@ -409,7 +458,7 @@ For bare native iOS apps, use the public SwiftPM repository:
 https://github.com/Mentra-Community/mentra-bluetooth-sdk-ios.git
 ```
 
-Add the `MentraBluetoothSDK` product to your app target at version `0.1.7` or newer.
+Add the `MentraBluetoothSDK` product to your app target at version `0.1.12` or newer.
 
 For local SDK development, add this package folder directly in Xcode:
 

package/android/build.gradle

@@ -213,6 +213,7 @@ android {
   defaultConfig {
     versionCode 1
     versionName project.version
+    buildConfigField "String", "SDK_VERSION", "\"${project.version}\""
   }
   publishing {
     singleVariant("release") {

package/android/src/main/java/com/mentra/bluetoothsdk/BluetoothSdkAnalytics.kt

@@ -0,0 +1,182 @@
+package com.mentra.bluetoothsdk
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.UUID
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.RejectedExecutionException
+
+class BluetoothSdkAnalyticsConfig private constructor(
+    val enabled: Boolean,
+    internal val surface: String,
+) {
+    @JvmOverloads
+    constructor(enabled: Boolean = true) : this(enabled, "android")
+
+    internal fun withSurface(surface: String): BluetoothSdkAnalyticsConfig =
+        BluetoothSdkAnalyticsConfig(enabled, surface)
+
+    companion object {
+        @JvmStatic
+        fun disabled(): BluetoothSdkAnalyticsConfig = BluetoothSdkAnalyticsConfig(enabled = false)
+    }
+}
+
+private data class BluetoothSdkAnalyticsRuntimeConfig(
+    val enabled: Boolean = true,
+    val surface: String = "android",
+) {
+    val isReady: Boolean
+        get() = enabled
+}
+
+internal class BluetoothSdkAnalytics(
+    private val context: Context,
+    initialConfig: BluetoothSdkAnalyticsConfig,
+) {
+    private val appContext = context.applicationContext
+    private val executor: ExecutorService = Executors.newSingleThreadExecutor { runnable ->
+        Thread(runnable, "MentraBluetoothSdkAnalytics").apply { isDaemon = true }
+    }
+    // startedCaptured/lastConnected are touched from store listeners and SDK
+    // entry points, hence @Synchronized on methods that read or write them.
+    private val config = initialConfig.toRuntimeConfig().resolvedForApp(appContext)
+    private var startedCaptured = false
+    private var lastConnected = false
+
+    @Synchronized
+    fun initializeGlassesStatus(status: GlassesStatus) {
+        lastConnected = status.analyticsConnected
+    }
+
+    @Synchronized
+    fun captureStarted() {
+        if (startedCaptured || !config.isReady) return
+        startedCaptured = true
+        capture("bluetooth_sdk_started", mapOf("event_kind" to "sdk_started"))
+    }
+
+    @Synchronized
+    fun observeGlassesStatus(status: GlassesStatus) {
+        val isConnected = status.analyticsConnected
+        val wasConnected = lastConnected
+        lastConnected = isConnected
+        if (!config.isReady) return
+        if (isConnected && !wasConnected) {
+            capture(
+                "bluetooth_sdk_glasses_connected",
+                buildMap {
+                    put("event_kind", "glasses_connected")
+                    put("fully_booted", status.fullyBooted)
+                    status.deviceModel.takeIf { it.isNotBlank() }?.let { put("glasses_model", it) }
+                },
+            )
+        }
+    }
+
+    fun shutdown() {
+        executor.shutdown()
+    }
+
+    private fun capture(
+        eventName: String,
+        eventProperties: Map<String, Any>,
+    ) {
+        val activeConfig = config
+        if (!activeConfig.isReady) return
+
+        try {
+            // Payload construction stays on the executor: distinctId() reads
+            // SharedPreferences, which must not run on the caller (often main) thread.
+            executor.execute {
+                try {
+                    val payload =
+                        JSONObject(
+                            mapOf(
+                                "api_key" to DEFAULT_POSTHOG_API_KEY,
+                                "event" to eventName,
+                                "distinct_id" to distinctId(),
+                                "properties" to baseProperties(activeConfig) + eventProperties,
+                            )
+                        )
+                    val connection = URL(captureUrl()).openConnection() as HttpURLConnection
+                    connection.requestMethod = "POST"
+                    connection.connectTimeout = 4_000
+                    connection.readTimeout = 4_000
+                    connection.doOutput = true
+                    connection.setRequestProperty("Content-Type", "application/json")
+                    connection.outputStream.use { output ->
+                        output.write(payload.toString().toByteArray(Charsets.UTF_8))
+                    }
+                    connection.inputStream.close()
+                    connection.disconnect()
+                } catch (_: Exception) {
+                    // Analytics must never affect Bluetooth SDK behavior.
+                }
+            }
+        } catch (_: RejectedExecutionException) {
+            // The executor was shut down (SDK closed); dropping the event is fine.
+        }
+    }
+
+    private fun baseProperties(activeConfig: BluetoothSdkAnalyticsRuntimeConfig): Map<String, Any> =
+        buildMap {
+            put("\$process_person_profile", false)
+            put("event_source", "mentra_bluetooth_sdk")
+            put("sdk_platform", "android")
+            put("sdk_surface", activeConfig.surface)
+            put("sdk_version", BuildConfig.SDK_VERSION)
+            put("app_package", appContext.packageName)
+            put("os_platform", "android")
+            put("os_version", Build.VERSION.SDK_INT)
+        }
+
+    private fun distinctId(): String {
+        val prefs = appContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        prefs.getString(PREFS_DISTINCT_ID, null)?.let { return it }
+        val generated = "mentra-bt-sdk-${UUID.randomUUID()}"
+        prefs.edit().putString(PREFS_DISTINCT_ID, generated).apply()
+        return generated
+    }
+
+    private fun captureUrl(): String {
+        val normalized = DEFAULT_POSTHOG_HOST.trim().trimEnd('/')
+        return "$normalized/i/v0/e/"
+    }
+
+    companion object {
+        internal const val META_ANALYTICS_DISABLED = "com.mentra.bluetoothsdk.analytics.disabled"
+        private const val PREFS_NAME = "mentra_bluetooth_sdk_analytics"
+        private const val PREFS_DISTINCT_ID = "distinct_id"
+        private const val DEFAULT_POSTHOG_API_KEY = "phc_FCweXVAxVgU7wZK4Fk3okOx4RmyNqVHJf62YpZSfJt5"
+        private const val DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com"
+    }
+}
+
+private fun BluetoothSdkAnalyticsConfig.toRuntimeConfig(): BluetoothSdkAnalyticsRuntimeConfig =
+    BluetoothSdkAnalyticsRuntimeConfig(enabled = enabled, surface = surface)
+
+private fun BluetoothSdkAnalyticsRuntimeConfig.resolvedForApp(context: Context): BluetoothSdkAnalyticsRuntimeConfig {
+    val metadata =
+        try {
+            context.packageManager
+                .getApplicationInfo(context.packageName, PackageManager.GET_META_DATA)
+                .metaData
+        } catch (_: Exception) {
+            null
+        }
+
+    val disabledByApp = metadata?.getBoolean(BluetoothSdkAnalytics.META_ANALYTICS_DISABLED, false) == true
+
+    return copy(
+        enabled = enabled && !disabledByApp,
+    )
+}
+
+private val GlassesStatus.analyticsConnected: Boolean
+    get() = connectionState.isConnected || connected || fullyBooted

package/android/src/main/java/com/mentra/bluetoothsdk/BluetoothSdkModule.kt

@@ -2,8 +2,11 @@ package com.mentra.bluetoothsdk
 
 import com.mentra.bluetoothsdk.debug.BleTraceLogger
 import com.mentra.bluetoothsdk.utils.DeviceTypes
+import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 
 class BluetoothSdkModule : Module() {
     private var sdk: MentraBluetoothSdk? = null
@@ -117,6 +120,10 @@ class BluetoothSdkModule : Module() {
                     sendEvent("video_recording_status", event.values)
                 }
 
+                override fun onMediaUpload(event: MediaUploadEvent) {
+                    sendEvent(event.type, event.values)
+                }
+
                 override fun onRgbLedControlResponse(event: RgbLedControlResponseEvent) {
                     sendEvent("rgb_led_control_response", event.values)
                 }
@@ -195,6 +202,9 @@ class BluetoothSdkModule : Module() {
             "glasses_not_ready",
             "button_press",
             "touch_event",
+            "accel_event",
+            "CompassHeadingEvent",
+            "CompassCalibrationEvent",
             "head_up",
             "voice_activity_detection_status",
             "speaking_status",
@@ -207,6 +217,8 @@ class BluetoothSdkModule : Module() {
             "photo_response",
             "photo_status",
             "video_recording_status",
+            "media_success",
+            "media_error",
             "gallery_status",
             "compatible_glasses_search_stop",
             "heartbeat_sent",
@@ -250,7 +262,14 @@ class BluetoothSdkModule : Module() {
                             ?: appContext.currentActivity
                                     ?: throw IllegalStateException("No context available")
             BleTraceLogger.logLifecycle(context, "BluetoothSdkModule", "module_create")
-            sdk = MentraBluetoothSdk.create(context, sdkListener)
+            sdk =
+                    MentraBluetoothSdk.create(
+                            context,
+                            MentraBluetoothSdkConfig(
+                                    analytics = BluetoothSdkAnalyticsConfig().withSurface("react_native")
+                            ),
+                            sdkListener,
+                    )
             deviceManager = DeviceManager.getInstance()
         }
 
@@ -499,12 +518,18 @@ class BluetoothSdkModule : Module() {
                             dim("width"),
                             dim("height"),
                             dim("fps"),
+                            dim("maxRecordingTimeMinutes"),
                     )
             ).values
         }
 
-        AsyncFunction("stopVideoRecording") { requestId: String ->
-            requireSdk().stopVideoRecording(requestId).values
+        // webhookUrl/authToken are supplied at stop (not start) so the token is
+        // fresh when the upload runs. Empty/null webhook = keep on device.
+        AsyncFunction("stopVideoRecording") {
+                requestId: String,
+                webhookUrl: String?,
+                authToken: String? ->
+            requireSdk().stopVideoRecording(requestId, webhookUrl, authToken).values
         }
 
         // MARK: - Stream Commands
@@ -534,7 +559,12 @@ class BluetoothSdkModule : Module() {
             )
         }
 
-        AsyncFunction("restartTranscriber") { deviceManager?.restartTranscriber() }
+        // Runs on Dispatchers.IO, not the shared Expo AsyncFunctionQueue: restart()
+        // does a synchronous JNI model reload that would otherwise block every other
+        // native call in the app until it completes.
+        AsyncFunction("restartTranscriber") Coroutine { ->
+            withContext(Dispatchers.IO) { deviceManager?.restartTranscriber() }
+        }
 
         // MARK: - Audio Playback Monitoring
 
@@ -542,14 +572,17 @@ class BluetoothSdkModule : Module() {
             sdk?.setOwnAppAudioPlaying(playing)
         }
 
-        AsyncFunction("getGlassesMediaVolume") {
+        // *Blocking on Dispatchers.IO, not the shared AsyncFunctionQueue: these wait on
+        // a CountDownLatch (up to 5s) for a BLE round-trip, which would otherwise stall
+        // every other native call queued behind them.
+        AsyncFunction("getGlassesMediaVolume") Coroutine { ->
             val cm = deviceManager ?: throw IllegalStateException("device_manager_null")
-            cm.getGlassesMediaVolumeBlocking()
+            withContext(Dispatchers.IO) { cm.getGlassesMediaVolumeBlocking() }
         }
 
-        AsyncFunction("setGlassesMediaVolume") { level: Int ->
+        AsyncFunction("setGlassesMediaVolume") Coroutine { level: Int ->
             val cm = deviceManager ?: throw IllegalStateException("device_manager_null")
-            cm.setGlassesMediaVolumeBlocking(level)
+            withContext(Dispatchers.IO) { cm.setGlassesMediaVolumeBlocking(level) }
         }
 
         // MARK: - RGB LED Control
@@ -605,8 +638,13 @@ class BluetoothSdkModule : Module() {
             com.mentra.bluetoothsdk.stt.STTTools.validateSTTModel(path)
         }
 
-        AsyncFunction("extractTarBz2") { sourcePath: String, destinationPath: String ->
-            com.mentra.bluetoothsdk.stt.STTTools.extractTarBz2(sourcePath, destinationPath)
+        // Runs on Dispatchers.IO, not the shared Expo AsyncFunctionQueue: bz2/tar
+        // extraction of the 100–350MB model is a multi-minute, CPU-bound job. On the
+        // shared queue it froze every other native call in the app until it finished.
+        AsyncFunction("extractTarBz2") Coroutine { sourcePath: String, destinationPath: String ->
+            withContext(Dispatchers.IO) {
+                com.mentra.bluetoothsdk.stt.STTTools.extractTarBz2(sourcePath, destinationPath)
+            }
         }
 
         // MARK: - TTS Commands
@@ -647,7 +685,9 @@ class BluetoothSdkModule : Module() {
             com.mentra.core.tts.TTSTools.validateTTSModel(path)
         }
 
-        AsyncFunction("generateTtsAudio") {
+        // Runs on Dispatchers.IO, not the shared Expo AsyncFunctionQueue: TTS synthesis
+        // is a synchronous JNI call that would otherwise block other native calls.
+        AsyncFunction("generateTtsAudio") Coroutine {
                 text: String,
                 modelPath: String,
                 outputPath: String,
@@ -657,14 +697,16 @@ class BluetoothSdkModule : Module() {
                     appContext.reactContext
                             ?: appContext.currentActivity
                                     ?: throw IllegalStateException("No context available")
-            com.mentra.core.tts.TTSTools.generateTtsAudio(
-                    context,
-                    text,
-                    modelPath,
-                    outputPath,
-                    speakerId,
-                    speed.toFloat()
-            )
+            withContext(Dispatchers.IO) {
+                com.mentra.core.tts.TTSTools.generateTtsAudio(
+                        context,
+                        text,
+                        modelPath,
+                        outputPath,
+                        speakerId,
+                        speed.toFloat()
+                )
+            }
         }
     }
 }

package/android/src/main/java/com/mentra/bluetoothsdk/Bridge.kt

@@ -417,6 +417,16 @@ public class Bridge private constructor() {
             sendTypedMessage("video_recording_status", body)
         }
 
+        @JvmStatic
+        fun sendMediaUploadEvent(type: String, values: Map<String, Any>) {
+            val body = HashMap<String, Any>()
+            body["type"] = type
+            values.forEach { (key, value) ->
+                body[key] = value
+            }
+            sendTypedMessage(type, body)
+        }
+
         @JvmStatic
         fun sendVersionInfo(values: Map<String, Any>) {
             fun stringField(vararg keys: String): String =
@@ -681,6 +691,20 @@ public class Bridge private constructor() {
             sendTypedMessage("imu_gesture_event", eventBody as Map<String, Any>)
         }
 
+        /**
+         * Send a single accelerometer reading from the glasses IMU - matches iOS
+         * Bridge.sendAccelEvent. A richer combined IMU event (gyro + magnetometer) is future work.
+         */
+        @JvmStatic
+        fun sendAccelEvent(x: Float, y: Float, z: Float, timestamp: Long) {
+            val body = HashMap<String, Any>()
+            body["x"] = x
+            body["y"] = y
+            body["z"] = z
+            body["timestamp"] = timestamp
+            sendTypedMessage("accel_event", body as Map<String, Any>)
+        }
+
         // Arbitrary WS Comms (don't use these, make a dedicated function for your use case):
 
         /** Send WebSocket text message */

package/android/src/main/java/com/mentra/bluetoothsdk/DeviceManager.kt

@@ -27,6 +27,9 @@ import com.mentra.bluetoothsdk.utils.MicMap
 import com.mentra.bluetoothsdk.utils.MicTypes
 import com.mentra.lc3Lib.Lc3Cpp
 import com.mentra.bluetoothsdk.stt.SherpaOnnxTranscriber
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import java.text.SimpleDateFormat
 import java.util.*
 import java.util.concurrent.CountDownLatch
@@ -1124,8 +1127,22 @@ class DeviceManager {
 
         syncSystemTimeOnceForConnection(readyKey)
 
-        // Apply dashboard position before any boot text so content doesn't jump.
-        sgc?.setDashboardPosition(dashboardHeight, dashboardDepth)
+        // re-apply display height/depth after reconnection
+        mainHandler.postDelayed(
+                {
+                    val h =
+                            (DeviceStore.store.get("bluetooth", "dashboard_height") as? Number)
+                                    ?.toInt()
+                                    ?: 4
+                    val rawDepth =
+                            (DeviceStore.store.get("bluetooth", "dashboard_depth") as? Number)
+                                    ?.toInt()
+                                    ?: dashboardDepth // canonical default (2), not 1
+                    val d = rawDepth.coerceIn(1, 4)
+                    sgc?.setDashboardPosition(h, d)
+                },
+                2000
+        )
 
         // Show welcome message on first connect for all display glasses
         if (shouldSendBootingMessage) {
@@ -1288,7 +1305,9 @@ class DeviceManager {
     }
 
     fun showNotificationsPanel() {
-        sgc?.showNotificationsPanel()
+        CoroutineScope(Dispatchers.Main).launch {
+            sgc?.showNotificationsPanel()
+        }
     }
 
     fun ping() {
@@ -1486,17 +1505,22 @@ class DeviceManager {
             width: Int = 0,
             height: 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"
+                        "resolution=${width}x${height}@${fps}fps, maxRecordingTimeMinutes=$maxRecordingTimeMinutes"
         )
-        sgc?.startVideoRecording(requestId, save, true, sound, width, height, fps)
+        sgc?.startVideoRecording(
+                requestId, save, true, sound, width, height, fps, maxRecordingTimeMinutes)
     }
 
-    fun stopVideoRecording(requestId: String) {
-        Bridge.log("MAN: onStopVideoRecording: requestId=$requestId")
-        sgc?.stopVideoRecording(requestId)
+    fun stopVideoRecording(requestId: String, webhookUrl: String?, authToken: String?) {
+        Bridge.log(
+                "MAN: onStopVideoRecording: requestId=$requestId, webhook=" +
+                        if (webhookUrl.isNullOrEmpty()) "none" else "set"
+        )
+        sgc?.stopVideoRecording(requestId, webhookUrl, authToken)
     }
 
     fun setMicState() {

package/android/src/main/java/com/mentra/bluetoothsdk/DeviceStore.kt

@@ -121,6 +121,7 @@ object 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.VOICE_ACTIVITY_DETECTION_ENABLED)
@@ -238,6 +239,13 @@ object DeviceStore {
                     DeviceManager.getInstance().sgc?.setHeadUpAngle(angle)
                 }
             }
+            "bluetooth" to "imu_enabled" -> {
+                (value as? Boolean)?.let { enabled ->
+                    CoroutineScope(Dispatchers.Main).launch {
+                        DeviceManager.getInstance().sgc?.setImuEnabled(enabled)
+                    }
+                }
+            }
             "bluetooth" to "menu_apps" -> {
                 @Suppress("UNCHECKED_CAST")
                 (value as? List<Map<String, Any>>)?.let { items ->