diff --git a/.gitignore b/.gitignore index b7c078e4..dc56b331 100644 --- a/.gitignore +++ b/.gitignore @@ -13,6 +13,9 @@ npm-debug.log* yarn-debug.log* yarn-error.log* +# npm test compile output (tests/tsconfig.json outDir) +.test-build/ + # General .DS_Store .AppleDouble diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.java b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.java index 0452bbda..39223a64 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.java +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.java @@ -31,11 +31,12 @@ import java.util.Set; * its company identifier restored so the "ER"+serial+MAC layout survives * intact, RSSI, advertised TX power, and connectability. * - * Admission is deliberately loose — a name containing G2 or R1, or the Even - * "ER" manufacturer signature — because renamed custom firmware may drop the - * stock name. Side, serial, and pair matching are decided in TypeScript - * (app/g2/even-advertisement.ts, app/g2/pairing-candidates.ts) where they can - * be unit-tested. + * Admission is deliberately loose — a name containing G2, the stock + * "EVEN R1…" ring prefix, or the Even "ER" manufacturer signature — because + * renamed custom firmware may drop the stock name. Side, serial, and pair + * matching are decided in TypeScript (app/g2/even-advertisement.ts, + * app/g2/pairing-candidates.ts) where they can be unit-tested; this filter + * must stay a superset of the TS classifier's admission. * * Ported from the discovery path of SybilSight's Bluetooth SDK (G2.didDiscover * and R1's advertisement snapshot), reduced to what Android exposes. @@ -288,7 +289,7 @@ public class FaceclawDeviceDiscovery { Integer rssiValue = (rssi == 127 || rssi == 0) ? null : rssi; boolean bonded = device.getBondState() == BluetoothDevice.BOND_BONDED; return buildJson( - device.getAddress(), name, toHex(manufacturerData), rssiValue, txPower, + device.getAddress(), name, FaceclawFirmwareUtil.bytesToHex(manufacturerData), rssiValue, txPower, connectable, bonded, "scan", System.currentTimeMillis()); } @@ -332,7 +333,9 @@ public class FaceclawDeviceDiscovery { return false; } String upper = name.toUpperCase(); - return upper.contains("G2") || upper.contains("R1"); + // A bare "R1" substring also matches unrelated hardware ("Oppo Enco + // R1"), and TS only classifies rings from the stock name prefix. + return upper.contains("G2") || upper.startsWith("EVEN R1"); } private static JSONObject buildJson( @@ -358,17 +361,6 @@ public class FaceclawDeviceDiscovery { } } - private static String toHex(byte[] bytes) { - if (bytes == null || bytes.length == 0) { - return ""; - } - StringBuilder sb = new StringBuilder(bytes.length * 2); - for (byte b : bytes) { - sb.append(String.format("%02X", b & 0xff)); - } - return sb.toString(); - } - private static String describeScanError(int errorCode) { switch (errorCode) { case ScanCallback.SCAN_FAILED_ALREADY_STARTED: diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawFirmwareUtil.java b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawFirmwareUtil.java index 31a43576..32ce5dc1 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawFirmwareUtil.java +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawFirmwareUtil.java @@ -11,24 +11,32 @@ import java.security.NoSuchAlgorithmException; * Native helpers for the on-device custom-firmware build: SHA-256 hashing and * binary file writing. Both take a java.nio.ByteBuffer so NativeScript can * marshal a JS ArrayBuffer straight across without a per-element copy of the - * ~4 MB firmware image (and with no overload ambiguity). + * ~4 MB firmware image (and with no overload ambiguity). Also home of the one + * shared byte→hex encoder for com.faceclaw.app. */ public final class FaceclawFirmwareUtil { private FaceclawFirmwareUtil() {} + /** Lowercase hex of the bytes. The TS-side decoder is case-insensitive. */ + public static String bytesToHex(byte[] bytes) { + if (bytes == null || bytes.length == 0) { + return ""; + } + StringBuilder sb = new StringBuilder(bytes.length * 2); + for (byte b : bytes) { + int v = b & 0xff; + sb.append(Character.forDigit(v >>> 4, 16)); + sb.append(Character.forDigit(v & 0x0f, 16)); + } + return sb.toString(); + } + /** Lowercase hex SHA-256 of the buffer's remaining bytes. */ public static String sha256Hex(ByteBuffer data) { try { MessageDigest md = MessageDigest.getInstance("SHA-256"); md.update(data.duplicate()); - byte[] digest = md.digest(); - StringBuilder sb = new StringBuilder(digest.length * 2); - for (byte b : digest) { - int v = b & 0xff; - sb.append(Character.forDigit(v >>> 4, 16)); - sb.append(Character.forDigit(v & 0x0f, 16)); - } - return sb.toString(); + return bytesToHex(md.digest()); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("SHA-256 unavailable", e); } diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawModelDownloader.java b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawModelDownloader.java index 02f50bb5..c1764d6e 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawModelDownloader.java +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawModelDownloader.java @@ -144,7 +144,7 @@ public class FaceclawModelDownloader { + expectedTotalBytes + " bytes); try again to resume"); return; } - String actualSha = toHex(digest.digest()); + String actualSha = FaceclawFirmwareUtil.bytesToHex(digest.digest()); if (!expectedSha256.isEmpty() && !actualSha.equals(expectedSha256)) { partFile.delete(); postError("Model download was corrupted (checksum mismatch); download it again"); @@ -177,12 +177,6 @@ public class FaceclawModelDownloader { return hashed; } - private static String toHex(byte[] bytes) { - StringBuilder sb = new StringBuilder(bytes.length * 2); - for (byte b : bytes) sb.append(String.format("%02x", b)); - return sb.toString(); - } - private void post(Runnable runnable) { callbackHandler.post(runnable); } diff --git a/app/app.css b/app/app.css index dedf8160..fc0bdb32 100644 --- a/app/app.css +++ b/app/app.css @@ -109,6 +109,7 @@ Button.-primary { .pairing-title { font-size: 16; font-weight: bold; + color: #222222; } .pairing-badge { @@ -182,3 +183,82 @@ Button.pairing-link { font-size: 14; border-width: 0; } + +/* + * Dark-mode pairing page. The cards keep their light-mode look above; here + * they go dark-gray, and every text colour set above gets a light counterpart + * so nothing renders dark-on-dark (the instructions) or dark-on-a-dark-card. + * Order matters: the -selected/-incomplete rules must follow .pairing-row so + * they win at equal specificity. + */ +.ns-dark .pairing-instructions { + color: #b0b0b0; +} + +.ns-dark .pairing-empty { + color: #999999; +} + +.ns-dark .pairing-row { + background-color: #2e2e2e; + border-color: #4a4a4a; +} + +.ns-dark .pairing-row-selected { + background-color: #333c4c; + border-color: #5b8def; +} + +.ns-dark .pairing-row-incomplete { + background-color: #282828; + border-color: #3c3c3c; +} + +.ns-dark .pairing-title { + color: #f0f0f0; +} + +.ns-dark .pairing-badge { + color: #a8c4f5; + background-color: #2a3b5e; +} + +.ns-dark .pairing-variant { + color: #cccccc; +} + +.ns-dark .pairing-proximity { + color: #a0a0a0; +} + +.ns-dark .pairing-proximity-immediate { + color: #7da7f5; +} + +.ns-dark .pairing-serial { + color: #a0a0a0; +} + +.ns-dark .pairing-arms { + color: #c0c0c0; +} + +.ns-dark .pairing-warning { + color: #e08a66; +} + +.ns-dark .pairing-swatch-label { + color: #aaaaaa; +} + +.ns-dark .pairing-chevron { + color: #bbbbbb; +} + +.ns-dark .pairing-selection { + background-color: #2e2e2e; +} + +.ns-dark Button.pairing-link { + color: #7da7f5; +} diff --git a/app/g2/ble-proximity.ts b/app/g2/ble-proximity.ts index 48e5d3dd..9bb24686 100644 --- a/app/g2/ble-proximity.ts +++ b/app/g2/ble-proximity.ts @@ -13,8 +13,11 @@ * * `txPower` is the expected signal at one metre and `n` the path loss * exponent — 2.0 in free space, higher indoors where walls and bodies absorb. - * A device that advertises its own TX power gets used as measured; everything - * else falls back to a per-product calibration. + * The reference power always comes from the per-product calibration table. An + * advertised BLE "TX Power Level" is deliberately NOT used: that field is the + * radiated power at the antenna (typically 0…+4 dBm), not an iBeacon-style + * measured power at one metre, and reading it as the latter inflates every + * distance by orders of magnitude. * * ## What this is for, and what it is not * @@ -33,6 +36,8 @@ * This module is pure (no NativeScript imports) so it can run under node tests. */ +import { clamp } from "../util/numeric-util"; + /** Expected RSSI at one metre, and the path loss exponent, per product. */ export type ProximityCalibration = { readonly txPowerAtOneMeter: number; @@ -66,8 +71,6 @@ export const MAXIMUM_METERS = 100; */ export type ProximityZone = "immediate" | "near" | "far" | "distant"; -const ZONE_ORDER: Record = { immediate: 0, near: 1, far: 2, distant: 3 }; - export function zoneFromMeters(meters: number): ProximityZone { if (meters < 0.5) return "immediate"; if (meters < 3) return "near"; @@ -75,10 +78,6 @@ export function zoneFromMeters(meters: number): ProximityZone { return "distant"; } -export function zoneRank(zone: ProximityZone): number { - return ZONE_ORDER[zone]; -} - export function zoneLabel(zone: ProximityZone): string { switch (zone) { case "immediate": @@ -109,7 +108,7 @@ export function zoneGlyph(zone: ProximityZone): string { /** A distance estimate and how much to trust it. */ export type ProximityEstimate = { readonly meters: number; - /** 0…1. Drops with weak signal and with having to guess the TX power. */ + /** 0…1. Drops with weak signal. */ readonly confidence: number; readonly zone: ProximityZone; }; @@ -140,33 +139,27 @@ export function proximitySummary(estimate: ProximityEstimate): string { * from, so callers can say "signal unknown" rather than render a fabricated * distance. 127 is the Bluetooth "RSSI unavailable" sentinel. */ -export function estimateProximity( - rssi: number | null | undefined, - txPower: number | null | undefined, - calibration: ProximityCalibration, -): ProximityEstimate | null { +export function estimateProximity(rssi: number | null | undefined, calibration: ProximityCalibration): ProximityEstimate | null { if (rssi == null || !Number.isFinite(rssi) || rssi === 127) return null; - const hasTxPower = txPower != null && Number.isFinite(txPower); - const referencePower = hasTxPower ? txPower! : calibration.txPowerAtOneMeter; - const ratio = (referencePower - rssi) / (10 * calibration.pathLossExponent); - const meters = Math.min(Math.max(Math.pow(10, ratio), MINIMUM_METERS), MAXIMUM_METERS); + const ratio = (calibration.txPowerAtOneMeter - rssi) / (10 * calibration.pathLossExponent); + const meters = clamp(Math.pow(10, ratio), MINIMUM_METERS, MAXIMUM_METERS); return { meters, - confidence: proximityConfidence(rssi, hasTxPower), + confidence: proximityConfidence(rssi), zone: zoneFromMeters(meters), }; } /** - * Confidence falls with signal strength, because a weak sample is a noisy one, - * and with having to assume the TX power instead of being told it. + * Confidence falls with signal strength, because a weak sample is a noisy one. + * The 0.85 ceiling reflects that the TX power is always an assumption from the + * calibration table, never a measurement. */ -export function proximityConfidence(rssi: number, hasAdvertisedTxPower: boolean): number { - let confidence = 1.0; +export function proximityConfidence(rssi: number): number { + let confidence = 0.85; if (rssi < -85) confidence *= 0.4; else if (rssi < -75) confidence *= 0.7; else if (rssi < -65) confidence *= 0.85; - confidence *= hasAdvertisedTxPower ? 1.0 : 0.85; return confidence; } diff --git a/app/g2/device-addresses.ts b/app/g2/device-addresses.ts index 90277ddb..b69a67bc 100644 --- a/app/g2/device-addresses.ts +++ b/app/g2/device-addresses.ts @@ -1,5 +1,9 @@ import { ApplicationSettings } from "@nativescript/core"; +import { normalizeMacAddress } from "./even-advertisement"; + +export { normalizeMacAddress }; + export type DeviceAddresses = { right: string; left: string; @@ -32,17 +36,6 @@ export function saveDeviceAddresses(addresses: DeviceAddresses): void { ApplicationSettings.setString(ADDRESS_KEYS.ring, normalizeMacAddress(addresses.ring)); } -export function normalizeMacAddress(value: string | null | undefined): string { - const compact = (value ?? "") - .trim() - .replace(/[^0-9a-fA-F]/g, "") - .toUpperCase(); - if (compact.length !== 12) { - return (value ?? "").trim().toUpperCase(); - } - return compact.match(/.{1,2}/g)?.join(":") ?? compact; -} - export function isValidMacAddress(value: string, allowEmpty = false): boolean { const trimmed = value.trim(); if (!trimmed) { diff --git a/app/g2/even-advertisement.ts b/app/g2/even-advertisement.ts index 0e9b1360..1f4ef724 100644 --- a/app/g2/even-advertisement.ts +++ b/app/g2/even-advertisement.ts @@ -27,28 +27,15 @@ * This module is pure (no NativeScript imports) so it can run under node tests. */ +import { bytesToHex, hexToBytes } from "../util/hex-util"; + +export { bytesToHex, hexToBytes }; + /** Even Realities' manufacturer-data company identifier (`"ER"` read little-endian). */ export const EVEN_COMPANY_IDENTIFIER = 0x5245; export type EvenDeviceRole = "left" | "right" | "ring"; -export function hexToBytes(hex: string | null | undefined): Uint8Array { - const clean = (hex ?? "").replace(/[^0-9a-fA-F]/g, ""); - const out = new Uint8Array(Math.floor(clean.length / 2)); - for (let i = 0; i < out.length; i++) { - out[i] = parseInt(clean.substr(i * 2, 2), 16); - } - return out; -} - -export function bytesToHex(bytes: ArrayLike): string { - let out = ""; - for (let i = 0; i < bytes.length; i++) { - out += (bytes[i]! & 0xff).toString(16).padStart(2, "0").toUpperCase(); - } - return out; -} - /** True when the manufacturer data opens with Even's `"ER"` marker. */ export function hasEvenManufacturerSignature(mfg: Uint8Array): boolean { return mfg.length >= 2 && mfg[0] === 0x45 && mfg[1] === 0x52; @@ -136,7 +123,7 @@ export function ringNameAddressOctets(name: string | null | undefined): number[] const marker = name.indexOf("R1_"); const suffix = (marker >= 0 ? name.slice(marker + 3) : name).trim(); if (suffix.length !== 6 || !/^[0-9a-fA-F]{6}$/.test(suffix)) return null; - return [0, 2, 4].map((i) => parseInt(suffix.substr(i, 2), 16)); + return [0, 2, 4].map((i) => parseInt(suffix.slice(i, i + 2), 16)); } /** @@ -233,20 +220,25 @@ export type EvenAdvertisement = { * Classify a raw advertisement. Returns null for anything that is not an Even * Realities G2 temple or R1 ring. Admission mirrors the SDK: stock names * contain "G2"/"R1", but renamed firmware may not, so the "ER" manufacturer - * signature is an equally strong admission path. + * signature is an equally strong admission path. The ring check is anchored to + * the stock "EVEN R1…" prefix — a bare `R1` substring also matches unrelated + * hardware ("Oppo Enco R1"), and every ring row is selectable, so a loose + * match here saves a stranger's earbuds as the ring. Keep this in sync with + * the Java pre-filter (FaceclawDeviceDiscovery.isAdmissible), which must stay + * a superset of it. */ export function classifyAdvertisement(raw: RawAdvertisement): EvenAdvertisement | null { const mfg = hexToBytes(raw.manufacturerData); const name = raw.name ?? ""; const upper = name.toUpperCase(); const hasSignature = hasEvenManufacturerSignature(mfg); - const looksLikeRing = /\bR1\b|EVEN R1|R1_/.test(upper); + const looksLikeRing = /^EVEN R1([_ ]|$)/.test(upper); const looksLikeG2 = upper.includes("G2"); if (!looksLikeRing && !looksLikeG2 && !hasSignature) return null; const base = { - address: normalizeAddress(raw.address), + address: normalizeMacAddress(raw.address), name, rssi: raw.rssi, txPower: raw.txPower, @@ -295,8 +287,19 @@ export function classifyAdvertisement(raw: RawAdvertisement): EvenAdvertisement }; } -export function normalizeAddress(value: string | null | undefined): string { - const compact = (value ?? "").replace(/[^0-9a-fA-F]/g, "").toUpperCase(); +/** + * Canonical MAC form: uppercase, colon-separated. Anything that does not + * contain exactly 12 hex digits is passed through trimmed and uppercased so + * an obviously-wrong value stays visible instead of being silently mangled. + * The single normalizer for every address comparison in the app — the stored + * side (device-addresses.ts re-exports this) and the scanned side must agree + * byte for byte or "is this the previously-paired device" checks break. + */ +export function normalizeMacAddress(value: string | null | undefined): string { + const compact = (value ?? "") + .trim() + .replace(/[^0-9a-fA-F]/g, "") + .toUpperCase(); if (compact.length !== 12) return (value ?? "").trim().toUpperCase(); return compact.match(/.{2}/g)!.join(":"); } diff --git a/app/g2/firmware-builder.ts b/app/g2/firmware-builder.ts index 01efe859..8465e59e 100644 --- a/app/g2/firmware-builder.ts +++ b/app/g2/firmware-builder.ts @@ -19,6 +19,7 @@ import { isEvenHubFontAsset, } from "./firmware-fonts"; import { fetchWithUserAgent } from "../util/http"; +import { bytesToHex, hexToBytes as hexToBytesLenient } from "../util/hex-util"; declare const com: any; @@ -237,23 +238,12 @@ function applyPatches( return buf; } +/** Patch-op hex is data, not user input: reject malformed strings instead of the shared decoder's silent stripping. */ function hexToBytes(hex: string): Uint8Array { - if (hex.length % 2 !== 0) { - throw new FirmwareBuildError(`odd-length hex string: ${hex}`); + if (hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex)) { + throw new FirmwareBuildError(`invalid hex string: ${hex}`); } - const out = new Uint8Array(hex.length / 2); - for (let i = 0; i < out.length; i++) { - out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16); - } - return out; -} - -function bytesToHex(bytes: Uint8Array): string { - let hex = ""; - for (let i = 0; i < bytes.length; i++) { - hex += bytes[i].toString(16).padStart(2, "0"); - } - return hex; + return hexToBytesLenient(hex); } function bytesEqual(a: Uint8Array, b: Uint8Array): boolean { diff --git a/app/g2/glasses-hardware-identity.ts b/app/g2/glasses-hardware-identity.ts index 291963cd..e178012e 100644 --- a/app/g2/glasses-hardware-identity.ts +++ b/app/g2/glasses-hardware-identity.ts @@ -280,16 +280,32 @@ export type GlassesPairSerialVerdict = | { kind: "unknown" } | { kind: "mismatched"; left: string; right: string }; +/** + * Canonical comparison key for a serial-ish string: the decoded serial when it + * decodes (so an `_L_1` arm suffix or casing difference is not read as + * different hardware), else the trimmed uppercase raw value. Null when empty. + * The single definition of serial equality — pair grouping, the pair check, + * and the "Yours" badge must all agree on it. + */ +export function serialKey(value: string | null | undefined): string | null { + const trimmed = nonEmpty(value); + if (!trimmed) return null; + return GlassesHardwareIdentity.decode(trimmed)?.serial ?? trimmed.toUpperCase(); +} + +/** True when both values carry a serial and the serials name the same hardware. */ +export function serialsMatch(a: string | null | undefined, b: string | null | undefined): boolean { + const keyA = serialKey(a); + const keyB = serialKey(b); + return !!keyA && !!keyB && keyA === keyB; +} + export function evaluatePairSerials(left: string | null | undefined, right: string | null | undefined): GlassesPairSerialVerdict { const l = nonEmpty(left); const r = nonEmpty(right); if (!l || !r) return { kind: "unknown" }; - // Compare on the decoded serial when both decode, so an arm suffix or casing - // difference in the reported string is not read as different hardware. - const leftKey = GlassesHardwareIdentity.decode(l)?.serial ?? l.toUpperCase(); - const rightKey = GlassesHardwareIdentity.decode(r)?.serial ?? r.toUpperCase(); - if (leftKey !== rightKey) return { kind: "mismatched", left: l, right: r }; - return { kind: "matched", serial: leftKey }; + if (!serialsMatch(l, r)) return { kind: "mismatched", left: l, right: r }; + return { kind: "matched", serial: serialKey(l)! }; } /** diff --git a/app/g2/pairing-candidates.ts b/app/g2/pairing-candidates.ts index 0c261f19..8ddd367d 100644 --- a/app/g2/pairing-candidates.ts +++ b/app/g2/pairing-candidates.ts @@ -21,7 +21,7 @@ import { type ProximityEstimate, type ProximityZone, } from "./ble-proximity"; -import { classifyAdvertisement, type EvenAdvertisement, type RawAdvertisement } from "./even-advertisement"; +import { classifyAdvertisement, normalizeMacAddress, type EvenAdvertisement, type RawAdvertisement } from "./even-advertisement"; import { glassesImagePath, R1_IMAGE_PATH } from "./glasses-artwork"; import { colorwayDisplayName, @@ -29,6 +29,8 @@ import { evaluatePairSerials, GlassesHardwareIdentity, pairSerialWarning, + serialKey, + serialsMatch, type GlassesColorway, } from "./glasses-hardware-identity"; @@ -45,9 +47,14 @@ export type GlassesPairCandidate = { completeness: PairCompleteness; /** Strongest smoothed signal across the arms that have one. */ rssi: number | null; - txPower: number | null; proximity: ProximityEstimate | null; lastSeenMs: number; + /** + * Set when this lone arm and a lone arm of the other side carry different + * serials — the mixed-pair situation the serial check exists to name. + * Grouping is by serial, so the mismatch can only show up across groups. + */ + mismatchWarning: string | null; }; export type RingCandidate = { @@ -84,10 +91,24 @@ export class DiscoveryAggregator { /** Feed one raw advertisement. Returns the classified record, or null when ignored. */ ingest(raw: RawAdvertisement): EvenAdvertisement | null { - const classified = classifyAdvertisement(raw); + let classified = classifyAdvertisement(raw); if (!classified) { - if (raw.name) this.rejectedNames.add(raw.name); - return null; + // Android sometimes splits an advertisement across reports — an ADV + // report without the scan response's name, or the reverse. If earlier + // traffic from this address already supplied the missing half, retry + // with it filled in rather than dropping the arm. + const remembered = this.byAddress.get(normalizeMacAddress(raw.address)); + if (remembered) { + classified = classifyAdvertisement({ + ...raw, + name: raw.name || remembered.name, + manufacturerData: raw.manufacturerData || remembered.manufacturerData, + }); + } + if (!classified) { + if (raw.name) this.rejectedNames.add(raw.name); + return null; + } } const previous = this.byAddress.get(classified.address); let smoothedRssi: number | null = classified.rssi; @@ -109,6 +130,19 @@ export class DiscoveryAggregator { seenAtMs: Math.max(classified.seenAtMs, previous?.seenAtMs ?? 0), smoothedRssi, }; + if (previous && !classified.manufacturerData && previous.manufacturerData) { + // A record without manufacturer data (a bonded listing, or a split + // report) parses to "serial unknown" notes and a possibly stale cached + // name; those must not overwrite what a fuller advertisement already + // established, or the row shows a serial and claims it is unknown. + merged.note = previous.note; + merged.flag = previous.flag; + merged.embeddedMacMismatch = previous.embeddedMacMismatch; + merged.ringSerialSuffix = previous.ringSerialSuffix; + if (previous.name && (!classified.name || classified.source === "paired")) { + merged.name = previous.name; + } + } this.byAddress.set(merged.address, merged); return merged; } @@ -144,7 +178,8 @@ export class DiscoveryAggregator { const groups = new Map(); for (const record of this.byAddress.values()) { if (record.role === "ring") continue; - const key = record.serial ? `serial:${record.serial}` : `arm:${record.address}`; + const canonical = serialKey(record.serial); + const key = canonical ? `serial:${canonical}` : `arm:${record.address}`; const group = groups.get(key) ?? { left: null, right: null }; const slot = record.role === "left" ? "left" : "right"; const incumbent = group[slot]; @@ -162,20 +197,31 @@ export class DiscoveryAggregator { const samples = [left, right].filter((arm): arm is NonNullable => !!arm && arm.smoothedRssi != null); const strongest = samples.length ? samples.reduce((a, b) => (a.smoothedRssi! >= b.smoothedRssi! ? a : b)) : null; const rssi = strongest ? Math.round(strongest.smoothedRssi!) : null; - const txPower = strongest?.txPower ?? left?.txPower ?? right?.txPower ?? null; pairs.push({ - id: serial ?? `arm:${any.address}`, + id: serialKey(serial) ?? `arm:${any.address}`, serial, identity: GlassesHardwareIdentity.decode(serial), left: left ? stripSmoothing(left) : null, right: right ? stripSmoothing(right) : null, completeness: left && right ? "complete" : left ? "left-only" : "right-only", rssi, - txPower, - proximity: estimateProximity(rssi, txPower, GLASSES_CALIBRATION), + proximity: estimateProximity(rssi, GLASSES_CALIBRATION), lastSeenMs: Math.max(left?.seenAtMs ?? 0, right?.seenAtMs ?? 0), + mismatchWarning: null, }); } + // Grouping on the serial means a group can never hold two different + // serials, so a mixed pair (left temple from A, right from B) surfaces as + // two lone arms, not as one mismatched row. With exactly one lone arm per + // side visible that IS the mixed-arms situation — name it on both rows so + // the wearer isn't left staring at two "waiting for the other" rows. + const loneLeft = pairs.filter((pair) => pair.completeness === "left-only" && pair.serial); + const loneRight = pairs.filter((pair) => pair.completeness === "right-only" && pair.serial); + if (loneLeft.length === 1 && loneRight.length === 1) { + const warning = pairSerialWarning(evaluatePairSerials(loneLeft[0]!.left!.serial, loneRight[0]!.right!.serial)); + loneLeft[0]!.mismatchWarning = warning; + loneRight[0]!.mismatchWarning = warning; + } return sortedByProximity(pairs, (pair) => pair.proximity, (pair) => pair.id); } @@ -189,7 +235,7 @@ export class DiscoveryAggregator { id: record.address, advertisement: stripSmoothing(record), rssi, - proximity: estimateProximity(rssi, record.txPower, RING_CALIBRATION), + proximity: estimateProximity(rssi, RING_CALIBRATION), lastSeenMs: record.seenAtMs, }); } @@ -221,19 +267,11 @@ export function nearestCandidateId(candidates: ReadonlyArray<{ id: string; rssi: /** * The saved pair identity is stored as the serial, but historical values may - * carry the `_L_1` arm suffix, so compare on the decoded serial when both - * sides decode and fall back to a containment check when they do not. + * carry the `_L_1` arm suffix; `serialsMatch` compares on the decoded serial + * so the suffix or casing is not read as different hardware. */ export function isPreviouslyPaired(name: string | null | undefined, pairedSerial: string | null | undefined): boolean { - if (!name || !pairedSerial) return false; - const saved = pairedSerial.trim(); - if (!saved) return false; - const left = GlassesHardwareIdentity.decode(name); - const right = GlassesHardwareIdentity.decode(saved); - if (left && right) return left.serial === right.serial; - const a = name.toLowerCase(); - const b = saved.toLowerCase(); - return a.includes(b) || b.includes(a); + return serialsMatch(name, pairedSerial); } // --------------------------------------------------------------------------- @@ -269,9 +307,6 @@ export type PairingRowPresentation = { warning: string; /** Both arms present (or a ring), so tapping can save addresses. */ canSelect: boolean; - leftAddress: string; - rightAddress: string; - ringAddress: string; }; export type RowContext = { @@ -283,6 +318,29 @@ export type RowContext = { pairedRingAddress?: string | null; }; +/** The presentation fields glasses and ring rows share, so badge and fallback rules cannot drift apart. */ +function presentationBase( + proximity: ProximityEstimate | null, + isNearest: boolean, + isPaired: boolean, + warnings: readonly string[], +): Pick { + return { + isNearest, + isPreviouslyPaired: isPaired, + badge: isPaired ? "Yours" : isNearest ? "Closest" : "", + proximitySummary: proximity ? proximitySummary(proximity) : "Signal unknown", + proximityGlyph: proximity ? zoneGlyph(proximity.zone) : "○○○○", + zone: proximity?.zone ?? null, + warning: warnings.join(" "), + }; +} + +function embeddedMacMismatchWarning(subject: string, ad: EvenAdvertisement | null): string | null { + if (!ad?.embeddedMacMismatch) return null; + return `${subject} advertised address ${ad.embeddedMac} differs from its radio address ${ad.address}.`; +} + export function glassesRow(pair: GlassesPairCandidate, context: RowContext = {}): PairingRowPresentation { const identity = pair.identity; const imagePath = glassesImagePath(identity); @@ -294,20 +352,17 @@ export function glassesRow(pair: GlassesPairCandidate, context: RowContext = {}) const rightNote = pair.right?.note; if (leftNote) warnings.push(`Left arm: ${leftNote}.`); if (rightNote) warnings.push(`Right arm: ${rightNote}.`); - if (pair.left?.embeddedMacMismatch) { - warnings.push(`Left arm's advertised address ${pair.left.embeddedMac} differs from its radio address ${pair.left.address}.`); - } - if (pair.right?.embeddedMacMismatch) { - warnings.push(`Right arm's advertised address ${pair.right.embeddedMac} differs from its radio address ${pair.right.address}.`); - } - const verdict = evaluatePairSerials(pair.left?.serial, pair.right?.serial); - const mismatch = pairSerialWarning(verdict); - if (mismatch) warnings.push(mismatch); + const leftMacWarning = embeddedMacMismatchWarning("Left arm's", pair.left); + if (leftMacWarning) warnings.push(leftMacWarning); + const rightMacWarning = embeddedMacMismatchWarning("Right arm's", pair.right); + if (rightMacWarning) warnings.push(rightMacWarning); + if (pair.mismatchWarning) warnings.push(pair.mismatchWarning); let armsSummary: string; switch (pair.completeness) { case "complete": - armsSummary = verdict.kind === "matched" ? "Left + right arms found · serials match" : "Left + right arms found"; + // Arms are grouped by serial, so a complete pair's serials match by construction. + armsSummary = "Left + right arms found · serials match"; break; case "left-only": armsSummary = "Only the left arm has been seen — waiting for the right"; @@ -328,30 +383,20 @@ export function glassesRow(pair: GlassesPairCandidate, context: RowContext = {}) swatchHex: identity?.colorway ? colorwaySwatchHex(identity.colorway) : null, imagePath, hasVariantImage: !!identity?.imageAssetName, - isNearest, - isPreviouslyPaired: isPreviouslyPairedRow, - badge: isPreviouslyPairedRow ? "Yours" : isNearest ? "Closest" : "", - proximitySummary: pair.proximity ? proximitySummary(pair.proximity) : "Signal unknown", - proximityGlyph: pair.proximity ? zoneGlyph(pair.proximity.zone) : "○○○○", - zone: pair.proximity?.zone ?? null, + ...presentationBase(pair.proximity, isNearest, isPreviouslyPairedRow, warnings), armsSummary, - warning: warnings.join(" "), - canSelect: pair.completeness === "complete" && verdict.kind !== "mismatched", - leftAddress: pair.left?.address ?? "", - rightAddress: pair.right?.address ?? "", - ringAddress: "", + canSelect: pair.completeness === "complete", }; } export function ringRow(ring: RingCandidate, context: RowContext = {}): PairingRowPresentation { const ad = ring.advertisement; - const isPaired = !!context.pairedRingAddress && context.pairedRingAddress.toUpperCase() === ad.address; + const isPaired = !!context.pairedRingAddress && normalizeMacAddress(context.pairedRingAddress) === ad.address; const isNearest = !!context.nearestId && context.nearestId === ring.id; const warnings: string[] = []; if (ad.note) warnings.push(`${ad.note}.`); - if (ad.embeddedMacMismatch) { - warnings.push(`The ring's advertised address ${ad.embeddedMac} differs from its radio address ${ad.address}.`); - } + const macWarning = embeddedMacMismatchWarning("The ring's", ad); + if (macWarning) warnings.push(macWarning); return { id: ring.id, kind: "ring", @@ -362,18 +407,9 @@ export function ringRow(ring: RingCandidate, context: RowContext = {}): PairingR swatchHex: null, imagePath: R1_IMAGE_PATH, hasVariantImage: true, - isNearest, - isPreviouslyPaired: isPaired, - badge: isPaired ? "Yours" : isNearest ? "Closest" : "", - proximitySummary: ring.proximity ? proximitySummary(ring.proximity) : "Signal unknown", - proximityGlyph: ring.proximity ? zoneGlyph(ring.proximity.zone) : "○○○○", - zone: ring.proximity?.zone ?? null, + ...presentationBase(ring.proximity, isNearest, isPaired, warnings), armsSummary: ad.bonded ? "Paired with this phone" : "Advertising", - warning: warnings.join(" "), canSelect: true, - leftAddress: "", - rightAddress: "", - ringAddress: ad.address, }; } diff --git a/app/native/device-discovery.ts b/app/native/device-discovery.ts index fc5063e6..e35c13c0 100644 --- a/app/native/device-discovery.ts +++ b/app/native/device-discovery.ts @@ -1,6 +1,7 @@ import { Utils } from "@nativescript/core"; -import { classifyAdvertisement, type RawAdvertisement } from "../g2/even-advertisement"; +import { type RawAdvertisement } from "../g2/even-advertisement"; +import { DiscoveryAggregator } from "../g2/pairing-candidates"; declare const com: any; @@ -80,13 +81,16 @@ export class DeviceDiscoveryBridge { /** * Collect advertisements for `timeoutMs` without blocking the UI thread * (scan callbacks are delivered on the main looper, so a blocking sleep - * there would starve them). Latest sample per address wins. + * there would starve them). Every sample is kept: Android can split one + * advertisement across reports (name in one, manufacturer data in another), + * so "latest per address" would drop the informative half — the aggregator + * in `buildAddressSet` merges them instead. */ scanCandidates(timeoutMs = 6000): Promise { return new Promise((resolve, reject) => { - const latest = new Map(); + const samples: RawAdvertisement[] = []; const started = this.startScan({ - onAdvertisement: (raw) => latest.set(raw.address, raw), + onAdvertisement: (raw) => samples.push(raw), onScanFailed: (code, message) => { this.stopScan(); reject(new Error(`Bluetooth scan failed: ${message} (${code})`)); @@ -98,7 +102,7 @@ export class DeviceDiscoveryBridge { } setTimeout(() => { this.stopScan(); - resolve(Array.from(latest.values())); + resolve(samples); }, Math.max(500, timeoutMs)); }); } @@ -106,24 +110,48 @@ export class DeviceDiscoveryBridge { /** * Pick one address per role from a batch of raw advertisements — the manual - * address page's "load" helper. The latest-seen device of each role wins; - * the summary names the serial where one was advertised. + * address page's "load" helper and the flash flow's address resolution. + * + * Runs the batch through the same `DiscoveryAggregator` the pairing page + * uses, so left/right come from ONE serial-joined pair (the closest complete + * one) rather than from whichever arm of whatever pair advertised last — + * "latest per role" silently welded together arms of two different pairs. + * When no arm carries a serial at all (a bonded-device listing has no + * manufacturer data), there is nothing to join on and the latest arm per side + * is used as before. */ export function buildAddressSet(candidates: RawAdvertisement[]): DiscoveredAddressSet { - const classified = candidates.map(classifyAdvertisement).filter((item): item is NonNullable => !!item); - const latestForRole = new Map<"left" | "right" | "ring", (typeof classified)[number]>(); - for (const candidate of classified) { - const incumbent = latestForRole.get(candidate.role); - if (!incumbent || incumbent.seenAtMs <= candidate.seenAtMs) latestForRole.set(candidate.role, candidate); + const aggregator = new DiscoveryAggregator(); + for (const raw of candidates) aggregator.ingest(raw); + const classified = aggregator.advertisements(); + const pairs = aggregator.pairs(); + + let left = ""; + let right = ""; + const completePair = pairs.find((pair) => pair.completeness === "complete"); + if (completePair) { + left = completePair.left!.address; + right = completePair.right!.address; + } else if (classified.every((candidate) => !candidate.serial)) { + for (const role of ["left", "right"] as const) { + const latest = classified + .filter((candidate) => candidate.role === role) + .sort((a, b) => b.seenAtMs - a.seenAtMs)[0]; + if (role === "left") left = latest?.address ?? ""; + else right = latest?.address ?? ""; + } } + // Arms with serials but no complete pair: leave the addresses empty. The + // summary below names what was heard; guessing would defeat the serial join. + const lines = classified.map((candidate) => { const extras = [candidate.serial ? `serial ${candidate.serial}` : null, candidate.rssi != null ? `${candidate.rssi} dBm` : null].filter(Boolean); return `${candidate.role}: ${candidate.name} ${candidate.address}${extras.length ? ` (${extras.join(", ")})` : ""}`; }); return { - left: latestForRole.get("left")?.address ?? "", - right: latestForRole.get("right")?.address ?? "", - ring: latestForRole.get("ring")?.address ?? "", + left, + right, + ring: aggregator.rings()[0]?.advertisement.address ?? "", summary: lines.length ? lines.join("\n") : "No matching devices found.", }; } diff --git a/app/phone-ui/config-view-model.ts b/app/phone-ui/config-view-model.ts index 65a767ab..40a78dad 100644 --- a/app/phone-ui/config-view-model.ts +++ b/app/phone-ui/config-view-model.ts @@ -12,6 +12,7 @@ import { import { glassesImagePath } from "../g2/glasses-artwork"; import { GlassesHardwareIdentity } from "../g2/glasses-hardware-identity"; import { buildAddressSet, DeviceDiscoveryBridge } from "../native/device-discovery"; +import { formatErrorMessage } from "../util/format-error"; type TextChangeArgs = { value?: string; object?: { text?: string } }; @@ -187,7 +188,23 @@ export class ConfigViewModel extends Observable { } /** The live scan page identifies pairs by serial, model, and distance; hand off to it. */ - onScanTap(): void { + async onScanTap(): Promise { + if (!this.onboarding) { + // A connected arm stops advertising, so drop the link before scanning. + // Required lazily: a module-scope import would instantiate the dashboard + // controller singleton during onboarding, which this page is part of. + // Outside onboarding the main page has already loaded it. + const { dashboardController } = require("../g2/dashboard-controller") as typeof import("../g2/dashboard-controller"); + const { resumeAutoReconnect } = require("../g2/reconnect-policy") as typeof import("../g2/reconnect-policy"); + try { + await dashboardController.disconnect(); + } catch { + // proceed anyway; the pairing page reports what it hears + } + // disconnect() enters the manual-disconnected state; pairing is a + // detour, so let the main page reconnect afterwards. + resumeAutoReconnect(); + } Frame.topmost()?.navigate({ moduleName: "phone-ui/pairing-page", context: { onboarding: this.onboarding }, @@ -273,7 +290,6 @@ export class ConfigViewModel extends Observable { } private formatError(error: unknown): string { - const raw = (error as Error)?.message ?? String(error); - return raw.replace(/[\x00-\x1f]+/g, " ").replace(/\s+/g, " ").trim(); + return formatErrorMessage(error); } } diff --git a/app/phone-ui/main-view-model.ts b/app/phone-ui/main-view-model.ts index 89677d2a..912bc37d 100644 --- a/app/phone-ui/main-view-model.ts +++ b/app/phone-ui/main-view-model.ts @@ -1,7 +1,8 @@ import { Application, Frame, ImageSource, Observable, Screen } from "@nativescript/core"; import { dashboardController } from "../g2/dashboard-controller"; import { isValidMacAddress, loadDeviceAddresses } from "../g2/device-addresses"; -import { isAutoReconnectSuppressed } from "../g2/reconnect-policy"; +import { isAutoReconnectSuppressed, resumeAutoReconnect } from "../g2/reconnect-policy"; +import { formatErrorMessage } from "../util/format-error"; import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../graphics/image"; const LENS_ASPECT_RATIO = G2_LENS_WIDTH / G2_LENS_HEIGHT; @@ -513,7 +514,10 @@ export class MainViewModel extends Observable { /** * Live scan that names each nearby pair by model, colour, and serial and * checks both arms belong together. A connected arm stops advertising, so - * drop the current link first; autoConnect picks it back up afterwards. + * drop the current link first. disconnect() enters the manual-disconnected + * state; pairing is a detour, not a Disconnect, so lift the suppression + * right away — nothing dials the glasses until the main page's autoConnect + * runs again on the way back. */ async onPairGlassesTap(): Promise { if (!this.canRun) return; @@ -523,6 +527,7 @@ export class MainViewModel extends Observable { } catch { // proceed anyway; the pairing page reports what it hears } + resumeAutoReconnect(); } Frame.topmost()?.navigate({ moduleName: "phone-ui/pairing-page", context: { onboarding: false } }); } @@ -632,9 +637,6 @@ export class MainViewModel extends Observable { } private formatError(error: unknown): string { - const raw = (error as Error)?.message ?? String(error); - const sanitized = raw.replace(/[\x00-\x1f]+/g, " ").replace(/\s+/g, " ").trim(); - if (sanitized.length <= 240) return sanitized; - return `${sanitized.slice(0, 237)}...`; + return formatErrorMessage(error, 240); } } diff --git a/app/phone-ui/onboarding-firmware-check-view-model.ts b/app/phone-ui/onboarding-firmware-check-view-model.ts index 5bb4a580..c3f2413c 100644 --- a/app/phone-ui/onboarding-firmware-check-view-model.ts +++ b/app/phone-ui/onboarding-firmware-check-view-model.ts @@ -10,6 +10,7 @@ import { import { classifyOnboardingFirmware, FLASHABLE_STOCK_VERSION_TEXT } from "../g2/firmware-compat"; import { DeviceInfoProbe, DeviceInfoState } from "../native/device-info-probe"; import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; +import { formatErrorMessage } from "../util/format-error"; type CheckPhase = "checking" | "fonts" | "custom" | "flashable" | "newer" | "error"; @@ -299,7 +300,6 @@ export class OnboardingFirmwareCheckViewModel extends Observable { } private formatError(error: unknown): string { - const raw = (error as Error)?.message ?? String(error); - return raw.replace(/[\x00-\x1f]+/g, " ").replace(/\s+/g, " ").trim(); + return formatErrorMessage(error); } } diff --git a/app/phone-ui/onboarding-flash-view-model.ts b/app/phone-ui/onboarding-flash-view-model.ts index b3be62dd..fa999606 100644 --- a/app/phone-ui/onboarding-flash-view-model.ts +++ b/app/phone-ui/onboarding-flash-view-model.ts @@ -17,6 +17,7 @@ import { FirmwareFlasher, FlashProgress, FlashState } from "../native/firmware-f import { FlashPromptCommunicator, FlashPromptState } from "../native/flash-prompt-communicator"; import { resumeAutoReconnect, suppressAutoReconnect } from "../g2/reconnect-policy"; import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; +import { formatErrorMessage } from "../util/format-error"; type FlashPhase = "intro" | "prompt" | "building" | "ready" | "flashing" | "flashed" | "error"; @@ -566,7 +567,6 @@ export class OnboardingFlashViewModel extends Observable { } private formatError(error: unknown): string { - const raw = (error as Error)?.message ?? String(error); - return raw.replace(/[\x00-\x1f]+/g, " ").replace(/\s+/g, " ").trim(); + return formatErrorMessage(error); } } diff --git a/app/phone-ui/pairing-page.ts b/app/phone-ui/pairing-page.ts index 0a2c8c41..e9a840db 100644 --- a/app/phone-ui/pairing-page.ts +++ b/app/phone-ui/pairing-page.ts @@ -21,5 +21,12 @@ export function navigatingTo(args: NavigatedData): void { export function navigatingFrom(args: NavigatedData): void { const page = args.object as Page; const model = page.bindingContext as PairingViewModel | undefined; - model?.stop(); + // Backing out destroys the page; a forward navigation (manual entry) keeps + // it on the stack, so only pause the scan and keep the model's app-lifecycle + // hooks for the return trip. + if (args.isBackNavigation) { + model?.dispose(); + } else { + model?.stop(); + } } diff --git a/app/phone-ui/pairing-page.xml b/app/phone-ui/pairing-page.xml index 484adf7c..c7e39b54 100644 --- a/app/phone-ui/pairing-page.xml +++ b/app/phone-ui/pairing-page.xml @@ -14,7 +14,7 @@ -