@glassly/bluetooth-sdk 0.1.0-dev.26

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

@@ -0,0 +1,319 @@
+package com.glassly.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(1_700_000_000_100L, compact.getLong("timestamp"));
+        assertFalse(compact.has("ts"));
+        assertTrue(compact.has("rc"));
+        assertFalse(compact.getBoolean("rc"));
+        assertEquals(1, compact.getJSONObject("cm").getInt("aes"));
+        assertEquals(1, compact.getJSONObject("cm").getInt("src"));
+        assertTrue(compact.toString().length() < input.toString().length());
+    }
+
+    @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 resolvedConfigIsAlwaysSent() 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"));
+        assertTrue(secondWire.has("resolvedConfig"));
+        assertFalse(secondWire.has(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
+
+        BleJsonCompact.markSessionConnected(9_000L);
+        JSONObject restoredSecond = BleJsonCompact.decode(secondWire);
+        assertEquals("sdk", restoredSecond.getJSONObject("resolvedConfig").getString("source"));
+        assertEquals(1_200L, restoredSecond.getLong("timestamp"));
+    }
+
+    @Test
+    public void legacyResolvedConfigHashStillDecodesWhenCached() throws Exception {
+        JSONObject config = new JSONObject("{\"source\":\"sdk\",\"transferMethod\":\"auto\"}");
+        JSONObject full =
+                new JSONObject(
+                        "{\"t\":\"stream_status\",\"s\":\"streaming\",\"resolvedConfig\":"
+                                + config
+                                + "}");
+        BleJsonCompact.decode(full);
+        JSONObject hashOnly =
+                new JSONObject(
+                        "{\"t\":\"stream_status\",\"s\":\"streaming\",\"rch\":\""
+                                + BleJsonCompact.hashConfig(config)
+                                + "\"}");
+
+        JSONObject restored = BleJsonCompact.decode(hashOnly);
+
+        assertEquals("sdk", restored.getJSONObject("resolvedConfig").getString("source"));
+        assertFalse(restored.has(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
+    }
+
+    @Test
+    public void legacyResolvedConfigCacheMissKeepsHashForDiagnostics() throws Exception {
+        JSONObject hashOnly =
+                new JSONObject(
+                        "{\"t\":\"stream_status\",\"s\":\"streaming\",\"rch\":\"deadbeef\"}");
+
+        JSONObject restored = BleJsonCompact.decode(hashOnly);
+
+        assertEquals("deadbeef", restored.getString(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
+        assertFalse(restored.has("resolvedConfig"));
+    }
+
+    @Test
+    public void ambiguousNestedWireKeysFallBackToVerboseJson() throws Exception {
+        JSONObject input =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"payload\":{"
+                                + "\"s\":\"literal\",\"kind\":0,\"source\":1}}");
+
+        JSONObject wire = BleJsonCompact.encode(input);
+
+        assertTrue(wire.has("type"));
+        assertFalse(wire.has("t"));
+        assertEquals("literal", wire.getJSONObject("payload").getString("s"));
+        assertEquals(0, wire.getJSONObject("payload").getInt("kind"));
+        assertEquals(1, wire.getJSONObject("payload").getInt("source"));
+        JSONObject restored = BleJsonCompact.decodeIfSupported(wire);
+        assertEquals("literal", restored.getJSONObject("payload").getString("s"));
+        assertEquals(0, restored.getJSONObject("payload").getInt("kind"));
+        assertEquals(1, restored.getJSONObject("payload").getInt("source"));
+    }
+
+    @Test
+    public void numericEnumFieldsFallBackToVerboseJson() throws Exception {
+        JSONObject input =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"payload\":{\"kind\":0,\"source\":1}}");
+
+        JSONObject wire = BleJsonCompact.encode(input);
+
+        assertTrue(wire.has("type"));
+        assertFalse(wire.has("t"));
+        assertEquals(0, wire.getJSONObject("payload").getInt("kind"));
+        assertEquals(1, wire.getJSONObject("payload").getInt("source"));
+    }
+
+    @Test
+    public void absoluteTimestampSurvivesDifferentSessionEpochs() throws Exception {
+        BleJsonCompact.markSessionConnected(1_000L);
+        JSONObject input =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"status\":\"streaming\","
+                                + "\"timestamp\":1700000000123}");
+
+        JSONObject wire = BleJsonCompact.encode(input);
+        BleJsonCompact.markSessionConnected(9_000L);
+        JSONObject restored = BleJsonCompact.decode(wire);
+
+        assertEquals(1_700_000_000_123L, wire.getLong("timestamp"));
+        assertFalse(wire.has("ts"));
+        assertEquals(1_700_000_000_123L, restored.getLong("timestamp"));
+    }
+
+    @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 startStreamPreservesDisabledSound() throws Exception {
+        JSONObject start =
+                new JSONObject(
+                        "{\"type\":\"start_stream\",\"streamUrl\":\"https://example.test/whip\","
+                                + "\"sound\":false}");
+
+        JSONObject wire = BleJsonCompact.encode(start);
+
+        assertEquals("start_stream", wire.getString("t"));
+        assertTrue(wire.has("sound"));
+        assertFalse(wire.getBoolean("sound"));
+        assertFalse(BleJsonCompact.decode(wire).getBoolean("sound"));
+    }
+
+    @Test
+    public void jsonValuesRoundTripAtEveryDepth() throws Exception {
+        JSONObject status =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"status\":\"stopped\","
+                                + "\"streaming\":false,\"reconnecting\":false,"
+                                + "\"resolvedConfig\":{\"audio\":{\"echoCancellation\":false,"
+                                + "\"noiseSuppression\":false}},"
+                                + "\"nullValue\":null,\"emptyObject\":{},\"emptyArray\":[]}");
+
+        JSONObject wire = BleJsonCompact.encode(status);
+
+        assertTrue(wire.has("streaming"));
+        assertFalse(wire.getBoolean("streaming"));
+        assertTrue(wire.has("rc"));
+        assertFalse(wire.getBoolean("rc"));
+        JSONObject wireAudio = wire.getJSONObject("resolvedConfig").getJSONObject("audio");
+        assertTrue(wireAudio.has("echoCancellation"));
+        assertFalse(wireAudio.getBoolean("echoCancellation"));
+        assertTrue(wireAudio.has("noiseSuppression"));
+        assertFalse(wireAudio.getBoolean("noiseSuppression"));
+        assertTrue(wire.has("nullValue"));
+        assertTrue(wire.isNull("nullValue"));
+        assertEquals(0, wire.getJSONObject("emptyObject").length());
+        assertEquals(0, wire.getJSONArray("emptyArray").length());
+
+        JSONObject restored = BleJsonCompact.decode(wire);
+        assertFalse(restored.getBoolean("streaming"));
+        assertFalse(restored.getBoolean("reconnecting"));
+        JSONObject restoredAudio =
+                restored.getJSONObject("resolvedConfig").getJSONObject("audio");
+        assertFalse(restoredAudio.getBoolean("echoCancellation"));
+        assertFalse(restoredAudio.getBoolean("noiseSuppression"));
+        assertTrue(restored.has("nullValue"));
+        assertTrue(restored.isNull("nullValue"));
+        assertEquals(0, restored.getJSONObject("emptyObject").length());
+        assertEquals(0, restored.getJSONArray("emptyArray").length());
+    }
+
+    @Test
+    public void streamTelemetryRoundTripsWithCompactKeys() throws Exception {
+        JSONObject status =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"status\":\"streaming\","
+                                + "\"stats\":{\"bitrate\":912345,\"fps\":19.8,"
+                                + "\"droppedFrames\":2,\"duration\":31,"
+                                + "\"temperatureC\":54.6}}\n");
+
+        JSONObject wire = BleJsonCompact.encode(status);
+        assertEquals(912345L, wire.getJSONObject("st").getLong("br"));
+        assertEquals(54.6d, wire.getJSONObject("st").getDouble("tc"), 0.001d);
+
+        JSONObject restored = BleJsonCompact.decode(wire);
+        JSONObject stats = restored.getJSONObject("stats");
+        assertEquals(19.8d, stats.getDouble("fps"), 0.001d);
+        assertEquals(2L, stats.getLong("droppedFrames"));
+        assertEquals(31L, stats.getLong("duration"));
+    }
+
+    @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"));
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/utils/BlePhotoUploadServiceTest.java

