@mentra/bluetooth-sdk 3.2.0-dev.209 → 3.2.0-dev.210

package/ios/Source/sgcs/G2SerialResolution.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+/// Which manufacturing serial to publish for a G2 connection.
+///
+/// A fresh pairing decodes the serial from the advertisement during the scan. A
+/// cached reconnect (UUID based, after a process restart) skips the scan, so the
+/// only serial the SDK still holds is the one it persisted as the device name at
+/// the previous auth completion. That persisted value is reused only when it is
+/// exactly the id this connection was asked for: the search id can be a partial
+/// string typed by a host, and a partial must never be reported as a serial.
+enum G2SerialResolution {
+    private static let unset = "NOT_SET"
+
+    static func resolve(scannedSerial: String?, requestedId: String, persistedDeviceName: String) -> String? {
+        if let scanned = scannedSerial?.trimmingCharacters(in: .whitespacesAndNewlines), !scanned.isEmpty {
+            return scanned
+        }
+        let persisted = persistedDeviceName.trimmingCharacters(in: .whitespacesAndNewlines)
+        let requested = requestedId.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !persisted.isEmpty, persisted != unset, persisted == requested else { return nil }
+        return persisted
+    }
+}

package/ios/Tests/BluetoothSdkAnalyticsHostTests.swift

@@ -0,0 +1,63 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class BluetoothSdkAnalyticsHostTests: XCTestCase {
+    func testSimulatorWinsOverEverything() {
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsHost.installSource(isSimulator: true, hasEmbeddedProvisioningProfile: true, receiptFileName: "sandboxReceipt"),
+            "simulator"
+        )
+    }
+
+    func testEmbeddedProfileMeansAdHocOrDevelopmentEvenWithSandboxReceipt() {
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsHost.installSource(isSimulator: false, hasEmbeddedProvisioningProfile: true, receiptFileName: "sandboxReceipt"),
+            "adhoc_or_dev"
+        )
+    }
+
+    func testSandboxReceiptWithoutProfileIsTestFlight() {
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsHost.installSource(isSimulator: false, hasEmbeddedProvisioningProfile: false, receiptFileName: "sandboxReceipt"),
+            "testflight"
+        )
+    }
+
+    func testNoProfileAndProductionReceiptIsAppStore() {
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsHost.installSource(isSimulator: false, hasEmbeddedProvisioningProfile: false, receiptFileName: "receipt"),
+            "app_store"
+        )
+    }
+
+    func testMissingOrUnrecognizedReceiptIsUnknownNotAppStore() {
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsHost.installSource(isSimulator: false, hasEmbeddedProvisioningProfile: false, receiptFileName: nil),
+            "unknown"
+        )
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsHost.installSource(isSimulator: false, hasEmbeddedProvisioningProfile: false, receiptFileName: "something-else"),
+            "unknown"
+        )
+    }
+
+    func testEnvironmentIsNormalizedAndValidated() {
+        XCTAssertEqual(BluetoothSdkAnalyticsHost.normalizedEnvironment(" Prod "), "prod")
+        XCTAssertEqual(BluetoothSdkAnalyticsHost.normalizedEnvironment("staging-eu_1"), "staging-eu_1")
+        XCTAssertNil(BluetoothSdkAnalyticsHost.normalizedEnvironment(nil))
+        XCTAssertNil(BluetoothSdkAnalyticsHost.normalizedEnvironment(""))
+        XCTAssertNil(BluetoothSdkAnalyticsHost.normalizedEnvironment("-leading"))
+        XCTAssertNil(BluetoothSdkAnalyticsHost.normalizedEnvironment("has space"))
+        XCTAssertNil(BluetoothSdkAnalyticsHost.normalizedEnvironment(String(repeating: "a", count: 33)))
+    }
+
+    func testResolveReadsTheBundleItIsGiven() {
+        let bundle = Bundle(for: BluetoothSdkAnalyticsHostTests.self)
+        let host = BluetoothSdkAnalyticsHost.resolve(bundle: bundle)
+        // The test bundle declares no lane and no analytics keys of its own.
+        XCTAssertNil(host.environment)
+        XCTAssertEqual(host.appVersion, bundle.infoDictionary?["CFBundleShortVersionString"] as? String)
+        XCTAssertEqual(host.appBuild, bundle.infoDictionary?["CFBundleVersion"] as? String)
+        XCTAssertEqual(host.properties["app_install_source"] as? String, host.installSource)
+    }
+}

