@glassly/bluetooth-sdk 0.1.0-dev.26

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

@@ -0,0 +1,199 @@
+package com.glassly.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/glassly/bluetoothsdk/utils/IncidentLogBleRelayNaming.java

@@ -0,0 +1,29 @@
+package com.glassly.bluetoothsdk.utils;
+
+import java.util.Locale;
+
+/**
+ * 16-byte K900 file name for incident log payloads relayed over BLE (must match ASG
+ * {@code IncidentLogBleRelayNaming}).
+ */
+public final class IncidentLogBleRelayNaming {
+
+    private static final int SUFFIX_LEN = 15;
+
+    private IncidentLogBleRelayNaming() {}
+
+    public static String bleFileBaseName(String incidentId, char prefix) {
+        if (incidentId == null || incidentId.isEmpty()) {
+            return prefix + "000000000000000";
+        }
+        String compact = incidentId.replace("-", "").toLowerCase(Locale.US);
+        if (compact.length() < SUFFIX_LEN) {
+            StringBuilder sb = new StringBuilder(compact);
+            while (sb.length() < SUFFIX_LEN) {
+                sb.append('0');
+            }
+            compact = sb.toString();
+        }
+        return prefix + compact.substring(0, SUFFIX_LEN);
+    }
+}

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

@@ -0,0 +1,77 @@
+package com.glassly.bluetoothsdk.utils;
+
+import android.util.Log;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.HttpUrl;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+/**
+ * POSTs report artifact JSON from the BLE relay using the same path as glasses direct upload.
+ */
+public final class IncidentLogBleUploadService {
+
+    private static final String TAG = "IncidentLogBleUpload";
+
+    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
+
+    private IncidentLogBleUploadService() {}
+
+    public interface Callback {
+        void onDone(boolean success, String message);
+    }
+
+    public static void upload(String apiBaseUrl, String incidentId, String authToken,
+                              byte[] jsonUtf8, Callback callback) {
+        new Thread(() -> {
+            try {
+                if (authToken == null || authToken.isEmpty()) {
+                    callback.onDone(false, "no auth token");
+                    return;
+                }
+                HttpUrl baseHttpUrl = HttpUrl.parse(apiBaseUrl != null ? apiBaseUrl.trim() : "");
+                if (baseHttpUrl == null) {
+                    callback.onDone(false, "empty or malformed api base url");
+                    return;
+                }
+                HttpUrl url = baseHttpUrl.newBuilder()
+                        .addPathSegment("api")
+                        .addPathSegment("client")
+                        .addPathSegment("reports")
+                        .addPathSegment(incidentId)
+                        .addPathSegment("artifacts")
+                        .build();
+                RequestBody body = RequestBody.create(jsonUtf8, JSON);
+                OkHttpClient client = new OkHttpClient.Builder()
+                        .connectTimeout(20, TimeUnit.SECONDS)
+                        .writeTimeout(60, TimeUnit.SECONDS)
+                        .readTimeout(60, TimeUnit.SECONDS)
+                        .build();
+                Request request = new Request.Builder()
+                        .url(url)
+                        .header("Authorization", "Bearer " + authToken)
+                        .post(body)
+                        .build();
+                try (Response response = client.newCall(request).execute()) {
+                    if (response.isSuccessful()) {
+                        Log.i(TAG, "Incident BLE relay upload OK: " + url);
+                        callback.onDone(true, null);
+                    } else {
+                        String msg = "HTTP " + response.code();
+                        Log.e(TAG, "Incident BLE relay upload failed: " + msg + " " + url);
+                        callback.onDone(false, msg);
+                    }
+                }
+            } catch (IOException e) {
+                Log.e(TAG, "Incident BLE relay upload IO error", e);
+                callback.onDone(false, e.getMessage());
+            }
+        }).start();
+    }
+}

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

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