@glassly/bluetooth-sdk 0.1.0-dev.26

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

@@ -0,0 +1,169 @@
+package com.glassly.bluetoothsdk.utils;
+
+import java.io.File;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.util.Log;
+import android.graphics.Bitmap;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+public class BitmapJavaUtils {
+    private static final String TAG = "WearableAi_BitmapJavaUtils";
+
+    public static Bitmap loadImageFromStorage(String path){
+        File imgFile = new  File(path);
+        if(imgFile.exists()){
+            Bitmap myBitmap = BitmapFactory.decodeFile(imgFile.getAbsolutePath());
+            return myBitmap;
+        } else {
+            Log.d(TAG, "Image doesn't exist");
+            return null;
+        }
+    }
+
+    /**
+     * Converts a standard Android ARGB Bitmap into a 1-bit-per-pixel (monochrome) BMP file in memory.
+     *
+     * <p>This method:
+     * <ul>
+     *   <li>Thresholds each pixel to black or white (simple average-based threshold).
+     *   <li>Packs the bits: leftmost pixel in the most significant bit.
+     *   <li>Writes a BITMAPFILEHEADER + BITMAPINFOHEADER + 2-entry palette + raw 1-bpp data.
+     * </ul>
+     *
+     * @param bitmap the Android Bitmap to convert. Its alpha channel is ignored.
+     * @param invert if {@code false}, bits of 0 map to white, bits of 1 map to black;
+     *               if {@code true}, the palette is reversed so 0 maps to black, 1 to white.
+     * @return A byte[] containing a valid 1-bpp BMP file.
+     * @throws IOException if an I/O error occurs writing to the buffer (unlikely in memory).
+     */
+    public static byte[] convertBitmapTo1BitBmpBytes(Bitmap bitmap, boolean invert) throws IOException {
+        int width = bitmap.getWidth();
+        int height = bitmap.getHeight();
+
+        // Each row is padded to a multiple of 4 bytes (32 bits).
+        int rowSizeBytes = ((width + 31) / 32) * 4;
+        int imageSize = rowSizeBytes * height;
+
+        // BMP header sizes for 1-bpp:
+        //  - File header: 14 bytes
+        //  - DIB header (BITMAPINFOHEADER): 40 bytes
+        //  - Color table: 2 entries × 4 bytes each = 8 bytes
+        // => Pixel data offset = 14 + 40 + 8 = 62
+        int dataOffset = 62;
+        int fileSize = dataOffset + imageSize;
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(fileSize);
+
+        // ================== BMP FILE HEADER (14 bytes) ==================
+        // Signature: "BM"
+        baos.write('B');
+        baos.write('M');
+        // File size (4 bytes, LE)
+        writeIntLE(baos, fileSize);
+        // Reserved (4 bytes)
+        writeShortLE(baos, 0);
+        writeShortLE(baos, 0);
+        // Offset to pixel data
+        writeIntLE(baos, dataOffset);
+
+        // ================== DIB HEADER: BITMAPINFOHEADER (40 bytes) ==================
+        writeIntLE(baos, 40);        // DIB header size
+        writeIntLE(baos, width);     // Width
+        writeIntLE(baos, height);    // Height (positive => bottom-to-top)
+        writeShortLE(baos, 1);       // Planes = 1
+        writeShortLE(baos, 1);       // Bits per pixel = 1
+        writeIntLE(baos, 0);         // Compression = BI_RGB (uncompressed)
+        writeIntLE(baos, imageSize); // Image size
+        writeIntLE(baos, 2835);      // X pixels per meter (72 DPI)
+        writeIntLE(baos, 2835);      // Y pixels per meter (72 DPI)
+        writeIntLE(baos, 2);         // # of colors in palette
+        writeIntLE(baos, 0);         // # of important colors
+
+        // ================== COLOR TABLE (8 bytes: 2 entries × 4 bytes each) ==================
+        // Each color entry: (Blue, Green, Red, Reserved)
+        // If invert=false, then 0 => White, 1 => Black. Otherwise, 0 => Black, 1 => White.
+        if (!invert) {
+            // color index 0 => white
+            baos.write(0xFF); baos.write(0xFF); baos.write(0xFF); baos.write(0x00);
+            // color index 1 => black
+            baos.write(0x00); baos.write(0x00); baos.write(0x00); baos.write(0x00);
+        } else {
+            // color index 0 => black
+            baos.write(0x00); baos.write(0x00); baos.write(0x00); baos.write(0x00);
+            // color index 1 => white
+            baos.write(0xFF); baos.write(0xFF); baos.write(0xFF); baos.write(0x00);
+        }
+
+        // ================== PIXEL DATA (1-bpp, bottom-to-top) ==================
+        // We'll iterate from top row to bottom row in the Android sense,
+        // but actually output from bottom row to top row in BMP format.
+        int[] rowPixels = new int[width];
+
+        for (int y = 0; y < height; y++) {
+            int py = height - 1 - y; // "py" is the actual row index in the source
+            bitmap.getPixels(rowPixels, 0, width, 0, py, width, 1);
+
+            byte[] packedRow = new byte[rowSizeBytes];
+            int bitIndex = 0;   // which bit within the current byte [0..7]
+            int byteIndex = 0;  // which byte in packedRow
+
+            for (int x = 0; x < width; x++) {
+                int color = rowPixels[x];
+                int r = (color >> 16) & 0xFF;
+                int g = (color >> 8) & 0xFF;
+                int b = (color) & 0xFF;
+
+                // Simple threshold (tweak if you want better dithering)
+                int gray = (r + g + b) / 3;
+                // int pixelVal = (gray < 128) ? 1 : 0; // 0=white or 1=black depending on palette
+                int pixelVal = 0;
+                if (!invert) {
+                    pixelVal = (gray < 128) ? 1 : 0; // Dark → 1 (black), Light → 0 (white)
+                } else {
+                    pixelVal = (gray < 128) ? 0 : 1; // Dark → 0 (black), Light → 1 (white)
+                }
+
+                // The leftmost pixel goes in the MSB of the byte => bit position = 7 - bitIndex
+                packedRow[byteIndex] |= (pixelVal << (7 - bitIndex));
+
+                bitIndex++;
+                if (bitIndex == 8) {
+                    bitIndex = 0;
+                    byteIndex++;
+                }
+            }
+
+            baos.write(packedRow, 0, rowSizeBytes);
+        }
+
+        return baos.toByteArray();
+    }
+
+    /**
+     * Writes an integer as 4 little-endian bytes.
+     */
+    private static void writeIntLE(OutputStream out, int value) throws IOException {
+        out.write(value & 0xFF);
+        out.write((value >> 8) & 0xFF);
+        out.write((value >> 16) & 0xFF);
+        out.write((value >> 24) & 0xFF);
+    }
+
+    /**
+     * Writes a short as 2 little-endian bytes.
+     */
+    private static void writeShortLE(OutputStream out, int value) throws IOException {
+        out.write(value & 0xFF);
+        out.write((value >> 8) & 0xFF);
+    }
+
+    public static Bitmap bytesToBitmap(byte[] imageData) {
+        if (imageData == null || imageData.length == 0) {
+            return null;
+        }
+        return BitmapFactory.decodeByteArray(imageData, 0, imageData.length);
+    }
+}

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

