mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
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:
1 parent
ee022cdc84
commit
17182532f4
24 files changed
+537
-250
No files matched your search
@@ -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
@@ -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
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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(":");
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
@@ -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)! };
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -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,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -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.",
|
||||
};
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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>
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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");
|
||||
});
|
||||
@@ -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", () => {
|
||||
|
||||
Reference in new issue
Block a user