@mentra/bluetooth-sdk 0.1.18 → 0.1.20

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;
+        }
+    }
 }

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

@@ -7,6 +7,7 @@ import org.json.JSONObject;
 
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -34,6 +35,8 @@ public class MessageChunker {
     private static final int INITIAL_CHUNK_DATA_SIZE = 80;
     private static final int MIN_CHUNK_DATA_SIZE = 4;
     private static final int MAX_PACKED_CHUNK_SIZE = 253;
+    private static final int MAX_BINARY_FRAGMENT_PAYLOAD = BleWireProtocol.MAX_FRAGMENT_PAYLOAD;
+    private static final int MAX_BINARY_FRAME_SIZE = BleWireProtocol.MTU_TARGET;
 
     /**
      * Check if a message needs to be chunked
@@ -207,6 +210,96 @@ public class MessageChunker {
         return json.optInt(compactKey, defaultValue);
     }
 
+    public static boolean needsBinaryFragmenting(byte[] payload) {
+        return payload != null && payload.length > MAX_BINARY_FRAGMENT_PAYLOAD;
+    }
+
+    public static boolean needsBinaryFragmenting(String json) {
+        if (json == null) {
+            return false;
+        }
+        return needsBinaryFragmenting(json.getBytes(StandardCharsets.UTF_8));
+    }
+
+    /**
+     * Split raw UTF-8 payload into binary wire fragments (v2 path).
+     */
+    public static List<BinaryFragment> createBinaryFragments(
+            byte[] payload, int msgId, boolean wakeup, boolean ackRequested) {
+        if (payload == null) {
+            throw new IllegalArgumentException("Cannot fragment null payload");
+        }
+
+        int fragCount = (payload.length + MAX_BINARY_FRAGMENT_PAYLOAD - 1) / MAX_BINARY_FRAGMENT_PAYLOAD;
+        if (fragCount > 255) {
+            throw new IllegalArgumentException("Payload too large for binary fragmentation");
+        }
+        if (fragCount == 0) {
+            fragCount = 1;
+        }
+
+        List<BinaryFragment> fragments = new ArrayList<>(fragCount);
+        for (int i = 0; i < fragCount; i++) {
+            int offset = i * MAX_BINARY_FRAGMENT_PAYLOAD;
+            int len = Math.min(MAX_BINARY_FRAGMENT_PAYLOAD, payload.length - offset);
+            byte[] fragPayload = Arrays.copyOfRange(payload, offset, offset + len);
+
+            byte flags = 0;
+            if (i == 0) {
+                flags |= BleWireProtocol.BLE_WIRE_FLAG_FIRST_FRAG;
+            }
+            if (i == fragCount - 1) {
+                flags |= BleWireProtocol.BLE_WIRE_FLAG_LAST_FRAG;
+            }
+            if (wakeup && i == 0) {
+                flags |= BleWireProtocol.BLE_WIRE_FLAG_WAKE;
+            }
+            if (ackRequested && i == fragCount - 1) {
+                flags |= BleWireProtocol.BLE_WIRE_FLAG_ACK_REQUESTED;
+            }
+
+            fragments.add(new BinaryFragment(flags, msgId, i, fragCount, fragPayload));
+        }
+
+        Log.d(TAG, "Created " + fragments.size() + " binary fragments for "
+                + payload.length + " byte payload");
+        return fragments;
+    }
+
+    public static boolean allBinaryFragmentsFit(List<BinaryFragment> fragments) {
+        for (BinaryFragment fragment : fragments) {
+            byte[] packed = K900ProtocolUtils.packBinaryFragment(
+                    fragment.flags,
+                    fragment.msgId,
+                    fragment.fragIdx,
+                    fragment.fragCount,
+                    fragment.payload);
+            if (packed == null || packed.length > MAX_BINARY_FRAME_SIZE) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Container for binary wire fragment metadata
+     */
+    public static class BinaryFragment {
+        public final byte flags;
+        public final int msgId;
+        public final int fragIdx;
+        public final int fragCount;
+        public final byte[] payload;
+
+        public BinaryFragment(byte flags, int msgId, int fragIdx, int fragCount, byte[] payload) {
+            this.flags = flags;
+            this.msgId = msgId;
+            this.fragIdx = fragIdx;
+            this.fragCount = fragCount;
+            this.payload = payload;
+        }
+    }
+
     /**
      * Container for chunk information
      */

package/android/src/main/java/com/mentra/bluetoothsdk/utils/NexSGCUtils.kt

@@ -15,6 +15,12 @@ import mentraos.ble.MentraosBle.ClearDisplay
 import mentraos.ble.MentraosBle.DisconnectRequest
 import mentraos.ble.MentraosBle.PhoneToGlasses
 import mentraos.ble.MentraosBle.DisplayImage
+import mentraos.ble.MentraosBle.CanvasCreateComponent
+import mentraos.ble.MentraosBle.CanvasUpdateImage
+import mentraos.ble.MentraosBle.CanvasUpdateText
+import mentraos.ble.MentraosBle.CanvasDeleteComponent
+import mentraos.ble.MentraosBle.CanvasClear
+import mentraos.ble.MentraosBle.CanvasComponentType
 import mentraos.ble.MentraosBle.BatteryStateRequest
 import mentraos.ble.MentraosBle.MicStateConfig
 import mentraos.ble.MentraosBle.BrightnessConfig
@@ -61,6 +67,25 @@ object NexProtobufUtils {
 
     private const val WHITELIST_CMD: Int = 0x04
 
+    // Characters the Nex font can render: letters, digits, whitespace, and a small
+    // punctuation set. Everything else (CJK, emoji, smart quotes, …) is stripped when
+    // Chinese captions are off. Compiled once — sanitizeDisplayText runs on every
+    // caption update (high frequency), so we don't rebuild it per call.
+    private val UNSUPPORTED_GLYPH_REGEX = Regex("""[^A-Za-z0-9 \r\n.,!?;:\-\[\]\(\)\{\}'"+=/]""")
+
+    /**
+     * Sanitize text bound for the glasses. When Chinese captions are disabled (the
+     * default) the Nex font can't render CJK/emoji/etc., so em-dashes are normalised
+     * to hyphens and any unsupported glyph is dropped. When enabled, text passes
+     * through untouched. Every text path that reaches the display funnels through
+     * here so the filter behaves identically for captions, text walls, and layouts.
+     */
+    private fun sanitizeDisplayText(text: String): String {
+        val chineseCaptionsEnabled = DeviceStore.get("bluetooth", "nex_chinese_captions") as? Boolean ?: false
+        if (chineseCaptionsEnabled) return text
+        return text.replace("—", "-").replace(UNSUPPORTED_GLYPH_REGEX, "")
+    }
+
     /**
      * Maps dashboard depth to the value Nex firmware expects in [DisplayDistanceConfig.distance_cm].
      * The protobuf field is still named `distance_cm`, but Nex treats it as a **tier** 1–4, not centimeters.
@@ -241,22 +266,97 @@ object NexProtobufUtils {
         return generateProtobufCommandBytes(phoneToGlasses)
     }
 
+    /**
+     * Canvas: create (or replace) a full-screen bitmap component. The firmware infers the bitmap
+     * pool from the id (10..13); we use a single fixed id for the full-screen image. Pixels follow
+     * via [generateCanvasUpdateImageCommandBytes] + the 0xB0 chunk stream.
+     */
+    fun generateCanvasCreateBitmapCommandBytes(id: Int, x: Int, y: Int, width: Int, height: Int): ByteArray {
+        // Negative geometry would serialize as a huge unsigned varint on the
+        // wire — clamp to the drawable range before it reaches the firmware.
+        val create = CanvasCreateComponent.newBuilder()
+            .setId(id)
+            .setType(CanvasComponentType.CANVAS_BITMAP)
+            .setX(x.coerceAtLeast(0))
+            .setY(y.coerceAtLeast(0))
+            .setWidth(width.coerceAtLeast(1))
+            .setHeight(height.coerceAtLeast(1))
+            .build()
+        val phoneToGlasses = PhoneToGlasses.newBuilder()
+            .setCanvasCreateComponent(create)
+            .build()
+        return generateProtobufCommandBytes(phoneToGlasses)
+    }
+
+    /** Canvas: create (or replace) a text component (TEXTBOX). Content follows via CanvasUpdateText. */
+    fun generateCanvasCreateTextboxCommandBytes(
+        id: Int, x: Int, y: Int, width: Int, height: Int, borderWidth: Int, borderRadius: Int
+    ): ByteArray {
+        val create = CanvasCreateComponent.newBuilder()
+            .setId(id)
+            .setType(CanvasComponentType.CANVAS_TEXTBOX)
+            .setX(x)
+            .setY(y)
+            .setWidth(width)
+            .setHeight(height)
+            .setBorderWidth(borderWidth)
+            .setBorderRadius(borderRadius)
+            .build()
+        val phoneToGlasses = PhoneToGlasses.newBuilder()
+            .setCanvasCreateComponent(create)
+            .build()
+        return generateProtobufCommandBytes(phoneToGlasses)
+    }
+
+    /** Canvas: set the text of a TEXTBOX / SCROLL_TEXTBOX component. */
+    fun generateCanvasUpdateTextCommandBytes(id: Int, text: String, scrollOffset: Int = 0): ByteArray {
+        val update = CanvasUpdateText.newBuilder()
+            .setId(id)
+            .setText(sanitizeDisplayText(text))
+            .setScrollOffset(scrollOffset)
+            .build()
+        val phoneToGlasses = PhoneToGlasses.newBuilder()
+            .setCanvasUpdateText(update)
+            .build()
+        return generateProtobufCommandBytes(phoneToGlasses)
+    }
+
+    /** Canvas: delete a single component by id. */
+    fun generateCanvasDeleteComponentCommandBytes(id: Int): ByteArray {
+        val del = CanvasDeleteComponent.newBuilder().setId(id).build()
+        val phoneToGlasses = PhoneToGlasses.newBuilder()
+            .setCanvasDeleteComponent(del)
+            .build()
+        return generateProtobufCommandBytes(phoneToGlasses)
+    }
+
+    /** Canvas: delete all components and exit the canvas view. */
+    fun generateCanvasClearCommandBytes(): ByteArray {
+        val phoneToGlasses = PhoneToGlasses.newBuilder()
+            .setCanvasClear(CanvasClear.newBuilder().build())
+            .build()
+        return generateProtobufCommandBytes(phoneToGlasses)
+    }
+
+    /** Canvas: begin streaming a 1-bit BMP into an existing bitmap component. */
+    fun generateCanvasUpdateImageCommandBytes(id: Int, streamId: String, totalChunks: Int): ByteArray {
+        val update = CanvasUpdateImage.newBuilder()
+            .setId(id)
+            .setStreamId(streamId)
+            .setTotalChunks(totalChunks)
+            .build()
+        val phoneToGlasses = PhoneToGlasses.newBuilder()
+            .setCanvasUpdateImage(update)
+            .build()
+        return generateProtobufCommandBytes(phoneToGlasses)
+    }
+
     fun generateDisplayTextCommandBytes(text: String): ByteArray {
         Bridge.log("Nex: === SENDING TEXT TO GLASSES ===")
         Bridge.log("Nex: Text: \"$text\"")
         Bridge.log("Nex: Text Length: ${text.length} characters")
 
-        // When Chinese captions are disabled (default), strip characters the Nex font
-        // can't render (CJK etc.): replace m-dashes, then keep only the supported ASCII set.
-        val chineseCaptionsEnabled = DeviceStore.get("bluetooth", "nex_chinese_captions") as? Boolean ?: false
-        val displayText = if (chineseCaptionsEnabled) {
-            text
-        } else {
-            text.replace("—", "-").replace(
-                Regex("""[^A-Za-z0-9 \r\n.,!?;:\-\[\]\(\)\{\}'"+=/]"""),
-                ""
-            )
-        }
+        val displayText = sanitizeDisplayText(text)
 
         val textNewBuilder = DisplayText.newBuilder()
             .setColor(10000)

package/android/src/test/java/com/mentra/bluetoothsdk/BluetoothSdkExceptionTest.kt

@@ -0,0 +1,18 @@
+package com.mentra.bluetoothsdk
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class BluetoothSdkExceptionTest {
+    @Test
+    fun `exception is usable without the Expo runtime`() {
+        val cause = IllegalArgumentException("cause")
+        val error = BluetoothSdkException("capture_failed", "Capture failed", cause)
+
+        assertThat(error.code).isEqualTo("capture_failed")
+        assertThat(error.message).isEqualTo("Capture failed")
+        assertThat(error.cause).isSameAs(cause)
+        assertThat(error).isInstanceOf(IllegalStateException::class.java)
+        assertThat(error.javaClass.superclass.name).doesNotStartWith("expo.modules")
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/camera/PhotoRequestTest.kt

@@ -1,12 +1,11 @@
 package com.mentra.bluetoothsdk.camera
 
 import com.mentra.bluetoothsdk.PhotoCompression
+import com.mentra.bluetoothsdk.PhotoMode
 import com.mentra.bluetoothsdk.PhotoRequest
 import com.mentra.bluetoothsdk.PhotoSize
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNull
-import kotlin.test.assertTrue
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
 
 class PhotoRequestTest {
     @Test
@@ -19,7 +18,7 @@ class PhotoRequestTest {
                 sound = true,
             )
 
-        assertTrue(request.requestId.startsWith("photo-"))
+        assertThat(request.requestId).startsWith("photo-")
     }
 
     @Test
@@ -35,7 +34,8 @@ class PhotoRequestTest {
                 )
             )
 
-        assertNull(request.exposureTimeNs)
+        assertThat(request.exposureTimeNs).isNull()
+        assertThat(request.mode).isEqualTo(PhotoMode.PHOTO)
     }
 
     @Test
@@ -60,8 +60,8 @@ class PhotoRequestTest {
                 )
             )
 
-        assertTrue(withoutRequestId.requestId.startsWith("photo-"))
-        assertTrue(blankRequestId.requestId.startsWith("photo-"))
+        assertThat(withoutRequestId.requestId).startsWith("photo-")
+        assertThat(blankRequestId.requestId).startsWith("photo-")
     }
 
     @Test
@@ -77,6 +77,20 @@ class PhotoRequestTest {
                 )
             )
 
-        assertEquals("photo-1", request.requestId)
+        assertThat(request.requestId).isEqualTo("photo-1")
+    }
+
+    @Test
+    fun `fromMap preserves text mode`() {
+        val request =
+            PhotoRequest.fromMap(
+                mapOf(
+                    "size" to "medium",
+                    "mode" to "text",
+                    "webhookUrl" to "https://example.com/upload",
+                )
+            )
+
+        assertThat(request.mode).isEqualTo(PhotoMode.TEXT)
     }
 }

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/G1TextSanitizerTest.kt

