@mentra/bluetooth-sdk 0.1.9 → 0.1.11

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
@@ -113,6 +116,14 @@ class BluetoothSdkModule : Module() {
                     sendEvent("photo_status", event.values)
                 }
 
+                override fun onVideoRecordingStatus(event: VideoRecordingStatusEvent) {
+                    sendEvent("video_recording_status", event.values)
+                }
+
+                override fun onRgbLedControlResponse(event: RgbLedControlResponseEvent) {
+                    sendEvent("rgb_led_control_response", event.values)
+                }
+
                 override fun onStreamStatus(event: StreamStatusEvent) {
                     sendEvent("stream_status", event.values)
                 }
@@ -121,6 +132,26 @@ class BluetoothSdkModule : Module() {
                     sendEvent("keep_alive_ack", event.values)
                 }
 
+                override fun onOtaUpdateAvailable(event: OtaUpdateAvailableEvent) {
+                    sendEvent("ota_update_available", event.values)
+                }
+
+                override fun onOtaStartAck(event: OtaStartAckEvent) {
+                    sendEvent("ota_start_ack", event.values)
+                }
+
+                override fun onOtaStatus(event: OtaStatusEvent) {
+                    sendEvent("ota_status", event.values)
+                }
+
+                override fun onSettingsAck(event: SettingsAckEvent) {
+                    sendEvent("settings_ack", event.values)
+                }
+
+                override fun onVersionInfo(event: VersionInfoResult) {
+                    sendEvent("version_info", event.toMap() + mapOf("type" to "version_info"))
+                }
+
                 override fun onMicPcm(event: MicPcmEvent) {
                     sendEvent("mic_pcm", event.toMap())
                 }
