@mentra/bluetooth-sdk 0.1.8 → 0.1.10

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

@@ -0,0 +1,199 @@
+package com.mentra.bluetoothsdk.utils;
+
+import androidx.annotation.Nullable;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Reads EXIF UserComment / ImageDescription from a TIFF block embedded in AVIF/HEIF when
+ * {@link androidx.exifinterface.media.ExifInterface} cannot (e.g. some OEMs omit MMR EXIF keys).
+ */
+final class HeifExifTagReader {
+    private static final int TAG_USER_COMMENT = 0x9286;
+    private static final int TAG_IMAGE_DESCRIPTION = 0x010E;
+    private static final int TAG_EXIF_IFD_POINTER = 0x8769;
+
+    private HeifExifTagReader() {}
+
+    @Nullable
+    static String readImuJson(byte[] fileBytes) {
+        int searchFrom = 0;
+        while (true) {
+            int exif = indexOf(fileBytes, new byte[] {'E', 'x', 'i', 'f', 0, 0}, searchFrom);
+            if (exif < 0) {
+                return null;
+            }
+            int tiff = exif + 6;
+            if (tiff + 8 <= fileBytes.length && isTiffHeader(fileBytes, tiff)) {
+                return readFromTiff(fileBytes, tiff);
+            }
+            searchFrom = exif + 1;
+        }
+    }
+
+    private static boolean isTiffHeader(byte[] data, int tiff) {
+        boolean littleEndian = data[tiff] == 'I' && data[tiff + 1] == 'I';
+        boolean bigEndian = data[tiff] == 'M' && data[tiff + 1] == 'M';
+        if (!littleEndian && !bigEndian) {
+            return false;
+        }
+        int magic = readUInt16(data, tiff + 2, littleEndian);
+        return magic == 0x002A;
+    }
+
+    @Nullable
+    private static String readFromTiff(byte[] fileBytes, int tiff) {
+        boolean littleEndian = fileBytes[tiff] == 'I' && fileBytes[tiff + 1] == 'I';
+        int ifd0 = readInt(fileBytes, tiff + 4, littleEndian);
+        int ifd0Offset = tiff + ifd0;
+        if (ifd0 < 0 || ifd0Offset < tiff || (long) ifd0Offset + 2 > fileBytes.length) {
+            return null;
+        }
+        String userComment = readTagString(fileBytes, tiff, ifd0Offset, TAG_USER_COMMENT, littleEndian);
+        if (userComment != null && !userComment.isEmpty()) {
+            return userComment;
+        }
+        userComment =
+                readTagFromLinkedIfd(fileBytes, tiff, ifd0Offset, TAG_EXIF_IFD_POINTER, TAG_USER_COMMENT, littleEndian);
+        if (userComment != null && !userComment.isEmpty()) {
+            return userComment;
+        }
+        String imageDescription =
+                readTagString(fileBytes, tiff, ifd0Offset, TAG_IMAGE_DESCRIPTION, littleEndian);
+        if (imageDescription != null && !imageDescription.isEmpty()) {
+            return imageDescription;
+        }
+        return readTagFromLinkedIfd(
+                fileBytes, tiff, ifd0Offset, TAG_EXIF_IFD_POINTER, TAG_IMAGE_DESCRIPTION, littleEndian);
+    }
+
+    @Nullable
+    private static String readTagFromLinkedIfd(
+            byte[] data,
+            int tiffStart,
+            int ifdOffset,
+            int pointerTag,
+            int targetTag,
+            boolean littleEndian) {
+        if ((long) ifdOffset + 2 > data.length) {
+            return null;
+        }
+        int count = readUInt16(data, ifdOffset, littleEndian);
+        int entryStart = ifdOffset + 2;
+        for (int i = 0; i < count; i++) {
+            int entry = entryStart + i * 12;
+            if ((long) entry + 12 > data.length) {
+                return null;
+            }
+            int tag = readUInt16(data, entry, littleEndian);
+            if (tag != pointerTag) {
+                continue;
+            }
+            int subIfdOffset = readInt(data, entry + 8, littleEndian);
+            int subIfdAbs = tiffStart + subIfdOffset;
+            if (subIfdOffset < 0
+                    || subIfdAbs < tiffStart
+                    || (long) subIfdAbs + 2 > data.length) {
+                return null;
+            }
+            return readTagString(data, tiffStart, subIfdAbs, targetTag, littleEndian);
+        }
+        return null;
+    }
+
+    private static int indexOf(byte[] data, byte[] needle, int fromIndex) {
+        outer:
+        for (int i = fromIndex; i <= data.length - needle.length; i++) {
+            for (int j = 0; j < needle.length; j++) {
+                if (data[i + j] != needle[j]) {
+                    continue outer;
+                }
+            }
+            return i;
+        }
+        return -1;
+    }
+
+    @Nullable
+    private static String readTagString(
+            byte[] data, int tiffStart, int ifdOffset, int tagId, boolean littleEndian) {
+        if ((long) ifdOffset + 2 > data.length) {
+            return null;
+        }
+        int count = readUInt16(data, ifdOffset, littleEndian);
+        int entryStart = ifdOffset + 2;
+        for (int i = 0; i < count; i++) {
+            int entry = entryStart + i * 12;
+            if ((long) entry + 12 > data.length) {
+                return null;
+            }
+            int tag = readUInt16(data, entry, littleEndian);
+            if (tag != tagId) {
+                continue;
+            }
+            int type = readUInt16(data, entry + 2, littleEndian);
+            int valueCount = readInt(data, entry + 4, littleEndian);
+            int valueOffset = readInt(data, entry + 8, littleEndian);
+            int valuePos = valueCount > 4 ? tiffStart + valueOffset : entry + 8;
+            if (valueCount > 4 && (valueOffset < 0 || valuePos < tiffStart || valuePos > data.length)) {
+                continue;
+            }
+            return decodeExifString(data, valuePos, valueCount, type);
+        }
+        return null;
+    }
+
+    @Nullable
+    private static String decodeExifString(byte[] data, int offset, int count, int type) {
+        if (count <= 0 || offset < 0) {
+            return null;
+        }
+        long end = (long) offset + count;
+        if (end > data.length) {
+            return null;
+        }
+        if (type == 2) {
+            int len = count;
+            while (len > 0 && data[offset + len - 1] == 0) {
+                len--;
+            }
+            return new String(data, offset, len, StandardCharsets.UTF_8);
+        }
+        if (type == 7 || type == 1) {
+            if (count >= 8 && data[offset] == 'A' && data[offset + 1] == 'S') {
+                int textStart = offset + 8;
+                int textLen = count - 8;
+                while (textLen > 0 && data[textStart + textLen - 1] == 0) {
+                    textLen--;
+                }
+                return new String(data, textStart, textLen, StandardCharsets.UTF_8);
+            }
+            int len = count;
+            while (len > 0 && data[offset + len - 1] == 0) {
+                len--;
+            }
+            return new String(data, offset, len, StandardCharsets.UTF_8);
+        }
+        return null;
+    }
+
+    private static int readUInt16(byte[] data, int offset, boolean littleEndian) {
+        if (littleEndian) {
+            return (data[offset] & 0xFF) | ((data[offset + 1] & 0xFF) << 8);
+        }
+        return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
+    }
+
+    private static int readInt(byte[] data, int offset, boolean littleEndian) {
+        if (littleEndian) {
+            return (data[offset] & 0xFF)
+                    | ((data[offset + 1] & 0xFF) << 8)
+                    | ((data[offset + 2] & 0xFF) << 16)
+                    | ((data[offset + 3] & 0xFF) << 24);
+        }
+        return ((data[offset] & 0xFF) << 24)
+                | ((data[offset + 1] & 0xFF) << 16)
+                | ((data[offset + 2] & 0xFF) << 8)
+                | (data[offset + 3] & 0xFF);
+    }
+}

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

