@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Tests/BluetoothSDKTests/G2FlashProtocolTests.swift

@@ -0,0 +1,182 @@
+@testable import BluetoothSDK
+import Foundation
+import XCTest
+
+final class G2FlashProtocolTests: XCTestCase {
+    func testCRC16GoldenVector() {
+        XCTAssertEqual(
+            G2FlashProtocol.crc16(Array("123456789".utf8)),
+            [0xB1, 0x29]
+        )
+    }
+
+    func testCRC32CGoldenVector() {
+        XCTAssertEqual(
+            G2FlashProtocol.crc32c(Array("123456789".utf8)),
+            0xC052_A8C8
+        )
+    }
+
+    func testFramesCarrySharedSequenceAndCRC() {
+        let frames = G2FlashProtocol.frames(sid: 0xC1, pb: [1, 2, 3], seq: 0x44)
+        XCTAssertEqual(frames.count, 1)
+        XCTAssertEqual(Array(frames[0].prefix(8)), [0xAA, 0x21, 0x44, 5, 1, 1, 0xC1, 0])
+        XCTAssertEqual(Array(frames[0].dropFirst(8).prefix(3)), [1, 2, 3])
+        XCTAssertEqual(Array(frames[0].suffix(2)), G2FlashProtocol.crc16([1, 2, 3]))
+    }
+
+    func testAuthenticationRequestAndResponse() throws {
+        let magic: UInt8 = 0x2A
+        let request = try XCTUnwrap(G2FlashProtocol.authenticationFrames(magic: magic).first)
+        XCTAssertEqual(Array(request.prefix(8)), [0xAA, 0x21, magic, 12, 1, 1, 0x80, 0])
+        XCTAssertEqual(
+            Array(request.dropFirst(8).prefix(10)),
+            [0x08, 0x04, 0x10, magic, 0x1A, 0x04, 0x08, 0x01, 0x10, 0x03]
+        )
+
+        let emptyResult: [UInt8] = [
+            0xAA, 0x12, magic, 8, 1, 1, 0x80, 0,
+            0x08, 0x04, 0x10, magic, 0x1A, 0x00, 0, 0,
+        ]
+        let rejectedResult: [UInt8] = [
+            0xAA, 0x12, magic, 10, 1, 1, 0x80, 0,
+            0x08, 0x04, 0x10, magic, 0x1A, 0x02, 0x08, 0x00, 0, 0,
+        ]
+        XCTAssertTrue(G2FlashProtocol.isAuthenticationSuccess(emptyResult, magic: magic))
+        XCTAssertFalse(G2FlashProtocol.isAuthenticationSuccess(rejectedResult, magic: magic))
+        XCTAssertFalse(G2FlashProtocol.isAuthenticationSuccess(emptyResult, magic: magic &+ 1))
+    }
+
+    func testReplyParserRejectsWrongEnvelopeAndExtractsStatus() {
+        XCTAssertNil(G2FlashProtocol.parseRx([0xAA, 0x21, 0, 0, 0, 0, 0, 0, 0, 0]))
+        let parsed = G2FlashProtocol.parseRx([0xAA, 0x12, 7, 4, 1, 1, 0xC0, 0, 3, 8])
+        XCTAssertEqual(parsed?.sequence, 7)
+        XCTAssertEqual(parsed?.sid, 0xC0)
+        XCTAssertEqual(parsed?.pb, [3, 8])
+    }
+
+    func testOtaAckMatchesOpcodeWithoutRequiringSequenceOrSidEcho() {
+        let unrelated = [UInt8]([0xAA, 0x12, 3, 4, 1, 1, 0xC0, 0, 1, 0])
+        let blockAck = [UInt8]([0xAA, 0x12, 99, 4, 1, 1, 0xC1, 0, 2, 0])
+        XCTAssertEqual(
+            G2FlashProtocol.otaAckStatus(in: [unrelated, blockAck], opcode: 0x02),
+            0
+        )
+    }
+
+    func testFlasherPreflightAcceptsConsistentImage() throws {
+        let validated = try G2Flasher.preflight(makeFirmware())
+        XCTAssertEqual(validated.segments.count, 5)
+        XCTAssertTrue(validated.guardResult.pass)
+    }
+
+    func testFlasherPreflightRejectsCorruptPayload() throws {
+        var image = makeFirmware()
+        let segment = try XCTUnwrap(G2FlashProtocol.parseSegments(image).first)
+        image[Int(segment.off) + 128] ^= 0x01
+        XCTAssertThrowsError(try G2Flasher.preflight(image)) { error in
+            XCTAssertTrue(String(describing: error).contains("CRC32C mismatch"))
+        }
+    }
+
+    func testFlasherPreflightRejectsStaleSubheaderCRC() throws {
+        var image = makeFirmware()
+        let segment = try XCTUnwrap(G2FlashProtocol.parseSegments(image).first)
+        image[Int(segment.off) + 12] ^= 0x01
+        XCTAssertThrowsError(try G2Flasher.preflight(image)) { error in
+            XCTAssertTrue(String(describing: error).contains("CRC32C mismatch"))
+        }
+    }
+
+    func testLocallyBundledFirmwarePassesPreflightWhenAvailable() throws {
+        var loaded: [(G2FirmwareArtifact, Data)] = []
+        for artifact in G2FirmwareCatalog.artifacts {
+            do {
+                try loaded.append((artifact, G2FirmwareCatalog.load(artifact)))
+            } catch where error.localizedDescription.contains("is missing from the app") {
+                continue
+            }
+        }
+        guard !loaded.isEmpty else {
+            throw XCTSkip("Firmware binaries are intentionally absent from fresh clones")
+        }
+
+        XCTAssertEqual(loaded.count, G2FirmwareCatalog.artifacts.count)
+        for (artifact, data) in loaded {
+            XCTAssertNoThrow(
+                try G2Flasher.preflight([UInt8](data)),
+                "\(artifact.displayName) failed full CRC/MRAM validation"
+            )
+        }
+    }
+
+    func testCfwNibblePackingAndRLE() {
+        // Round-to-nearest quantization (reference GRAY_TO_NIBBLE): 0 stays 0,
+        // 0xFF -> 15, 0x88 (136) -> 9.
+        let packed = G2CfwRenderer.pack4Bpp(Data([0x00, 0xFF, 0x88]))
+        XCTAssertEqual(Array(packed), [0x0F, 0x90])
+        XCTAssertEqual(Array(G2CfwRenderer.rleEncode(packed)), [0x10, 0x1F, 0x19, 0x10])
+
+        // Rounding boundaries: [8,15] promotes to level 1 (truncation lost it),
+        // 7 stays 0, and 0 is pinned to 0 for the transparent color key.
+        XCTAssertEqual(G2CfwRenderer.grayNibble(0), 0)
+        XCTAssertEqual(G2CfwRenderer.grayNibble(7), 0)
+        XCTAssertEqual(G2CfwRenderer.grayNibble(8), 1)
+        XCTAssertEqual(G2CfwRenderer.grayNibble(234), 15)
+        XCTAssertEqual(G2CfwRenderer.grayNibble(255), 15)
+
+        let longRun = G2CfwRenderer.rleEncode(Data(repeating: 0, count: 128))
+        XCTAssertEqual(Array(longRun), [0, 0, 0, 1])
+    }
+
+    func testCfwBlackPayloadUsesModeSixZlibEnvelope() throws {
+        let payload = try XCTUnwrap(G2CfwRenderer.blackPayload())
+        XCTAssertEqual(Array(payload.prefix(3)), [6, 0x78, 0x9C])
+    }
+
+    private func makeFirmware() -> [UInt8] {
+        let names = [
+            "firmware/codec.bin",
+            "firmware/ble.bin",
+            "firmware/touch.bin",
+            "ota/s200_bootloader.bin",
+            G2FlashProtocol.REQUIRED_SEGMENT,
+        ]
+        var image = [UInt8](repeating: 0, count: 0x100)
+        writeU32(UInt32(names.count), at: 8, into: &image)
+        var offset = 0x100
+
+        for (index, name) in names.enumerated() {
+            var payload = [UInt8](repeating: UInt8(index + 1), count: 32)
+            if name == G2FlashProtocol.REQUIRED_SEGMENT {
+                writeU32(UInt32(payload.count), at: 0, into: &payload)
+                writeU32(G2FlashProtocol.APP_LOAD_ADDR, at: 0x14, into: &payload)
+            }
+            let crc = G2FlashProtocol.crc32c(payload)
+            let end = offset + 128 + payload.count
+            if image.count < end {
+                image.append(contentsOf: repeatElement(0, count: end - image.count))
+            }
+
+            let toc = 0x40 + index * 16
+            writeU32(UInt32(index + 1), at: toc, into: &image)
+            writeU32(UInt32(offset), at: toc + 4, into: &image)
+            writeU32(UInt32(payload.count + 128), at: toc + 8, into: &image)
+            writeU32(crc, at: toc + 12, into: &image)
+
+            writeU32(UInt32(payload.count), at: offset + 8, into: &image)
+            writeU32(crc, at: offset + 12, into: &image)
+            image.replaceSubrange(offset + 48 ..< offset + 48 + name.utf8.count, with: name.utf8)
+            image.replaceSubrange(offset + 128 ..< end, with: payload)
+            offset = end
+        }
+        return image
+    }
+
+    private func writeU32(_ value: UInt32, at offset: Int, into bytes: inout [UInt8]) {
+        bytes[offset] = UInt8(value & 0xFF)
+        bytes[offset + 1] = UInt8((value >> 8) & 0xFF)
+        bytes[offset + 2] = UInt8((value >> 16) & 0xFF)
+        bytes[offset + 3] = UInt8((value >> 24) & 0xFF)
+    }
+}