package/ios/Tests/BluetoothSdkAnalyticsQueueTests.swift

@@ -0,0 +1,97 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class BluetoothSdkAnalyticsQueueTests: XCTestCase {
+    private var fileURL: URL!
+
+    override func setUpWithError() throws {
+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        fileURL = directory.appendingPathComponent("queue.jsonl")
+    }
+
+    override func tearDownWithError() throws {
+        try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent())
+    }
+
+    private func payload(_ id: String) -> [String: Any] {
+        ["uuid": id, "event": "bluetooth_sdk_started"]
+    }
+
+    func testDrainsOldestFirstAndKeepsFailuresInOrder() {
+        let queue = BluetoothSdkAnalyticsQueue(fileURL: fileURL)
+        queue.enqueue(payload("a"), now: Date(timeIntervalSince1970: 1))
+        queue.enqueue(payload("b"), now: Date(timeIntervalSince1970: 2))
+        queue.enqueue(payload("c"), now: Date(timeIntervalSince1970: 3))
+
+        var sent: [String] = []
+        queue.drain(now: Date(timeIntervalSince1970: 4)) { p in
+            let id = p["uuid"] as? String ?? ""
+            if id == "b" { return .retry }
+            sent.append(id)
+            return .delivered
+        }
+        XCTAssertEqual(sent, ["a"])
+        XCTAssertEqual(queue.count, 2)
+
+        var second: [String] = []
+        queue.drain(now: Date(timeIntervalSince1970: 5)) { p in
+            second.append(p["uuid"] as? String ?? "")
+            return .delivered
+        }
+        XCTAssertEqual(second, ["b", "c"])
+        XCTAssertEqual(queue.count, 0)
+        XCTAssertFalse(FileManager.default.fileExists(atPath: fileURL.path))
+    }
+
+    func testDropsPastCapAndExpiredEntries() {
+        let queue = BluetoothSdkAnalyticsQueue(fileURL: fileURL, maxEntries: 2, maxAge: 10)
+        queue.enqueue(payload("old"), now: Date(timeIntervalSince1970: 0))
+        queue.enqueue(payload("mid"), now: Date(timeIntervalSince1970: 5))
+        queue.enqueue(payload("new"), now: Date(timeIntervalSince1970: 6))
+        XCTAssertEqual(queue.count, 2)
+
+        var sent: [String] = []
+        queue.drain(now: Date(timeIntervalSince1970: 16)) { p in
+            sent.append(p["uuid"] as? String ?? "")
+            return .delivered
+        }
+        XCTAssertEqual(sent, ["new"])
+    }
+
+    func testSurvivesACorruptLine() throws {
+        let queue = BluetoothSdkAnalyticsQueue(fileURL: fileURL)
+        queue.enqueue(payload("a"), now: Date(timeIntervalSince1970: 1))
+        let handle = try FileHandle(forWritingTo: fileURL)
+        handle.seekToEndOfFile()
+        try handle.write(XCTUnwrap("not json\n".data(using: .utf8)))
+        try handle.close()
+        queue.enqueue(payload("b"), now: Date(timeIntervalSince1970: 2))
+        XCTAssertEqual(queue.count, 2)
+    }
+
+    func testPermanentlyRejectedPayloadIsDroppedWithoutBlockingTheRest() {
+        let queue = BluetoothSdkAnalyticsQueue(fileURL: fileURL)
+        queue.enqueue(payload("bad"), now: Date(timeIntervalSince1970: 1))
+        queue.enqueue(payload("good"), now: Date(timeIntervalSince1970: 2))
+
+        var sent: [String] = []
+        queue.drain(now: Date(timeIntervalSince1970: 3)) { p in
+            let id = p["uuid"] as? String ?? ""
+            if id == "bad" { return .discard }
+            sent.append(id)
+            return .delivered
+        }
+        XCTAssertEqual(sent, ["good"])
+        XCTAssertEqual(queue.count, 0)
+    }
+
+    func testHttpStatusMapsToOutcome() {
+        XCTAssertEqual(SendOutcome.fromHTTPStatus(200), .delivered)
+        XCTAssertEqual(SendOutcome.fromHTTPStatus(400), .discard)
+        XCTAssertEqual(SendOutcome.fromHTTPStatus(401), .discard)
+        XCTAssertEqual(SendOutcome.fromHTTPStatus(408), .retry)
+        XCTAssertEqual(SendOutcome.fromHTTPStatus(429), .retry)
+        XCTAssertEqual(SendOutcome.fromHTTPStatus(503), .retry)
+    }
+}

