@mentra/bluetooth-sdk 0.1.17 → 0.1.19

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

@@ -37,7 +37,10 @@ import org.json.JSONObject;
  */
 public class BlePhotoUploadService {
     private static final String TAG = "BlePhotoUploadService";
-    private static final int JPEG_QUALITY = 90;
+    // 100: the source already went through a lossy AVIF pass on the glasses, so
+    // this re-encode must not compound the loss. Phone CPU and upload bandwidth
+    // are cheap relative to what was paid to get the bytes over BLE.
+    private static final int JPEG_QUALITY = 100;
 
     public interface UploadCallback {
         void onSuccess(String requestId, String responseBody);

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

@@ -0,0 +1,108 @@
+package com.mentra.bluetoothsdk.utils;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * BLE Wire Protocol v2 shared constants and binary frame helpers.
+ * All multi-byte fields use little-endian byte order.
+ */
+public final class BleWireProtocol {
+
+    private BleWireProtocol() {}
+
+    public static final byte CMD_TYPE_BINARY_MSG = 0x40;
+
+    public static final byte BLE_WIRE_FLAG_FIRST_FRAG = 0x01;
+    public static final byte BLE_WIRE_FLAG_LAST_FRAG = 0x02;
+    public static final byte BLE_WIRE_FLAG_WAKE = 0x04;
+    public static final byte BLE_WIRE_FLAG_HANDSHAKE = 0x08;
+    public static final byte BLE_WIRE_FLAG_ACK_REQUESTED = 0x10;
+
+    public static final int BINARY_HEADER_SIZE = 7;
+    public static final int MAX_FRAGMENT_PAYLOAD = 480;
+    public static final int MTU_TARGET = 509;
+
+    public static final String HANDSHAKE_PAYLOAD_V2 = "v2";
+    public static final int PROTOCOL_V1 = 1;
+    public static final int PROTOCOL_V2 = 2;
+
+    public static class BinaryFragmentInfo {
+        public byte flags;
+        public int msgId;
+        public int fragIdx;
+        public int fragCount;
+        public byte[] payload;
+    }
+
+    public static boolean isBinaryFrame(byte[] data) {
+        return K900ProtocolUtils.isK900ProtocolFormat(data)
+                && data.length >= 7
+                && data[2] == CMD_TYPE_BINARY_MSG;
+    }
+
+    public static byte[] packBinaryFragment(
+            byte flags, int msgId, int fragIdx, int fragCount, byte[] payload) {
+        int payloadLen = payload != null ? payload.length : 0;
+        byte[] inner = new byte[BINARY_HEADER_SIZE + payloadLen];
+        inner[0] = flags;
+        writeLe16(inner, 1, msgId);
+        inner[3] = (byte) fragIdx;
+        inner[4] = (byte) fragCount;
+        writeLe16(inner, 5, payloadLen);
+        if (payloadLen > 0) {
+            System.arraycopy(payload, 0, inner, BINARY_HEADER_SIZE, payloadLen);
+        }
+        return K900ProtocolUtils.packDataToK900(
+                inner, CMD_TYPE_BINARY_MSG, K900LengthCodec.Endian.LE);
+    }
+
+    public static BinaryFragmentInfo extractBinaryFragmentInfo(byte[] frame) {
+        if (!isBinaryFrame(frame)) {
+            return null;
+        }
+
+        int innerLen = readLe16(frame, 3);
+        if (innerLen < BINARY_HEADER_SIZE || frame.length < 7 + innerLen) {
+            return null;
+        }
+
+        int offset = 5;
+        int payloadLen = readLe16(frame, offset + 5);
+        if (BINARY_HEADER_SIZE + payloadLen > innerLen) {
+            return null;
+        }
+
+        BinaryFragmentInfo info = new BinaryFragmentInfo();
+        info.flags = frame[offset];
+        info.msgId = readLe16(frame, offset + 1);
+        info.fragIdx = frame[offset + 3] & 0xFF;
+        info.fragCount = frame[offset + 4] & 0xFF;
+        info.payload = new byte[payloadLen];
+        if (payloadLen > 0) {
+            System.arraycopy(frame, offset + BINARY_HEADER_SIZE, info.payload, 0, payloadLen);
+        }
+        return info;
+    }
+
+    public static byte[] extractBinaryPayload(byte[] frame) {
+        BinaryFragmentInfo info = extractBinaryFragmentInfo(frame);
+        return info != null ? info.payload : null;
+    }
+
+    public static boolean isHandshakeV2(BinaryFragmentInfo info) {
+        if (info == null || (info.flags & BLE_WIRE_FLAG_HANDSHAKE) == 0) {
+            return false;
+        }
+        String payload = new String(info.payload, StandardCharsets.UTF_8);
+        return HANDSHAKE_PAYLOAD_V2.equals(payload);
+    }
+
+    static int readLe16(byte[] data, int offset) {
+        return (data[offset] & 0xFF) | ((data[offset + 1] & 0xFF) << 8);
+    }
+
+    static void writeLe16(byte[] data, int offset, int value) {
+        data[offset] = (byte) (value & 0xFF);
+        data[offset + 1] = (byte) ((value >> 8) & 0xFF);
+    }
+}

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

@@ -13,7 +13,7 @@ import okhttp3.RequestBody;
 import okhttp3.Response;
 
 /**
- * POSTs incident log JSON (from BLE relay) using the same path as glasses direct upload.
+ * POSTs report artifact JSON from the BLE relay using the same path as glasses direct upload.
  */
 public final class IncidentLogBleUploadService {
 
@@ -42,9 +42,10 @@ public final class IncidentLogBleUploadService {
                 }
                 HttpUrl url = baseHttpUrl.newBuilder()
                         .addPathSegment("api")
-                        .addPathSegment("incidents")
+                        .addPathSegment("client")
+                        .addPathSegment("reports")
                         .addPathSegment(incidentId)
-                        .addPathSegment("logs")
+                        .addPathSegment("artifacts")
                         .build();
                 RequestBody body = RequestBody.create(jsonUtf8, JSON);
                 OkHttpClient client = new OkHttpClient.Builder()

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

@@ -0,0 +1,115 @@
+package com.mentra.bluetoothsdk.utils;
+
+/**
+ * Encodes and decodes the 2-byte length field of K900 {@code ##} STRING (0x30) frames.
+ *
+ * <p>Legacy BES firmware uses big-endian for this field; BLE Wire v2 clients use little-endian.
+ * The two conventions are negotiated per link (see {@code wire_caps}); until a peer advertises
+ * little-endian, callers should default to {@link Endian#BE}. On receive, {@link #detectLength}
+ * heuristically recovers the endianness so we interoperate with peers of unknown vintage.
+ *
+ * <p>File-transfer header fields (packSize/packIndex/fileSize) are always big-endian and are not
+ * handled here.
+ *
+ * <p>Mirror of the ASG-side {@code K900LengthCodec} and firmware {@code k900_detect_string_length}.
+ */
+public final class K900LengthCodec {
+
+    private K900LengthCodec() {}
+
+    public enum Endian {
+        BE,
+        LE
+    }
+
+    public static final int FRAME_OVERHEAD = 7;
+    public static final int LENGTH_OFFSET = 3;
+    public static final int PAYLOAD_OFFSET = 5;
+    public static final int MAX_STRING_LENGTH = 512;
+
+    public static int readLength(byte[] frame, int offset, Endian endian) {
+        int b0 = frame[offset] & 0xFF;
+        int b1 = frame[offset + 1] & 0xFF;
+        return endian == Endian.LE ? (b0 | (b1 << 8)) : ((b0 << 8) | b1);
+    }
+
+    public static void writeLength(byte[] frame, int offset, int value, Endian endian) {
+        if (endian == Endian.LE) {
+            frame[offset] = (byte) (value & 0xFF);
+            frame[offset + 1] = (byte) ((value >> 8) & 0xFF);
+        } else {
+            frame[offset] = (byte) ((value >> 8) & 0xFF);
+            frame[offset + 1] = (byte) (value & 0xFF);
+        }
+    }
+
+    public static final class Detected {
+        public final int length;
+        public final Endian endian;
+
+        Detected(int length, Endian endian) {
+            this.length = length;
+            this.endian = endian;
+        }
+    }
+
+    /**
+     * Heuristically determine the STRING length field's endianness for a received frame. A length is
+     * plausible when it is non-zero, within the cap, and the full framed command fits inside the
+     * buffer. When both interpretations fit, prefer the one whose payload lands exactly on the
+     * trailing {@code $$}, then the smaller.
+     *
+     * @return the detected length + endianness, or {@code null} if neither interpretation is valid
+     */
+    public static Detected detectLength(byte[] frame) {
+        if (frame == null || frame.length < FRAME_OVERHEAD) {
+            return null;
+        }
+
+        int leLen = readLength(frame, LENGTH_OFFSET, Endian.LE);
+        int beLen = readLength(frame, LENGTH_OFFSET, Endian.BE);
+
+        boolean leOk = leLen > 0 && leLen <= MAX_STRING_LENGTH && leLen + FRAME_OVERHEAD <= frame.length;
+        boolean beOk = beLen > 0 && beLen <= MAX_STRING_LENGTH && beLen + FRAME_OVERHEAD <= frame.length;
+
+        if (leOk && beOk) {
+            if (endsWithEndCode(frame, PAYLOAD_OFFSET + leLen)) {
+                return new Detected(leLen, Endian.LE);
+            }
+            if (endsWithEndCode(frame, PAYLOAD_OFFSET + beLen)) {
+                return new Detected(beLen, Endian.BE);
+            }
+            return leLen <= beLen ? new Detected(leLen, Endian.LE) : new Detected(beLen, Endian.BE);
+        }
+        if (leOk) {
+            return new Detected(leLen, Endian.LE);
+        }
+        if (beOk) {
+            return new Detected(beLen, Endian.BE);
+        }
+        return null;
+    }
+
+    private static boolean endsWithEndCode(byte[] frame, int endOffset) {
+        return endOffset + 1 < frame.length
+                && frame[endOffset] == K900ProtocolUtils.CMD_END_CODE[0]
+                && frame[endOffset + 1] == K900ProtocolUtils.CMD_END_CODE[1];
+    }
+
+    /**
+     * Transcode a K900 STRING frame's length bytes from one endianness to another, leaving the
+     * payload untouched. Returns a new array; the input is not modified.
+     */
+    public static byte[] repackStringFrame(byte[] frame, Endian from, Endian to) {
+        if (frame == null || frame.length < FRAME_OVERHEAD) {
+            return frame;
+        }
+        if (from == to) {
+            return frame.clone();
+        }
+        byte[] out = frame.clone();
+        int length = readLength(frame, LENGTH_OFFSET, from);
+        writeLength(out, LENGTH_OFFSET, length, to);
+        return out;
+    }
+}

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

@@ -27,6 +27,7 @@ public class K900ProtocolUtils {
     public static final byte CMD_TYPE_MUSIC = 0x33; // Music file type
     public static final byte CMD_TYPE_AUDIO = 0x34; // Audio file type
     public static final byte CMD_TYPE_DATA = 0x35; // Generic data type
+    public static final byte CMD_TYPE_BINARY_MSG = BleWireProtocol.CMD_TYPE_BINARY_MSG;
 
     // File transfer constants
     public static final int FILE_PACK_SIZE = 400; // Max data size per packet
@@ -54,6 +55,10 @@ public class K900ProtocolUtils {
      * @return Byte array with packed data according to protocol format
      */
     public static byte[] packJsonCommand(String jsonData) {
+        return packJsonCommand(jsonData, K900LengthCodec.Endian.BE);
+    }
+
+    public static byte[] packJsonCommand(String jsonData, K900LengthCodec.Endian endian) {
         if (jsonData == null) {
             return null;
         }
@@ -68,7 +73,7 @@ public class K900ProtocolUtils {
 
             // Then pack with BES2700 protocol format
             byte[] jsonBytes = wrappedJson.getBytes(StandardCharsets.UTF_8);
-            return packDataCommand(jsonBytes, CMD_TYPE_STRING);
+            return packDataCommand(jsonBytes, CMD_TYPE_STRING, endian);
 
         } catch (JSONException e) {
             android.util.Log.e("K900ProtocolUtils", "Error creating JSON wrapper", e);
@@ -85,6 +90,16 @@ public class K900ProtocolUtils {
      * @return Byte array with packed data according to protocol format
      */
     public static byte[] packDataCommand(byte[] data, byte cmdType) {
+        // Default to legacy big-endian until wire_caps negotiates little-endian.
+        return packDataCommand(data, cmdType, K900LengthCodec.Endian.BE);
+    }
+
+    /**
+     * Pack raw byte data with K900 BES2700 protocol format, writing the 2-byte length field with an
+     * explicit endianness. Use the negotiated per-link endianness so both legacy big-endian and
+     * wire-v2 little-endian peers can parse the frame.
+     */
+    public static byte[] packDataCommand(byte[] data, byte cmdType, K900LengthCodec.Endian endian) {
         if (data == null) {
             return null;
         }
@@ -101,13 +116,8 @@ public class K900ProtocolUtils {
         // Command type
         result[2] = cmdType;
 
-        // Length (2 bytes, big-endian)
-        result[3] = (byte)((dataLength >> 8) & 0xFF); // MSB first
-        result[4] = (byte)(dataLength & 0xFF);        // LSB second
-
-        // Original little-endian implementation (commented out)
-        // result[3] = (byte)(dataLength & 0xFF);        // LSB first
-        // result[4] = (byte)((dataLength >> 8) & 0xFF); // MSB second
+        // Length (2 bytes, negotiated endianness)
+        K900LengthCodec.writeLength(result, 3, dataLength, endian);
 
         // Copy the data
         System.arraycopy(data, 0, result, 5, dataLength);
@@ -129,34 +139,15 @@ public class K900ProtocolUtils {
      * @return Byte array with packed data according to protocol format
      */
     public static byte[] packDataToK900(byte[] data, byte cmdType) {
-        if (data == null) {
-            return null;
-        }
-
-        int dataLength = data.length;
-
-        // Command structure: ## + type + length(2 bytes) + data + $$
-        byte[] result = new byte[dataLength + 7]; // 2(start) + 1(type) + 2(length) + data + 2(end)
-
-        // Start code ##
-        result[0] = CMD_START_CODE[0]; // #
-        result[1] = CMD_START_CODE[1]; // #
-
-        // Command type
-        result[2] = cmdType;
-
-        // Length (2 bytes, little-endian for phone-to-device)
-        result[3] = (byte) (dataLength & 0xFF);        // LSB first
-        result[4] = (byte) ((dataLength >> 8) & 0xFF); // MSB second
-
-        // Copy the data
-        System.arraycopy(data, 0, result, 5, dataLength);
-
-        // End code $$
-        result[5 + dataLength] = CMD_END_CODE[0]; // $
-        result[6 + dataLength] = CMD_END_CODE[1]; // $
+        return packDataToK900(data, cmdType, K900LengthCodec.Endian.BE);
+    }
 
-        return result;
+    /**
+     * Pack raw byte data with K900 BES2700 protocol format for phone-to-device communication.
+     * Format: ## + command_type + length(2bytes) + data + $$
+     */
+    public static byte[] packDataToK900(byte[] data, byte cmdType, K900LengthCodec.Endian endian) {
+        return packDataCommand(data, cmdType, endian);
     }
 
     /**
@@ -168,6 +159,15 @@ public class K900ProtocolUtils {
      * @return Byte array with packed data according to protocol format
      */
     public static byte[] packJsonToK900(String jsonData, boolean wakeup) {
+        return packJsonToK900(jsonData, wakeup, K900LengthCodec.Endian.BE);
+    }
+
+    /**
+     * Pack a C-wrapped JSON string for phone-to-glasses transmission, writing the STRING frame
+     * length with the negotiated per-link endianness. Legacy big-endian glasses require BE until
+     * they advertise {@code wire_caps.k900_le}.
+     */
+    public static byte[] packJsonToK900(String jsonData, boolean wakeup, K900LengthCodec.Endian endian) {
         if (jsonData == null) {
             return null;
         }
@@ -183,9 +183,9 @@ public class K900ProtocolUtils {
             // Convert to string
             String wrappedJson = wrapper.toString();
 
-            // Then pack with BES2700 protocol format using little-endian
+            // Then pack with BES2700 protocol format using the negotiated endianness
             byte[] jsonBytes = wrappedJson.getBytes(StandardCharsets.UTF_8);
-            return packDataToK900(jsonBytes, CMD_TYPE_STRING);
+            return packDataCommand(jsonBytes, CMD_TYPE_STRING, endian);
 
         } catch (JSONException e) {
             android.util.Log.e("K900ProtocolUtils", "Error creating JSON wrapper for K900", e);
@@ -203,6 +203,14 @@ public class K900ProtocolUtils {
      * @return Formatted bytes ready for transmission
      */
     public static byte[] formatMessageForTransmission(String jsonData) {
+        return formatMessageForTransmission(jsonData, K900LengthCodec.Endian.BE);
+    }
+
+    /**
+     * Format an ASG-client JSON message for transmission, writing the STRING frame length with the
+     * negotiated per-link endianness.
+     */
+    public static byte[] formatMessageForTransmission(String jsonData, K900LengthCodec.Endian endian) {
         try {
             android.util.Log.e("K900ProtocolUtils", "🔄 Formatting message: " + jsonData);
 
@@ -218,7 +226,9 @@ public class K900ProtocolUtils {
             android.util.Log.e("K900ProtocolUtils", "🔄 After C-wrapping: " + wrappedJson);
 
             // Now format with BES2700 protocol
-            byte[] result = packDataCommand(wrappedJson.getBytes(StandardCharsets.UTF_8), CMD_TYPE_STRING);
+            byte[] result =
+                    packDataCommand(
+                            wrappedJson.getBytes(StandardCharsets.UTF_8), CMD_TYPE_STRING, endian);
 
             // Log some bytes for debugging
             StringBuilder hexDump = new StringBuilder();
@@ -233,7 +243,7 @@ public class K900ProtocolUtils {
         } catch (JSONException e) {
             android.util.Log.e("K900ProtocolUtils", "❌ Error in formatMessageForTransmission", e);
             // Fallback: if json is invalid, still try to pack it without validation
-            return packJsonCommand(jsonData);
+            return packJsonCommand(jsonData, endian);
         }
     }
 
@@ -304,56 +314,59 @@ public class K900ProtocolUtils {
      * @return Raw payload data or null if format is invalid
      */
     public static byte[] extractPayload(byte[] protocolData) {
+        return extractPayload(protocolData, K900LengthCodec.Endian.BE);
+    }
+
+    /**
+     * Extract payload from a K900 STRING frame, reading the length field with an explicit
+     * endianness. Prefer {@link #extractPayloadAuto} on receive when the peer endianness is not yet
+     * negotiated.
+     */
+    public static byte[] extractPayload(byte[] protocolData, K900LengthCodec.Endian endian) {
         if (!isK900ProtocolFormat(protocolData) || protocolData.length < 7) {
             return null;
         }
 
-        // Extract length (big-endian)
-        int length = ((protocolData[3] & 0xFF) << 8) | (protocolData[4] & 0xFF);
-
-        // Original little-endian implementation (commented out)
-        // int length = (protocolData[3] & 0xFF) | ((protocolData[4] & 0xFF) << 8);
+        int length = K900LengthCodec.readLength(protocolData, 3, endian);
 
         if (length + 7 > protocolData.length) {
             return null; // Invalid length
         }
 
-        // Extract payload
         byte[] payload = new byte[length];
         System.arraycopy(protocolData, 5, payload, 0, length);
         return payload;
     }
 
     /**
-     * Extract payload from K900 protocol formatted data received from device
-     * Uses little-endian byte order for length field
-     * @return Raw payload data or null if format is invalid
+     * Extract payload from a K900 STRING frame, heuristically detecting the length field's
+     * endianness. Safe RX entry point when the peer endianness is not yet negotiated (fixes the
+     * "Extracted length=9472" misframe against legacy big-endian BES firmware).
      */
-    public static byte[] extractPayloadFromK900(byte[] protocolData) {
+    public static byte[] extractPayloadAuto(byte[] protocolData) {
         if (!isK900ProtocolFormat(protocolData) || protocolData.length < 7) {
-            Log.e("K900ProtocolUtils", "extractPayloadFromK900: Not K900 format or too short. Length=" +
-                  (protocolData != null ? protocolData.length : 0));
             return null;
         }
-
-        // Extract length (little-endian for device-to-phone)
-        int length = (protocolData[3] & 0xFF) | ((protocolData[4] & 0xFF) << 8);
-
-        Log.d("K900ProtocolUtils", "extractPayloadFromK900: Extracted length=" + length +
-              ", message length=" + protocolData.length + ", expected total=" + (length + 7));
-
-        if (length + 7 > protocolData.length) {
-            Log.e("K900ProtocolUtils", "extractPayloadFromK900: Invalid length. Need " +
-                  (length + 7) + " bytes but have " + protocolData.length);
-            return null; // Invalid length
+        K900LengthCodec.Detected detected = K900LengthCodec.detectLength(protocolData);
+        if (detected == null) {
+            return null;
         }
-
-        // Extract payload
-        byte[] payload = new byte[length];
-        System.arraycopy(protocolData, 5, payload, 0, length);
+        byte[] payload = new byte[detected.length];
+        System.arraycopy(protocolData, 5, payload, 0, detected.length);
         return payload;
     }
 
+    /**
+     * Extract payload from K900 protocol formatted data received from device
+     * Uses little-endian byte order for length field
+     * @return Raw payload data or null if format is invalid
+     */
+    public static byte[] extractPayloadFromK900(byte[] protocolData) {
+        // Retained for backward compatibility: device-to-phone frames may arrive in either
+        // endianness depending on firmware vintage, so auto-detect rather than assuming LE.
+        return extractPayloadAuto(protocolData);
+    }
+
     /**
      * Process received bytes from Bluetooth into a JSON object
      * Handles K900 protocol format detection, payload extraction, and C-field unwrapping
@@ -379,8 +392,13 @@ public class K900ProtocolUtils {
         // Extract the command type
         byte commandType = data[2];
 
-        // Extract the length using big-endian format (MSB first)
-        int payloadLength = ((data[3] & 0xFF) << 8) | (data[4] & 0xFF);
+        // Extract the length, auto-detecting endianness so we parse both legacy big-endian and
+        // wire-v2 little-endian frames.
+        K900LengthCodec.Detected detected = K900LengthCodec.detectLength(data);
+        int payloadLength =
+                detected != null
+                        ? detected.length
+                        : ((data[3] & 0xFF) | ((data[4] & 0xFF) << 8));
 
         android.util.Log.d("K900ProtocolUtils", "Command type: 0x" + String.format("%02X", commandType) +
                          ", Payload length: " + payloadLength);
@@ -565,6 +583,23 @@ public class K900ProtocolUtils {
         return false;
     }
 
+    public static boolean isBinaryFrame(byte[] data) {
+        return BleWireProtocol.isBinaryFrame(data);
+    }
+
+    public static byte[] packBinaryFragment(
+            byte flags, int msgId, int fragIdx, int fragCount, byte[] payload) {
+        return BleWireProtocol.packBinaryFragment(flags, msgId, fragIdx, fragCount, payload);
+    }
+
+    public static BleWireProtocol.BinaryFragmentInfo extractBinaryFragmentInfo(byte[] frame) {
+        return BleWireProtocol.extractBinaryFragmentInfo(frame);
+    }
+
+    public static byte[] extractBinaryPayload(byte[] frame) {
+        return BleWireProtocol.extractBinaryPayload(frame);
+    }
+
     /**
      * Inner class to represent file packet information
      */

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

@@ -15,6 +15,48 @@ public class MessageChunkReassembler {
 
     private final Map<String, ChunkSession> activeSessions = new ConcurrentHashMap<>();
 
+    private final Map<Integer, BinarySession> activeBinarySessions = new ConcurrentHashMap<>();
+
+    public byte[] addBinaryFragment(int msgId, int fragIdx, int fragCount, byte[] data) {
+        cleanupTimedOutSessions();
+
+        if (msgId < 0 || fragCount <= 0 || fragIdx < 0 || fragIdx >= fragCount || data == null) {
+            Log.w(TAG, "Dropping invalid binary fragment: msgId=" + msgId + ", index=" + fragIdx
+                    + ", total=" + fragCount);
+            return null;
+        }
+
+        if (activeBinarySessions.size() >= MAX_CONCURRENT_SESSIONS
+                && !activeBinarySessions.containsKey(msgId)) {
+            removeOldestBinarySession();
+        }
+
+        BinarySession session = activeBinarySessions.compute(msgId, (ignored, existingSession) -> {
+            if (existingSession == null) {
+                return new BinarySession(msgId, fragCount);
+            }
+            if (existingSession.fragCount != fragCount) {
+                Log.w(TAG, "fragCount mismatch for msgId " + msgId + ", resetting session");
+                return new BinarySession(msgId, fragCount);
+            }
+            return existingSession;
+        });
+
+        if (!session.addFragment(fragIdx, data)) {
+            return null;
+        }
+
+        if (!session.isComplete()) {
+            return null;
+        }
+
+        byte[] reassembled = session.reassemble();
+        activeBinarySessions.remove(msgId);
+        Log.d(TAG, "Reassembled binary message of " + reassembled.length + " bytes from "
+                + fragCount + " fragments");
+        return reassembled;
+    }
+
     public String addChunk(String chunkId, int chunkIndex, int totalChunks, String data) {
         cleanupTimedOutSessions();
 
@@ -61,11 +103,28 @@ public class MessageChunkReassembler {
 
     public void clear() {
         activeSessions.clear();
+        activeBinarySessions.clear();
     }
 
     private void cleanupTimedOutSessions() {
         long now = System.currentTimeMillis();
         activeSessions.entrySet().removeIf(entry -> now - entry.getValue().createdAt > CHUNK_TIMEOUT_MS);
+        activeBinarySessions.entrySet()
+                .removeIf(entry -> now - entry.getValue().createdAt > CHUNK_TIMEOUT_MS);
+    }
+
+    private void removeOldestBinarySession() {
+        Integer oldestId = null;
+        long oldestTime = Long.MAX_VALUE;
+        for (Map.Entry<Integer, BinarySession> entry : activeBinarySessions.entrySet()) {
+            if (entry.getValue().createdAt < oldestTime) {
+                oldestTime = entry.getValue().createdAt;
+                oldestId = entry.getKey();
+            }
+        }
+        if (oldestId != null) {
+            activeBinarySessions.remove(oldestId);
+        }
     }
 
     private void removeOldestSession() {
@@ -119,4 +178,51 @@ public class MessageChunkReassembler {
             return reassembled.toString();
         }
     }
+
+    private static class BinarySession {
+        final int msgId;
+        final int fragCount;
+        final long createdAt;
+        final Map<Integer, byte[]> fragments;
+
+        BinarySession(int msgId, int fragCount) {
+            this.msgId = msgId;
+            this.fragCount = fragCount;
+            this.createdAt = System.currentTimeMillis();
+            this.fragments = new ConcurrentHashMap<>();
+        }
+
+        boolean addFragment(int index, byte[] data) {
+            if (index < 0 || index >= fragCount) {
+                return false;
+            }
+            fragments.put(index, data);
+            return true;
+        }
+
+        boolean isComplete() {
+            return fragments.size() == fragCount;
+        }
+
+        byte[] reassemble() {
+            int totalLen = 0;
+            for (int i = 0; i < fragCount; i++) {
+                byte[] fragment = fragments.get(i);
+                if (fragment == null) {
+                    throw new IllegalStateException("Missing binary fragment " + i + " for msgId "
+                            + msgId);
+                }
+                totalLen += fragment.length;
+            }
+
+            byte[] result = new byte[totalLen];
+            int offset = 0;
+            for (int i = 0; i < fragCount; i++) {
+                byte[] fragment = fragments.get(i);
+                System.arraycopy(fragment, 0, result, offset, fragment.length);
+                offset += fragment.length;
+            }
+            return result;
+        }
+    }
 }