@@ -0,0 +1,107 @@
+package com.glassly.bluetoothsdk.utils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import android.graphics.Bitmap;
+import android.graphics.Color;
+
+import androidx.exifinterface.media.ExifInterface;
+
+import org.json.JSONObject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import java.io.File;
+import java.io.FileOutputStream;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 31)
+public class BlePhotoUploadServiceTest {
+
+    @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
+
+    @Test
+    public void describeContainer_detectsJpegAndAvifBrands() {
+        byte[] jpegHeader = {(byte) 0xFF, (byte) 0xD8, 0x00};
+        assertThat(BlePhotoUploadService.describeContainer(jpegHeader)).isEqualTo("jpeg");
+
+        byte[] avif =
+                new byte[] {
+                    0, 0, 0, 0,
+                    'f', 't', 'y', 'p',
+                    'a', 'v', 'i', 'f',
+                };
+        assertThat(BlePhotoUploadService.describeContainer(avif)).isEqualTo("iso_bmff/ftyp=avif");
+    }
+
+    @Test
+    public void containsExifMarkerInBytes_findsExifHeader() {
+        byte[] withExif = new byte[] {0, 1, 'E', 'x', 'i', 'f', 0, 0, 2};
+        assertThat(BlePhotoUploadService.containsExifMarkerInBytes(withExif)).isTrue();
+        assertThat(BlePhotoUploadService.containsExifMarkerInBytes(new byte[] {0, 1, 2, 3})).isFalse();
+    }
+
+    @Test
+    public void readImuJsonFromBleImage_parsesTiffUserCommentInAvif() throws Exception {
+        byte[] avif =
+                java.nio.file.Files.readAllBytes(
+                        new File("src/test/resources/avif_with_exif.avif").toPath());
+        File temp = tempFolder.newFile("ble.avif");
+        java.nio.file.Files.write(temp.toPath(), avif);
+        String json = BlePhotoUploadService.readImuJsonFromBleImage(avif, temp.getAbsolutePath());
+        assertThat(json).isNotNull();
+        assertThat(new JSONObject(json).getInt("sampleCount")).isEqualTo(5);
+    }
+
+    @Test
+    public void convertToJpeg_passesThroughExistingJpegWithoutReencode() throws Exception {
+        File input = tempFolder.newFile("input.jpg");
+        writeMinimalJpeg(input);
+        byte[] inputBytes = java.nio.file.Files.readAllBytes(input.toPath());
+        byte[] outputBytes = BlePhotoUploadService.convertToJpegPreservingExif(inputBytes);
+        assertThat(outputBytes).isEqualTo(inputBytes);
+    }
+
+    @Test
+    public void convertToJpegPreservesUserComment() throws Exception {
+        File input = tempFolder.newFile("input.jpg");
+        writeMinimalJpeg(input);
+        JSONObject payload = new JSONObject();
+        payload.put("version", 1);
+        payload.put("sampleCount", 2);
+        payload.put("samplingRateHz", 100);
+        payload.put("startTimeNs", 1000L);
+        payload.put("durationMs", 20);
+        payload.put("samples", new org.json.JSONArray());
+        ExifInterface inputExif = new ExifInterface(input.getAbsolutePath());
+        inputExif.setAttribute(ExifInterface.TAG_USER_COMMENT, payload.toString());
+        inputExif.saveAttributes();
+
+        byte[] inputBytes = java.nio.file.Files.readAllBytes(input.toPath());
+        byte[] outputBytes = BlePhotoUploadService.convertToJpegPreservingExif(inputBytes);
+
+        File output = tempFolder.newFile("out.jpg");
+        try (FileOutputStream fos = new FileOutputStream(output)) {
+            fos.write(outputBytes);
+        }
+
+        ExifInterface exif = new ExifInterface(output.getAbsolutePath());
+        String comment = exif.getAttribute(ExifInterface.TAG_USER_COMMENT);
+        assertThat(comment).isNotNull();
+        assertThat(new JSONObject(comment).getInt("sampleCount")).isEqualTo(2);
+    }
+
+    private static void writeMinimalJpeg(File dest) throws Exception {
+        Bitmap bitmap = Bitmap.createBitmap(2, 2, Bitmap.Config.ARGB_8888);
+        bitmap.eraseColor(Color.BLACK);
+        try (FileOutputStream fos = new FileOutputStream(dest)) {
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);
+        } finally {
+            bitmap.recycle();
+        }
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/utils/K900ProtocolUtilsEndiannessTest.java

@@ -0,0 +1,172 @@
+package com.glassly.bluetoothsdk.utils;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.json.JSONObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import java.nio.charset.StandardCharsets;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 33)
+public class K900ProtocolUtilsEndiannessTest {
+
+    @Test
+    public void packDataCommandUsesBigEndianLengthByDefault() {
+        byte[] payload = new byte[0x123];
+        byte[] packed = K900ProtocolUtils.packDataCommand(payload, K900ProtocolUtils.CMD_TYPE_STRING);
+
+        assertEquals(0x01, packed[3] & 0xFF);
+        assertEquals(0x23, packed[4] & 0xFF);
+    }
+
+    @Test
+    public void extractPayloadExplicitBigEndianRoundTripsLegacyFrame() {
+        byte[] payload = "{\"t\":\"ping\"}".getBytes(StandardCharsets.UTF_8);
+        byte[] packed = K900ProtocolUtils.packDataToK900(payload, K900ProtocolUtils.CMD_TYPE_STRING);
+        byte[] extracted = K900ProtocolUtils.extractPayload(packed, K900LengthCodec.Endian.BE);
+
+        assertNotNull(extracted);
+        assertArrayEquals(payload, extracted);
+    }
+
+    @Test
+    public void extractPayloadNoArgUsesBigEndianLengthByDefault() {
+        byte[] payload = "{\"t\":\"ping\"}".getBytes(StandardCharsets.UTF_8);
+        byte[] packed = K900ProtocolUtils.packDataToK900(payload, K900ProtocolUtils.CMD_TYPE_STRING);
+        byte[] extracted = K900ProtocolUtils.extractPayload(packed);
+
+        assertNotNull(extracted);
+        assertArrayEquals(payload, extracted);
+    }
+
+    @Test
+    public void processReceivedBytesToJsonUsesBigEndianLengthByDefault() throws Exception {
+        String inner = "{\"type\":\"ping\"}";
+        byte[] packed = K900ProtocolUtils.packDataToK900(
+                inner.getBytes(StandardCharsets.UTF_8),
+                K900ProtocolUtils.CMD_TYPE_STRING);
+
+        JSONObject json = K900ProtocolUtils.processReceivedBytesToJson(packed);
+
+        assertNotNull(json);
+        assertEquals("ping", json.getString("type"));
+    }
+
+    @Test
+    public void packDataCommandBigEndianWritesLengthMsbFirst() {
+        byte[] payload = new byte[0x123];
+        byte[] packed =
+                K900ProtocolUtils.packDataCommand(
+                        payload, K900ProtocolUtils.CMD_TYPE_STRING, K900LengthCodec.Endian.BE);
+
+        assertEquals(0x01, packed[3] & 0xFF);
+        assertEquals(0x23, packed[4] & 0xFF);
+    }
+
+    @Test
+    public void extractPayloadRoundTripsForBothEndianness() {
+        byte[] payload = "{\"type\":\"ping\"}".getBytes(StandardCharsets.UTF_8);
+
+        byte[] be =
+                K900ProtocolUtils.packDataCommand(
+                        payload, K900ProtocolUtils.CMD_TYPE_STRING, K900LengthCodec.Endian.BE);
+        byte[] le =
+                K900ProtocolUtils.packDataCommand(
+                        payload, K900ProtocolUtils.CMD_TYPE_STRING, K900LengthCodec.Endian.LE);
+
+        assertArrayEquals(payload, K900ProtocolUtils.extractPayload(be, K900LengthCodec.Endian.BE));
+        assertArrayEquals(payload, K900ProtocolUtils.extractPayload(le, K900LengthCodec.Endian.LE));
+    }
+
+    @Test
+    public void extractPayloadAutoDetectsBigEndianLegacyFrame() {
+        byte[] payload = "{\"type\":\"cs_syvr\"}".getBytes(StandardCharsets.UTF_8);
+        byte[] be =
+                K900ProtocolUtils.packDataCommand(
+                        payload, K900ProtocolUtils.CMD_TYPE_STRING, K900LengthCodec.Endian.BE);
+
+        assertArrayEquals(payload, K900ProtocolUtils.extractPayloadAuto(be));
+    }
+
+    @Test
+    public void extractPayloadAutoDetectsLittleEndianWireV2Frame() {
+        byte[] payload = "{\"type\":\"cs_syvr\"}".getBytes(StandardCharsets.UTF_8);
+        byte[] le =
+                K900ProtocolUtils.packDataCommand(
+                        payload, K900ProtocolUtils.CMD_TYPE_STRING, K900LengthCodec.Endian.LE);
+
+        assertArrayEquals(payload, K900ProtocolUtils.extractPayloadAuto(le));
+    }
+
+    @Test
+    public void processReceivedBytesToJsonAutoDetectsBigEndianFrame() throws Exception {
+        String inner = "{\"type\":\"ping\"}";
+        byte[] be =
+                K900ProtocolUtils.packDataCommand(
+                        inner.getBytes(StandardCharsets.UTF_8),
+                        K900ProtocolUtils.CMD_TYPE_STRING,
+                        K900LengthCodec.Endian.BE);
+
+        JSONObject json = K900ProtocolUtils.processReceivedBytesToJson(be);
+
+        assertNotNull(json);
+        assertEquals("ping", json.getString("type"));
+    }
+
+    @Test
+    public void repackStringFrameTranscodesLengthEndiannessOnly() {
+        byte[] payload = "{\"type\":\"ping\"}".getBytes(StandardCharsets.UTF_8);
+        byte[] be =
+                K900ProtocolUtils.packDataCommand(
+                        payload, K900ProtocolUtils.CMD_TYPE_STRING, K900LengthCodec.Endian.BE);
+
+        byte[] le =
+                K900LengthCodec.repackStringFrame(
+                        be, K900LengthCodec.Endian.BE, K900LengthCodec.Endian.LE);
+
+        assertEquals(payload.length & 0xFF, le[3] & 0xFF);
+        assertEquals((payload.length >> 8) & 0xFF, le[4] & 0xFF);
+        assertArrayEquals(payload, K900ProtocolUtils.extractPayload(le, K900LengthCodec.Endian.LE));
+    }
+
+    @Test
+    public void packBinaryFragmentUsesLittleEndianOuterLength() {
+        byte[] payload = new byte[300];
+        byte flags =
+                (byte)
+                        (BleWireProtocol.BLE_WIRE_FLAG_FIRST_FRAG
+                                | BleWireProtocol.BLE_WIRE_FLAG_LAST_FRAG);
+        byte[] frame = K900ProtocolUtils.packBinaryFragment(flags, 1, 0, 1, payload);
+
+        int innerLen = frame[3] & 0xFF | ((frame[4] & 0xFF) << 8);
+        assertEquals(BleWireProtocol.BINARY_HEADER_SIZE + payload.length, innerLen);
+        assertNotNull(K900ProtocolUtils.extractBinaryFragmentInfo(frame));
+    }
+
+    @Test
+    public void packAndExtractBinaryFragmentRoundTrip() {
+        byte[] payload = "v2".getBytes(StandardCharsets.UTF_8);
+        byte flags = (byte) (BleWireProtocol.BLE_WIRE_FLAG_HANDSHAKE
+                | BleWireProtocol.BLE_WIRE_FLAG_FIRST_FRAG
+                | BleWireProtocol.BLE_WIRE_FLAG_LAST_FRAG);
+        byte[] frame = K900ProtocolUtils.packBinaryFragment(flags, 0, 0, 1, payload);
+
+        assertTrue(K900ProtocolUtils.isBinaryFrame(frame));
+
+        BleWireProtocol.BinaryFragmentInfo info = K900ProtocolUtils.extractBinaryFragmentInfo(frame);
+        assertNotNull(info);
+        assertEquals(flags, info.flags);
+        assertEquals(0, info.msgId);
+        assertEquals(0, info.fragIdx);
+        assertEquals(1, info.fragCount);
+        assertArrayEquals(payload, info.payload);
+        assertTrue(BleWireProtocol.isHandshakeV2(info));
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/utils/K900ProtocolUtilsTest.java

@@ -0,0 +1,24 @@
+package com.glassly.bluetoothsdk.utils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class K900ProtocolUtilsTest {
+
+    @Test
+    public void packDataToK900_usesBigEndianLengthAt256ByteBoundary() {
+        byte[] payload = new byte[256];
+
+        byte[] packet = K900ProtocolUtils.packDataToK900(payload, K900ProtocolUtils.CMD_TYPE_STRING);
+
+        assertThat(packet).hasSize(263);
+        assertThat(packet[0]).isEqualTo((byte) '#');
+        assertThat(packet[1]).isEqualTo((byte) '#');
+        assertThat(packet[2]).isEqualTo(K900ProtocolUtils.CMD_TYPE_STRING);
+        assertThat(packet[3]).isEqualTo((byte) 0x01);
+        assertThat(packet[4]).isEqualTo((byte) 0x00);
+        assertThat(packet[261]).isEqualTo((byte) '$');
+        assertThat(packet[262]).isEqualTo((byte) '$');
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/utils/PhoneAudioMonitorTest.kt

@@ -0,0 +1,45 @@
+package com.glassly.bluetoothsdk.utils
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class PhoneAudioMonitorTest {
+    @Test
+    fun `keeps explicit playback hint while Android reports active media`() {
+        assertThat(
+                PhoneAudioMonitor.shouldKeepOwnAppAudioSignal(
+                        signalledPlaying = true,
+                        systemAudioPlaying = true,
+                        nowMs = 10_000,
+                        holdoffUntilMs = 1_000,
+                )
+            )
+            .isTrue()
+    }
+
+    @Test
+    fun `keeps explicit playback hint during codec transition holdoff`() {
+        assertThat(
+                PhoneAudioMonitor.shouldKeepOwnAppAudioSignal(
+                        signalledPlaying = true,
+                        systemAudioPlaying = false,
+                        nowMs = 500,
+                        holdoffUntilMs = 1_000,
+                )
+            )
+            .isTrue()
+    }
+
+    @Test
+    fun `expires stale playback hint when Android media is inactive`() {
+        assertThat(
+                PhoneAudioMonitor.shouldKeepOwnAppAudioSignal(
+                        signalledPlaying = true,
+                        systemAudioPlaying = false,
+                        nowMs = 1_000,
+                        holdoffUntilMs = 1_000,
+                )
+            )
+            .isFalse()
+    }
+}

package/app.plugin.js

@@ -0,0 +1,3 @@
+const plugin = require('./plugin/build');
+
+module.exports = plugin.default ?? plugin;