Address review findings for the proximity-pairing PR

Correctness:
- Pair-glasses flows no longer strand the app in the manual-disconnected
  state: the pre-scan disconnect is followed by resumeAutoReconnect(), and
  the config page's scan hand-off drops the live link too.
- The mixed-arms serial warning is reachable now: pairs() groups by the
  canonical serial key, and a lone left + lone right with different serials
  get the mismatch warning on both rows (it previously required two
  different serials inside one serial-keyed group, which cannot happen).
- A selected pair that degrades to one arm (prune while the page is open)
  is deselected, and Save never pads a missing arm from stored addresses.
- DiscoveryAggregator.ingest no longer lets a bonded re-emit or split
  advertisement overwrite the note/name/flag learned from a full
  advertisement, and reclassifies split reports using remembered fields so
  a nameless half doesn't drop the arm.
- estimateProximity ignores the advertised TX Power Level (radiated power,
  not measured-power-at-1m); the calibration table is the only reference.
- Saving a ring without a glasses pair updates the stored identity's ring
  name/address instead of leaving the previous ring on record.
- Ring detection requires the stock "EVEN R1" name prefix in both the TS
  classifier and the Java pre-filter; a bare "R1" substring matched
  unrelated devices, and ring rows are always selectable.
- One-shot scans keep every sample (buildAddressSet merges them through
  DiscoveryAggregator), and flash-flow address resolution takes left/right
  from one serial-joined complete pair instead of latest-per-role.

Lifecycle:
- The pairing scan and its refresh timer pause on app suspend and resume
  with the app, and the model's app-event hooks are detached when the page
  is left for good.

Cleanup:
- One MAC normalizer (even-advertisement.normalizeMacAddress, re-exported
  by device-addresses), used for the ring "Yours" comparison too.
- One serial-equality definition (serialKey/serialsMatch); the containment
  fallback in isPreviouslyPaired is gone.
- Shared formatErrorMessage replaces five per-view-model copies; shared
  hex-util replaces the duplicate TS hex codecs; one Java bytesToHex in
  FaceclawFirmwareUtil replaces three hand-rolled encoders.
- glassesRow/ringRow share a presentation-base helper; dead row address
  fields, the constant glassesSectionVisibility, the identical-branch
  status ternary, and zoneRank/ZONE_ORDER are removed.
- .gitignore now actually covers .test-build/ as tests/README claims.

UI:
- Dark-mode styles for the pairing page: readable instructions, dark-gray
  cards with consistent light text; light mode keeps its current look.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016ZqzwmRQ3HQxasBz5rYyZV
This commit is contained in:
James BabcockandClaude Fable 5 committed 2026-08-23 15:28:59 -07:00
1 parent ee022cdc84
commit 17182532f4
24 files changed
+537 -250

No files matched your search