@@ -144,7 +175,14 @@ class BluetoothSdkModule : Module() {
                 override fun onRawEvent(eventName: String, values: Map<String, Any>) {
                     sendEvent(eventName, values)
                 }
-            }
+        }
+
+    private fun requireSdk(): MentraBluetoothSdk =
+            sdk
+                    ?: throw BluetoothException(
+                            "sdk_not_initialized",
+                            "Bluetooth SDK is not initialized.",
+                    )
 
     override fun definition() = ModuleDefinition {
         Name("BluetoothSdk")
@@ -160,16 +198,21 @@ class BluetoothSdkModule : Module() {
             "glasses_not_ready",
             "button_press",
             "touch_event",
+            "accel_event",
+            "CompassHeadingEvent",
+            "CompassCalibrationEvent",
             "head_up",
             "voice_activity_detection_status",
             "speaking_status",
             "battery_status",
             "local_transcription",
             "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",
@@ -179,6 +222,8 @@ class BluetoothSdkModule : Module() {
             "swipe_volume_status",
             "switch_status",
             "rgb_led_control_response",
+            "settings_ack",
+            "version_info",
             "pair_failure",
             "audio_pairing_needed",
             "audio_connected",
@@ -202,6 +247,7 @@ class BluetoothSdkModule : Module() {
             "receive_command_from_ble",
             "miniapp_selected",
             "captions_tester_incident",
+            "extraction_progress",
         )
 
         OnCreate {
@@ -356,29 +402,58 @@ class BluetoothSdkModule : Module() {
 
         // MARK: - WiFi Commands
 
-        AsyncFunction("requestWifiScan") { sdk?.requestWifiScan() }
+        AsyncFunction("requestWifiScan") { requireSdk().requestWifiScan().map { it.toMap() } }
 
         AsyncFunction("sendWifiCredentials") { ssid: String, password: String ->
-            sdk?.sendWifiCredentials(ssid, password)
+            requireSdk().sendWifiCredentials(ssid, password).values
         }
 
-        AsyncFunction("forgetWifiNetwork") { ssid: String -> sdk?.forgetWifiNetwork(ssid) }
+        AsyncFunction("forgetWifiNetwork") { ssid: String -> requireSdk().forgetWifiNetwork(ssid).values }
 
         AsyncFunction("setHotspotState") { enabled: Boolean ->
-            sdk?.setHotspotState(enabled)
+            requireSdk().setHotspotState(enabled).values
+        }
+
+        AsyncFunction("setSystemTime") { timestampMs: Double ->
+            sdk?.setSystemTime(timestampMs.toLong())
         }
 
         // MARK: - Gallery Commands
 
         AsyncFunction("setGalleryModeEnabled") { enabled: Boolean ->
-            sdk?.setGalleryModeEnabled(enabled)
+            requireSdk().setGalleryModeEnabled(enabled).values
         }
 
         AsyncFunction("setVoiceActivityDetectionEnabled") { enabled: Boolean ->
             sdk?.setVoiceActivityDetectionEnabled(enabled)
         }
 
-        AsyncFunction("queryGalleryStatus") { sdk?.queryGalleryStatus() }
+        AsyncFunction("setButtonPhotoSettings") { size: String ->
+            requireSdk().setButtonPhotoSettings(ButtonPhotoSize.fromValue(size)).values
+        }
+
+        AsyncFunction("setButtonVideoRecordingSettings") { width: Int, height: Int, fps: Int ->
+            requireSdk().setButtonVideoRecordingSettings(width, height, fps).values
+        }
+
+        AsyncFunction("setButtonCameraLed") { enabled: Boolean ->
+            requireSdk().setButtonCameraLed(enabled).values
+        }
+
+        AsyncFunction("setButtonMaxRecordingTime") { minutes: Int ->
+            requireSdk().setButtonMaxRecordingTime(minutes).values
+        }
+
+        AsyncFunction("setCameraFov") { fov: Map<String, Any> ->
+            val value = (fov["fov"] as? Number)?.toInt() ?: CameraFov.DEFAULT_FOV
+            val roiPosition = CameraRoiPosition.fromValue(
+                (fov["roiPosition"] as? Number)?.toInt()
+                    ?: (fov["roi_position"] as? Number)?.toInt(),
+            )
+            requireSdk().setCameraFov(CameraFov(value, roiPosition)).values
+        }
+
+        AsyncFunction("queryGalleryStatus") { requireSdk().queryGalleryStatus().values }
 
         AsyncFunction("requestPhoto") { params: Map<String, Any?> ->
             // JS may pass null for optional fields; Map<String, Any> rejects null values at the bridge.
@@ -390,25 +465,20 @@ class BluetoothSdkModule : Module() {
             Bridge.log(
                     "NATIVE: PHOTO PIPELINE [3/6] BluetoothSdk.requestPhoto requestId=${req.requestId} appId=${req.appId} size=${req.size} compress=${req.compress} flash=${req.flash} sound=${req.sound} exposureTimeNs=${req.exposureTimeNs} iso=${req.iso}"
             )
-            val activeSdk = sdk
-            if (activeSdk == null) {
-                Bridge.log(
-                        "NATIVE: PHOTO PIPELINE — sdk is null; requestPhoto dropped requestId=${req.requestId}"
-                )
-            } else {
-                activeSdk.requestPhoto(req)
-            }
+            requireSdk().requestPhoto(req).values
         }
 
         // MARK: - OTA Commands
 
-        AsyncFunction("sendOtaStart") { sdk?.sendOtaStart() }
+        AsyncFunction("sendOtaStart") { requireSdk().sendOtaStart().values }
 
-        AsyncFunction("sendOtaQueryStatus") { sdk?.sendOtaQueryStatus() }
+        AsyncFunction("sendOtaQueryStatus") { requireSdk().sendOtaQueryStatus().values }
+
+        AsyncFunction("retryOtaVersionCheck") { requireSdk().retryOtaVersionCheck().values }
 
         // MARK: - Version Info Commands
 
-        AsyncFunction("requestVersionInfo") { sdk?.requestVersionInfo() }
+        AsyncFunction("requestVersionInfo") { requireSdk().requestVersionInfo().toMap() }
 
         // MARK: - Power Control Commands
 
@@ -418,24 +488,41 @@ class BluetoothSdkModule : Module() {
 
         // MARK: - Video Recording Commands
 
-        AsyncFunction("startVideoRecording") { requestId: String, save: Boolean, sound: Boolean ->
-            sdk?.startVideoRecording(VideoRecordingRequest(requestId, save, sound))
+        AsyncFunction("startVideoRecording") {
+                requestId: String,
+                save: Boolean,
+                sound: Boolean,
+                settings: Map<String, Any?>? ->
+            // 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.
+            fun dim(key: String): Int = (settings?.get(key) as? Number)?.toInt() ?: 0
+            requireSdk().startVideoRecording(
+                    VideoRecordingRequest(
+                            requestId,
+                            save,
+                            sound,
+                            dim("width"),
+                            dim("height"),
+                            dim("fps"),
+                    )
+            ).values
         }
 
         AsyncFunction("stopVideoRecording") { requestId: String ->
-            sdk?.stopVideoRecording(requestId)
+            requireSdk().stopVideoRecording(requestId).values
         }
 
         // MARK: - Stream Commands
 
         AsyncFunction("startStream") { params: Map<String, Any> ->
-            sdk?.startStream(StreamRequest.fromMap(params))
+            requireSdk().startStream(StreamRequest.fromMap(params)).values
         }
 
-        AsyncFunction("stopStream") { sdk?.stopStream() }
+        AsyncFunction("stopStream") { requireSdk().stopStream().values }
 
-        AsyncFunction("sendCloudStreamKeepAlive") { params: Map<String, Any> ->
-            sdk?.sendCloudStreamKeepAlive(StreamKeepAliveRequest.fromMap(params))
+        AsyncFunction("sendExternallyManagedStreamKeepAlive") { params: Map<String, Any> ->
+            sdk?.sendExternallyManagedStreamKeepAlive(StreamKeepAliveRequest.fromMap(params))
         }
 
         // MARK: - Microphone Commands
@@ -453,7 +540,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
 
@@ -461,14 +553,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
@@ -481,7 +576,7 @@ class BluetoothSdkModule : Module() {
                 onDurationMs: Int,
                 offDurationMs: Int,
                 count: Int ->
-            sdk?.rgbLedControl(
+            requireSdk().rgbLedControl(
                     RgbLedRequest(
                             requestId = requestId,
                             packageName = packageName,
@@ -491,7 +586,7 @@ class BluetoothSdkModule : Module() {
                             offDurationMs = offDurationMs,
                             count = count,
                     )
-            )
+            ).values
         }
 
         // MARK: - STT Commands
@@ -524,10 +619,76 @@ 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
+
+        AsyncFunction("setTtsModelDetails") { path: String, languageCode: String ->
+            val context =
+                    appContext.reactContext
+                            ?: appContext.currentActivity
+                                    ?: throw IllegalStateException("No context available")
+            com.mentra.core.tts.TTSTools.setTtsModelDetails(context, path, languageCode)
+        }
+
+        AsyncFunction("getTtsModelPath") { ->
+            val context =
+                    appContext.reactContext
+                            ?: appContext.currentActivity
+                                    ?: throw IllegalStateException("No context available")
+            com.mentra.core.tts.TTSTools.getTtsModelPath(context)
+        }
+
+        AsyncFunction("getTtsModelLanguage") { ->
+            val context =
+                    appContext.reactContext
+                            ?: appContext.currentActivity
+                                    ?: throw IllegalStateException("No context available")
+            com.mentra.core.tts.TTSTools.getTtsModelLanguage(context)
+        }
+
+        AsyncFunction("checkTtsModelAvailable") { ->
+            val context =
+                    appContext.reactContext
+                            ?: appContext.currentActivity
+                                    ?: throw IllegalStateException("No context available")
+            com.mentra.core.tts.TTSTools.checkTTSModelAvailable(context)
+        }
+
+        AsyncFunction("validateTtsModel") { path: String ->
+            com.mentra.core.tts.TTSTools.validateTTSModel(path)
         }
 
+        // 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,
+                speakerId: Int,
+                speed: Double ->
+            val context =
+                    appContext.reactContext
+                            ?: appContext.currentActivity
+                                    ?: throw IllegalStateException("No context available")
+            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

@@ -107,6 +107,16 @@ public class Bridge private constructor() {
             sendTypedMessage("log", data as Map<String, Any>)
         }
 
+        /** Report tar.bz2 extraction progress to JavaScript. */
+        @JvmStatic
+        fun sendExtractionProgress(percentage: Int, bytesRead: Long, totalBytes: Long) {
+            val data = HashMap<String, Any>()
+            data["percentage"] = percentage
+            data["bytesRead"] = bytesRead
+            data["totalBytes"] = totalBytes
+            sendTypedMessage("extraction_progress", data as Map<String, Any>)
+        }
+
         /** Send head position event */
         @JvmStatic
         fun sendHeadUp(isUp: Boolean) {
@@ -153,7 +163,7 @@ public class Bridge private constructor() {
         private fun micPcmEventBody(data: ByteArray): HashMap<String, Any> {
             val voiceActivityDetectionEnabled =
                     DeviceStore.get("glasses", "voiceActivityDetectionEnabled") as? Boolean
-                            ?: true
+                            ?: BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED
             val body = HashMap<String, Any>()
             body["pcm"] = data
             body["sampleRate"] = MIC_SAMPLE_RATE
@@ -167,7 +177,7 @@ public class Bridge private constructor() {
         private fun micLc3EventBody(data: ByteArray): HashMap<String, Any> {
             val voiceActivityDetectionEnabled =
                     DeviceStore.get("glasses", "voiceActivityDetectionEnabled") as? Boolean
-                            ?: true
+                            ?: BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED
             val frameSizeBytes =
                     (DeviceStore.store.get("bluetooth", "lc3_frame_size") as? Number)?.toInt()
                             ?: DEFAULT_LC3_FRAME_SIZE_BYTES
@@ -357,15 +367,6 @@ public class Bridge private constructor() {
             event["errorMessage"] = errorMessage
             event["timestamp"] = timestamp
             sendTypedMessage("photo_response", event as Map<String, Any>)
-
-            val status = HashMap<String, Any>()
-            status["type"] = "photo_status"
-            status["status"] = "failed"
-            status["requestId"] = requestId
-            status["errorCode"] = errorCode
-            status["errorMessage"] = errorMessage
-            status["timestamp"] = timestamp
-            sendTypedMessage("photo_status", status as Map<String, Any>)
         }
 
         @JvmStatic
@@ -373,6 +374,11 @@ public class Bridge private constructor() {
             sendTypedMessage("photo_status", statusJson)
         }
 
+        @JvmStatic
+        fun sendPhotoResponse(responseJson: Map<String, Any>) {
+            sendTypedMessage("photo_response", responseJson)
+        }
+
         /** Send RGB LED control response */
         @JvmStatic
         fun sendRgbLedControlResponse(requestId: String, success: Boolean, error: String?) {
@@ -391,6 +397,45 @@ public class Bridge private constructor() {
             }
         }
 
+        @JvmStatic
+        fun sendSettingsAck(values: Map<String, Any>) {
+            val body = HashMap<String, Any>()
+            body["type"] = "settings_ack"
+            values.forEach { (key, value) ->
+                body[key] = value
+            }
+            sendTypedMessage("settings_ack", body)
+        }
+
+        @JvmStatic
+        fun sendVideoRecordingStatus(values: Map<String, Any>) {
+            val body = HashMap<String, Any>()
+            body["type"] = "video_recording_status"
+            values.forEach { (key, value) ->
+                body[key] = value
+            }
+            sendTypedMessage("video_recording_status", body)
+        }
+
+        @JvmStatic
+        fun sendVersionInfo(values: Map<String, Any>) {
+            fun stringField(vararg keys: String): String =
+                    keys.firstNotNullOfOrNull { key -> values[key] as? String } ?: ""
+            val body = HashMap<String, Any>()
+            body["type"] = "version_info"
+            body["androidVersion"] = stringField("androidVersion", "android_version")
+            body["firmwareVersion"] = stringField("firmwareVersion", "firmware_version")
+            body["besFirmwareVersion"] = stringField("besFirmwareVersion", "bes_fw_version")
+            body["mtkFirmwareVersion"] = stringField("mtkFirmwareVersion", "mtk_fw_version")
+            body["buildNumber"] = stringField("buildNumber", "build_number")
+            (values["systemTimeMs"] as? Number ?: values["system_time_ms"] as? Number)?.let {
+                body["systemTimeMs"] = it.toLong()
+            }
+            body["otaVersionUrl"] = stringField("otaVersionUrl", "ota_version_url")
+            body["appVersion"] = stringField("appVersion", "app_version")
+            sendTypedMessage("version_info", body)
+        }
+
         /**
          * Send transcription result to server Used by AOSManager to send pre-formatted
          * transcription results Matches the Swift structure exactly
@@ -457,7 +502,7 @@ public class Bridge private constructor() {
 
         /** Send WiFi scan results */
         @JvmStatic
-        fun updateWifiScanResults(networks: List<Map<String, Any>>) {
+        fun updateWifiScanResults(networks: List<Map<String, Any>>, scanComplete: Boolean) {
             var storedNetworks: List<Map<String, Any>> =
                     DeviceStore.get("bluetooth", "wifiScanResults") as? List<Map<String, Any>>
                             ?: emptyList()
@@ -469,6 +514,10 @@ public class Bridge private constructor() {
                 }
             }
             DeviceStore.apply("bluetooth", "wifiScanResults", updatedNetworks)
+            val body = HashMap<String, Any>()
+            body["networks"] = updatedNetworks
+            body["scanComplete"] = scanComplete
+            sendTypedMessage("wifi_scan_result", body)
         }
 
         /** Send gallery status - matches iOS MentraLive.swift handleGalleryStatus pattern */
@@ -478,14 +527,21 @@ public class Bridge private constructor() {
                 videoCount: Int,
                 totalCount: Int,
                 totalSize: Long,
-                hasContent: Boolean
+                hasContent: Boolean,
+                cameraBusy: Boolean,
+                cameraBusyReason: String?
         ) {
             val galleryData = HashMap<String, Any>()
+            galleryData["type"] = "gallery_status"
             galleryData["photos"] = photoCount
             galleryData["videos"] = videoCount
             galleryData["total"] = totalCount
             galleryData["totalSize"] = totalSize
             galleryData["hasContent"] = hasContent
+            galleryData["cameraBusy"] = cameraBusy
+            if (!cameraBusyReason.isNullOrBlank()) {
+                galleryData["cameraBusyReason"] = cameraBusyReason
+            }
 
             sendTypedMessage("gallery_status", galleryData as Map<String, Any>)
         }
@@ -550,6 +606,7 @@ public class Bridge private constructor() {
         }
 
         @JvmStatic
+        @JvmOverloads
         fun sendOtaStatus(
                 sessionId: String,
                 totalSteps: Int,
@@ -559,7 +616,8 @@ public class Bridge private constructor() {
                 stepPercent: Int,
                 overallPercent: Int,
                 status: String,
-                errorMessage: String?
+                errorMessage: String? = null,
+                glassesTimeMs: Long? = null,
         ) {
             val eventBody = HashMap<String, Any>()
             eventBody["session_id"] = sessionId
@@ -571,6 +629,9 @@ public class Bridge private constructor() {
             eventBody["overall_percent"] = overallPercent
             eventBody["status"] = status
             errorMessage?.let { eventBody["error_message"] = it }
+            if (glassesTimeMs != null && glassesTimeMs > 0) {
+                eventBody["glasses_time_ms"] = glassesTimeMs
+            }
 
             Log.d(TAG, "Bridge: sendOtaStatus: $eventBody")
 
@@ -620,6 +681,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 */
@@ -661,13 +736,17 @@ public class Bridge private constructor() {
                     return
                 }
 
-                if (type != "log") {
-                    BleTraceLogger.logMap(
-                        "phone_to_app",
-                        "sdk_event_dispatch",
-                        type,
-                        mutableBody as Map<String, Any>,
-                    )
+                if (shouldTraceTypedMessage(type)) {
+                    try {
+                        BleTraceLogger.logMap(
+                            "phone_to_app",
+                            "sdk_event_dispatch",
+                            type,
+                            mutableBody as Map<String, Any>,
+                        )
+                    } catch (e: Exception) {
+                        Log.d(TAG, "BLE trace logging failed for typed message '$type'", e)
+                    }
                 }
 
                 // Send directly using type as event name - no JSON serialization
@@ -687,6 +766,9 @@ public class Bridge private constructor() {
                 Log.e(TAG, "Error sending typed message of type '$type'", e)
             }
         }
+
+        private fun shouldTraceTypedMessage(type: String): Boolean =
+                type != "log" && type != "mic_pcm" && type != "mic_lc3"
     }
 
     init {