package/ios/Tests/BluetoothSdkAnalyticsTrackerTests.swift

@@ -0,0 +1,122 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class BluetoothSdkAnalyticsTrackerTests: XCTestCase {
+    private var tracker = BluetoothSdkAnalyticsTracker(simulatedModel: "Simulated Glasses")
+
+    private func snapshot(connected: Bool, model: String = "Mentra Live", serial: String = "") -> AnalyticsGlassesSnapshot {
+        AnalyticsGlassesSnapshot(connected: connected, fullyBooted: connected, model: model, serialNumber: serial)
+    }
+
+    func testConnectThenSerialEmitsEachOncePerConnection() {
+        tracker.initialize(snapshot(connected: false), reportingDay: 100)
+        XCTAssertEqual(tracker.observe(snapshot(connected: true), reportingDay: 100).map(\.name), ["bluetooth_sdk_glasses_connected"])
+
+        let identified = tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100)
+        XCTAssertEqual(identified.map(\.name), ["bluetooth_sdk_glasses_identified"])
+        XCTAssertEqual(identified[0].properties["event_kind"] as? String, "glasses_identified")
+        XCTAssertEqual(identified[0].properties["glasses_device_id"] as? String, "MLAB0001")
+        XCTAssertEqual(identified[0].properties["glasses_is_simulated"] as? Bool, false)
+
+        XCTAssertTrue(tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100).isEmpty)
+
+        _ = tracker.observe(snapshot(connected: false), reportingDay: 100)
+        XCTAssertEqual(
+            tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100).map(\.name),
+            ["bluetooth_sdk_glasses_connected", "bluetooth_sdk_glasses_identified"]
+        )
+    }
+
+    func testConnectedWaitsForTheModel() {
+        tracker.initialize(snapshot(connected: false), reportingDay: 100)
+        XCTAssertTrue(tracker.observe(snapshot(connected: true, model: ""), reportingDay: 100).isEmpty)
+        let withModel = tracker.observe(snapshot(connected: true, model: "Even Realities G2"), reportingDay: 100)
+        XCTAssertEqual(withModel.map(\.name), ["bluetooth_sdk_glasses_connected"])
+        XCTAssertEqual(withModel[0].properties["glasses_model"] as? String, "Even Realities G2")
+        XCTAssertNil(withModel[0].properties["glasses_model_unresolved"])
+    }
+
+    func testConnectedWithoutModelIsCountedWhenTheConnectionEndsFirst() {
+        tracker.initialize(snapshot(connected: false), reportingDay: 100)
+        _ = tracker.observe(snapshot(connected: true, model: ""), reportingDay: 100)
+        let ended = tracker.observe(snapshot(connected: false, model: ""), reportingDay: 100)
+        XCTAssertEqual(ended.map(\.name), ["bluetooth_sdk_glasses_connected"])
+        XCTAssertEqual(ended[0].properties["glasses_model_unresolved"] as? Bool, true)
+        XCTAssertNil(ended[0].properties["glasses_model"])
+    }
+
+    func testHeartbeatOncePerUtcDayWhileConnected() {
+        tracker.initialize(snapshot(connected: false), reportingDay: 100)
+        _ = tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100)
+        XCTAssertTrue(tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100).isEmpty)
+        let nextDay = tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 101)
+        XCTAssertEqual(nextDay.map(\.name), ["bluetooth_sdk_glasses_identified"])
+        XCTAssertEqual(nextDay[0].properties["event_kind"] as? String, "glasses_heartbeat")
+        XCTAssertTrue(tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 101).isEmpty)
+    }
+
+    func testInitializingWhileConnectedSuppressesDuplicateIdentificationButNotHeartbeats() {
+        tracker.initialize(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100)
+        XCTAssertTrue(tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100).isEmpty)
+        XCTAssertEqual(tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 101)[0].properties["event_kind"] as? String, "glasses_heartbeat")
+
+        var late = BluetoothSdkAnalyticsTracker(simulatedModel: "Simulated Glasses")
+        late.initialize(snapshot(connected: true, serial: ""), reportingDay: 100)
+        XCTAssertEqual(late.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: 100)[0].properties["event_kind"] as? String, "glasses_identified")
+    }
+
+    func testPlaceholderSerialsIgnoredAndSimulatedFlagged() {
+        tracker.initialize(snapshot(connected: false), reportingDay: 100)
+        let events = tracker.observe(snapshot(connected: true, model: "Simulated Glasses", serial: "0000"), reportingDay: 100)
+        XCTAssertEqual(events.map(\.name), ["bluetooth_sdk_glasses_connected"])
+        XCTAssertEqual(events[0].properties["glasses_is_simulated"] as? Bool, true)
+    }
+
+    func testIdentificationCarriesKnownGlassesSoftwareVersions() {
+        tracker.initialize(snapshot(connected: false), reportingDay: 100)
+        var full = snapshot(connected: true, serial: "MLAB0001")
+        full.firmwareVersion = "26.9.3.0"
+        full.mtkFirmwareVersion = "20260709"
+        full.appVersion = "5.2.1"
+        let identified = tracker.observe(full, reportingDay: 100).first { $0.name == "bluetooth_sdk_glasses_identified" }
+        XCTAssertEqual(identified?.properties["glasses_firmware_version"] as? String, "26.9.3.0")
+        XCTAssertEqual(identified?.properties["glasses_mtk_firmware_version"] as? String, "20260709")
+        XCTAssertEqual(identified?.properties["glasses_app_version"] as? String, "5.2.1")
+        XCTAssertNil(identified?.properties["glasses_bes_firmware_version"])
+        XCTAssertNil(identified?.properties["glasses_build_number"])
+    }
+
+    private func millis(_ iso: String) -> Int64 {
+        let formatter = ISO8601DateFormatter()
+        return Int64(formatter.date(from: iso)!.timeIntervalSince1970 * 1000)
+    }
+
+    func testReportingDayFollowsTheLosAngelesCalendarNotUtc() {
+        let sundayEveningPacific = millis("2026-09-14T00:30:00Z") // Sun 2026-09-13 17:30 PDT
+        let mondayEarlyPacific = millis("2026-09-14T08:00:00Z") // Mon 2026-09-14 01:00 PDT
+        XCTAssertEqual(sundayEveningPacific / 86_400_000, mondayEarlyPacific / 86_400_000)
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: sundayEveningPacific),
+            BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: mondayEarlyPacific) - 1
+        )
+        // Spring-forward day: 01:30 PST and 03:30 PDT are the same Pacific day.
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: millis("2026-03-08T09:30:00Z")),
+            BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: millis("2026-03-08T10:30:00Z"))
+        )
+        // Pacific midnight is the boundary.
+        XCTAssertEqual(
+            BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: millis("2026-09-14T06:59:59Z")) + 1,
+            BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: millis("2026-09-14T07:00:00Z"))
+        )
+    }
+
+    func testConnectionAcrossPacificSundayMondayBoundaryHeartbeatsOnMonday() {
+        tracker.initialize(snapshot(connected: false), reportingDay: 0)
+        let sunday = BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: millis("2026-09-14T00:30:00Z"))
+        let monday = BluetoothSdkAnalyticsTracker.reportingDay(epochMillis: millis("2026-09-14T08:00:00Z"))
+        _ = tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: sunday)
+        let onMonday = tracker.observe(snapshot(connected: true, serial: "MLAB0001"), reportingDay: monday)
+        XCTAssertEqual(onMonday.first?.properties["event_kind"] as? String, "glasses_heartbeat")
+    }
+}