+3
View File
@@ -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
@@ -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:
@@ -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);
}
@@ -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);
}
+80
View File
@@ -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;
}
+17 -24
View File
@@ -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<ProximityZone, number> = { 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;
}
+4 -11
View File
@@ -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) {
+26 -23
View File
@@ -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<number>): 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(":");
}
+5 -15
View File
@@ -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 {
+22 -6
View File
@@ -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)! };
}
/**
+96 -60
View File
@@ -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<string, { left: (EvenAdvertisement & { smoothedRssi: number | null }) | null; right: (EvenAdvertisement & { smoothedRssi: number | null }) | null }>();
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<typeof arm> => !!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<PairingRowPresentation, "isNearest" | "isPreviouslyPaired" | "badge" | "proximitySummary" | "proximityGlyph" | "zone" | "warning"> {
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,
};
}
+43 -15
View File
@@ -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<RawAdvertisement[]> {
return new Promise((resolve, reject) => {
const latest = new Map<string, RawAdvertisement>();
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<typeof item> => !!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.",
};
}
+19 -3
View File
@@ -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<void> {
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);
}
}
+8 -6
View File
@@ -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<void> {
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);
}
}
@@ -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);
}
}
+2 -2
View File
@@ -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);
}
}
+8 -1
View File
@@ -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();
}
}
+1 -1
View File
@@ -14,7 +14,7 @@
<ScrollView row="2" class="m-t-12">
<StackLayout>
<Label text="Glasses" class="h2 pairing-section" visibility="{{ glassesSectionVisibility }}" />
<Label text="Glasses" class="h2 pairing-section" />
<Label text="{{ emptyGlassesMessage }}" class="pairing-empty" textWrap="true" visibility="{{ emptyGlassesVisibility }}" />
<Repeater items="{{ glassesRows }}">
<Repeater.itemsLayout>
+61 -19
View File
@@ -1,7 +1,8 @@
import { EventData, Frame, Observable, View } from "@nativescript/core";
import { Application, EventData, Frame, Observable, View } from "@nativescript/core";
import { ensureBlePermissions } from "../g2/android-permissions";
import { loadDeviceAddresses, loadPairedGlassesIdentity, saveDeviceAddresses, savePairedGlassesIdentity } from "../g2/device-addresses";
import { formatErrorMessage } from "../util/format-error";
import {
colorwayLabel,
DEFAULT_STALE_AFTER_MS,
@@ -71,10 +72,38 @@ export class PairingViewModel extends Observable {
this.onboarding = options?.onboarding ?? false;
this.previouslyPairedSerial = loadPairedGlassesIdentity()?.serial ?? null;
this.previouslyPairedRing = loadDeviceAddresses().ring;
// A backgrounded phone (Home, screen lock, a call) must not keep the
// low-latency scan and the refresh timer burning; pick both back up when
// the app returns.
Application.on(Application.suspendEvent, this.onAppSuspend);
Application.on(Application.resumeEvent, this.onAppResume);
}
// --- lifecycle -------------------------------------------------------------
private resumeScanAfterSuspend = false;
private readonly onAppSuspend = (): void => {
if (this._scanning) {
this.resumeScanAfterSuspend = true;
this.stop();
}
};
private readonly onAppResume = (): void => {
if (this.resumeScanAfterSuspend) {
this.resumeScanAfterSuspend = false;
void this.start();
}
};
/** Final teardown when the page is left for good (not a detour to manual entry). */
dispose(): void {
this.stop();
Application.off(Application.suspendEvent, this.onAppSuspend);
Application.off(Application.resumeEvent, this.onAppResume);
}
async start(): Promise<void> {
if (this._scanning) return;
if (!global.isAndroid) {
@@ -187,10 +216,6 @@ export class PairingViewModel extends Observable {
return this._ringRows;
}
get glassesSectionVisibility(): "visible" | "collapse" {
return "visible";
}
get emptyGlassesVisibility(): "visible" | "collapse" {
return this._glassesRows.length ? "collapse" : "visible";
}
@@ -280,26 +305,41 @@ export class PairingViewModel extends Observable {
const pair = this.selectedPair;
const ring = this.selectedRing;
if (!pair && !ring) return;
// refresh() drops a selection whose pair regressed below complete, but the
// tap can race a prune: never fall back to previously stored addresses for
// a missing arm — that silently welds together arms of two different pairs.
if (pair && (!pair.left || !pair.right)) return;
const existing = loadDeviceAddresses();
const addresses = {
right: pair?.right?.address ?? existing.right,
left: pair?.left?.address ?? existing.left,
right: pair ? pair.right!.address : existing.right,
left: pair ? pair.left!.address : existing.left,
ring: ring?.advertisement.address ?? existing.ring,
};
saveDeviceAddresses(addresses);
if (pair?.left && pair.right) {
if (pair) {
savePairedGlassesIdentity({
serial: pair.serial ?? "",
leftName: pair.left.name,
rightName: pair.right.name,
leftAddress: pair.left.address,
rightAddress: pair.right.address,
leftName: pair.left!.name,
rightName: pair.right!.name,
leftAddress: pair.left!.address,
rightAddress: pair.right!.address,
ringName: ring?.advertisement.name ?? (addresses.ring === existing.ring ? (loadPairedGlassesIdentity()?.ringName ?? "") : ""),
ringAddress: addresses.ring,
pairedAtMs: Date.now(),
});
} else if (ring) {
// Replacing just the ring: keep the stored glasses identity current so
// the config page doesn't keep naming the old ring.
const identity = loadPairedGlassesIdentity();
if (identity) {
savePairedGlassesIdentity({
...identity,
ringName: ring.advertisement.name,
ringAddress: ring.advertisement.address,
});
}
}
this.stop();
this.dispose();
if (this.onboarding) {
setPreviewOnlyMode(false);
// Continue the onboarding chain: unpair the official app next.
@@ -310,7 +350,7 @@ export class PairingViewModel extends Observable {
}
onSecondaryTap(): void {
this.stop();
this.dispose();
const frame = Frame.topmost();
if (frame?.canGoBack()) {
frame.goBack();
@@ -348,9 +388,12 @@ export class PairingViewModel extends Observable {
const rings = this.aggregator.rings();
// Keep the selection pointing at live data (addresses can only change if a
// side was replaced); drop it if the pair disappeared.
// side was replaced); drop it if the pair disappeared — or if it degraded
// below complete (an arm went back in the case), so Save can never write a
// one-armed selection padded with stale addresses.
if (this.selectedPair) {
this.selectedPair = pairs.find((pair) => pair.id === this.selectedPair!.id) ?? null;
const live = pairs.find((pair) => pair.id === this.selectedPair!.id) ?? null;
this.selectedPair = live?.completeness === "complete" ? live : null;
}
if (this.selectedRing) {
this.selectedRing = rings.find((ring) => ring.id === this.selectedRing!.id) ?? null;
@@ -378,7 +421,7 @@ export class PairingViewModel extends Observable {
if (this.scanFailure) {
this.status = `Scan failed: ${this.scanFailure}`;
} else if (!this._scanning) {
this.status = pairs.length ? "Scan paused." : "Scan paused.";
this.status = "Scan paused.";
} else if (!pairs.length && !rings.length) {
this.status = "Scanning…";
} else {
@@ -413,8 +456,7 @@ export class PairingViewModel 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);
}
}
+13
View File
@@ -0,0 +1,13 @@
/**
* One-line error text safe for a status label: control characters stripped,
* whitespace collapsed, optionally truncated. Shared by the view models so a
* fix to error rendering lands everywhere at once.
*/
export function formatErrorMessage(error: unknown, maxLength?: number): string {
const raw = (error as Error)?.message ?? String(error);
const sanitized = raw.replace(/[\x00-\x1f]+/g, " ").replace(/\s+/g, " ").trim();
if (maxLength != null && sanitized.length > maxLength) {
return `${sanitized.slice(0, Math.max(0, maxLength - 3))}...`;
}
return sanitized;
}
+22
View File
@@ -0,0 +1,22 @@
/**
* Hex ⇄ byte helpers shared by the advertisement parsers and the firmware
* builder. Pure (no NativeScript imports) so it can run under node tests.
*/
/** Lenient decode: non-hex characters (separators, whitespace) are stripped first. */
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.slice(i * 2, i * 2 + 2), 16);
}
return out;
}
export function bytesToHex(bytes: ArrayLike<number>): string {
let out = "";
for (let i = 0; i < bytes.length; i++) {
out += (bytes[i]! & 0xff).toString(16).padStart(2, "0").toUpperCase();
}
return out;
}
+22 -22
View File
@@ -23,37 +23,37 @@ const {
const near = (a, b, eps) => Math.abs(a - b) <= eps;
test("distance falls as signal weakens", () => {
const close = estimateProximity(-40, null, GLASSES_CALIBRATION);
const mid = estimateProximity(-70, null, GLASSES_CALIBRATION);
const farAway = estimateProximity(-95, null, GLASSES_CALIBRATION);
const close = estimateProximity(-40, GLASSES_CALIBRATION);
const mid = estimateProximity(-70, GLASSES_CALIBRATION);
const farAway = estimateProximity(-95, GLASSES_CALIBRATION);
assert.ok(close.meters < mid.meters);
assert.ok(mid.meters < farAway.meters);
});
test("the reference power reads as one metre", () => {
const estimate = estimateProximity(GLASSES_CALIBRATION.txPowerAtOneMeter, null, GLASSES_CALIBRATION);
const estimate = estimateProximity(GLASSES_CALIBRATION.txPowerAtOneMeter, GLASSES_CALIBRATION);
assert.ok(near(estimate.meters, 1.0, 0.001));
assert.equal(estimate.zone, "near");
});
test("estimates stay inside a plausible band", () => {
assert.ok(near(estimateProximity(20, null, GLASSES_CALIBRATION).meters, MINIMUM_METERS, 0.0001));
assert.ok(near(estimateProximity(-127, null, GLASSES_CALIBRATION).meters, MAXIMUM_METERS, 0.0001));
assert.ok(near(estimateProximity(20, GLASSES_CALIBRATION).meters, MINIMUM_METERS, 0.0001));
assert.ok(near(estimateProximity(-127, GLASSES_CALIBRATION).meters, MAXIMUM_METERS, 0.0001));
});
test("an advertised TX power overrides the calibration", () => {
const assumed = estimateProximity(-60, null, GLASSES_CALIBRATION);
const measured = estimateProximity(-60, -50, GLASSES_CALIBRATION);
// A device that says it transmits at -50 dBm at 1 m, heard at -60, is further
// away than one assumed to transmit at -62 — and it is trusted more.
assert.ok(measured.meters > assumed.meters);
assert.ok(measured.confidence > assumed.confidence);
test("the calibration table is the only reference power", () => {
// An advertised BLE "TX Power Level" is radiated power at the antenna, not a
// measured power at 1 m; estimateProximity deliberately takes no TX power
// argument, so a 0 dBm advertisement cannot inflate the estimate. The API
// itself enforces it — this pins the arity so a txPower parameter cannot
// quietly return.
assert.equal(estimateProximity.length, 2);
});
test("no signal yields no estimate (127 is the unavailable sentinel)", () => {
assert.equal(estimateProximity(null, null, GLASSES_CALIBRATION), null);
assert.equal(estimateProximity(undefined, null, GLASSES_CALIBRATION), null);
assert.equal(estimateProximity(127, null, GLASSES_CALIBRATION), null);
assert.equal(estimateProximity(null, GLASSES_CALIBRATION), null);
assert.equal(estimateProximity(undefined, GLASSES_CALIBRATION), null);
assert.equal(estimateProximity(127, GLASSES_CALIBRATION), null);
});
test("zones and their boundaries", () => {
@@ -67,15 +67,15 @@ test("zones and their boundaries", () => {
});
test("weak signals are marked as approximate", () => {
const strong = estimateProximity(-45, -60, GLASSES_CALIBRATION);
const weak = estimateProximity(-95, null, GLASSES_CALIBRATION);
const strong = estimateProximity(-45, GLASSES_CALIBRATION);
const weak = estimateProximity(-95, GLASSES_CALIBRATION);
assert.ok(!formatDistance(strong).startsWith("~"));
assert.ok(formatDistance(weak).startsWith("~"));
assert.ok(weak.confidence < strong.confidence);
});
test("distance formatting is rounded hard", () => {
const centimetres = estimateProximity(-30, -60, GLASSES_CALIBRATION);
const centimetres = estimateProximity(-30, GLASSES_CALIBRATION);
assert.ok(formatDistance(centimetres).includes("cm"), formatDistance(centimetres));
assert.equal(formatDistance({ meters: 2.34, confidence: 1, zone: "near" }), "2.3 m");
assert.equal(formatDistance({ meters: 42.6, confidence: 1, zone: "distant" }), "43 m");
@@ -83,7 +83,7 @@ test("distance formatting is rounded hard", () => {
});
const device = (id, rssi) => ({ id, rssi });
const estimate = (d) => estimateProximity(d.rssi, null, GLASSES_CALIBRATION);
const estimate = (d) => estimateProximity(d.rssi, GLASSES_CALIBRATION);
const byId = (d) => d.id;
test("glasses sort closest first", () => {
@@ -106,7 +106,7 @@ test("equal signals keep a stable order", () => {
test("ring and glasses are calibrated separately", () => {
// The ring's antenna reads weaker than the glasses at the same distance, so
// the same RSSI must not be reported as the same distance for both.
const ring = estimateProximity(-70, null, RING_CALIBRATION);
const glasses = estimateProximity(-70, null, GLASSES_CALIBRATION);
const ring = estimateProximity(-70, RING_CALIBRATION);
const glasses = estimateProximity(-70, GLASSES_CALIBRATION);
assert.ok(ring.meters < glasses.meters);
});
+9 -2
View File
@@ -19,7 +19,7 @@ const {
ringMacWireBytes,
extractRingSerialSuffix,
classifyAdvertisement,
normalizeAddress,
normalizeMacAddress,
EVEN_COMPANY_IDENTIFIER,
} = require("../.test-build/app/g2/even-advertisement.js");
@@ -80,7 +80,7 @@ test("address codec crosses wire/human order exactly once", () => {
assert.equal(bytesToHex(wire), "E26EB5D27FDA");
assert.equal(humanReadableAddressFromWireBytes(wire), "DA:7F:D2:B5:6E:E2");
assert.equal(wireBytesFromHumanReadableAddress("nope"), null);
assert.equal(normalizeAddress("e0ecb61412e0"), "E0:EC:B6:14:12:E0");
assert.equal(normalizeMacAddress("e0ecb61412e0"), "E0:EC:B6:14:12:E0");
});
test("ring name suffix octets parse from the full name and the bare id", () => {
@@ -155,3 +155,10 @@ test("ignores unrelated advertisers", () => {
assert.equal(classifyAdvertisement(raw({ name: "Pixel Buds", manufacturerData: "E000010203" })), null);
assert.equal(classifyAdvertisement(raw({ name: "", manufacturerData: "" })), null);
});
test("a bare R1 substring is not a ring — only the stock EVEN R1 prefix is", () => {
assert.equal(classifyAdvertisement(raw({ name: "Oppo Enco R1", manufacturerData: "" })), null);
assert.equal(classifyAdvertisement(raw({ name: "R1 Speaker", manufacturerData: "" })), null);
const ad = classifyAdvertisement(raw({ address: "DA:7F:D2:B5:6E:E2", name: "EVEN R1_B56EE2", manufacturerData: "" }));
assert.equal(ad.role, "ring");
});
+46 -4
View File
@@ -156,7 +156,7 @@ test("rings are grouped separately and sorted closest first", () => {
const row = ringRow(aggregator.rings()[1]);
assert.equal(row.modelTitle, "Even R1");
assert.match(row.deviceName, /140137/);
assert.equal(row.ringAddress, "DA:7F:D2:B5:6E:E2");
assert.equal(aggregator.rings()[1].advertisement.address, "DA:7F:D2:B5:6E:E2");
});
test("nearest requires a clear signal lead", () => {
@@ -227,11 +227,53 @@ test("frame C resolves to the generic shot with the swatch still available", ()
test("an incomplete pair cannot be selected and says which arm is missing", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(RIGHT);
const row = glassesRow(aggregator.pairs()[0]);
const pair = aggregator.pairs()[0];
const row = glassesRow(pair);
assert.equal(row.canSelect, false);
assert.match(row.armsSummary, /Only the right arm/);
assert.equal(row.rightAddress, "E0:12:14:8D:6E:3C");
assert.equal(row.leftAddress, "");
assert.equal(pair.right.address, "E0:12:14:8D:6E:3C");
assert.equal(pair.left, null);
});
test("a lone left and lone right with different serials warn about mixed arms", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(LEFT);
aggregator.ingest(OTHER_RIGHT);
for (const pair of aggregator.pairs()) {
const row = glassesRow(pair);
assert.match(row.warning, /arms from two different pairs/);
assert.match(row.warning, /S211GBBC180304/);
assert.match(row.warning, /S211GCBC300403/);
assert.equal(row.canSelect, false);
}
});
test("a bonded re-emit does not overwrite live scan notes or name", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(LEFT);
// Every pairing-page re-entry replays bonded devices: no manufacturer data,
// possibly stale cached name. That must not turn a fully-parsed row into
// "serial unknown" or swap in the stale name.
aggregator.ingest({ ...LEFT, name: "Even G2_32_L_0LDCAF", manufacturerData: "", rssi: null, bonded: true, source: "paired", seenAtMs: 2000 });
const pair = aggregator.pairs()[0];
assert.equal(pair.serial, "S211GBBC180304");
assert.equal(pair.left.name, LEFT.name);
assert.equal(pair.left.note, null);
assert.equal(glassesRow(pair).warning, "");
});
test("a split report without the name keeps the arm by merging earlier traffic", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(LEFT);
// Android sometimes delivers the ADV report (manufacturer data, no name)
// separately from the scan response carrying the name.
const merged = aggregator.ingest({ ...LEFT, name: "", seenAtMs: 2000 });
assert.ok(merged, "the nameless half must not drop the arm");
assert.equal(merged.role, "left");
const pair = aggregator.pairs()[0];
assert.equal(pair.completeness, "left-only");
assert.equal(pair.left.name, LEFT.name);
assert.equal(pair.left.seenAtMs, 2000);
});
test("an embedded-MAC mismatch is surfaced as a warning", () => {