@@ -0,0 +1,31 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class G1TextSanitizerTest {
+
+    @Test
+    fun `strips Vietnamese diacritics unsupported by G1`() {
+        assertThat(sanitizeG1DisplayText("Tiếng Việt: Đặng, Nguyễn, phở bò"))
+            .isEqualTo("Tieng Viet: Dang, Nguyen, pho bo")
+    }
+
+    @Test
+    fun `handles decomposed marks and preserves layout`() {
+        assertThat(sanitizeG1DisplayText("Cafe\u0301\nĐa Nang"))
+            .isEqualTo("Cafe\nDa Nang")
+    }
+
+    @Test
+    fun `expands Latin letters that do not decompose into combining marks`() {
+        assertThat(sanitizeG1DisplayText("Øresund Łódź Æsir Œuvre Straße Ðingvellir Þingvellir"))
+            .isEqualTo("Oresund Lodz AEsir OEuvre Strasse Dingvellir THingvellir")
+    }
+
+    @Test
+    fun `leaves text without diacritics unchanged`() {
+        assertThat(sanitizeG1DisplayText("Hello, world! 123"))
+            .isEqualTo("Hello, world! 123")
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/utils/AvifExifStripperTest.java

@@ -19,12 +19,28 @@ public class AvifExifStripperTest {
                 java.nio.file.Files.readAllBytes(
                         new File("src/test/resources/avif_with_exif.avif").toPath());
         assertThat(BlePhotoUploadService.containsExifMarkerInBytes(withExif)).isTrue();
+        int originalMarkerCount = countExifMarkers(withExif);
 
         byte[] stripped = AvifExifStripper.stripForDecode(withExif);
         assertThat(stripped.length).isLessThan(withExif.length);
-        assertThat(BlePhotoUploadService.containsExifMarkerInBytes(stripped)).isFalse();
+        assertThat(countExifMarkers(stripped)).isLessThan(originalMarkerCount);
 
         byte[] jpeg = BlePhotoUploadService.convertToJpegPreservingExif(withExif);
         assertThat(jpeg.length).isGreaterThan(100);
     }
+
+    private static int countExifMarkers(byte[] data) {
+        byte[] marker = new byte[] {'E', 'x', 'i', 'f', 0, 0};
+        int count = 0;
+        outer:
+        for (int i = 0; i <= data.length - marker.length; i++) {
+            for (int j = 0; j < marker.length; j++) {
+                if (data[i + j] != marker[j]) {
+                    continue outer;
+                }
+            }
+            count++;
+        }
+        return count;
+    }
 }

package/android/src/test/java/com/mentra/bluetoothsdk/utils/BinaryMessageChunkerTest.java

@@ -0,0 +1,84 @@
+package com.mentra.bluetoothsdk.utils;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 33)
+public class BinaryMessageChunkerTest {
+
+    @Test
+    public void smallPayloadProducesSingleFragment() {
+        byte[] payload = "{\"type\":\"ping\"}".getBytes(StandardCharsets.UTF_8);
+
+        assertFalse(MessageChunker.needsBinaryFragmenting(payload));
+
+        List<MessageChunker.BinaryFragment> fragments =
+                MessageChunker.createBinaryFragments(payload, 42, false, false);
+
+        assertEquals(1, fragments.size());
+        assertEquals(42, fragments.get(0).msgId);
+        assertEquals(0, fragments.get(0).fragIdx);
+        assertEquals(1, fragments.get(0).fragCount);
+        assertTrue(MessageChunker.allBinaryFragmentsFit(fragments));
+    }
+
+    @Test
+    public void largePayloadSplitsIntoMultipleFragments() {
+        byte[] payload = new byte[1000];
+        for (int i = 0; i < payload.length; i++) {
+            payload[i] = (byte) ('a' + (i % 26));
+        }
+
+        assertTrue(MessageChunker.needsBinaryFragmenting(payload));
+
+        List<MessageChunker.BinaryFragment> fragments =
+                MessageChunker.createBinaryFragments(payload, 7, true, true);
+
+        assertEquals(3, fragments.size());
+        assertEquals(7, fragments.get(0).msgId);
+        assertEquals(0, fragments.get(0).fragIdx);
+        assertEquals(2, fragments.get(2).fragIdx);
+        assertEquals(3, fragments.get(0).fragCount);
+        assertTrue((fragments.get(0).flags & BleWireProtocol.BLE_WIRE_FLAG_WAKE) != 0);
+        assertTrue((fragments.get(2).flags & BleWireProtocol.BLE_WIRE_FLAG_ACK_REQUESTED) != 0);
+        assertTrue(MessageChunker.allBinaryFragmentsFit(fragments));
+    }
+
+    @Test
+    public void binaryReassemblerRebuildsPayload() {
+        byte[] payload = new byte[900];
+        for (int i = 0; i < payload.length; i++) {
+            payload[i] = (byte) (i & 0xFF);
+        }
+
+        List<MessageChunker.BinaryFragment> fragments =
+                MessageChunker.createBinaryFragments(payload, 99, false, false);
+        MessageChunkReassembler reassembler = new MessageChunkReassembler();
+
+        byte[] rebuilt = null;
+        for (MessageChunker.BinaryFragment fragment : fragments) {
+            rebuilt = reassembler.addBinaryFragment(
+                    fragment.msgId,
+                    fragment.fragIdx,
+                    fragment.fragCount,
+                    fragment.payload);
+        }
+
+        assertNotNull(rebuilt);
+        assertEquals(payload.length, rebuilt.length);
+        for (int i = 0; i < payload.length; i++) {
+            assertEquals(payload[i], rebuilt[i]);
+        }
+    }
+}