package/ios/Tests/BluetoothSdkAnalyticsTransportTests.swift

@@ -0,0 +1,36 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class BluetoothSdkAnalyticsTransportTests: XCTestCase {
+    func testDrainStartedByAnOldInstanceCannotOverwriteAnEventANewInstancePersists() throws {
+        let dir = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let queue = BluetoothSdkAnalyticsQueue(fileURL: dir.appendingPathComponent("queue.jsonl"))
+        queue.enqueue(["uuid": "old"], now: Date(timeIntervalSince1970: 1))
+        let drainStarted = DispatchSemaphore(value: 0)
+        let newInstanceReady = DispatchSemaphore(value: 0)
+
+        // "Old instance": a slow drain that snapshots the file, then rewrites it.
+        BluetoothSdkAnalyticsTransport.queue.async {
+            queue.drain(now: Date(timeIntervalSince1970: 2)) { _ in
+                drainStarted.signal()
+                _ = newInstanceReady.wait(timeout: .now() + 2)
+                return .delivered
+            }
+        }
+        // "New instance": persists a failed event while that drain is in progress.
+        // Through the shared serial queue it runs after the drain instead of racing its rewrite.
+        XCTAssertEqual(drainStarted.wait(timeout: .now() + 2), .success)
+        BluetoothSdkAnalyticsTransport.queue.async { queue.enqueue(["uuid": "new"], now: Date(timeIntervalSince1970: 3)) }
+        newInstanceReady.signal()
+        BluetoothSdkAnalyticsTransport.queue.sync {}
+
+        var remaining: [String] = []
+        queue.drain(now: Date(timeIntervalSince1970: 4)) { p in
+            remaining.append(p["uuid"] as? String ?? "")
+            return .retry
+        }
+        XCTAssertEqual(remaining, ["new"])
+        try? FileManager.default.removeItem(at: dir)
+    }
+}