@@ -0,0 +1,496 @@
+package com.glassly.bluetoothsdk.utils;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** BLE Wire Protocol v2 JSON compaction with lossless fallback for ambiguous payloads. */
+public final class BleJsonCompact {
+
+    private static final Map<String, String> LONG_TO_SHORT = new HashMap<>();
+    private static final Map<String, String> SHORT_TO_LONG = new HashMap<>();
+
+    private static final Map<String, Integer> PHOTO_STATUS_TO_INT = new HashMap<>();
+    private static final Map<Integer, String> PHOTO_STATUS_FROM_INT = new HashMap<>();
+    private static final Map<String, Integer> KIND_TO_INT = new HashMap<>();
+    private static final Map<Integer, String> KIND_FROM_INT = new HashMap<>();
+    private static final Map<String, Integer> SOURCE_TO_INT = new HashMap<>();
+    private static final Map<Integer, String> SOURCE_FROM_INT = new HashMap<>();
+    private static final Map<String, Integer> AE_STATE_TO_INT = new HashMap<>();
+    private static final Map<Integer, String> AE_STATE_FROM_INT = new HashMap<>();
+
+    public static final String KEY_RESOLVED_CONFIG_HASH = "rch";
+
+    /** ROI 8–10 message types: compact outbound and accept compact inbound. */
+    private static final Set<String> HIGH_ROI_MESSAGE_TYPES =
+            Collections.unmodifiableSet(
+                    new HashSet<>(
+                            Arrays.asList(
+                                    "photo_status",
+                                    "stream_status",
+                                    "wifi_scan_result",
+                                    "start_stream",
+                                    "photo_response")));
+
+    /** Structural chunk envelope (always compact on wire). */
+    private static final Set<String> CHUNK_MESSAGE_TYPES =
+            Collections.unmodifiableSet(new HashSet<>(Arrays.asList("ck", "chunked_msg")));
+
+    private static long sessionConnectEpochMs;
+    private static final Map<String, JSONObject> resolvedConfigByHash = new HashMap<>();
+
+    static {
+        putKey("type", "t");
+        putKey("requestId", "r");
+        putKey("timestamp", "ts");
+        putKey("status", "s");
+        putKey("kind", "k");
+        putKey("source", "src");
+        putKey("requestedCaptureConfig", "rcc");
+        putKey("meteredPreview", "mp");
+        putKey("exposureTimeNs", "etn");
+        putKey("captureMetadata", "cm");
+        putKey("aeStateName", "aes");
+        putKey("transferMethod", "tm");
+        putKey("manual", "m");
+        putKey("reconnecting", "rc");
+        putKey("stats", "st");
+        putKey("width", "w");
+        putKey("height", "h");
+        putKey("bitrate", "br");
+        putKey("fps", "f");
+        putKey("droppedFrames", "df");
+        putKey("duration", "du");
+        putKey("temperatureC", "tc");
+
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "accepted", 0);
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "queued", 1);
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "configuring", 2);
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "capturing", 3);
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "captured", 4);
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "uploading", 5);
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "uploaded", 6);
+        putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "failed", 7);
+
+        putEnum(KIND_TO_INT, KIND_FROM_INT, "lifecycle", 0);
+        putEnum(KIND_TO_INT, KIND_FROM_INT, "snapshot", 1);
+
+        putEnum(SOURCE_TO_INT, SOURCE_FROM_INT, "sdk", 0);
+        putEnum(SOURCE_TO_INT, SOURCE_FROM_INT, "button", 1);
+
+        putEnum(AE_STATE_TO_INT, AE_STATE_FROM_INT, "CONVERGED", 0);
+        putEnum(AE_STATE_TO_INT, AE_STATE_FROM_INT, "SEARCHING", 1);
+        putEnum(AE_STATE_TO_INT, AE_STATE_FROM_INT, "INACTIVE", 2);
+        putEnum(AE_STATE_TO_INT, AE_STATE_FROM_INT, "LOCKED", 3);
+        putEnum(AE_STATE_TO_INT, AE_STATE_FROM_INT, "FLASH_REQUIRED", 4);
+        putEnum(AE_STATE_TO_INT, AE_STATE_FROM_INT, "PRECAPTURE", 5);
+    }
+
+    private BleJsonCompact() {}
+
+    public static void resetSession() {
+        sessionConnectEpochMs = 0L;
+        resolvedConfigByHash.clear();
+    }
+
+    public static void markSessionConnected(long epochMs) {
+        resetSession();
+        sessionConnectEpochMs = epochMs;
+    }
+
+    public static boolean isCameraCommandJson(String jsonData) {
+        if (jsonData == null || jsonData.isEmpty()) {
+            return false;
+        }
+        return jsonData.contains("cs_pho")
+                || jsonData.contains("cs_cpho")
+                || jsonData.contains("cs_vid")
+                || jsonData.contains("\"type\":\"take_photo\"");
+    }
+
+    public static boolean shouldCompactOutbound(String messageType) {
+        return messageType != null && HIGH_ROI_MESSAGE_TYPES.contains(messageType);
+    }
+
+    public static boolean supportsCompactInbound(String messageType) {
+        if (messageType == null || messageType.isEmpty()) {
+            return false;
+        }
+        return HIGH_ROI_MESSAGE_TYPES.contains(messageType)
+                || CHUNK_MESSAGE_TYPES.contains(messageType);
+    }
+
+    /** Compact wire form uses short `t` key without verbose `type`. */
+    public static boolean isCompactWireForm(JSONObject json) {
+        return json != null && json.has("t") && !json.has("type");
+    }
+
+    public static String extractMessageType(JSONObject json) {
+        if (json == null) {
+            return "";
+        }
+        if (json.has("type")) {
+            return json.optString("type", "");
+        }
+        if (json.has("t")) {
+            return json.optString("t", "");
+        }
+        return "";
+    }
+
+    public static JSONObject encode(JSONObject json) throws JSONException {
+        if (json == null) {
+            return null;
+        }
+        if (isCameraCommandJson(json.toString())) {
+            return json;
+        }
+        String messageType = extractMessageType(json);
+        if (!shouldCompactOutbound(messageType) || !canCompactLosslessly(json, true)) {
+            return json;
+        }
+        return compactObject(json, true);
+    }
+
+    public static JSONObject encode(String jsonData) throws JSONException {
+        if (jsonData == null || !jsonData.startsWith("{")) {
+            return null;
+        }
+        return encode(new JSONObject(jsonData));
+    }
+
+    public static JSONObject decode(JSONObject json) throws JSONException {
+        if (json == null) {
+            return null;
+        }
+        if (isCameraCommandJson(json.toString())) {
+            return json;
+        }
+        return expandObject(json, true);
+    }
+
+    /**
+     * Expand compact wire JSON only when the message type is on the ROI allowlist.
+     *
+     * @return expanded JSON, passthrough expanded JSON, or {@code null} if compact form is unsupported
+     */
+    public static JSONObject decodeIfSupported(JSONObject json) throws JSONException {
+        if (json == null) {
+            return null;
+        }
+        if (isCameraCommandJson(json.toString())) {
+            return json;
+        }
+        if (!isCompactWireForm(json)) {
+            return json;
+        }
+        String compactType = json.optString("t", "");
+        if (!supportsCompactInbound(compactType)) {
+            return null;
+        }
+        return expandObject(json, true);
+    }
+
+    public static JSONObject decode(String jsonData) throws JSONException {
+        if (jsonData == null || !jsonData.startsWith("{")) {
+            return null;
+        }
+        return decode(new JSONObject(jsonData));
+    }
+
+    private static void putKey(String longKey, String shortKey) {
+        LONG_TO_SHORT.put(longKey, shortKey);
+        SHORT_TO_LONG.put(shortKey, longKey);
+    }
+
+    private static void putEnum(
+            Map<String, Integer> toInt, Map<Integer, String> fromInt, String value, int code) {
+        toInt.put(value, code);
+        fromInt.put(code, value);
+    }
+
+    /**
+     * Compact JSON has reserved short keys and enum integers. If an otherwise valid future payload
+     * already uses one of those wire representations, sending verbose JSON is the only way an older
+     * decoder can distinguish the original value.
+     */
+    private static boolean canCompactLosslessly(JSONObject input, boolean topLevel)
+            throws JSONException {
+        String messageType = input.optString("type", input.optString("t", ""));
+        Iterator<String> keys = input.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object value = input.get(key);
+            if (SHORT_TO_LONG.containsKey(key)
+                    || (topLevel && KEY_RESOLVED_CONFIG_HASH.equals(key))
+                    || isAmbiguousEnumValue(key, value, messageType)) {
+                return false;
+            }
+            if (value instanceof JSONObject
+                    && !canCompactLosslessly((JSONObject) value, false)) {
+                return false;
+            }
+            if (value instanceof JSONArray
+                    && !canCompactArrayLosslessly((JSONArray) value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean canCompactArrayLosslessly(JSONArray array) throws JSONException {
+        for (int i = 0; i < array.length(); i++) {
+            Object value = array.get(i);
+            if (value instanceof JSONObject
+                    && !canCompactLosslessly((JSONObject) value, false)) {
+                return false;
+            }
+            if (value instanceof JSONArray
+                    && !canCompactArrayLosslessly((JSONArray) value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean isAmbiguousEnumValue(
+            String key, Object value, String messageType) {
+        if (!(value instanceof Number)) {
+            return false;
+        }
+        return "kind".equals(key)
+                || "source".equals(key)
+                || "aeStateName".equals(key)
+                || ("status".equals(key) && "photo_status".equals(messageType));
+    }
+
+    private static JSONObject compactObject(JSONObject input, boolean topLevel) throws JSONException {
+        JSONObject output = new JSONObject();
+        String messageType = input.optString("type", input.optString("t", ""));
+
+        Iterator<String> keys = input.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object value = input.get(key);
+            // Keep the absolute timestamp under its verbose key. Legacy peers recognize it and
+            // therefore do not mistake it for the old session-relative `ts` representation.
+            String shortKey =
+                    topLevel && "timestamp".equals(key)
+                            ? key
+                            : LONG_TO_SHORT.getOrDefault(key, key);
+            Object compacted = compactValue(key, value, messageType);
+            output.put(shortKey, compacted);
+        }
+        return output;
+    }
+
+    private static Object compactValue(String longKey, Object value, String messageType)
+            throws JSONException {
+        if (value == JSONObject.NULL || value == null) {
+            return JSONObject.NULL;
+        }
+        if (value instanceof JSONObject) {
+            return compactObject((JSONObject) value, false);
+        }
+        if (value instanceof JSONArray) {
+            return compactArray((JSONArray) value);
+        }
+        if (value instanceof Boolean || value instanceof Number) {
+            return value;
+        }
+        String str = String.valueOf(value);
+        if ("status".equals(longKey) && "photo_status".equals(messageType)) {
+            Integer code = PHOTO_STATUS_TO_INT.get(str);
+            if (code != null) {
+                return code;
+            }
+        }
+        if ("kind".equals(longKey)) {
+            Integer code = KIND_TO_INT.get(str);
+            if (code != null) {
+                return code;
+            }
+        }
+        if ("source".equals(longKey)) {
+            Integer code = SOURCE_TO_INT.get(str);
+            if (code != null) {
+                return code;
+            }
+        }
+        if ("aeStateName".equals(longKey)) {
+            Integer code = AE_STATE_TO_INT.get(str);
+            if (code != null) {
+                return code;
+            }
+        }
+        return str;
+    }
+
+    private static JSONArray compactArray(JSONArray array) throws JSONException {
+        JSONArray out = new JSONArray();
+        for (int i = 0; i < array.length(); i++) {
+            Object value = array.get(i);
+            if (value instanceof JSONObject) {
+                out.put(compactObject((JSONObject) value, false));
+            } else {
+                out.put(value);
+            }
+        }
+        return out;
+    }
+
+    private static JSONObject expandObject(JSONObject input, boolean topLevel) throws JSONException {
+        JSONObject output = new JSONObject();
+        String messageType = input.optString("type", input.optString("t", ""));
+
+        Iterator<String> keys = input.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object value = input.get(key);
+            if (topLevel && "ts".equals(key)) {
+                output.put("ts", value);
+                continue;
+            }
+            String longKey = SHORT_TO_LONG.getOrDefault(key, key);
+            Object expanded = expandValue(longKey, value, messageType);
+            output.put(longKey, expanded);
+        }
+
+        if (topLevel) {
+            expandTimestamp(output);
+            expandResolvedConfigHash(output);
+            cacheResolvedConfigIfPresent(output);
+        }
+        return output;
+    }
+
+    private static void cacheResolvedConfigIfPresent(JSONObject output) throws JSONException {
+        if (!(output.opt("resolvedConfig") instanceof JSONObject)) {
+            return;
+        }
+        JSONObject resolvedConfig = output.getJSONObject("resolvedConfig");
+        String hash = hashConfig(resolvedConfig);
+        resolvedConfigByHash.put(hash, cloneObject(resolvedConfig));
+    }
+
+    private static void expandResolvedConfigHash(JSONObject output) throws JSONException {
+        if (output.has("resolvedConfig") || !output.has(KEY_RESOLVED_CONFIG_HASH)) {
+            return;
+        }
+        String hash = output.optString(KEY_RESOLVED_CONFIG_HASH, "");
+        JSONObject cached = resolvedConfigByHash.get(hash);
+        if (cached != null) {
+            output.put("resolvedConfig", cloneObject(cached));
+            output.remove(KEY_RESOLVED_CONFIG_HASH);
+        }
+    }
+
+    private static Object expandValue(String longKey, Object value, String messageType)
+            throws JSONException {
+        if (value == JSONObject.NULL || value == null) {
+            return JSONObject.NULL;
+        }
+        if (value instanceof JSONObject) {
+            return expandObject((JSONObject) value, false);
+        }
+        if (value instanceof JSONArray) {
+            JSONArray out = new JSONArray();
+            JSONArray array = (JSONArray) value;
+            for (int i = 0; i < array.length(); i++) {
+                Object item = array.get(i);
+                if (item instanceof JSONObject) {
+                    out.put(expandObject((JSONObject) item, false));
+                } else {
+                    out.put(item);
+                }
+            }
+            return out;
+        }
+        if ("status".equals(longKey) && value instanceof Number && "photo_status".equals(messageType)) {
+            String restored = PHOTO_STATUS_FROM_INT.get(((Number) value).intValue());
+            return restored != null ? restored : value;
+        }
+        if ("kind".equals(longKey) && value instanceof Number) {
+            String restored = KIND_FROM_INT.get(((Number) value).intValue());
+            return restored != null ? restored : value;
+        }
+        if ("source".equals(longKey) && value instanceof Number) {
+            String restored = SOURCE_FROM_INT.get(((Number) value).intValue());
+            return restored != null ? restored : value;
+        }
+        if ("aeStateName".equals(longKey) && value instanceof Number) {
+            String restored = AE_STATE_FROM_INT.get(((Number) value).intValue());
+            return restored != null ? restored : value;
+        }
+        return value;
+    }
+
+    private static void expandTimestamp(JSONObject output) throws JSONException {
+        if (!output.has("timestamp") && output.has("ts")) {
+            Object timestamp = output.opt("ts");
+            if (!(timestamp instanceof Number)) {
+                output.put("timestamp", timestamp);
+                output.remove("ts");
+                return;
+            }
+            long delta = ((Number) timestamp).longValue();
+            long absolute = sessionConnectEpochMs > 0 ? sessionConnectEpochMs + delta : delta;
+            output.put("timestamp", absolute);
+            output.remove("ts");
+            if (sessionConnectEpochMs <= 0) {
+                sessionConnectEpochMs = absolute - delta;
+            }
+        }
+    }
+
+    public static String hashConfig(JSONObject config) {
+        try {
+            return fnv1a32Hex(canonicalObject(config).toString());
+        } catch (JSONException e) {
+            return fnv1a32Hex(config.toString());
+        }
+    }
+
+    private static JSONObject canonicalObject(JSONObject input) throws JSONException {
+        List<String> keys = new ArrayList<>();
+        Iterator<String> it = input.keys();
+        while (it.hasNext()) {
+            keys.add(it.next());
+        }
+        Collections.sort(keys);
+        JSONObject out = new JSONObject();
+        for (String key : keys) {
+            Object value = input.get(key);
+            if (value instanceof JSONObject) {
+                out.put(key, canonicalObject((JSONObject) value));
+            } else {
+                out.put(key, value);
+            }
+        }
+        return out;
+    }
+
+    private static JSONObject cloneObject(JSONObject input) throws JSONException {
+        return new JSONObject(input.toString());
+    }
+
+    private static String fnv1a32Hex(String value) {
+        byte[] bytes = value.getBytes(StandardCharsets.UTF_8);
+        int hash = 0x811c9dc5;
+        for (byte b : bytes) {
+            hash ^= (b & 0xff);
+            hash *= 0x01000193;
+        }
+        return String.format("%08x", hash);
+    }
+}