@@ -18,12 +18,29 @@ public class MessageChunkReassembler {
     public String addChunk(String chunkId, int chunkIndex, int totalChunks, String data) {
         cleanupTimedOutSessions();
 
+        if (chunkId == null || chunkId.isEmpty() || totalChunks <= 0 || chunkIndex < 0
+                || chunkIndex >= totalChunks || data == null) {
+            Log.w(TAG, "Dropping invalid chunk metadata: id=" + chunkId + ", index=" + chunkIndex
+                    + ", total=" + totalChunks);
+            return null;
+        }
+
         if (activeSessions.size() >= MAX_CONCURRENT_SESSIONS && !activeSessions.containsKey(chunkId)) {
             Log.w(TAG, "Maximum concurrent chunk sessions reached, dropping oldest");
             removeOldestSession();
         }
 
-        ChunkSession session = activeSessions.computeIfAbsent(chunkId, ignored -> new ChunkSession(chunkId, totalChunks));
+        ChunkSession session = activeSessions.compute(chunkId, (ignored, existingSession) -> {
+            if (existingSession == null) {
+                return new ChunkSession(chunkId, totalChunks);
+            }
+            if (existingSession.totalChunks != totalChunks) {
+                Log.w(TAG, "totalChunks mismatch for " + chunkId + " (expected "
+                        + existingSession.totalChunks + ", got " + totalChunks + "), resetting session");
+                return new ChunkSession(chunkId, totalChunks);
+            }
+            return existingSession;
+        });
         boolean added = session.addChunk(chunkIndex, data);
         if (!added) {
             Log.w(TAG, "Failed to add chunk " + chunkIndex + " to session " + chunkId);

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

@@ -5,6 +5,7 @@ import android.util.Log;
 import org.json.JSONException;
 import org.json.JSONObject;
 
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -20,8 +21,8 @@ import java.util.List;
  *   d  = chunk data payload
  *
  * Each chunk after C-wrapping + K900 framing must fit within the BES2700's
- * 253-byte BLE write limit. With compact keys, 80 bytes of raw data produces
- * a final packed size of ~245 bytes worst-case (with heavy JSON escaping).
+ * 253-byte BLE write limit. Payload size is selected by measuring the final
+ * packed chunk so JSON escaping cannot push a chunk over the BLE limit.
  */
 public class MessageChunker {
     private static final String TAG = "MessageChunker";
@@ -30,9 +31,9 @@ public class MessageChunker {
     // BES2700 limit is 253 bytes; anything over ~200 bytes packed needs chunking.
     private static final int MESSAGE_SIZE_THRESHOLD = 200;
 
-    // Maximum raw bytes per chunk. After double JSON escaping + compact envelope
-    // + C-wrapper + K900 framing, 80 bytes stays under the 253-byte BLE limit.
-    private static final int CHUNK_DATA_SIZE = 80;
+    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;
 
     /**
      * Check if a message needs to be chunked
@@ -44,7 +45,7 @@ public class MessageChunker {
             return false;
         }
 
-        int messageBytes = message.getBytes().length;
+        int messageBytes = message.getBytes(StandardCharsets.UTF_8).length;
         boolean needsChunking = messageBytes > MESSAGE_SIZE_THRESHOLD;
 
         if (needsChunking) {
@@ -62,29 +63,39 @@ public class MessageChunker {
      * @return List of chunk JSON objects ready to be C-wrapped and sent
      */
     public static List<JSONObject> createChunks(String originalJson, long messageId) throws JSONException {
+        return createChunks(originalJson, messageId, false);
+    }
+
+    public static List<JSONObject> createChunks(String originalJson, long messageId, boolean wakeup) throws JSONException {
         if (originalJson == null) {
             throw new IllegalArgumentException("Cannot chunk null message");
         }
 
-        List<JSONObject> chunks = new ArrayList<>();
-        byte[] messageBytes = originalJson.getBytes();
+        byte[] messageBytes = originalJson.getBytes(StandardCharsets.UTF_8);
         int totalBytes = messageBytes.length;
 
         // Compact chunk session ID: messageId_timestamp (no "chunk_" prefix)
         String chunkId = messageId + "_" + System.currentTimeMillis();
 
-        // Calculate total chunks needed
-        int totalChunks = (int) Math.ceil((double) totalBytes / CHUNK_DATA_SIZE);
+        for (int chunkSize = INITIAL_CHUNK_DATA_SIZE; chunkSize >= MIN_CHUNK_DATA_SIZE; chunkSize--) {
+            List<JSONObject> chunks = buildChunks(messageBytes, chunkId, messageId, chunkSize);
+            if (allChunksFit(chunks, wakeup)) {
+                Log.d(TAG, "Creating " + chunks.size() + " chunks for message of size " + totalBytes
+                        + " bytes using " + chunkSize + "-byte UTF-8 slices");
+                return chunks;
+            }
+        }
 
-        Log.d(TAG, "Creating " + totalChunks + " chunks for message of size " + totalBytes + " bytes");
+        throw new JSONException("Unable to create K900 chunks within " + MAX_PACKED_CHUNK_SIZE + " bytes");
+    }
 
-        for (int i = 0; i < totalChunks; i++) {
-            int startIndex = i * CHUNK_DATA_SIZE;
-            int endIndex = Math.min(startIndex + CHUNK_DATA_SIZE, totalBytes);
-            int chunkLength = endIndex - startIndex;
+    private static List<JSONObject> buildChunks(byte[] messageBytes, String chunkId, long messageId, int chunkSize) throws JSONException {
+        List<JSONObject> chunks = new ArrayList<>();
+        List<String> chunkDataList = splitUtf8(messageBytes, chunkSize);
+        int totalChunks = chunkDataList.size();
 
-            // Extract chunk data as string
-            String chunkData = new String(messageBytes, startIndex, chunkLength);
+        for (int i = 0; i < totalChunks; i++) {
+            String chunkData = chunkDataList.get(i);
 
             // Create chunk JSON with compact keys
             JSONObject chunk = new JSONObject();
@@ -101,12 +112,47 @@ public class MessageChunker {
 
             chunks.add(chunk);
 
-            Log.d(TAG, "Created chunk " + i + "/" + (totalChunks - 1) + " with " + chunkLength + " bytes");
+            Log.d(TAG, "Created chunk " + i + "/" + (totalChunks - 1) + " with " + chunkData.getBytes(StandardCharsets.UTF_8).length + " bytes");
         }
 
         return chunks;
     }
 
+    private static boolean allChunksFit(List<JSONObject> chunks, boolean wakeup) {
+        for (int i = 0; i < chunks.size(); i++) {
+            byte[] packed = K900ProtocolUtils.packJsonToK900(chunks.get(i).toString(), wakeup && i == 0);
+            if (packed == null || packed.length > MAX_PACKED_CHUNK_SIZE) {
+                Log.d(TAG, "Chunk " + i + " packed to " + (packed != null ? packed.length : 0)
+                        + " bytes, exceeding " + MAX_PACKED_CHUNK_SIZE);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static List<String> splitUtf8(byte[] messageBytes, int chunkSize) {
+        List<String> chunkDataList = new ArrayList<>();
+        int offset = 0;
+        while (offset < messageBytes.length) {
+            int endIndex = findUtf8ChunkEnd(messageBytes, offset, chunkSize);
+            chunkDataList.add(new String(messageBytes, offset, endIndex - offset, StandardCharsets.UTF_8));
+            offset = endIndex;
+        }
+        return chunkDataList;
+    }
+
+    private static int findUtf8ChunkEnd(byte[] messageBytes, int startIndex, int chunkSize) {
+        int endIndex = Math.min(startIndex + chunkSize, messageBytes.length);
+        while (endIndex > startIndex && endIndex < messageBytes.length && isUtf8ContinuationByte(messageBytes[endIndex])) {
+            endIndex--;
+        }
+        return endIndex > startIndex ? endIndex : Math.min(startIndex + chunkSize, messageBytes.length);
+    }
+
+    private static boolean isUtf8ContinuationByte(byte value) {
+        return (value & 0xC0) == 0x80;
+    }
+
     /**
      * Check if a received message is a chunked message.
      * Supports both verbose ("type":"chunked_msg") and compact ("t":"ck") formats.

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

@@ -8,12 +8,13 @@ import android.content.Context
 import android.util.Log
 
 import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceStore
 
 import mentraos.ble.MentraosBle.DisplayText
 import mentraos.ble.MentraosBle.ClearDisplay
+import mentraos.ble.MentraosBle.DisconnectRequest
 import mentraos.ble.MentraosBle.PhoneToGlasses
 import mentraos.ble.MentraosBle.DisplayImage
-import mentraos.ble.MentraosBle.PongResponse
 import mentraos.ble.MentraosBle.BatteryStateRequest
 import mentraos.ble.MentraosBle.MicStateConfig
 import mentraos.ble.MentraosBle.BrightnessConfig
@@ -21,7 +22,7 @@ import mentraos.ble.MentraosBle.AutoBrightnessConfig
 import mentraos.ble.MentraosBle.HeadUpAngleConfig
 import mentraos.ble.MentraosBle.DisplayDistanceConfig
 import mentraos.ble.MentraosBle.DisplayHeightConfig
-import mentraos.ble.MentraosBle.VersionRequest
+import mentraos.ble.MentraosBle.VadEnabledConfig
 
 import org.json.JSONArray
 import org.json.JSONException
@@ -43,9 +44,9 @@ object NexDisplayConstants {
     const val FONT_DIVIDER: Float = 2.0f
     const val LINES_PER_SCREEN: Int = 5 // Lines per screen
 
-    /** Matches dashboard depth slider in app settings (1-3); values outside range clamp. */
+    /** Matches dashboard depth slider in app settings (1-4); values outside range clamp. */
     const val DASHBOARD_DEPTH_MIN: Int = 1
-    const val DASHBOARD_DEPTH_MAX: Int = 3
+    const val DASHBOARD_DEPTH_MAX: Int = 4
 }
 
 object NexBluetoothPacketTypes {
@@ -62,7 +63,7 @@ object NexProtobufUtils {
 
     /**
      * 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–3, not centimeters.
+     * The protobuf field is still named `distance_cm`, but Nex treats it as a **tier** 1–4, not centimeters.
      * Keep in sync with iOS `NexDashboardDisplayWire.depthToWireTier`.
      */
     fun dashboardDepthToDistanceCm(depth: Int): Int {
@@ -112,16 +113,6 @@ object NexProtobufUtils {
         return chunks
     }
 
-    fun constructPongResponse(): ByteArray {
-        Bridge.log("Nex: Constructing pong response to glasses ping")
-        
-        // Create the PongResponse message
-        val pongResponse = PongResponse.newBuilder().build()
-        // Create the PhoneToGlasses message with the pong response
-        val phoneToGlasses = PhoneToGlasses.newBuilder().setPong(pongResponse).build()
-        return generateProtobufCommandBytes(phoneToGlasses)
-    }
-    
     /**
      * Gets the current protobuf schema version from the compiled protobuf descriptor
      */
@@ -202,13 +193,15 @@ object NexProtobufUtils {
     }
 
     fun generateVersionRequestCommandBytes(): ByteArray {
-        val msgId = "ver_req_${System.currentTimeMillis()}"
-        val versionRequest = VersionRequest.newBuilder()
-            .setMsgId(msgId)
-            .build()
+        // VersionRequest/VersionResponse removed from the BLE schema; fw_version now comes via DeviceInfo.
+        Bridge.log("Nex: generateVersionRequestCommandBytes is a no-op after schema removal")
+        return ByteArray(0)
+    }
+
+    fun generateDisconnectRequestCommandBytes(): ByteArray {
+        val disconnectRequest = DisconnectRequest.newBuilder().build()
         val phoneToGlasses = PhoneToGlasses.newBuilder()
-            .setMsgId(msgId)
-            .setVersionRequest(versionRequest)
+            .setDisconnect(disconnectRequest)
             .build()
         return generateProtobufCommandBytes(phoneToGlasses)
     }
@@ -253,17 +246,21 @@ object NexProtobufUtils {
         Bridge.log("Nex: Text: \"$text\"")
         Bridge.log("Nex: Text Length: ${text.length} characters")
 
-        // Replace all m-dashes with normal dash
-        val textWithNormalDash = text.replace("—", "-")
-        
-        val sanitizedText = textWithNormalDash.replace(
-            Regex("""[^A-Za-z0-9 \r\n.,!?;:\-\[\]\(\)\{\}'"+=/]"""),
-            ""
-        )
+        // 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 textNewBuilder = DisplayText.newBuilder()
             .setColor(10000)
-            .setText(sanitizedText)
+            .setText(displayText)
             .setSize(48)
             .setX(20)
             .setY(260)
@@ -361,6 +358,18 @@ object NexProtobufUtils {
         return generateProtobufCommandBytes(phoneToGlasses)
     }
 
+    fun generateVadEnabledRequestCommandBytes(enable: Boolean): ByteArray {
+        Bridge.log("Nex: VAD Enabled: $enable")
+        val vadEnabledConfig = VadEnabledConfig.newBuilder()
+            .setEnabled(enable)
+            .build()
+        val phoneToGlasses = PhoneToGlasses.newBuilder()
+            .setVadEnabled(vadEnabledConfig)
+            .build()
+
+        return generateProtobufCommandBytes(phoneToGlasses)
+    }
+
     fun generateAutoBrightnessConfigCommandBytes(autoLight: Boolean): ByteArray {
         Bridge.log("Nex: === SENDING AUTO BRIGHTNESS COMMAND TO GLASSES ===")
         Bridge.log("Nex: Auto Brightness Enabled: $autoLight")
@@ -425,18 +434,18 @@ object NexProtobufUtils {
         }
     }
 
+    /**
+     * Returns the raw serialized PhoneToGlasses protobuf bytes.
+     *
+     * Transport framing (the 0x02 packet type and the [seq][totalChunks][chunkIndex]
+     * fragmentation header) is applied at send time by MentraNexSGC.sendProtobuf(),
+     * which owns the negotiated MTU / chunk size. Keeping framing out of here lets a
+     * single chunker handle every control command uniformly.
+     */
     private fun generateProtobufCommandBytes(phoneToGlasses: PhoneToGlasses): ByteArray {
         val contentBytes = phoneToGlasses.toByteArray()
-        val chunk = ByteBuffer.allocate(contentBytes.size + 1)
-
-        chunk.put(NexBluetoothPacketTypes.PACKET_TYPE_PROTOBUF)
-        chunk.put(contentBytes)
-
-        // Enhanced logging for protobuf messages
-        val result = chunk.array()
-        logProtobufMessage(phoneToGlasses, result)
-
-        return result
+        logProtobufMessage(phoneToGlasses, contentBytes)
+        return contentBytes
     }
 
     private fun logProtobufMessage(phoneToGlasses: PhoneToGlasses, fullMessage: ByteArray) {

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

@@ -0,0 +1,23 @@
+package com.mentra.bluetoothsdk.camera
+
+import kotlin.test.Test
+import kotlin.test.assertNull
+
+class PhotoRequestTest {
+    @Test
+    fun `fromMap defaults exposureTimeNs null`() {
+        val request =
+            PhotoRequest.fromMap(
+                mapOf(
+                    "requestId" to "photo-1",
+                    "appId" to "com.test.app",
+                    "size" to "medium",
+                    "webhookUrl" to "https://example.com/upload",
+                    "compress" to "none",
+                    "sound" to true,
+                )
+            )
+
+        assertNull(request.exposureTimeNs)
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/photoreceiver/LocalPhotoReceiverRegistryTest.java

@@ -0,0 +1,75 @@
+package com.mentra.bluetoothsdk.photoreceiver;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.After;
+import org.junit.Test;
+
+public class LocalPhotoReceiverRegistryTest {
+
+    @After
+    public void tearDown() {
+        LocalPhotoReceiverRegistry.unregister();
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_rewritesRegisteredReceiverUrl() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_doesNotRewriteDifferentHostOnSamePort() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("https://api.example.com:8787/upload"))
+                .isNull();
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://devbox:8787/upload"))
+                .isNull();
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_doesNotRewriteDifferentPath() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/other"))
+                .isNull();
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_keepsEarlierReceiverUrlsUntilUnregister() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+        LocalPhotoReceiverRegistry.register("http://10.0.0.12:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://10.0.0.12:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+
+        LocalPhotoReceiverRegistry.unregister();
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isNull();
+    }
+
+    @Test
+    public void register_keepsExistingReceiverUrlsWhenInvalidUrlArrives() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+        LocalPhotoReceiverRegistry.register("not a url");
+
+        assertThat(LocalPhotoReceiverRegistry.isActive()).isTrue();
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+    }
+
+    @Test
+    public void register_rejectsInvalidReceiverUrl() {
+        LocalPhotoReceiverRegistry.register("https://api.example.com/photo");
+
+        assertThat(LocalPhotoReceiverRegistry.isActive()).isFalse();
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("https://api.example.com/photo"))
+                .isNull();
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.mentra.bluetoothsdk.utils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import java.io.File;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 31)
+public class AvifExifStripperTest {
+
+    @Test
+    public void stripForDecode_removesExifTailAndKeepsPrimaryIlocValid() throws Exception {
+        byte[] withExif =
+                java.nio.file.Files.readAllBytes(
+                        new File("src/test/resources/avif_with_exif.avif").toPath());
+        assertThat(BlePhotoUploadService.containsExifMarkerInBytes(withExif)).isTrue();
+
+        byte[] stripped = AvifExifStripper.stripForDecode(withExif);
+        assertThat(stripped.length).isLessThan(withExif.length);
+        assertThat(BlePhotoUploadService.containsExifMarkerInBytes(stripped)).isFalse();
+
+        byte[] jpeg = BlePhotoUploadService.convertToJpegPreservingExif(withExif);
+        assertThat(jpeg.length).isGreaterThan(100);
+    }
+}