package/ios/Tests/G2SerialResolutionTests.swift

@@ -0,0 +1,19 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class G2SerialResolutionTests: XCTestCase {
+    func testScannedSerialAlwaysWins() {
+        XCTAssertEqual(G2SerialResolution.resolve(scannedSerial: "S2ABCD12345678", requestedId: "OTHER", persistedDeviceName: "S2OLD000000000"), "S2ABCD12345678")
+    }
+
+    func testCachedReconnectReusesPersistedSerialOnlyWhenItIsTheRequestedId() {
+        XCTAssertEqual(G2SerialResolution.resolve(scannedSerial: nil, requestedId: "S2ABCD12345678", persistedDeviceName: "S2ABCD12345678"), "S2ABCD12345678")
+        XCTAssertNil(G2SerialResolution.resolve(scannedSerial: nil, requestedId: "12345678", persistedDeviceName: "S2ABCD12345678"))
+        XCTAssertNil(G2SerialResolution.resolve(scannedSerial: nil, requestedId: "S2ABCD12345678", persistedDeviceName: ""))
+        XCTAssertNil(G2SerialResolution.resolve(scannedSerial: nil, requestedId: "NOT_SET", persistedDeviceName: "NOT_SET"))
+    }
+
+    func testSwitchingPairsDoesNotLeakThePreviousSerial() {
+        XCTAssertNil(G2SerialResolution.resolve(scannedSerial: nil, requestedId: "S2NEW000000001", persistedDeviceName: "S2OLD000000000"))
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.0-dev.209",
+  "version": "3.2.0-dev.210",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/plugin/build/analyticsProps.d.ts

@@ -0,0 +1,9 @@
+import { type BluetoothSdkPluginProps } from "./index";
+export interface ResolvedAnalyticsProps {
+    /** `undefined` leaves the native default (enabled) untouched. */
+    disabled?: boolean;
+    /** Normalized host lane such as `dev`, `staging`, or `prod`. */
+    environment?: string;
+}
+export declare function normalizeAnalyticsEnvironment(raw: unknown): string | undefined;
+export declare function resolveAnalyticsProps(props: BluetoothSdkPluginProps | undefined): ResolvedAnalyticsProps;

package/plugin/build/analyticsProps.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAnalyticsEnvironment = normalizeAnalyticsEnvironment;
+exports.resolveAnalyticsProps = resolveAnalyticsProps;
+const ENVIRONMENT_PATTERN = /^[a-z0-9][a-z0-9_-]{0,31}$/;
+function normalizeAnalyticsEnvironment(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (typeof raw !== "string") {
+        throw new Error(`@mentra/bluetooth-sdk: analytics.environment must be a string, received ${typeof raw}`);
+    }
+    const value = raw.trim().toLowerCase();
+    if (!ENVIRONMENT_PATTERN.test(value)) {
+        throw new Error(`@mentra/bluetooth-sdk: analytics.environment "${raw}" must match ${ENVIRONMENT_PATTERN} (for example "dev", "staging", "prod")`);
+    }
+    return value;
+}
+function resolveAnalyticsProps(props) {
+    const analytics = props?.analytics;
+    let disabled;
+    let environment;
+    if (analytics === false) {
+        disabled = true;
+    }
+    else if (analytics === true) {
+        disabled = false;
+    }
+    else if (typeof analytics === "object" && analytics !== null) {
+        if (analytics.enabled !== undefined)
+            disabled = !analytics.enabled;
+        environment = normalizeAnalyticsEnvironment(analytics.environment);
+    }
+    return { disabled, environment };
+}

package/plugin/build/index.d.ts

@@ -5,6 +5,14 @@ export interface BluetoothSdkPluginProps {
 }
 export interface BluetoothSdkAnalyticsPluginProps {
     enabled?: boolean;
+    /**
+     * Host-declared build lane (`dev`, `staging`, `prod`, ...), reported as
+     * `app_environment` on every SDK analytics event. Trimmed and lowercased;
+     * must then start with a letter or digit, followed by letters, digits, `_`
+     * or `-`, at most 32 characters. Store/TestFlight/sideload detection is
+     * automatic; this only adds the lane the host itself knows about.
+     */
+    environment?: string;
 }
 declare const withBluetoothSdk: ConfigPlugin<BluetoothSdkPluginProps>;
 export default withBluetoothSdk;

package/plugin/build/withAndroid.js

@@ -7,10 +7,17 @@ exports.withAndroidConfiguration = void 0;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const config_plugins_1 = require("expo/config-plugins");
+const analyticsProps_1 = require("./analyticsProps");
 const META_ANALYTICS_DISABLED = "com.mentra.bluetoothsdk.analytics.disabled";
+const META_ANALYTICS_ENVIRONMENT = "com.mentra.bluetoothsdk.analytics.environment";
 const STALE_META_POSTHOG_API_KEY = "com.mentra.bluetoothsdk.analytics.posthog_api_key";
 const STALE_META_POSTHOG_HOST = "com.mentra.bluetoothsdk.analytics.posthog_host";
-const ANALYTICS_META_NAMES = [META_ANALYTICS_DISABLED, STALE_META_POSTHOG_API_KEY, STALE_META_POSTHOG_HOST];
+const ANALYTICS_META_NAMES = [
+    META_ANALYTICS_DISABLED,
+    META_ANALYTICS_ENVIRONMENT,
+    STALE_META_POSTHOG_API_KEY,
+    STALE_META_POSTHOG_HOST,
+];
 function getBluetoothSdkRoot() {
     return path_1.default.dirname(require.resolve("../../package.json"));
 }
@@ -137,22 +144,6 @@ function withSherpaOnnxLocalMavenRepo(config) {
         return config;
     });
 }