package/ios/Tests/MentraLivePairingAdvertisementTests.swift

@@ -0,0 +1,160 @@
+import Foundation
+@testable import BluetoothSDK
+import XCTest
+
+final class MentraLivePairingAdvertisementTests: XCTestCase {
+    func testConnectedPairingRecoveryRequiresExplicitPendingTarget() {
+        XCTAssertFalse(
+            MentraLivePendingPairingTarget.matches(
+                connectedName: "MENTRA_LIVE_BLE_OWNER",
+                connectedIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE",
+                pendingName: "",
+                pendingIdentifier: ""
+            )
+        )
+        XCTAssertTrue(
+            MentraLivePendingPairingTarget.matches(
+                connectedName: "MENTRA_LIVE_BLE_TARGET",
+                connectedIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE",
+                pendingName: "MENTRA_LIVE_BLE_TARGET",
+                pendingIdentifier: ""
+            )
+        )
+        XCTAssertTrue(
+            MentraLivePendingPairingTarget.matches(
+                connectedName: "MENTRA_LIVE_BLE_TARGET",
+                connectedIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE",
+                pendingName: "OTHER",
+                pendingIdentifier: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+            )
+        )
+        XCTAssertFalse(
+            MentraLivePendingPairingTarget.matches(
+                connectedName: "MENTRA_LIVE_BLE_TARGET",
+                connectedIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE",
+                pendingName: "MENTRA_LIVE_BLE_TARGET",
+                pendingIdentifier: "11111111-2222-3333-4444-555555555555"
+            )
+        )
+    }
+
+    func testConnectedPairingRecoveryRequiresActiveGattConnection() {
+        XCTAssertFalse(
+            MentraLivePendingPairingTarget.shouldRecover(
+                isConnected: false,
+                connectedName: "MENTRA_LIVE_BLE_TARGET",
+                connectedIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE",
+                pendingName: "MENTRA_LIVE_BLE_TARGET",
+                pendingIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"
+            )
+        )
+        XCTAssertTrue(
+            MentraLivePendingPairingTarget.shouldRecover(
+                isConnected: true,
+                connectedName: "MENTRA_LIVE_BLE_TARGET",
+                connectedIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE",
+                pendingName: "MENTRA_LIVE_BLE_TARGET",
+                pendingIdentifier: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"
+            )
+        )
+    }
+
+    func testConnectionCallbackPolicyRejectsPairingYieldAndStaleAttempts() {
+        XCTAssertFalse(
+            MentraLiveConnectionAttemptPolicy.shouldAcceptDidConnect(
+                pairingYieldActive: true,
+                matchesActiveAttempt: true
+            )
+        )
+        XCTAssertFalse(
+            MentraLiveConnectionAttemptPolicy.shouldAcceptDidConnect(
+                pairingYieldActive: false,
+                matchesActiveAttempt: false
+            )
+        )
+        XCTAssertTrue(
+            MentraLiveConnectionAttemptPolicy.shouldAcceptDidConnect(
+                pairingYieldActive: false,
+                matchesActiveAttempt: true
+            )
+        )
+    }
+
+    func testParsesMarkedSecurePairingAdvertisement() {
+        let result = MentraLivePairingAdvertisement.parse(
+            coreBluetoothManufacturerData: securePayload(pairingFlag: 1)
+        )
+
+        XCTAssertEqual(result?.pairingCode, "1234")
+        XCTAssertEqual(result?.pairingMode, true)
+    }
+
+    func testParsesMarkedOwnedAdvertisement() {
+        let result = MentraLivePairingAdvertisement.parse(
+            coreBluetoothManufacturerData: securePayload(pairingFlag: 0)
+        )
+
+        XCTAssertEqual(result?.pairingCode, "1234")
+        XCTAssertEqual(result?.pairingMode, false)
+    }
+
+    func testRejectsLegacyPayloadThatMatchesOldVersionCapabilityHeuristic() {
+        var payload = legacyPayload()
+        payload[2 + 5] = 0
+        payload[2 + 6] = 1
+        payload[2 + 7] = 1
+        payload[2 + 8] = 0x34
+        payload[2 + 9] = 0x12
+
+        XCTAssertNil(
+            MentraLivePairingAdvertisement.parse(coreBluetoothManufacturerData: payload)
+        )
+    }
+
+    func testRejectsUnmarkedFirstGenerationSecureTrailer() {
+        var payload = securePayload(pairingFlag: 1)
+        payload[2 + 10] = 0x11
+        payload[2 + 11] = 0x22
+
+        XCTAssertNil(
+            MentraLivePairingAdvertisement.parse(coreBluetoothManufacturerData: payload)
+        )
+    }
+
+    func testRejectsEveryLegacyVersionAndCapabilityCombination() {
+        for version in UInt8.min ... UInt8.max {
+            for capability in UInt8.min ... UInt8.max {
+                var payload = legacyPayload()
+                payload[2 + 5] = 1
+                payload[2 + 6] = version
+                payload[2 + 7] = capability
+                payload[2 + 10] = 0x4D
+                // Offset 11 is padding in the legacy format, so it cannot contain the second
+                // non-zero marker byte.
+                payload[2 + 11] = 0
+                XCTAssertNil(
+                    MentraLivePairingAdvertisement.parse(coreBluetoothManufacturerData: payload)
+                )
+            }
+        }
+    }
+
+    private func legacyPayload() -> Data {
+        var data = Data(repeating: 0, count: 29)
+        data[0] = 0x22
+        data[1] = 0xB8
+        return data
+    }
+
+    private func securePayload(pairingFlag: UInt8) -> Data {
+        var data = legacyPayload()
+        data[2 + 5] = pairingFlag
+        data[2 + 6] = 2
+        data[2 + 7] = 1
+        data[2 + 8] = 0x34
+        data[2 + 9] = 0x12
+        data[2 + 10] = 0x4D
+        data[2 + 11] = 0x50
+        return data
+    }
+}

