@mentra/bluetooth-sdk 0.1.6 → 0.1.8

package/android/src/main/java/com/mentra/bluetoothsdk/status/DeviceStatus.kt

@@ -32,6 +32,7 @@ internal data class GlassesStatus(
     val fullyBooted: Boolean,
     val connected: Boolean,
     val micEnabled: Boolean,
+    val voiceActivityDetectionEnabled: Boolean,
     val connectionState: GlassesConnectionState,
     val bluetoothClassicConnected: Boolean,
     val signalStrength: Int,
@@ -72,6 +73,7 @@ internal data class GlassesStatus(
         mapOf(
             "connection" to connectionState.toStatusMap(connected, fullyBooted),
             "micEnabled" to micEnabled,
+            "voiceActivityDetectionEnabled" to voiceActivityDetectionEnabled,
             "bluetoothClassicConnected" to bluetoothClassicConnected,
             "signalStrength" to signalStrength,
             "signalStrengthUpdatedAt" to signalStrengthUpdatedAt,
@@ -114,6 +116,7 @@ internal data class GlassesStatus(
                 fullyBooted = boolValue(values, "fullyBooted") ?: false,
                 connected = boolValue(values, "connected") ?: false,
                 micEnabled = boolValue(values, "micEnabled") ?: false,
+                voiceActivityDetectionEnabled = boolValue(values, "voiceActivityDetectionEnabled") ?: true,
                 connectionState = GlassesConnectionState.fromValue(stringValue(values, "connectionState")),
                 bluetoothClassicConnected = boolValue(values, "bluetoothClassicConnected") ?: false,
                 signalStrength = numberValue(values, "signalStrength") ?: -1,
@@ -186,7 +189,7 @@ internal data class BluetoothStatus(
     val dashboardDepth: Int,
     val headUpAngle: Int,
     val contextualDashboard: Boolean,
-    val galleryModeAuto: Boolean,
+    val galleryModeEnabled: Boolean,
     val buttonPhotoSize: ButtonPhotoSize,
     val buttonCameraLed: Boolean,
     val buttonMaxRecordingTime: Int,
@@ -196,7 +199,6 @@ internal data class BluetoothStatus(
     val shouldSendPcm: Boolean,
     val shouldSendLc3: Boolean,
     val shouldSendTranscript: Boolean,
-    val bypassVad: Boolean,
     val offlineCaptionsRunning: Boolean,
     val localSttFallbackActive: Boolean,
     val shouldSendBootingMessage: Boolean,
@@ -240,7 +242,7 @@ internal data class BluetoothStatus(
             "dashboard_depth" to dashboardDepth,
             "head_up_angle" to headUpAngle,
             "contextual_dashboard" to contextualDashboard,
-            "galleryModeAuto" to galleryModeAuto,
+            "galleryModeEnabled" to galleryModeEnabled,
             "button_photo_size" to buttonPhotoSize.value,
             "button_camera_led" to buttonCameraLed,
             "button_max_recording_time" to buttonMaxRecordingTime,
@@ -250,7 +252,6 @@ internal data class BluetoothStatus(
             "should_send_pcm" to shouldSendPcm,
             "should_send_lc3" to shouldSendLc3,
             "should_send_transcript" to shouldSendTranscript,
-            "bypass_vad" to bypassVad,
             "offline_captions_running" to offlineCaptionsRunning,
             "local_stt_fallback_active" to localSttFallbackActive,
             "shouldSendBootingMessage" to shouldSendBootingMessage,
@@ -288,7 +289,8 @@ internal data class BluetoothStatus(
                 dashboardDepth = numberValue(values, "dashboard_depth") ?: 2,
                 headUpAngle = numberValue(values, "head_up_angle") ?: 30,
                 contextualDashboard = boolValue(values, "contextual_dashboard") ?: true,
-                galleryModeAuto = boolValue(values, "galleryModeAuto") ?: true,
+                galleryModeEnabled =
+                    boolValue(values, "gallery_mode") ?: boolValue(values, "galleryModeEnabled") ?: true,
                 buttonPhotoSize = ButtonPhotoSize.fromValue(stringValue(values, "button_photo_size")),
                 buttonCameraLed = boolValue(values, "button_camera_led") ?: true,
                 buttonMaxRecordingTime = numberValue(values, "button_max_recording_time") ?: 10,
@@ -298,7 +300,6 @@ internal data class BluetoothStatus(
                 shouldSendPcm = boolValue(values, "should_send_pcm") ?: false,
                 shouldSendLc3 = boolValue(values, "should_send_lc3") ?: false,
                 shouldSendTranscript = boolValue(values, "should_send_transcript") ?: false,
-                bypassVad = boolValue(values, "bypass_vad") ?: true,
                 offlineCaptionsRunning = boolValue(values, "offline_captions_running") ?: false,
                 localSttFallbackActive = boolValue(values, "local_stt_fallback_active") ?: false,
                 shouldSendBootingMessage = boolValue(values, "shouldSendBootingMessage") ?: true,
@@ -310,6 +311,7 @@ internal data class GlassesStatusUpdate(
     val fullyBooted: Boolean? = null,
     val connected: Boolean? = null,
     val micEnabled: Boolean? = null,
+    val voiceActivityDetectionEnabled: Boolean? = null,
     val connectionState: GlassesConnectionState? = null,
     val bluetoothClassicConnected: Boolean? = null,
     val signalStrength: Int? = null,
@@ -359,6 +361,7 @@ internal data class GlassesStatusUpdate(
                 put("connection", state.toStatusMap(connected == true, fullyBooted == true))
             }
             putIfNotNull("micEnabled", micEnabled)
+            putIfNotNull("voiceActivityDetectionEnabled", voiceActivityDetectionEnabled)
             putIfNotNull("bluetoothClassicConnected", bluetoothClassicConnected)
             putIfNotNull("signalStrength", signalStrength)
             putIfNotNull("signalStrengthUpdatedAt", signalStrengthUpdatedAt)
@@ -405,6 +408,7 @@ internal data class GlassesStatusUpdate(
                 fullyBooted = optionalBoolValue(values, "fullyBooted"),
                 connected = optionalBoolValue(values, "connected"),
                 micEnabled = optionalBoolValue(values, "micEnabled"),
+                voiceActivityDetectionEnabled = optionalBoolValue(values, "voiceActivityDetectionEnabled"),
                 connectionState = GlassesConnectionState.optionalFromValue(optionalStringValue(values, "connectionState")),
                 bluetoothClassicConnected = optionalBoolValue(values, "bluetoothClassicConnected"),
                 signalStrength = optionalNumberValue(values, "signalStrength"),
@@ -491,7 +495,7 @@ internal data class BluetoothStatusUpdate(
     val dashboardDepth: Int? = null,
     val headUpAngle: Int? = null,
     val contextualDashboard: Boolean? = null,
-    val galleryModeAuto: Boolean? = null,
+    val galleryModeEnabled: Boolean? = null,
     val buttonPhotoSize: ButtonPhotoSize? = null,
     val buttonCameraLed: Boolean? = null,
     val buttonMaxRecordingTime: Int? = null,
@@ -501,7 +505,6 @@ internal data class BluetoothStatusUpdate(
     val shouldSendPcm: Boolean? = null,
     val shouldSendLc3: Boolean? = null,
     val shouldSendTranscript: Boolean? = null,
-    val bypassVad: Boolean? = null,
     val offlineCaptionsRunning: Boolean? = null,
     val localSttFallbackActive: Boolean? = null,
     val shouldSendBootingMessage: Boolean? = null,
@@ -535,7 +538,7 @@ internal data class BluetoothStatusUpdate(
             putIfNotNull("dashboard_depth", dashboardDepth)
             putIfNotNull("head_up_angle", headUpAngle)
             putIfNotNull("contextual_dashboard", contextualDashboard)
-            putIfNotNull("galleryModeAuto", galleryModeAuto)
+            putIfNotNull("galleryModeEnabled", galleryModeEnabled)
             buttonPhotoSize?.let { put("button_photo_size", it.value) }
             putIfNotNull("button_camera_led", buttonCameraLed)
             putIfNotNull("button_max_recording_time", buttonMaxRecordingTime)
@@ -545,7 +548,6 @@ internal data class BluetoothStatusUpdate(
             putIfNotNull("should_send_pcm", shouldSendPcm)
             putIfNotNull("should_send_lc3", shouldSendLc3)
             putIfNotNull("should_send_transcript", shouldSendTranscript)
-            putIfNotNull("bypass_vad", bypassVad)
             putIfNotNull("offline_captions_running", offlineCaptionsRunning)
             putIfNotNull("local_stt_fallback_active", localSttFallbackActive)
             putIfNotNull("shouldSendBootingMessage", shouldSendBootingMessage)
@@ -585,7 +587,8 @@ internal data class BluetoothStatusUpdate(
                 dashboardDepth = optionalNumberValue(values, "dashboard_depth"),
                 headUpAngle = optionalNumberValue(values, "head_up_angle"),
                 contextualDashboard = optionalBoolValue(values, "contextual_dashboard"),
-                galleryModeAuto = optionalBoolValue(values, "galleryModeAuto"),
+                galleryModeEnabled =
+                    optionalBoolValue(values, "gallery_mode") ?: optionalBoolValue(values, "galleryModeEnabled"),
                 buttonPhotoSize =
                     optionalStringValue(values, "button_photo_size")?.let(ButtonPhotoSize::fromValue),
                 buttonCameraLed = optionalBoolValue(values, "button_camera_led"),
@@ -596,7 +599,6 @@ internal data class BluetoothStatusUpdate(
                 shouldSendPcm = optionalBoolValue(values, "should_send_pcm"),
                 shouldSendLc3 = optionalBoolValue(values, "should_send_lc3"),
                 shouldSendTranscript = optionalBoolValue(values, "should_send_transcript"),
-                bypassVad = optionalBoolValue(values, "bypass_vad"),
                 offlineCaptionsRunning = optionalBoolValue(values, "offline_captions_running"),
                 localSttFallbackActive = optionalBoolValue(values, "local_stt_fallback_active"),
                 shouldSendBootingMessage = optionalBoolValue(values, "shouldSendBootingMessage"),

package/android/src/main/java/com/mentra/bluetoothsdk/status/RuntimeState.kt

@@ -74,6 +74,7 @@ sealed interface GlassesRuntimeState {
         val hotspot: HotspotStatus,
         override val ready: Boolean,
         val signal: SignalState,
+        val voiceActivityDetectionEnabled: Boolean,
         val wifi: WifiStatus,
     ) : GlassesRuntimeState {
         override val connected: Boolean = true
@@ -95,6 +96,7 @@ sealed interface GlassesRuntimeState {
                     strengthDbm = status.signalStrength.takeUnless { it == -1 },
                     updatedAt = status.signalStrengthUpdatedAt.takeUnless { it <= 0L },
                 ),
+                voiceActivityDetectionEnabled = status.voiceActivityDetectionEnabled,
                 wifi = status.wifi,
             )
         }
@@ -149,7 +151,7 @@ enum class MicMode(val value: String) {
 }
 
 data class GalleryModeState(
-    val desired: GalleryMode,
+    val enabled: Boolean,
 )
 
 data class PhoneSdkRuntimeState(
@@ -169,7 +171,7 @@ data class PhoneSdkRuntimeState(
             PhoneSdkRuntimeState(
                 currentMic = MicMode.fromValue(status.currentMic),
                 defaultDevice = status.defaultDevice,
-                galleryMode = GalleryModeState(if (status.galleryModeAuto) GalleryMode.AUTO else GalleryMode.MANUAL),
+                galleryMode = GalleryModeState(enabled = status.galleryModeEnabled),
                 lastLog = status.lastLog,
                 micRanking = status.micRanking.mapNotNull { MicMode.fromValue(it) },
                 otherBluetoothConnected = status.otherBtConnected,

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamModels.kt

@@ -4,14 +4,14 @@ data class StreamVideoConfig @JvmOverloads constructor(
     val width: Int? = null,
     val height: Int? = null,
     val bitrate: Int? = null,
-    val frameRate: Int? = null,
+    val fps: Int? = null,
 ) {
     fun toMap(): Map<String, Any> =
         listOfNotNull(
             width?.let { "width" to it },
             height?.let { "height" to it },
             bitrate?.let { "bitrate" to it },
-            frameRate?.let { "frameRate" to it },
+            fps?.let { "frameRate" to it },
         ).toMap()
 
     companion object {
@@ -22,7 +22,7 @@ data class StreamVideoConfig @JvmOverloads constructor(
                 width = numberValue(values, "width"),
                 height = numberValue(values, "height"),
                 bitrate = numberValue(values, "bitrate"),
-                frameRate = numberValue(values, "frameRate"),
+                fps = numberValue(values, "fps"),
             )
         }
     }
@@ -56,11 +56,115 @@ data class StreamAudioConfig @JvmOverloads constructor(
     }
 }
 
+data class StreamResolvedVideoConfig @JvmOverloads constructor(
+    val width: Int,
+    val height: Int,
+    val captureWidth: Int? = null,
+    val captureHeight: Int? = null,
+    val bitrate: Int,
+    val fps: Int,
+) {
+    fun toMap(): Map<String, Any> =
+        buildMap {
+            put("width", width)
+            put("height", height)
+            captureWidth?.let { put("captureWidth", it) }
+            captureHeight?.let { put("captureHeight", it) }
+            put("bitrate", bitrate)
+            put("fps", fps)
+        }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>?): StreamResolvedVideoConfig? {
+            values ?: return null
+            return StreamResolvedVideoConfig(
+                width = numberValue(values, "width") ?: return null,
+                height = numberValue(values, "height") ?: return null,
+                captureWidth = numberValue(values, "captureWidth"),
+                captureHeight = numberValue(values, "captureHeight"),
+                bitrate = numberValue(values, "bitrate") ?: return null,
+                fps = numberValue(values, "fps") ?: return null,
+            )
+        }
+    }
+}
+
+data class StreamResolvedAudioConfig @JvmOverloads constructor(
+    val bitrate: Int? = null,
+    val sampleRate: Int? = null,
+    val echoCancellation: Boolean? = null,
+    val noiseSuppression: Boolean? = null,
+) {
+    fun toMap(): Map<String, Any> =
+        buildMap {
+            bitrate?.let { put("bitrate", it) }
+            sampleRate?.let { put("sampleRate", it) }
+            echoCancellation?.let { put("echoCancellation", it) }
+            noiseSuppression?.let { put("noiseSuppression", it) }
+        }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>?): StreamResolvedAudioConfig? {
+            values ?: return null
+            return StreamResolvedAudioConfig(
+                bitrate = numberValue(values, "bitrate"),
+                sampleRate = numberValue(values, "sampleRate"),
+                echoCancellation = boolValue(values, "echoCancellation"),
+                noiseSuppression = boolValue(values, "noiseSuppression"),
+            )
+        }
+    }
+}
+
+enum class StreamTransport(val value: String) {
+    RTMP("rtmp"),
+    SRT("srt"),
+    WHIP("whip");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): StreamTransport? =
+            when (value?.lowercase()) {
+                "rtmp" -> RTMP
+                "srt" -> SRT
+                "whip" -> WHIP
+                else -> null
+            }
+    }
+}
+
+data class StreamResolvedConfig @JvmOverloads constructor(
+    val transport: StreamTransport? = null,
+    val video: StreamResolvedVideoConfig? = null,
+    val audio: StreamResolvedAudioConfig? = null,
+) {
+    fun toMap(): Map<String, Any> =
+        buildMap {
+            transport?.let { put("transport", it.value) }
+            video?.let { put("video", it.toMap()) }
+            audio?.let { put("audio", it.toMap()) }
+        }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>?): StreamResolvedConfig? {
+            values ?: return null
+            return StreamResolvedConfig(
+                transport = StreamTransport.fromValue(stringValue(values, "transport")),
+                video = StreamResolvedVideoConfig.fromMap(stringMapValue(values["video"])),
+                audio = StreamResolvedAudioConfig.fromMap(stringMapValue(values["audio"])),
+            )
+        }
+    }
+}
+
 data class StreamRequest @JvmOverloads constructor(
     val streamUrl: String,
     val streamId: String = "",
     val keepAlive: Boolean = true,
-    val keepAliveIntervalSeconds: Int = 15,
+    val keepAliveIntervalSeconds: Int = 5,
     val sound: Boolean = true,
     val video: StreamVideoConfig? = null,
     val audio: StreamAudioConfig? = null,
@@ -68,6 +172,7 @@ data class StreamRequest @JvmOverloads constructor(
 ) {
     fun toMap(): Map<String, Any> {
         val values = extraValues.toMutableMap()
+        values.remove("keepAliveMode")
         values["type"] = "start_stream"
         values["streamUrl"] = streamUrl
         values["streamId"] = streamId
@@ -90,7 +195,7 @@ data class StreamRequest @JvmOverloads constructor(
                         ?: "",
                 streamId = values["streamId"] as? String ?: "",
                 keepAlive = values["keepAlive"] as? Boolean ?: true,
-                keepAliveIntervalSeconds = (values["keepAliveIntervalSeconds"] as? Number)?.toInt() ?: 15,
+                keepAliveIntervalSeconds = (values["keepAliveIntervalSeconds"] as? Number)?.toInt() ?: 5,
                 sound = values["sound"] as? Boolean ?: true,
                 video = StreamVideoConfig.fromMap(stringMapValue(values["video"])),
                 audio = StreamAudioConfig.fromMap(stringMapValue(values["audio"])),
@@ -99,7 +204,10 @@ data class StreamRequest @JvmOverloads constructor(
     }
 }
 
-data class StreamKeepAliveRequest @JvmOverloads constructor(
+internal fun StreamRequest.isExternallyManagedKeepAlive(): Boolean =
+    stringValue(extraValues, "keepAliveMode") == "external"
+
+internal data class StreamKeepAliveRequest @JvmOverloads constructor(
     val streamId: String,
     val ackId: String,
     val extraValues: Map<String, Any> = emptyMap(),
@@ -162,6 +270,7 @@ sealed interface StreamStatus {
     val state: StreamState
     val streamId: String?
     val timestamp: Long?
+    val resolvedConfig: StreamResolvedConfig?
 
     fun toMap(): Map<String, Any> {
         val values = mutableMapOf<String, Any>(
@@ -170,6 +279,7 @@ sealed interface StreamStatus {
         )
         streamId?.takeIf { it.isNotBlank() }?.let { values["streamId"] = it }
         timestamp?.let { values["timestamp"] = it }
+        resolvedConfig?.let { values["resolvedConfig"] = it.toMap() }
 
         when (this) {
             is Lifecycle -> Unit
@@ -197,6 +307,7 @@ sealed interface StreamStatus {
         override val state: StreamState,
         override val streamId: String?,
         override val timestamp: Long?,
+        override val resolvedConfig: StreamResolvedConfig?,
     ) : StreamStatus {
         override val kind: StreamStatusKind = StreamStatusKind.LIFECYCLE
     }
@@ -207,6 +318,7 @@ sealed interface StreamStatus {
         val maxAttempts: Int,
         val reason: String,
         override val timestamp: Long?,
+        override val resolvedConfig: StreamResolvedConfig?,
     ) : StreamStatus {
         override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
         override val state: StreamState = StreamState.RECONNECTING
@@ -216,6 +328,7 @@ sealed interface StreamStatus {
         override val streamId: String?,
         val attempt: Int,
         override val timestamp: Long?,
+        override val resolvedConfig: StreamResolvedConfig?,
     ) : StreamStatus {
         override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
         override val state: StreamState = StreamState.RECONNECTED
@@ -225,6 +338,7 @@ sealed interface StreamStatus {
         override val streamId: String?,
         val maxAttempts: Int,
         override val timestamp: Long?,
+        override val resolvedConfig: StreamResolvedConfig?,
     ) : StreamStatus {
         override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
         override val state: StreamState = StreamState.RECONNECT_FAILED
@@ -234,6 +348,7 @@ sealed interface StreamStatus {
         override val streamId: String?,
         val errorDetails: String,
         override val timestamp: Long?,
+        override val resolvedConfig: StreamResolvedConfig?,
     ) : StreamStatus {
         override val kind: StreamStatusKind = StreamStatusKind.ERROR
         override val state: StreamState = StreamState.ERROR
@@ -246,6 +361,7 @@ sealed interface StreamStatus {
         override val streamId: String?,
         val attempt: Int?,
         override val timestamp: Long?,
+        override val resolvedConfig: StreamResolvedConfig?,
     ) : StreamStatus {
         override val kind: StreamStatusKind = StreamStatusKind.SNAPSHOT
     }
@@ -258,6 +374,7 @@ sealed interface StreamStatus {
             val reconnecting = boolValue(values, "reconnecting") ?: false
             val streamId = stringValue(values, "streamId")
             val timestamp = longValue(values, "timestamp")
+            val resolvedConfig = StreamResolvedConfig.fromMap(stringMapValue(values["resolvedConfig"]))
             val attempt = numberValue(values, "attempt")
             val maxAttempts = numberValue(values, "maxAttempts") ?: 0
 
@@ -273,6 +390,7 @@ sealed interface StreamStatus {
                     streamId = streamId,
                     attempt = attempt,
                     timestamp = timestamp,
+                    resolvedConfig = resolvedConfig,
                 )
             }
 
@@ -281,6 +399,7 @@ sealed interface StreamStatus {
                     streamId = streamId,
                     errorDetails = rawState?.let { "Unknown stream status: $it" } ?: "Missing stream status",
                     timestamp = timestamp,
+                    resolvedConfig = resolvedConfig,
                 )
 
             return when (state) {
@@ -290,27 +409,32 @@ sealed interface StreamStatus {
                     maxAttempts = maxAttempts,
                     reason = stringValue(values, "reason") ?: "",
                     timestamp = timestamp,
+                    resolvedConfig = resolvedConfig,
                 )
                 StreamState.RECONNECTED -> Reconnected(
                     streamId = streamId,
                     attempt = attempt ?: 0,
                     timestamp = timestamp,
+                    resolvedConfig = resolvedConfig,
                 )
                 StreamState.RECONNECT_FAILED -> ReconnectFailed(
                     streamId = streamId,
                     maxAttempts = maxAttempts,
                     timestamp = timestamp,
+                    resolvedConfig = resolvedConfig,
                 )
                 StreamState.ERROR -> Error(
                     streamId = streamId,
                     errorDetails = stringValue(values, "errorDetails")
                         ?: if (rawState == "error_not_streaming") "not_streaming" else "Unknown stream error",
                     timestamp = timestamp,
+                    resolvedConfig = resolvedConfig,
                 )
                 else -> Lifecycle(
                     state = state,
                     streamId = streamId,
                     timestamp = timestamp,
+                    resolvedConfig = resolvedConfig,
                 )
             }
         }
@@ -324,6 +448,7 @@ data class StreamStatusEvent(
 
     val state: StreamState get() = status.state
     val streamId: String? get() = status.streamId
+    val resolvedConfig: StreamResolvedConfig? get() = status.resolvedConfig
     val values: Map<String, Any> get() = status.toEventMap()
 }
 

package/android/src/main/java/com/mentra/bluetoothsdk/stt/SherpaOnnxTranscriber.kt

@@ -226,8 +226,7 @@ class SherpaOnnxTranscriber(private val context: Context) {
      * Feed PCM audio data (16-bit little endian) into the transcriber. This method should be called
      * continuously with short chunks (e.g., 100-300ms).
      *
-     * Note: Audio passed to this method is assumed to have already passed VAD elsewhere, so it's
-     * directly queued for processing without additional VAD checks.
+     * Audio is queued directly; microphone VAD gating is not applied in the SDK.
      */
     fun acceptAudio(pcm16le: ByteArray) {
         if (!running.get()) {
@@ -235,7 +234,6 @@ class SherpaOnnxTranscriber(private val context: Context) {
             return
         }
 
-        // Directly queue the audio data for processing
         if (!pcmQueue.offer(pcm16le.copyOf())) {
             // Queue is full, drop oldest and try again
             pcmQueue.poll()

package/android/src/main/java/com/mentra/bluetoothsdk/utils/MessageChunkReassembler.java

@@ -0,0 +1,105 @@
+package com.mentra.bluetoothsdk.utils;
+
+import android.util.Log;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Reassembles compact JSON chunks from the glasses before normal event dispatch.
+ */
+public class MessageChunkReassembler {
+    private static final String TAG = "MessageChunkReassembler";
+    private static final long CHUNK_TIMEOUT_MS = 30000;
+    private static final int MAX_CONCURRENT_SESSIONS = 10;
+
+    private final Map<String, ChunkSession> activeSessions = new ConcurrentHashMap<>();
+
+    public String addChunk(String chunkId, int chunkIndex, int totalChunks, String data) {
+        cleanupTimedOutSessions();
+
+        if (activeSessions.size() >= MAX_CONCURRENT_SESSIONS && !activeSessions.containsKey(chunkId)) {
+            Log.w(TAG, "Maximum concurrent chunk sessions reached, dropping oldest");
+            removeOldestSession();
+        }
+
+        ChunkSession session = activeSessions.computeIfAbsent(chunkId, ignored -> new ChunkSession(chunkId, totalChunks));
+        boolean added = session.addChunk(chunkIndex, data);
+        if (!added) {
+            Log.w(TAG, "Failed to add chunk " + chunkIndex + " to session " + chunkId);
+            return null;
+        }
+
+        Log.d(TAG, "Added chunk " + chunkIndex + "/" + (totalChunks - 1) + " for session " + chunkId);
+
+        if (!session.isComplete()) {
+            return null;
+        }
+
+        String reassembled = session.reassemble();
+        activeSessions.remove(chunkId);
+        Log.d(TAG, "Reassembled message of " + reassembled.length() + " bytes from " + totalChunks + " chunks");
+        return reassembled;
+    }
+
+    public void clear() {
+        activeSessions.clear();
+    }
+
+    private void cleanupTimedOutSessions() {
+        long now = System.currentTimeMillis();
+        activeSessions.entrySet().removeIf(entry -> now - entry.getValue().createdAt > CHUNK_TIMEOUT_MS);
+    }
+
+    private void removeOldestSession() {
+        String oldestId = null;
+        long oldestTime = Long.MAX_VALUE;
+        for (Map.Entry<String, ChunkSession> entry : activeSessions.entrySet()) {
+            if (entry.getValue().createdAt < oldestTime) {
+                oldestTime = entry.getValue().createdAt;
+                oldestId = entry.getKey();
+            }
+        }
+        if (oldestId != null) {
+            activeSessions.remove(oldestId);
+        }
+    }
+
+    private static class ChunkSession {
+        final String chunkId;
+        final int totalChunks;
+        final long createdAt;
+        final Map<Integer, String> chunks;
+
+        ChunkSession(String chunkId, int totalChunks) {
+            this.chunkId = chunkId;
+            this.totalChunks = totalChunks;
+            this.createdAt = System.currentTimeMillis();
+            this.chunks = new ConcurrentHashMap<>();
+        }
+
+        boolean addChunk(int index, String data) {
+            if (index < 0 || index >= totalChunks) {
+                return false;
+            }
+            chunks.put(index, data);
+            return true;
+        }
+
+        boolean isComplete() {
+            return chunks.size() == totalChunks;
+        }
+
+        String reassemble() {
+            StringBuilder reassembled = new StringBuilder();
+            for (int i = 0; i < totalChunks; i++) {
+                String chunk = chunks.get(i);
+                if (chunk == null) {
+                    throw new IllegalStateException("Missing chunk " + i + " for session " + chunkId);
+                }
+                reassembled.append(chunk);
+            }
+            return reassembled.toString();
+        }
+    }
+}