-function resolveAnalyticsProps(props) {
-    const analytics = props?.analytics;
-    let disabled;
-    if (analytics === false) {
-        disabled = true;
-    }
-    else if (analytics === true) {
-        disabled = false;
-    }
-    else if (typeof analytics === "object" && analytics.enabled !== undefined) {
-        disabled = !analytics.enabled;
-    }
-    return {
-        disabled,
-    };
-}
 function upsertMetaData(application, name, value) {
     application["meta-data"] ??= [];
     const existing = application["meta-data"].find((item) => item.$?.["android:name"] === name);
@@ -167,7 +158,7 @@ function removeMetaData(application, name) {
 }
 function withAnalyticsManifestMetadata(config, props) {
     return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
-        const analytics = resolveAnalyticsProps(props);
+        const analytics = (0, analyticsProps_1.resolveAnalyticsProps)(props);
         const application = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
         for (const name of ANALYTICS_META_NAMES) {
             removeMetaData(application, name);
@@ -175,6 +166,9 @@ function withAnalyticsManifestMetadata(config, props) {
         if (analytics.disabled !== undefined) {
             upsertMetaData(application, META_ANALYTICS_DISABLED, analytics.disabled ? "true" : "false");
         }
+        if (analytics.environment !== undefined) {
+            upsertMetaData(application, META_ANALYTICS_ENVIRONMENT, analytics.environment);
+        }
         return config;
     });
 }

package/plugin/build/withIos.d.ts

@@ -1,5 +1,6 @@
 import { IOSConfig, type ConfigPlugin } from "expo/config-plugins";
 import { type BluetoothSdkPluginProps } from "./index";
+export declare const INFO_ANALYTICS_ENVIRONMENT = "MentraBluetoothSdkAnalyticsEnvironment";
 export declare const INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
 export declare function applyBluetoothSdkInfoPlist(infoPlist: IOSConfig.InfoPlist, props: BluetoothSdkPluginProps | undefined): IOSConfig.InfoPlist;
 export declare const withIosConfiguration: ConfigPlugin<BluetoothSdkPluginProps>;

package/plugin/build/withIos.js

@@ -3,15 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withIosConfiguration = exports.INFO_SDK_VERSION = void 0;
+exports.withIosConfiguration = exports.INFO_SDK_VERSION = exports.INFO_ANALYTICS_ENVIRONMENT = void 0;
 exports.applyBluetoothSdkInfoPlist = applyBluetoothSdkInfoPlist;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_plugins_1 = require("expo/config-plugins");
+const analyticsProps_1 = require("./analyticsProps");
 const BLUETOOTH_SDK_EXPO_ADAPTER_ENV = "MENTRA_BLUETOOTH_SDK_INCLUDE_EXPO_ADAPTER";
 const BLUETOOTH_SDK_EXPO_ADAPTER_LINE = `ENV['${BLUETOOTH_SDK_EXPO_ADAPTER_ENV}'] ||= '1'`;
 const INFO_ANALYTICS_DISABLED = "MentraBluetoothSdkAnalyticsDisabled";
+exports.INFO_ANALYTICS_ENVIRONMENT = "MentraBluetoothSdkAnalyticsEnvironment";
 exports.INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
 const STALE_INFO_POSTHOG_API_KEY = "MentraBluetoothSdkPostHogApiKey";
 const STALE_INFO_POSTHOG_HOST = "MentraBluetoothSdkPostHogHost";
@@ -56,36 +58,24 @@ const withXcodeEnvLocal = (config) => {
         },
     ]);
 };