package/ios/Tests/ReleaseChangelogTests.swift

@@ -0,0 +1,13 @@
+@testable import BluetoothSDK
+import XCTest
+
+final class ReleaseChangelogTests: XCTestCase {
+    func testIncludesTargetNotesForTransitionWithinOneReleaseTrain() throws {
+        let changelogs = try ReleaseChangelogCatalog.select(
+            fromVersion: "3.1.0-dev.2",
+            toVersion: "3.1.0-beta.8"
+        )
+
+        XCTAssertEqual(changelogs.map(\.version), ["3.1.0"])
+    }
+}

package/package.json

@@ -0,0 +1,129 @@
+{
+  "name": "@glassly/bluetooth-sdk",
+  "version": "0.1.0-dev.26",
+  "description": "SDK for communicating with smart glasses",
+  "main": "build/index.js",
+  "react-native": "src/index.ts",
+  "app.plugin": "app.plugin.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "react-native": "./src/index.ts",
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./internal": {
+      "react-native": "./src/_internal.ts",
+      "types": "./build/_internal.d.ts",
+      "default": "./build/_internal.js"
+    },
+    "./react": {
+      "react-native": "./src/react/index.ts",
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./types": {
+      "react-native": "./src/types/index.ts",
+      "types": "./build/types/index.d.ts",
+      "default": "./build/types/index.js"
+    },
+    "./photo-receiver": {
+      "react-native": "./src/photo-receiver/index.ts",
+      "types": "./build/photo-receiver/index.d.ts",
+      "default": "./build/photo-receiver/index.js"
+    },
+    "./ota-transport": {
+      "react-native": "./src/ota-transport/index.ts",
+      "types": "./build/ota-transport/index.d.ts",
+      "default": "./build/ota-transport/index.js"
+    },
+    "./debug": {
+      "react-native": "./src/debug.ts",
+      "types": "./build/debug.d.ts",
+      "default": "./build/debug.js"
+    },
+    "./_private/*": null,
+    "./build/*": null,
+    "./src/*": null,
+    "./app.plugin": "./app.plugin.js",
+    "./app.plugin.js": "./app.plugin.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "android",
+    "!android/.gradle",
+    "!android/.gradle/**",
+    "!android/build",
+    "!android/build/**",
+    "!android/lc3Lib/.cxx",
+    "!android/lc3Lib/.cxx/**",
+    "!android/lc3Lib/build",
+    "!android/lc3Lib/build/**",
+    "app.plugin.js",
+    "build",
+    "expo-module.config.json",
+    "ios",
+    "!ios/build",
+    "!ios/build/**",
+    "!ios/Pods",
+    "!ios/Pods/**",
+    "plugin/build",
+    "README.md",
+    "scripts",
+    "src",
+    "!src/__tests__"
+  ],
+  "scripts": {
+    "build": "expo-module build",
+    "build:plugin": "expo-module build plugin",
+    "clean": "expo-module clean",
+    "test": "expo-module test",
+    "test:release-metadata": "node --test scripts/*.test.mjs",
+    "prepare": "EXPO_NONINTERACTIVE=1 expo-module build && EXPO_NONINTERACTIVE=1 expo-module build plugin",
+    "prepack": "node scripts/inject-ios-sdk-version.mjs",
+    "postpack": "node scripts/inject-ios-sdk-version.mjs --restore",
+    "write:release-metadata": "node scripts/write-release-metadata.mjs",
+    "verify:release-package": "node scripts/verify-release-package.mjs",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "lint": "expo-module lint",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "smart-glasses",
+    "bluetooth",
+    "ble",
+    "ar-glasses"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tetramo-labs/glassly.git",
+    "directory": "mobile/modules/bluetooth-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/tetramo-labs/glassly/issues"
+  },
+  "author": "Glassly",
+  "license": "MIT",
+  "homepage": "https://github.com/tetramo-labs/glassly/tree/main/mobile/modules/bluetooth-sdk#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "expo-module-scripts": "^56.0.3",
+    "typescript": "~5.9.2"
+  },
+  "peerDependencies": {
+    "@expo/config-plugins": ">=8.0.0",
+    "@types/react": ">=18.0.0",
+    "expo": ">=49.0.0",
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,10 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+export interface BluetoothSdkPluginProps {
+    node?: boolean;
+    analytics?: boolean | BluetoothSdkAnalyticsPluginProps;
+}
+export interface BluetoothSdkAnalyticsPluginProps {
+    enabled?: boolean;
+}
+declare const withBluetoothSdk: ConfigPlugin<BluetoothSdkPluginProps>;
+export default withBluetoothSdk;

package/plugin/build/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const withAndroid_1 = require("./withAndroid");
+const withIos_1 = require("./withIos");
+const withBluetoothSdk = (config, props) => {
+    // Apply Android configurations
+    config = (0, withAndroid_1.withAndroidConfiguration)(config, props);
+    // Apply iOS configurations
+    config = (0, withIos_1.withIosConfiguration)(config, props);
+    return config;
+};
+exports.default = withBluetoothSdk;

package/plugin/build/withAndroid.d.ts

@@ -0,0 +1,3 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+import { type BluetoothSdkPluginProps } from "./index";
+export declare const withAndroidConfiguration: ConfigPlugin<BluetoothSdkPluginProps>;