@mentra/bluetooth-sdk 0.1.17 → 0.1.19

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/camera/PhotoRequestTest.kt

@@ -3,10 +3,8 @@ package com.mentra.bluetoothsdk.camera
 import com.mentra.bluetoothsdk.PhotoCompression
 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 +17,7 @@ class PhotoRequestTest {
                 sound = true,
             )
 
-        assertTrue(request.requestId.startsWith("photo-"))
+        assertThat(request.requestId).startsWith("photo-")
     }
 
     @Test
@@ -35,7 +33,7 @@ class PhotoRequestTest {
                 )
             )
 
-        assertNull(request.exposureTimeNs)
+        assertThat(request.exposureTimeNs).isNull()
     }
 
     @Test
@@ -60,8 +58,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 +75,6 @@ class PhotoRequestTest {
                 )
             )
 
-        assertEquals("photo-1", request.requestId)
+        assertThat(request.requestId).isEqualTo("photo-1")
     }
 }

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

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

@@ -0,0 +1,158 @@
+package com.mentra.bluetoothsdk.utils;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.json.JSONObject;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 33)
+public class BleJsonCompactTest {
+
+    @After
+    public void tearDown() {
+        BleJsonCompact.resetSession();
+    }
+
+    @Test
+    public void encodeShortensKeysAndEnums() throws Exception {
+        BleJsonCompact.markSessionConnected(1_700_000_000_000L);
+        JSONObject input =
+                new JSONObject(
+                        "{"
+                                + "\"type\":\"photo_status\","
+                                + "\"requestId\":\"p1\","
+                                + "\"status\":\"capturing\","
+                                + "\"timestamp\":1700000000100,"
+                                + "\"reconnecting\":false,"
+                                + "\"captureMetadata\":{"
+                                + "\"aeStateName\":\"SEARCHING\","
+                                + "\"source\":\"button\""
+                                + "}"
+                                + "}");
+
+        JSONObject compact = BleJsonCompact.encode(input);
+
+        assertTrue(compact.has("t"));
+        assertEquals("photo_status", compact.getString("t"));
+        assertEquals("p1", compact.getString("r"));
+        assertEquals(3, compact.getInt("s"));
+        assertEquals(100L, compact.getLong("ts"));
+        assertFalse(compact.has("rc"));
+        assertEquals(1, compact.getJSONObject("cm").getInt("aes"));
+        assertEquals(1, compact.getJSONObject("cm").getInt("src"));
+    }
+
+    @Test
+    public void decodeRestoresVerboseJson() throws Exception {
+        BleJsonCompact.markSessionConnected(1_700_000_000_000L);
+        JSONObject compact =
+                new JSONObject(
+                        "{"
+                                + "\"t\":\"photo_status\","
+                                + "\"r\":\"p1\","
+                                + "\"s\":4,"
+                                + "\"ts\":42,"
+                                + "\"cm\":{\"aes\":0,\"etn\":8333333}"
+                                + "}");
+
+        JSONObject restored = BleJsonCompact.decode(compact);
+
+        assertEquals("photo_status", restored.getString("type"));
+        assertEquals("p1", restored.getString("requestId"));
+        assertEquals("captured", restored.getString("status"));
+        assertEquals(1_700_000_000_042L, restored.getLong("timestamp"));
+        assertEquals("CONVERGED", restored.getJSONObject("captureMetadata").getString("aeStateName"));
+        assertEquals(8333333L, restored.getJSONObject("captureMetadata").getLong("exposureTimeNs"));
+    }
+
+    @Test
+    public void resolvedConfigDiffOmitsRepeatPayload() throws Exception {
+        BleJsonCompact.markSessionConnected(1_000L);
+        JSONObject config = new JSONObject("{\"source\":\"sdk\",\"transferMethod\":\"auto\"}");
+        JSONObject first =
+                new JSONObject(
+                        "{"
+                                + "\"type\":\"stream_status\","
+                                + "\"status\":\"streaming\","
+                                + "\"timestamp\":1000,"
+                                + "\"resolvedConfig\":"
+                                + config
+                                + "}");
+        JSONObject second =
+                new JSONObject(
+                        "{"
+                                + "\"type\":\"stream_status\","
+                                + "\"status\":\"streaming\","
+                                + "\"timestamp\":1200,"
+                                + "\"resolvedConfig\":"
+                                + config
+                                + "}");
+
+        JSONObject firstWire = BleJsonCompact.encode(first);
+        JSONObject secondWire = BleJsonCompact.encode(second);
+
+        assertTrue(firstWire.has("resolvedConfig"));
+        assertFalse(secondWire.has("resolvedConfig"));
+        assertEquals(
+                BleJsonCompact.hashConfig(config),
+                secondWire.getString(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
+
+        JSONObject restoredSecond = BleJsonCompact.decode(secondWire);
+        assertEquals("sdk", restoredSecond.getJSONObject("resolvedConfig").getString("source"));
+    }
+
+    @Test
+    public void cameraCommandsAreLeftUntouched() throws Exception {
+        String camera = "{\"type\":\"take_photo\",\"requestId\":\"1\"}";
+        JSONObject encoded = BleJsonCompact.encode(camera);
+        assertTrue(encoded.has("type"));
+        assertEquals("take_photo", encoded.getString("type"));
+    }
+
+    @Test
+    public void lowRoiCommandsStayExpandedOutbound() throws Exception {
+        JSONObject ping = new JSONObject("{\"type\":\"ping\"}");
+        JSONObject transfer = new JSONObject("{\"type\":\"transfer_complete\",\"requestId\":\"1\"}");
+
+        assertTrue(BleJsonCompact.encode(ping).has("type"));
+        assertFalse(BleJsonCompact.encode(ping).has("t"));
+        assertTrue(BleJsonCompact.encode(transfer).has("type"));
+    }
+
+    @Test
+    public void highRoiCommandsCompactOutbound() throws Exception {
+        JSONObject photoResponse = new JSONObject("{\"type\":\"photo_response\",\"status\":\"ok\"}");
+        JSONObject wifiScan = new JSONObject("{\"type\":\"wifi_scan_result\",\"networks\":[]}");
+
+        assertEquals("photo_response", BleJsonCompact.encode(photoResponse).getString("t"));
+        assertEquals("wifi_scan_result", BleJsonCompact.encode(wifiScan).getString("t"));
+    }
+
+    @Test
+    public void decodeIfSupported_rejectsCompactLowRoi() throws Exception {
+        JSONObject compactPing = new JSONObject("{\"t\":\"ping\"}");
+
+        assertEquals(null, BleJsonCompact.decodeIfSupported(compactPing));
+    }
+
+    @Test
+    public void decodeIfSupported_acceptsExpandedLowRoi() throws Exception {
+        JSONObject expandedPing = new JSONObject("{\"type\":\"ping\"}");
+
+        assertEquals("ping", BleJsonCompact.decodeIfSupported(expandedPing).getString("type"));
+    }
+
+    @Test
+    public void decodeIfSupported_acceptsCompactChunkEnvelope() throws Exception {
+        JSONObject chunk = new JSONObject("{\"t\":\"ck\",\"id\":\"1\",\"c\":0,\"n\":2,\"d\":\"x\"}");
+
+        assertEquals("ck", BleJsonCompact.decodeIfSupported(chunk).getString("type"));
+    }
+}