-function resolveAnalyticsProps(props) {
-    const analytics = props?.analytics;
-    let disabled;
-    if (analytics === false) {
-        disabled = true;
-    }
-    else if (analytics === true) {
-        disabled = false;
-    }
-    else if (typeof analytics === "object" && analytics.enabled !== undefined) {
-        disabled = !analytics.enabled;
-    }
-    return {
-        disabled,
-    };
-}
 function applyBluetoothSdkInfoPlist(infoPlist, props) {
     const packageJson = require("../../package.json");
     const sdkVersion = typeof packageJson.version === "string" ? packageJson.version.trim() : "";
     if (!sdkVersion) {
         throw new Error("@mentra/bluetooth-sdk package.json is missing a version");
     }
-    const analytics = resolveAnalyticsProps(props);
+    const analytics = (0, analyticsProps_1.resolveAnalyticsProps)(props);
     delete infoPlist[INFO_ANALYTICS_DISABLED];
+    delete infoPlist[exports.INFO_ANALYTICS_ENVIRONMENT];
     delete infoPlist[STALE_INFO_POSTHOG_API_KEY];
     delete infoPlist[STALE_INFO_POSTHOG_HOST];
     infoPlist[exports.INFO_SDK_VERSION] = sdkVersion;
     if (analytics.disabled !== undefined) {
         infoPlist[INFO_ANALYTICS_DISABLED] = analytics.disabled;
     }
+    if (analytics.environment !== undefined) {
+        infoPlist[exports.INFO_ANALYTICS_ENVIRONMENT] = analytics.environment;
+    }
     return infoPlist;
 }
 function withBluetoothSdkInfoPlist(config, props) {

package/src/generated/changelogCatalog.ts

@@ -7,7 +7,7 @@ export const GENERATED_RELEASE_CHANGELOGS = Object.freeze(
   },
   {
     "version": "3.1.0",
-    "markdown": "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."
+    "markdown": "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic.\n- Bluetooth SDK usage analytics now report the host app's version, build type, and install source (store, TestFlight, sideload, simulator), plus the glasses firmware versions on identification, so store usage can be measured separately from development builds.\n- Bluetooth SDK usage analytics now identify G2 glasses by serial, keep long-lived connections visible across day boundaries, and retry failed uploads instead of dropping them."
   }
 ] as const,
 )

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.0",
-  "releaseIdentity": "3.2.0-dev.209",
-  "releaseSetId": "mentra-3.2.0-dev.209",
-  "sourceCommit": "b1606374e1508f0993d1a7e391fddeb4f8fac5bd",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.209.json",
-  "otaManifestSha256": "de5936b765f7deb07a1fd448bb4e9c00f36e1b1313d16c021aff843cf801b489"
+  "releaseIdentity": "3.2.0-dev.210",
+  "releaseSetId": "mentra-3.2.0-dev.210",
+  "sourceCommit": "259fb93fd2ecae4ed7bf280fe3b4e2b2cc594611",
+  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.210.json",
+  "otaManifestSha256": "7d8fb1f69ca9a0a6b9d00f87a60694e74aa5377776d1818a7b982b09d9bb65dc"
 })