@mentra/bluetooth-sdk 0.1.7 → 0.1.9

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/MentraLive.java

@@ -35,12 +35,14 @@ import androidx.core.app.ActivityCompat;
 import com.mentra.bluetoothsdk.sgcs.SGCManager;
 import com.mentra.bluetoothsdk.DeviceManager;
 import com.mentra.bluetoothsdk.Bridge;
+import com.mentra.bluetoothsdk.debug.BleTraceLogger;
 import com.mentra.bluetoothsdk.utils.DeviceTypes;
 import com.mentra.bluetoothsdk.utils.ConnTypes;
 import com.mentra.bluetoothsdk.utils.BitmapJavaUtils;
 import com.mentra.bluetoothsdk.utils.SmartGlassesConnectionState;
 import com.mentra.bluetoothsdk.utils.K900ProtocolUtils;
 import com.mentra.bluetoothsdk.utils.MessageChunker;
+import com.mentra.bluetoothsdk.utils.MessageChunkReassembler;
 import com.mentra.bluetoothsdk.utils.audio.Lc3Player;
 import com.mentra.bluetoothsdk.utils.BlePhotoUploadService;
 import com.mentra.bluetoothsdk.utils.IncidentLogBleRelayNaming;
@@ -248,6 +250,7 @@ public class MentraLive extends SGCManager {
     private int filePacketBufferSize = 0;
     private final Object filePacketBufferLock = new Object();
     private int fileReadNotificationCount = 0; // Debug counter for FILE_READ notifications
+    private final MessageChunkReassembler incomingChunkReassembler = new MessageChunkReassembler();
 
     private final Object connectionLock = new Object();
 
@@ -1781,6 +1784,7 @@ public class MentraLive extends SGCManager {
                     if ("take_photo".equals(json.optString("type", ""))) {
                         Bridge.log("LIVE: PHOTO PIPELINE [4/4] sendJson(build<5) -> sendDataToGlasses — " + summarizeOutgoingMessage(jsonStr));
                     }
+                    BleTraceLogger.logJson("phone_to_glasses", "sdk_ble_command", json, jsonStr.length());
                     sendDataToGlasses(jsonStr, wakeup);
                 } else {
                     // Add esoteric message ID to the JSON
@@ -1819,6 +1823,7 @@ public class MentraLive extends SGCManager {
                     if ("take_photo".equals(json.optString("type", ""))) {
                         Bridge.log("LIVE: PHOTO PIPELINE [4/4] sendJson -> sendDataToGlasses (mId=" + messageId + ", ackTimeoutMs=" + ackTimeout + ") — " + summarizeOutgoingMessage(jsonStr));
                     }
+                    BleTraceLogger.logJson("phone_to_glasses", "sdk_ble_command", json, jsonStr.length());
                     sendDataToGlasses(jsonStr, wakeup);
                 }
             } catch (JSONException e) {
@@ -2258,6 +2263,13 @@ public class MentraLive extends SGCManager {
             Log.d(TAG, "LIVE: Got some JSON from glasses: " + json.toString());
         }
 
+        if (MessageChunker.isChunkedMessage(json)) {
+            processChunkedJsonMessage(json);
+            return;
+        }
+
+        BleTraceLogger.logJson("glasses_to_phone", "sdk_ble_event", json, json.toString().length());
+
         // Check if this is an ACK response
         String type = json.optString("type", "");
         if ("msg_ack".equals(type)) {
@@ -2287,6 +2299,13 @@ public class MentraLive extends SGCManager {
             case "ble_photo_ready":
                 processBlePhotoReady(json);
                 break;
+            case "photo_status":
+                try {
+                    Bridge.sendPhotoStatus(jsonObjectToMap(json));
+                } catch (JSONException e) {
+                    Log.e(TAG, "Error converting photo status to Map", e);
+                }
+                break;
             case "stream_status":
                 // Process streaming status update from ASG client
                 Bridge.log("LIVE: Received stream status update from glasses: " + json.toString());
@@ -2321,13 +2340,7 @@ public class MentraLive extends SGCManager {
 
                 // Forward to websocket system via Bridge (matches iOS emitRtmpStreamStatus)
                 try {
-                    Map<String, Object> rtmpMap = new HashMap<>();
-                    Iterator<String> keys = json.keys();
-                    while (keys.hasNext()) {
-                        String key = keys.next();
-                        rtmpMap.put(key, json.get(key));
-                    }
-                    Bridge.sendStreamStatus(rtmpMap);
+                    Bridge.sendStreamStatus(jsonObjectToMap(json));
                 } catch (JSONException e) {
                     Log.e(TAG, "Error converting RTMP status to Map", e);
                 }
@@ -2994,6 +3007,62 @@ public class MentraLive extends SGCManager {
         }
     }
 
+    private Map<String, Object> jsonObjectToMap(JSONObject json) throws JSONException {
+        Map<String, Object> map = new HashMap<>();
+        Iterator<String> keys = json.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object value = json.get(key);
+            if (value == JSONObject.NULL) {
+                continue;
+            }
+            map.put(key, jsonValueToBridgeValue(value));
+        }
+        return map;
+    }
+
+    private Object jsonValueToBridgeValue(Object value) throws JSONException {
+        if (value instanceof JSONObject) {
+            return jsonObjectToMap((JSONObject) value);
+        }
+        if (value instanceof JSONArray) {
+            JSONArray array = (JSONArray) value;
+            List<Object> list = new ArrayList<>();
+            for (int i = 0; i < array.length(); i++) {
+                Object item = array.get(i);
+                if (item != JSONObject.NULL) {
+                    list.add(jsonValueToBridgeValue(item));
+                }
+            }
+            return list;
+        }
+        return value;
+    }
+
+    private void processChunkedJsonMessage(JSONObject json) {
+        try {
+            MessageChunker.ChunkInfo chunkInfo = MessageChunker.getChunkInfo(json);
+            if (chunkInfo == null) {
+                Log.w(TAG, "LIVE: Received malformed chunked message: " + json);
+                return;
+            }
+
+            String reassembled = incomingChunkReassembler.addChunk(
+                    chunkInfo.chunkId,
+                    chunkInfo.chunkIndex,
+                    chunkInfo.totalChunks,
+                    chunkInfo.data);
+            if (reassembled == null) {
+                return;
+            }
+
+            JSONObject reassembledJson = new JSONObject(reassembled);
+            processJsonMessage(reassembledJson);
+        } catch (Exception e) {
+            Log.e(TAG, "Error processing chunked JSON message", e);
+        }
+    }
+
     /**
      * Process K900 command format JSON messages (messages with "C" field)
      */
@@ -3048,6 +3117,7 @@ public class MentraLive extends SGCManager {
                 BlePhotoTransfer photoTransfer = blePhotoTransfers.remove(bleImgId);
                 if (photoTransfer != null) {
                     Bridge.log("LIVE: 🧹 Cleaned up timed out BLE photo transfer for: " + bleImgId);
+                    Bridge.sendPhotoError(photoTransfer.requestId, "TRANSFER_TIMEOUT", "Transfer timed out for: " + fileName);
                 }
 
                 // Reset stale session on incident log relay so a retry starts fresh.
@@ -3080,8 +3150,19 @@ public class MentraLive extends SGCManager {
                 return;
             }
 
+            String bleImgId = fileName;
+            int dotIndex = bleImgId.lastIndexOf('.');
+            if (dotIndex > 0) {
+                bleImgId = bleImgId.substring(0, dotIndex);
+            }
+            BlePhotoTransfer photoTransfer = blePhotoTransfers.get(bleImgId);
+            String effectiveRequestId = requestId;
+            if (effectiveRequestId.isEmpty() && photoTransfer != null) {
+                effectiveRequestId = photoTransfer.requestId;
+            }
+
             Log.e(TAG, "❌ Transfer failed for: " + fileName + " (reason: " + reason + ")");
-            Bridge.sendPhotoError(requestId, "TRANSFER_FAILED", "Transfer failed for: " + fileName + " (reason: " + reason + ")");
+            Bridge.sendPhotoError(effectiveRequestId, "TRANSFER_FAILED", "Transfer failed for: " + fileName + " (reason: " + reason + ")");
 
             // Clean up any active transfer for this file
             FileTransferSession session = activeFileTransfers.remove(fileName);
@@ -3090,12 +3171,7 @@ public class MentraLive extends SGCManager {
             }
 
             // Clean up any BLE photo transfer
-            String bleImgId = fileName;
-            int dotIndex = bleImgId.lastIndexOf('.');
-            if (dotIndex > 0) {
-                bleImgId = bleImgId.substring(0, dotIndex);
-            }
-            BlePhotoTransfer photoTransfer = blePhotoTransfers.remove(bleImgId);
+            photoTransfer = blePhotoTransfers.remove(bleImgId);
             if (photoTransfer != null) {
                 Bridge.log("LIVE: 🧹 Cleaned up failed BLE photo transfer for: " + bleImgId + " (requestId: " + photoTransfer.requestId + ")");
             }
@@ -3352,8 +3428,8 @@ public class MentraLive extends SGCManager {
                     // Try to parse the "C" field as JSON
                     JSONObject innerJson = new JSONObject(command);
 
-                    // If it has a "type" field, it's a standard message that got C-wrapped
-                    if (innerJson.has("type")) {
+                    // If it has a "type" field or chunk envelope, it's a standard message that got C-wrapped
+                    if (innerJson.has("type") || MessageChunker.isChunkedMessage(innerJson)) {
                         String messageType = innerJson.optString("type", "");
                         Log.d(TAG, "📦 Detected C-wrapped standard JSON message with type: " + messageType);
                         Log.d(TAG, "🔓 Unwrapping and processing through standard message handler");
@@ -4160,9 +4236,9 @@ public class MentraLive extends SGCManager {
         }
     }
 
-    public void requestPhoto(String requestId, String appId, String size, String webhookUrl, String authToken, String compress, boolean flash, boolean sound, Long exposureTimeNs) {
+    public void requestPhoto(String requestId, String appId, String size, String webhookUrl, String authToken, String compress, boolean flash, boolean sound, Long exposureTimeNs, Integer iso) {
         boolean hasAuthToken = authToken != null && !authToken.isEmpty();
-        Bridge.log("LIVE: Requesting photo: " + requestId + " for app: " + appId + " with size: " + size + ", webhookUrl: " + webhookUrl + ", authToken: " + (hasAuthToken ? "***" : "none") + ", compress=" + compress + ", flash=" + flash + ", sound=" + sound + ", exposureTimeNs=" + exposureTimeNs);
+        Bridge.log("LIVE: Requesting photo: " + requestId + " for app: " + appId + " with size: " + size + ", webhookUrl: " + webhookUrl + ", authToken: " + (hasAuthToken ? "***" : "none") + ", compress=" + compress + ", flash=" + flash + ", sound=" + sound + ", exposureTimeNs=" + exposureTimeNs + ", iso=" + iso);
         Bridge.log("LIVE: PHOTO PIPELINE [5/6] requestPhoto() entry — requestId=" + requestId + ", appId=" + appId);
 
         try {
@@ -4190,6 +4266,10 @@ public class MentraLive extends SGCManager {
                 Bridge.log("LIVE: Using manual exposure time for photo request " + requestId + ": " + exposureTimeNs + " ns");
                 json.put("exposureTimeNs", exposureTimeNs);
             }
+            if (iso != null && iso > 0) {
+                Bridge.log("LIVE: Using manual ISO for photo request " + requestId + ": ISO " + iso);
+                json.put("iso", iso);
+            }
 
             // Always generate BLE ID for potential fallback
             String bleImgId = "I" + String.format("%09d", System.currentTimeMillis() % 1000000000);
@@ -5723,7 +5803,7 @@ public class MentraLive extends SGCManager {
 
     private String summarizeOutgoingMessage(String payload) {
         if (payload == null || payload.isEmpty()) {
-            return "type=unknown, requestId=none, appId=none, transferMethod=none, bleImgId=none, exposureTimeNs=none, mId=none";
+            return "type=unknown, requestId=none, appId=none, transferMethod=none, bleImgId=none, exposureTimeNs=none, iso=none, mId=none";
         }
         try {
             JSONObject obj = new JSONObject(payload);
@@ -5733,6 +5813,7 @@ public class MentraLive extends SGCManager {
             String transferMethod = obj.optString("transferMethod", "none");
             String bleImgId = obj.optString("bleImgId", "none");
             String exposure = obj.has("exposureTimeNs") ? String.valueOf(obj.optLong("exposureTimeNs")) : "none";
+            String iso = obj.has("iso") ? String.valueOf(obj.optInt("iso")) : "none";
             String mId = obj.has("mId") ? String.valueOf(obj.optLong("mId")) : "none";
             return "type=" + type
                     + ", requestId=" + requestId
@@ -5740,6 +5821,7 @@ public class MentraLive extends SGCManager {
                     + ", transferMethod=" + transferMethod
                     + ", bleImgId=" + bleImgId
                     + ", exposureTimeNs=" + exposure
+                    + ", iso=" + iso
                     + ", mId=" + mId;
         } catch (JSONException ignored) {
             return "type=non_json, payloadLen=" + payload.length();
@@ -6152,9 +6234,10 @@ public class MentraLive extends SGCManager {
                     Log.e(TAG, "❌ BLE photo transfer incomplete after final packet. Missing " + missingPackets.size() + " packets: " + missingPackets);
                     Log.e(TAG, "❌ Telling glasses to retry entire transfer");
 
-                    // Tell glasses transfer failed, they will retry
+                    // Tell glasses transfer failed, they will retry. Keep the photo transfer
+                    // entry so the retry still maps back to the original requestId.
                     sendTransferCompleteConfirmation(packetInfo.fileName, false);
-                    blePhotoTransfers.remove(bleImgId);
+                    photoTransfer.session = null;
                 }
             }
 

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/MentraNex.kt

@@ -290,7 +290,7 @@ class MentraNex : SGCManager() {
     override fun requestVersionInfo() { Bridge.log("Nex: requestVersionInfo operation not supported") }
 
     // Camera & Media: Not supported on Nex (No camera)
-    override fun requestPhoto(requestId: String, appId: String, size: String, webhookUrl: String?, authToken: String?, compress: String?, flash: Boolean, sound: Boolean, exposureTimeNs: Long?) { Bridge.log("Nex: requestPhoto operation not supported") }
+    override fun requestPhoto(requestId: String, appId: String, size: String, webhookUrl: String?, authToken: String?, compress: String?, flash: Boolean, sound: Boolean, exposureTimeNs: Long?, iso: Int?) { Bridge.log("Nex: requestPhoto operation not supported") }
     override fun startStream(message: MutableMap<String, Any>) { Bridge.log("Nex: startStream operation not supported") }
     override fun stopStream() { Bridge.log("Nex: stopStream operation not supported") }
     override fun sendStreamKeepAlive(message: MutableMap<String, Any>) { Bridge.log("Nex: sendStreamKeepAlive operation not supported") }

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/SGCManager.kt

@@ -23,6 +23,7 @@ abstract class SGCManager {
             flash: Boolean,
             sound: Boolean,
             exposureTimeNs: Long?,
+            iso: Int?,
     )
     abstract fun startStream(message: MutableMap<String, Any>)
     abstract fun stopStream()

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/Simulated.kt

@@ -37,6 +37,7 @@ class Simulated : SGCManager() {
             flash: Boolean,
             sound: Boolean,
             exposureTimeNs: Long?,
+            iso: Int?,
     ) {
         Bridge.log("requestPhoto flash=$flash, sound=$sound")
     }

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

@@ -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/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();
+        }
+    }
+}