From 4d101eefe18118cf55200330d1d22e0abe731cac Mon Sep 17 00:00:00 2001 From: James Babcock Date: Sun, 1 Nov 2026 17:19:55 -0800 Subject: [PATCH 01/34] Partial support for Rayneo iO --- ACKNOWLEDGEMENTS.md | 5 + .../faceclaw/app/FaceclawBleCommunicator.kt | 19 + .../faceclaw/app/FaceclawDeviceDiscovery.kt | 8 +- app/g2/dashboard-controller.ts | 19 +- app/g2/even-advertisement.ts | 36 +- app/g2/pairing-candidates.ts | 53 +- app/graphics/image.ts | 3 + app/native/faceclaw-communicator.ios.ts | 6 +- app/native/faceclaw-communicator.ts | 5 +- app/phone-ui/pairing-view-model.ts | 79 ++- app/ui/dashboard-settings.ts | 24 + .../faceclaw/app/g2protocol/CfwTransport.kt | 36 +- .../session/GlassesSessionBrightness.kt | 5 + .../session/GlassesSessionControls.kt | 2 + .../g2protocol/session/GlassesSessionCore.kt | 101 +++- .../g2protocol/session/GlassesSessionIo.kt | 544 ++++++++++++++++++ .../g2protocol/session/GlassesSessionSend.kt | 28 +- .../faceclaw/app/rayneo/RayNeoIoProtocol.kt | 469 +++++++++++++++ tests/display-layout-setting.test.cjs | 14 + tests/even-advertisement.test.cjs | 18 + .../com/faceclaw/app/RayNeoIoProtocolTest.kt | 152 +++++ .../com/faceclaw/app/RayNeoIoSessionTest.kt | 380 ++++++++++++ tests/pairing-candidates.test.cjs | 17 + 23 files changed, 1954 insertions(+), 69 deletions(-) create mode 100644 native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt create mode 100644 native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt create mode 100644 tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt create mode 100644 tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt diff --git a/ACKNOWLEDGEMENTS.md b/ACKNOWLEDGEMENTS.md index a054eae1..95e41c3f 100644 --- a/ACKNOWLEDGEMENTS.md +++ b/ACKNOWLEDGEMENTS.md @@ -13,6 +13,11 @@ and others who contributed to documenting the G2's bluetooth protocol and firmwa G2 microphone LC3 decoding uses Google's liblc3: https://github.com/google/liblc3 +RayNeo iO support builds on the Glassly SDK and custom firmware by Tetramo, Inc. +and Mentra Labs, Inc. (MIT License): https://github.com/tetramo-labs/glassly and +https://github.com/tetramo-labs/glassly-rayneo-cfw. The iO wire codecs in +native/kotlin/shared/.../rayneo/RayNeoIoProtocol.kt follow their protocol work. + iPhone notification icons are Pebble's notification and timeline icons, from https://github.com/pebble-dev/iconography: the original Pebble Technology icons and Rebble community additions. They are licensed under the Apache License 2.0; diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt index e384d0da..5089a039 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt @@ -189,6 +189,25 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun setRequiredFirmwareRevision(revision: Int) = core.setRequiredFirmwareRevision(revision) + /** + * Drive a RayNeo iO (constructed with its address as both arms and no ring). The phone's + * protocol identity is derived from ANDROID_ID so it survives reinstalls: the glasses bind + * to the first identity that authenticates and refuse others until put in pairing mode. + */ + fun useRayNeoIo() { + val androidId = try { + android.provider.Settings.Secure.getString(appContext.contentResolver, android.provider.Settings.Secure.ANDROID_ID) + } catch (_: Exception) { + null + } + val seed = "faceclaw-rayneo-phone-id:" + (androidId ?: android.os.Build.FINGERPRINT) + val phoneId = java.security.MessageDigest.getInstance("SHA-256").digest(seed.toByteArray(Charsets.UTF_8)).copyOf(6) + val model = android.os.Build.MODEL ?: "Android" + core.useRayNeoIo(phoneId, model, android.os.Build.MANUFACTURER ?: "Android", model) + } + + fun isRayNeoIo(): Boolean = core.isRayNeoIo() + fun start() { if (core.start()) { activeInstance = this diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt index b43bcaae..5cc8f369 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt @@ -129,13 +129,19 @@ class FaceclawDeviceDiscovery(context: Context) { && manufacturerData[0] == 0x45.toByte() && manufacturerData[1] == 0x52.toByte()) { return true } + // RayNeo iO: manufacturer company 0x5716 ([07][MAC]...) outside pairing mode; + // in pairing mode only the "RayNeo iO-xxxx" name identifies it. + if (manufacturerData != null && manufacturerData.size >= 2 + && manufacturerData[0] == 0x16.toByte() && manufacturerData[1] == 0x57.toByte()) { + return true + } if (name == null) { return false } val upper = name.uppercase() // 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") + return upper.contains("G2") || upper.startsWith("EVEN R1") || upper.startsWith("RAYNEO") } private fun buildJson( diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index 87e67ac7..83f976db 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -56,7 +56,7 @@ import { claimGlassesOnboardingAutoLaunch, ONBOARDING_APP_ID } from "../apps/onb import { beginRenderPass, endRenderPass } from "../util/render-freshness"; import { voiceControlBridge } from "../native/voice-control"; import { voiceActivity } from "../ui/shell/voice-activity"; -import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage } from "../graphics/image"; +import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage, RAYNEO_IO_HEIGHT, RAYNEO_IO_WIDTH } from "../graphics/image"; import { flattenPlanesWithDraws, planesFingerprint, type Plane } from "../graphics/plane"; import { prepareFrameDraws } from "../graphics/glyph-wire"; import { createLockScreenImage, LOCK_SCREEN_SURFACE_ID } from "./lock-screen"; @@ -78,7 +78,7 @@ import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-a import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible, type ScreenRect, type WindowHeightMode } from "../ui/shell/geometry"; import { type ContinuousCaptureOptions, type LayerActions, type TextSettingsEditToggle, type TranscriptionChoice } from "../ui/layers"; import { type KeyboardInputSession } from "../ui/shell/keyboard-input"; -import { appSwitcherPositionSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayLayoutSetting, navigateDisplayLayoutSetting, terminalDisplayLayoutSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, whisperServerApiKeySetting, whisperServerLanguageSetting, whisperServerModelSetting, whisperServerUrlSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, type RingConnectionMode, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; +import { appSwitcherPositionSetting, glassesTypeSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayLayoutSetting, navigateDisplayLayoutSetting, terminalDisplayLayoutSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, whisperServerApiKeySetting, whisperServerLanguageSetting, whisperServerModelSetting, whisperServerUrlSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, type RingConnectionMode, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization"; import { getInstalledEvenHubAppById, @@ -1479,12 +1479,15 @@ class DashboardController { // address disables every direct-ring code path in the communicator. const ringMode = ringConnectionModeSetting.get(); this.ringModeAtConnect = ringMode; - const ringAddress = ringMode !== "glasses" ? addresses.ring : ""; + // A RayNeo iO is one link (its address in both arm slots) and has no ring. + const glassesType = glassesTypeSetting.get(); + const ringAddress = ringMode !== "glasses" && glassesType === "g2" ? addresses.ring : ""; // Direct mode may unpair the ring from the glasses; remember to hand it // back once a later session runs in another mode. if (ringMode === "direct" && ringAddress) setBooleanSetting(RING_TAKEN_FROM_GLASSES_KEY, true); - this.appendLog( - `Using configured arms: R=${addresses.right} L=${addresses.left}${ringAddress ? ` ring=${ringAddress}` : ""}`, + this.appendLog(glassesType === "rayneo-io" + ? `Using configured RayNeo iO: ${addresses.right}` + : `Using configured arms: R=${addresses.right} L=${addresses.left}${ringAddress ? ` ring=${ringAddress}` : ""}`, ); let communicator: FaceclawCommunicatorBridge | null = null; @@ -1506,6 +1509,7 @@ class DashboardController { // sync needs the phone role, which the session borrows briefly for // each pull (GlassesSessionRing.beginRingHealthWindowLocked). ringRole: ringMode === "direct" ? "glasses" : "phone", + glassesType, }); this.communicator = communicator; // Size the compositor before anything else is awaited: windows opened @@ -1513,7 +1517,10 @@ class DashboardController { // configure their surfaces through this.communicator, and the Java call // queue is FIFO, so enqueuing the screen size first guarantees it lands // ahead of them. Mirrors ensurePreviewDisplay. - await communicator.configureCompositorScreen(G2_LENS_WIDTH, G2_LENS_HEIGHT); + // The iO shows 540x220: the layout stays the G2's and is cropped at the right and + // bottom (geometry.ts pins the band to the top-left while an iO is configured). + if (glassesType === "rayneo-io") await communicator.configureCompositorScreen(RAYNEO_IO_WIDTH, RAYNEO_IO_HEIGHT); + else await communicator.configureCompositorScreen(G2_LENS_WIDTH, G2_LENS_HEIGHT); await communicator.configureBrightness(getBrightnessPreferences()); this.offState = communicator.onStateChange((state) => { if (state.phase !== "connected") resetRingInputFilter(); diff --git a/app/g2/even-advertisement.ts b/app/g2/even-advertisement.ts index 84a9c3c0..d974c87e 100644 --- a/app/g2/even-advertisement.ts +++ b/app/g2/even-advertisement.ts @@ -30,7 +30,7 @@ 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 type EvenDeviceRole = "left" | "right" | "ring" | "rayneo-io"; /** True when the manufacturer data opens with Even's `"ER"` marker. */ export function hasEvenManufacturerSignature(mfg: Uint8Array): boolean { @@ -71,6 +71,14 @@ export function extractG2AdvertisementFlag(mfg: Uint8Array): number | null { return mfg[22]!; } +/** RayNeo iO manufacturer data (company 0x5716, little-endian first): `[07][MAC x6]...`, outside pairing mode. */ +export const RAYNEO_COMPANY_IDENTIFIER = 0x5716; + +export function extractRayNeoMac(mfg: Uint8Array): string | null { + if (mfg.length < 9 || mfg[0] !== 0x16 || mfg[1] !== 0x57 || mfg[2] !== 0x07) return null; + return Array.from(mfg.subarray(3, 9), (byte) => byte.toString(16).padStart(2, "0").toUpperCase()).join(":"); +} + /** * Which side a G2 temple advertisement belongs to, from the local name. * Null when the name carries neither or both markers. @@ -230,8 +238,32 @@ export function classifyAdvertisement(raw: RawAdvertisement): EvenAdvertisement const hasSignature = hasEvenManufacturerSignature(mfg); const looksLikeRing = /^EVEN R1([_ ]|$)/.test(upper); const looksLikeG2 = upper.includes("G2"); + const rayneoMac = extractRayNeoMac(mfg); + const looksLikeRayNeo = upper.startsWith("RAYNEO") || rayneoMac !== null; - if (!looksLikeRing && !looksLikeG2 && !hasSignature) return null; + if (!looksLikeRing && !looksLikeG2 && !hasSignature && !looksLikeRayNeo) return null; + + if (looksLikeRayNeo && !hasSignature) { + const address = normalizeMacAddress(raw.address); + return { + address, + name, + role: "rayneo-io", + serial: null, + embeddedMac: rayneoMac, + embeddedMacMismatch: !!rayneoMac && rayneoMac !== address, + flag: null, + ringSerialSuffix: null, + rssi: raw.rssi, + txPower: raw.txPower, + connectable: raw.connectable, + bonded: raw.bonded, + source: raw.source, + seenAtMs: raw.seenAtMs, + manufacturerData: raw.manufacturerData ?? "", + note: null, + }; + } const base = { address: normalizeMacAddress(raw.address), diff --git a/app/g2/pairing-candidates.ts b/app/g2/pairing-candidates.ts index b891581a..05076a5b 100644 --- a/app/g2/pairing-candidates.ts +++ b/app/g2/pairing-candidates.ts @@ -21,7 +21,7 @@ import { type ProximityZone, } from "./ble-proximity"; import { classifyAdvertisement, normalizeMacAddress, type EvenAdvertisement, type RawAdvertisement } from "./even-advertisement"; -import { glassesImagePath, R1_IMAGE_PATH } from "./glasses-artwork"; +import { GENERIC_G2_IMAGE_PATH, glassesImagePath, R1_IMAGE_PATH } from "./glasses-artwork"; import { colorwayDisplayName, colorwaySwatchHex, @@ -56,6 +56,15 @@ export type GlassesPairCandidate = { mismatchWarning: string | null; }; +/** A RayNeo iO: one device, one address (no arms to join). */ +export type RayNeoCandidate = { + id: string; + advertisement: EvenAdvertisement; + rssi: number | null; + proximity: ProximityEstimate | null; + lastSeenMs: number; +}; + export type RingCandidate = { id: string; advertisement: EvenAdvertisement; @@ -176,7 +185,7 @@ export class DiscoveryAggregator { pairs(): GlassesPairCandidate[] { const groups = new Map(); for (const record of this.byAddress.values()) { - if (record.role === "ring") continue; + if (record.role === "ring" || record.role === "rayneo-io") continue; const canonical = serialKey(record.serial); const key = canonical ? `serial:${canonical}` : `arm:${record.address}`; const group = groups.get(key) ?? { left: null, right: null }; @@ -225,6 +234,22 @@ export class DiscoveryAggregator { } /** Every R1 ring seen, closest first. */ + rayneos(): RayNeoCandidate[] { + const found: RayNeoCandidate[] = []; + for (const record of this.byAddress.values()) { + if (record.role !== "rayneo-io") continue; + const rssi = record.smoothedRssi != null ? Math.round(record.smoothedRssi) : null; + found.push({ + id: `rayneo:${record.address}`, + advertisement: stripSmoothing(record), + rssi, + proximity: estimateProximity(rssi, GLASSES_CALIBRATION), + lastSeenMs: record.seenAtMs, + }); + } + return sortedByProximity(found, (candidate) => candidate.proximity, (candidate) => candidate.id); + } + rings(): RingCandidate[] { const rings: RingCandidate[] = []; for (const record of this.byAddress.values()) { @@ -281,7 +306,7 @@ export function isPreviouslyPaired(name: string | null | undefined, pairedSerial export type PairingRowPresentation = { id: string; - kind: "glasses" | "ring"; + kind: "glasses" | "ring" | "rayneo-io"; /** "Even G2 B" / "Even R1" / fallback product name. */ modelTitle: string; /** The serial (glasses) or local name (ring). */ @@ -416,6 +441,28 @@ export function ringRow(ring: RingCandidate, context: RowContext = {}): PairingR }; } +export function rayneoRow(candidate: RayNeoCandidate, context: { pairedAddress?: string; nearestId?: string | null } = {}): PairingRowPresentation { + const ad = candidate.advertisement; + const isPaired = !!context.pairedAddress && normalizeMacAddress(context.pairedAddress) === ad.address; + const isNearest = !!context.nearestId && context.nearestId === candidate.id; + const warnings: string[] = []; + if (ad.embeddedMacMismatch) warnings.push(`It advertises ${ad.embeddedMac} but was heard as ${ad.address}.`); + return { + id: candidate.id, + kind: "rayneo-io", + modelTitle: "RayNeo iO", + deviceName: ad.name || ad.address, + variantSummary: null, + colorway: null, + swatchHex: null, + imagePath: GENERIC_G2_IMAGE_PATH, + hasVariantImage: false, + ...presentationBase(candidate.proximity, isNearest, isPaired, warnings), + armsSummary: "Needs the Faceclaw custom firmware. First time: put it in pairing mode (on the charger, hold the button ~5 s until the light blinks blue).", + canSelect: true, + }; +} + /** Convenience: a colourway's display text, for rows that show the swatch alone. */ export function colorwayLabel(colorway: GlassesColorway | null): string { return colorway ? colorwayDisplayName(colorway) : ""; diff --git a/app/graphics/image.ts b/app/graphics/image.ts index f36a0dd7..f03c6f78 100644 --- a/app/graphics/image.ts +++ b/app/graphics/image.ts @@ -6,6 +6,9 @@ import { wrapText } from "./textwrap"; export const G2_LENS_WIDTH = 640; export const G2_LENS_HEIGHT = 480; +/** RayNeo iO screen (per eye) with the Faceclaw firmware: 540x220. */ +export const RAYNEO_IO_WIDTH = 540; +export const RAYNEO_IO_HEIGHT = 220; const DEFAULT_CORNER_RADIUS = 8; /** diff --git a/app/native/faceclaw-communicator.ios.ts b/app/native/faceclaw-communicator.ios.ts index 377dbe07..712a4da0 100644 --- a/app/native/faceclaw-communicator.ios.ts +++ b/app/native/faceclaw-communicator.ios.ts @@ -1,3 +1,4 @@ +import type { GlassesType } from "../ui/dashboard-settings"; import type { RingInput } from "../g2/ring-input"; import { File, knownFolders, path, type ImageSource } from "@nativescript/core"; import { REQUIRED_FACECLAW_FIRMWARE_VERSION, type FirmwareInfo } from "../g2/firmware-compat"; @@ -241,7 +242,10 @@ export class FaceclawCommunicatorBridge { return FaceclawCommunicatorBridge.active; } - constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string }) { + constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string; glassesType?: GlassesType }) { + if (addresses.glassesType === "rayneo-io") { + throw new Error("RayNeo iO glasses are not supported on iOS yet."); + } this.communicator = FaceclawKitIosGlassesSession.alloc().initWithRightAddressLeftAddressRingAddress( String(addresses.right ?? "").toUpperCase(), String(addresses.left ?? "").toUpperCase(), diff --git a/app/native/faceclaw-communicator.ts b/app/native/faceclaw-communicator.ts index 1f7f3965..80d13b24 100644 --- a/app/native/faceclaw-communicator.ts +++ b/app/native/faceclaw-communicator.ts @@ -1,3 +1,4 @@ +import type { GlassesType } from "../ui/dashboard-settings"; import type { RingInput } from "../g2/ring-input"; import { ImageSource, Utils } from "@nativescript/core"; import * as frameTimings from "./frame-timings"; @@ -161,7 +162,7 @@ export class FaceclawCommunicatorBridge { private readonly firmwareInfoListeners = new Set<(info: FirmwareInfo) => void>(); private readonly previewAnimationListeners = new Set<() => void>(); - constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string }) { + constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string; glassesType?: GlassesType }) { const context = Utils.android.getApplicationContext(); if (!context) throw new Error("Android application context unavailable"); @@ -173,6 +174,8 @@ export class FaceclawCommunicatorBridge { ); // The shared session halts on any other firmware ("incompatible-firmware"). this.communicator.setRequiredFirmwareRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION); + // RayNeo iO: one link (its address in both arm slots), its own handshake and page lease. + if (addresses.glassesType === "rayneo-io") this.communicator.useRayNeoIo(); // Which R1 role the direct ring link claims; only matters with a ring address. if (addresses.ringRole) this.communicator.setDirectRingRole(addresses.ringRole); this.listenerProxy = new com.faceclaw.app.FaceclawBleCommunicatorListener({ diff --git a/app/phone-ui/pairing-view-model.ts b/app/phone-ui/pairing-view-model.ts index 3323a20a..7336f44e 100644 --- a/app/phone-ui/pairing-view-model.ts +++ b/app/phone-ui/pairing-view-model.ts @@ -10,11 +10,14 @@ import { DiscoveryAggregator, glassesRow, nearestCandidateId, + rayneoRow, ringRow, type GlassesPairCandidate, type PairingRowPresentation, + type RayNeoCandidate, type RingCandidate, } from "../g2/pairing-candidates"; +import { glassesTypeSetting } from "../ui/dashboard-settings"; import { DeviceDiscoveryBridge } from "../native/device-discovery"; import { setPreviewOnlyMode } from "./onboarding-state"; @@ -65,6 +68,8 @@ export class PairingViewModel extends Observable { private _ringRows: PairingRowItem[] = []; private selectedPair: GlassesPairCandidate | null = null; private selectedRing: RingCandidate | null = null; + /** A RayNeo iO instead of a G2 pair (the two are exclusive). */ + private selectedIo: RayNeoCandidate | null = null; private readonly previouslyPairedSerial: string | null; private readonly previouslyPairedRing: string; @@ -181,7 +186,7 @@ export class PairingViewModel extends Observable { get instructions(): string { return ( - "Select your G2 glasses and R1 ring below. Wear the glasses or take them out of the case, " + + "Select your G2 glasses and R1 ring, or your RayNeo iO, below. Wear the glasses or take them out of the case, " + "and keep the glasses and phone nearby. If your glasses are not detected, make sure no other " + "apps are connected." ); @@ -249,11 +254,14 @@ export class PairingViewModel extends Observable { } get selectionVisibility(): "visible" | "collapse" { - return this.selectedPair || this.selectedRing ? "visible" : "collapse"; + return this.selectedPair || this.selectedRing || this.selectedIo ? "visible" : "collapse"; } get selectionSummary(): string { const parts: string[] = []; + if (this.selectedIo) { + parts.push(`RayNeo iO · ${this.selectedIo.advertisement.name} · ${this.selectedIo.advertisement.address}`); + } if (this.selectedPair) { const identity = this.selectedPair.identity; const label = identity ? identity.displayName : "Even Realities G2"; @@ -273,7 +281,7 @@ export class PairingViewModel extends Observable { } get primaryEnabled(): boolean { - return !!this.selectedPair || (!this.onboarding && !!this.selectedRing); + return !!this.selectedPair || !!this.selectedIo || (!this.onboarding && !!this.selectedRing); } get secondaryLabel(): string { @@ -287,7 +295,14 @@ export class PairingViewModel extends Observable { readonly onRowTap = (args: EventData): void => { const row = (args.object as View).bindingContext as PairingRowItem | undefined; if (!row) return; - if (row.kind === "glasses") { + if (row.kind === "rayneo-io") { + const io = this.aggregator.rayneos().find((candidate) => candidate.id === row.id) ?? null; + this.selectedIo = this.selectedIo?.id === io?.id ? null : io; + if (this.selectedIo) { + this.selectedPair = null; + this.selectedRing = null; + } + } else if (row.kind === "glasses") { const pair = this.aggregator.pairs().find((candidate) => candidate.id === row.id) ?? null; if (!pair) return; if (!row.canSelect) { @@ -295,14 +310,39 @@ export class PairingViewModel extends Observable { return; } this.selectedPair = this.selectedPair?.id === pair.id ? null : pair; + if (this.selectedPair) this.selectedIo = null; } else { const ring = this.aggregator.rings().find((candidate) => candidate.id === row.id) ?? null; this.selectedRing = this.selectedRing?.id === ring?.id ? null : ring; + if (this.selectedRing) this.selectedIo = null; } this.refresh(); }; onPrimaryTap(): void { + const io = this.selectedIo; + if (io) { + // One link: the same address stands for both arms; no ring. + const address = io.advertisement.address; + saveDeviceAddresses({ right: address, left: address, ring: "" }); + glassesTypeSetting.set("rayneo-io"); + savePairedGlassesIdentity({ + serial: io.advertisement.embeddedMac ?? address, + leftName: io.advertisement.name, + rightName: io.advertisement.name, + leftAddress: address, + rightAddress: address, + ringName: "", + ringAddress: "", + pairedAtMs: Date.now(), + }); + this.dispose(); + if (this.onboarding) setPreviewOnlyMode(false); + // The G2 firmware check/flash pages don't apply; the session reports + // incompatible firmware if the iO lacks the Faceclaw build. + finishOnboardingNavigation(); + return; + } const pair = this.selectedPair; const ring = this.selectedRing; if (!pair && !ring) return; @@ -317,6 +357,7 @@ export class PairingViewModel extends Observable { ring: ring?.advertisement.address ?? existing.ring, }; saveDeviceAddresses(addresses); + if (pair) glassesTypeSetting.set("g2"); if (pair) { savePairedGlassesIdentity({ serial: pair.serial ?? "", @@ -387,6 +428,10 @@ export class PairingViewModel extends Observable { this.aggregator.prune(Date.now(), DEFAULT_STALE_AFTER_MS); const pairs = this.aggregator.pairs(); const rings = this.aggregator.rings(); + const rayneos = this.aggregator.rayneos(); + if (this.selectedIo) { + this.selectedIo = rayneos.find((candidate) => candidate.id === this.selectedIo!.id) ?? null; + } // Keep the selection pointing at live data (addresses can only change if a // side was replaced); drop it if the pair disappeared — or if it degraded @@ -402,13 +447,24 @@ export class PairingViewModel extends Observable { const nearestPair = nearestCandidateId(pairs); const nearestRing = nearestCandidateId(rings); - this._glassesRows = pairs.map((pair) => - toRowItem( - glassesRow(pair, { pairedSerial: this.previouslyPairedSerial, nearestId: nearestPair }), - this.selectedPair?.id === pair.id, - this.onRowTap, + const pairedAddress = glassesTypeSetting.get() === "rayneo-io" ? loadDeviceAddresses().right : ""; + const nearestIo = nearestCandidateId(rayneos); + this._glassesRows = [ + ...rayneos.map((candidate) => + toRowItem( + rayneoRow(candidate, { pairedAddress, nearestId: nearestIo }), + this.selectedIo?.id === candidate.id, + this.onRowTap, + ), ), - ); + ...pairs.map((pair) => + toRowItem( + glassesRow(pair, { pairedSerial: this.previouslyPairedSerial, nearestId: nearestPair }), + this.selectedPair?.id === pair.id, + this.onRowTap, + ), + ), + ]; this._ringRows = rings.map((ring) => toRowItem( ringRow(ring, { pairedRingAddress: this.previouslyPairedRing, nearestId: nearestRing }), @@ -423,13 +479,14 @@ export class PairingViewModel extends Observable { this.status = `Scan failed: ${this.scanFailure}`; } else if (!this._scanning) { this.status = "Scan paused."; - } else if (!pairs.length && !rings.length) { + } else if (!pairs.length && !rings.length && !rayneos.length) { this.status = "Scanning…"; } else { const bits = [ complete ? `${complete} ${complete === 1 ? "pair" : "pairs"} ready` : null, partial ? `${partial} with one arm heard` : null, rings.length ? `${rings.length} ${rings.length === 1 ? "ring" : "rings"}` : null, + rayneos.length ? `${rayneos.length} RayNeo iO` : null, ].filter(Boolean); this.status = `Scanning… ${bits.join(" · ")}. Tap a pair to select it.`; } diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 69381c2e..b158c3fb 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -153,15 +153,19 @@ type ConfigSettingEnumOptions = Confi normalize?: (value: string | null | undefined) => TValue; /** Dynamic availability check used by enum picker rows. */ isDisabled?: (value: TValue) => boolean; + /** A value forced regardless of storage while it returns one (stored choice untouched). */ + pinned?: () => TValue | undefined; }; export class ConfigSettingEnum extends ConfigSetting { readonly values: readonly TValue[]; private readonly normalizer: (value: string | null | undefined) => TValue; private readonly disabledPredicate: (value: TValue) => boolean; + protected readonly pinned: (() => TValue | undefined) | undefined; constructor(options: ConfigSettingEnumOptions) { super(options); + this.pinned = options.pinned; if (options.reportInAnalytics !== false) fixedChoiceSettings.set(options.storageKey, this); this.values = options.values; this.disabledPredicate = options.isDisabled ?? (() => false); @@ -177,6 +181,8 @@ export class ConfigSettingEnum({ */ export type AppSwitcherPosition = "left" | "right" | "bottom" | "popup"; +/** Which glasses the saved addresses belong to (set by pairing; see g2/device-addresses.ts). */ +export type GlassesType = "g2" | "rayneo-io"; + +export const glassesTypeSetting = new ConfigSettingEnum({ + id: "glasses-type", + label: "Glasses", + storageKey: "deviceType", + defaultValue: "g2", + values: ["g2", "rayneo-io"], + reportInAnalytics: false, +}); + const APP_SWITCHER_POSITION_LABELS: Record = { left: "Left", right: "Right", @@ -380,6 +398,8 @@ export const appSwitcherPositionSetting = new ConfigSettingEnum (glassesTypeSetting.get() === "rayneo-io" ? "right" : undefined), formatValue: (value) => APP_SWITCHER_POSITION_LABELS[value] ?? value, description: "Where the open-app icons go. Left and right take a column beside windows; bottom puts a row beneath the window, which makes full-height windows a little shorter; popup shows them only while you're in the app switcher, in a box over the dimmed window. Bottom and popup leave room at the sides to set the display's depth. Open apps reopen at their new size when a change resizes windows.", @@ -395,6 +415,8 @@ class ConfigSettingEnumWithLegacy extends ConfigSettingEn } get(): TValue { + const pinned = this.pinned?.(); + if (pinned !== undefined) return pinned; return getStringSetting(this.storageKey, "") === "" ? this.legacyValue() : super.get(); } } @@ -456,6 +478,8 @@ export const displayLayoutSetting = new ConfigSettingEnumWithLegacy (glassesTypeSetting.get() === "rayneo-io" ? "band-top" : undefined), formatValue: displayLayoutLabel, isDisabled: (value) => value === "fullscreen" && !fullScreenAvailable(), description: diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwTransport.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwTransport.kt index 75d47d36..88c252fa 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwTransport.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwTransport.kt @@ -28,7 +28,18 @@ class CfwTransport(private val platform: ProtocolPlatform) { fun encode(message: ByteArray?, streamId: Int, lenses: Int, mtu: Int): List = lock.withLock { validate(message, streamId, lenses, mtu) - val input = message!! + g2Packets(encodeRecord(message!!, lenses), streamId, mtu) + } + + /** + * One record, `[flags][wire length u16][decoded CRC u16][body]`, compressed with this + * transport's persistent context. The packet envelope is the caller's: [encode] wraps it + * in G2 TPL packets, [RayNeoIoProtocol.cfwPackets] in RayNeo iO business-0xF0 packets. + */ + fun encodeRecord(message: ByteArray, lenses: Int): ByteArray = + lock.withLock { + require(message.size <= MAX_MESSAGE && lenses in 1..BOTH) { "invalid CFW record parameters" } + val input = message if (previousLenses != lenses) reset() val reset = resetPending val encoder = deflater ?: platform.createDeflater().also { deflater = it } @@ -44,7 +55,7 @@ class CfwTransport(private val platform: ProtocolPlatform) { resetPending = false previousLenses = lenses } - frameRecord(body, crc(input), streamId, flags, mtu) + record(body, crc(input), flags) } companion object { @@ -71,18 +82,12 @@ class CfwTransport(private val platform: ProtocolPlatform) { @JvmStatic fun frame(message: ByteArray?, streamId: Int, lenses: Int, mtu: Int): List { validate(message, streamId, lenses, mtu) - return frameRecord(message!!, crc(message), streamId, lenses or RESET_CONTEXT, mtu) + return g2Packets(record(message!!, crc(message), lenses or RESET_CONTEXT), streamId, mtu) } - private fun frameRecord( - body: ByteArray, - checksum: Int, - streamId: Int, - flags: Int, - mtu: Int, - ): List { - val lenses = flags and BOTH - val capacity = minOf(252, mtu - 14) + /** `[flags][wire length u16][decoded CRC u16][body]`, shared by every packet envelope. */ + @JvmStatic + fun record(body: ByteArray, checksum: Int, flags: Int): ByteArray { val stream = ByteArray(body.size + 5) stream[0] = flags.toByte() stream[1] = body.size.toByte() @@ -90,6 +95,13 @@ class CfwTransport(private val platform: ProtocolPlatform) { stream[3] = checksum.toByte() stream[4] = (checksum ushr 8).toByte() body.copyInto(stream, 5) + return stream + } + + /** G2 TPL packets (SID 0xf0) carrying one record: options byte = lenses | RESET | END. */ + private fun g2Packets(stream: ByteArray, streamId: Int, mtu: Int): List { + val lenses = stream[0].toInt() and BOTH + val capacity = minOf(252, mtu - 14) val packets = mutableListOf() for (offset in stream.indices step capacity) { val count = minOf(capacity, stream.size - offset) diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt index 5a3c0418..3e9a4463 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt @@ -4,6 +4,11 @@ package com.faceclaw.app * queued state and sensor freshness do not. Private commands are ordered with * frames, so wake starts on the intended PRESENT, never on an older black frame. */ internal fun GlassesSessionCore.enqueueBrightnessLocked(frameVisible: Boolean? = null) { + if (isIo) { + // The iO has no CFW brightness; ioMaintain drives the launcher's (and the screen) instead. + ioNoteFrameVisibleLocked(frameVisible) + return + } if (!customFirmwareDetected || !sessionReady || !fixedLayoutCreated || shutdownRequested) return val visible = frameVisible ?: brightnessSentVisible ?: return val target = brightnessPolicy.target diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt index 717f2004..31e2192f 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt @@ -345,6 +345,8 @@ internal fun GlassesSessionCore.releaseFaceclawFramebufferLease(): Boolean { /** The address of a configured arm the OS no longer holds a bond for, or null. */ internal fun GlassesSessionCore.firstUnpairedArm(): String? { + // The iO identifies the phone by its protocol id, not an OS bond. + if (isIo) return null if (!link.isBonded(rightAddress)) return rightAddress if (!link.isBonded(leftAddress)) return leftAddress return null diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index e0af63bb..a471bc4c 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -107,6 +107,11 @@ class GlassesSessionCore( @Volatile internal var listener: FaceclawBleCommunicatorListener? = null + /** G2 unless [useRayNeoIo] was called before [start]. */ + @Volatile internal var glassesType = GlassesType.G2 + /** RayNeo iO link state (GlassesSessionIo.kt); guarded by [monitor]. */ + internal val io = IoSessionState() + /** * Optional tap for relay frames the session does not interpret: notifications on the * right arm's data characteristic whose first two bytes are 'A','N' (the iOS ANCS @@ -543,6 +548,28 @@ class GlassesSessionCore( requiredFirmwareRevision = revision } + /** + * Drive a RayNeo iO instead of a G2: one BLE link (pass its address as both arms; no + * ring), the iO handshake and page lease, and the Faceclaw display lists of the + * faceclaw-rayneo-cfw firmware. [phoneId] is this phone's stable 6-byte protocol identity: + * the glasses bind to the first one that authenticates and refuse others until they are + * put in pairing mode. Call before [start]. + */ + fun useRayNeoIo(phoneId: ByteArray, phoneName: String, manufacturer: String, model: String) { + require(phoneId.size == 6) { "RayNeo iO phone id must be 6 bytes" } + require(rightAddress.equals(leftAddress, ignoreCase = true)) { "RayNeo iO uses one address for both arms" } + monitor.withLock { + glassesType = GlassesType.RAYNEO_IO + io.phoneId = phoneId.copyOf() + io.phoneName = phoneName.ifEmpty { "Faceclaw" } + io.manufacturer = manufacturer.ifEmpty { "Android" } + io.model = model.ifEmpty { "Android" } + } + } + + /** True when this session drives a RayNeo iO. */ + fun isRayNeoIo(): Boolean = isIo + /** Start the worker (through the host); false when it was already running. */ fun start(): Boolean { monitor.withLock { @@ -575,7 +602,7 @@ class GlassesSessionCore( * quiescing its producers. Also cover direct/early close callers here; * a successful cleanup must remain the final BLE message. Older CFWs * fall back to the standalone framebuffer-lease release. */ - if (!cfwCleanupDelivered && !sendCfwCleanup()) { + if (!cfwCleanupDelivered && !sendCfwCleanup() && !isIo) { releaseFaceclawFramebufferLease() } monitor.withLock { @@ -594,6 +621,14 @@ class GlassesSessionCore( host.joinWorker(5_000) ringDone?.await(5_000) ringWorkerDone = null + if (isIo && link.isConnected(rightAddress)) { + // Otherwise the blank page stays up until the firmware's 120 s lease runs out. + try { + ioWriteControl(RayNeoIoProtocol.CTRL_PAGE_CLOSE) + } catch (t: Throwable) { + logLine("RayNeo iO page close failed: " + safeMessage(t)) + } + } monitor.withLock { resetSessionStateLocked() clearAllMessagesLocked("disconnect") @@ -1533,6 +1568,7 @@ class GlassesSessionCore( // EvenHub page lifecycle fun sendShutdown(exitMode: Int): Boolean { + if (isIo) return ioSuspend() return sendShutdownInternal(exitMode, true) } @@ -1624,6 +1660,7 @@ class GlassesSessionCore( * reconnecting Bluetooth here would defeat the power-saving mode. */ fun suspendEvenHubSession(): Boolean { + if (isIo) return ioSuspend() // Ending the plugin task releases the fb lease, which frees the // on-glasses resource cache; forget it phone-side either way (a lost // ack may still have taken effect). @@ -1647,6 +1684,7 @@ class GlassesSessionCore( * the desired frame. */ fun resumeEvenHubSession(): Boolean { + if (isIo) return ioResume() var claimGeneration = 0 monitor.withLock { if (!running || !sessionReady || chargingMode) { @@ -1727,7 +1765,7 @@ class GlassesSessionCore( continue } logWarn("Attempting to connect") - connectLoopOnce() + if (isIo) ioConnectLoopOnce() else connectLoopOnce() continue } @@ -1754,6 +1792,10 @@ class GlassesSessionCore( return } val uuid = characteristicUuid.lowercase() + if (isIo) { + ioOnNotification(address, uuid, data) + return + } if (isDirectRingNotification(address, uuid)) { handleDirectRingNotification(uuid, data) return @@ -1768,28 +1810,7 @@ class GlassesSessionCore( if (data.size >= 7 && (data[6].toInt() and 255) == CfwTransport.SID) { val acks = CfwTransport.parseAcks(data) ?: return monitor.withLock { - lastIncomingAtMs = now() - val arm = armIndex(address) - if (arm >= 0) lastArmCfwAckAtMs[arm] = lastIncomingAtMs - for (ack in acks) { - for (message in inFlightMessages) { - val ingress = if (message.isLeftArmMessage) leftAddress else rightAddress - if (message.sid == CfwTransport.SID && address.equals(ingress, ignoreCase = true) && message.magic == ack.streamId) { - message.acceptCfwAck(ack) - if (ack.nack) ConnectionCounters.increment("g2.cfw-nack") - logLine("CFW " + (if (ack.nack) "NACK" else "ACK") + " id=" + ack.streamId - + " ordinal=" + ack.messageId + " lens=" + ack.lens + " txseq=" + (data[2].toInt() and 255) - + " redundant=" + (ack !== acks[0]) - + " size=" + ack.size + " crc=" + ack.checksum - + " expected=" + message.message.size + "/" + message.cfwChecksum - + " ackedLenses=" + message.cfwAckLenses - + " ageMs=" + (lastIncomingAtMs - message.sentAtMs)) - message.ackPayload = data.copyOf() - break - } - } - } - drainCfwAcknowledgementsLocked() + acceptCfwAcksLocked(address, acks, data[2].toInt() and 255, data) } interruptibleSleep.interrupt() return @@ -2106,6 +2127,35 @@ class GlassesSessionCore( } } + /** + * Apply CFW ACKs/NACKs from [address] (the G2's `aa 12` frames, or the iO's 9-byte bodies) + * to the in-flight messages they name, then complete what they finished. + */ + internal fun acceptCfwAcksLocked(address: String, acks: Array, txSeq: Int, payload: ByteArray) { + lastIncomingAtMs = now() + val arm = armIndex(address) + if (arm >= 0) lastArmCfwAckAtMs[arm] = lastIncomingAtMs + for (ack in acks) { + for (message in inFlightMessages) { + val ingress = if (message.isLeftArmMessage) leftAddress else rightAddress + if (message.sid == CfwTransport.SID && address.equals(ingress, ignoreCase = true) && message.magic == ack.streamId) { + message.acceptCfwAck(ack) + if (ack.nack) ConnectionCounters.increment("g2.cfw-nack") + logLine("CFW " + (if (ack.nack) "NACK" else "ACK") + " id=" + ack.streamId + + " ordinal=" + ack.messageId + " lens=" + ack.lens + " txseq=" + txSeq + + " redundant=" + (ack !== acks[0]) + + " size=" + ack.size + " crc=" + ack.checksum + + " expected=" + message.message.size + "/" + message.cfwChecksum + + " ackedLenses=" + message.cfwAckLenses + + " ageMs=" + (lastIncomingAtMs - message.sentAtMs)) + message.ackPayload = payload.copyOf() + break + } + } + } + drainCfwAcknowledgementsLocked() + } + override fun onConnectionStateChange(address: String?, connected: Boolean) { if (address == null) { return @@ -2141,11 +2191,14 @@ class GlassesSessionCore( monitor.withLock { if (address.equals(rightAddress, ignoreCase = true)) { rightConnected = connected + // The iO's one link stands for both arms. + if (isIo) leftConnected = connected } else if (address.equals(leftAddress, ignoreCase = true)) { leftConnected = connected } else { return } + if (!connected && isIo) io.reassembler.reset() if (!connected) { // Before the session is ready, this is an attempt failing (or an arm // dropping mid-setup): the connect sequence notices on its own and diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt new file mode 100644 index 00000000..eb4c83d1 --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt @@ -0,0 +1,544 @@ +package com.faceclaw.app + +import com.faceclaw.app.GlassesSessionCore.Companion.hex +import com.faceclaw.app.GlassesSessionCore.Companion.safeMessage +import kotlin.random.Random + +/** Which glasses a session drives. Set before [GlassesSessionCore.start]; see [GlassesSessionCore.useRayNeoIo]. */ +enum class GlassesType { G2, RAYNEO_IO } + +/** + * RayNeo iO session state ([GlassesSessionCore.io]); guarded by the core's monitor. + * + * The iO is one SoC on ONE BLE link that drives both eyes, so the core runs it with the same + * address in both arm slots: CFW messages keep going to the "left" arm, per-arm bookkeeping + * resolves to index 0, and the firmware ACKs each lens of a record separately, exactly what + * the existing window expects. What differs lives here: the AA55 envelope, the TLV handshake + * and guest authentication, IDENT-based capability detection, and the page lease + * (PAGE_OPEN + KEEPALIVE) that stands in for the G2's EvenHub page and framebuffer lease. + * Wire codecs: [RayNeoIoProtocol]; firmware: faceclaw-rayneo-cfw (docs/FACECLAW.md). + */ +internal class IoSessionState { + var phoneId = ByteArray(6) + var phoneName = "Faceclaw" + var manufacturer = "Android" + var model = "Android" + + val reassembler = RayNeoIoProtocol.FrameReassembler() + var messageNumber = Random.nextInt(0, 0x10000) + var launcherSequence = 0 + + var versionReply: RayNeoIoProtocol.VersionReply? = null + var authReply: ByteArray? = null + var ident: RayNeoIoProtocol.Ident? = null + var osVersion = "" + var maxChunk = RayNeoIoProtocol.DEFAULT_MAX_CHUNK + + /** Last PAGE state the glasses reported: 1 open, 0 closed, -1 none yet this link. */ + var pageState = -1 + var pageReason = 0 + var pageReplies = 0 + /** Whether the phone wants the page open (false while suspended or after the wearer closed it). */ + var pageWanted = true + var pageRequestSentAtMs = 0L + var lastKeepaliveAtMs = 0L + var lastStatusAtMs = 0L + var refusals = 0 + + /** Whether Faceclaw's latest frame is meant to be seen (false for its blanked frames). */ + var displayVisible = false + var brightnessSentLevel = -1 + var lastBrightnessAtMs = 0L + /** Last `screen_status` push: 1 on, 0 off, -1 unknown. */ + var screenStatus = -1 + + fun resetLink() { + reassembler.reset() + versionReply = null + authReply = null + ident = null + pageState = -1 + pageReason = 0 + pageRequestSentAtMs = 0 + lastKeepaliveAtMs = 0 + lastStatusAtMs = 0 + brightnessSentLevel = -1 + lastBrightnessAtMs = 0 + screenStatus = -1 + } +} + +internal object IoTimings { + const val VERSION_REPLY_MS = 4_000L + const val AUTH_REPLY_MS = 4_000L + const val OS_VERSION_MS = 1_500L + const val IDENT_MS = 3_000L + const val PAGE_REPLY_MS = 4_000L + /** Well inside the firmware's 120 s page lease. */ + const val KEEPALIVE_MS = 30_000L + const val STATUS_MS = 60_000L + const val PAGE_RETRY_MS = 3_000L + /** Retry cadence while the glasses refuse this phone id (waiting for pairing mode). */ + const val PAIRING_RETRY_MS = 2_000L + const val PAGE_REASON_USER = 4 + /** While Faceclaw shows content, re-assert the screen this often (the stock auto-off is short). */ + const val SCREEN_REFRESH_MS = 5_000L +} + +/** The glasses hung up at the version request: bound to another phone id, or not in pairing mode. */ +internal class IoPairingRefusedException : IllegalStateException("glasses hung up at the version request") + +/** CFW message types the iO firmware implements (fc_glue.c + raster cleanup). */ +internal fun ioSupportsCfwType(type: Int): Boolean = + type == CFW_MSG_CLEANUP || type == CFW_MSG_UPLOAD_RESOURCE || type == CFW_MSG_EVICT_RESOURCE || + type == CFW_MSG_DRAW_CALLS || type == CFW_MSG_SET_ROOT_DISPLAY_LIST || + type == CFW_MSG_PRESENT || type == CFW_MSG_CREATE_SURFACE + +internal val GlassesSessionCore.isIo: Boolean get() = glassesType == GlassesType.RAYNEO_IO + +/** Messages the iO cannot take (stock EvenHub/settings traffic, the G2's hardware CFW modes). */ +internal fun GlassesSessionCore.ioSupportsMessage(message: OutboundMessage): Boolean = + message.sid == CfwTransport.SID && message.message.isNotEmpty() && ioSupportsCfwType(message.message[0].toInt() and 255) + +// --------------------------------------------------------------------------------------------- +// Writes + +private fun GlassesSessionCore.ioNextMessageNumberLocked(): Int { + val n = io.messageNumber and 0xffff + io.messageNumber = (io.messageNumber + 1) and 0xffff + return n +} + +/** One AA55 frame on the iO write characteristic; worker thread, outside the monitor. */ +internal fun GlassesSessionCore.ioWriteFrame(business: Int, payload: ByteArray): Boolean { + val frame = monitor.withLock { RayNeoIoProtocol.encodeFrame(ioNextMessageNumberLocked(), business, payload) } + return link.writeFrames( + rightAddress, RayNeoIoBle.WRITE_CHAR_UUID, + RayNeoIoProtocol.writes(frame, link.negotiatedMtu(rightAddress)), + GattWriteMode.WITHOUT_RESPONSE, ConnectionOptions.WRITE_TIMEOUT_MS, + ) +} + +internal fun GlassesSessionCore.ioWriteControl(ctrl: Int): Boolean = + ioWriteFrame(RayNeoIoProtocol.BUSINESS_CFW, RayNeoIoProtocol.controlPacket(ctrl)) + +private fun GlassesSessionCore.ioWriteLauncher(type: Int, json: String): Boolean { + val sequence = monitor.withLock { + io.launcherSequence = if (io.launcherSequence >= 0xffff) 1 else io.launcherSequence + 1 + io.launcherSequence + } + val envelope = RayNeoIoProtocol.Envelope(type, json, sequence = sequence, mode = RayNeoIoProtocol.MODE_REQUEST) + return ioWriteFrame(RayNeoIoProtocol.BUSINESS_LAUNCHER, RayNeoIoProtocol.encodeEnvelope(envelope)) +} + +internal fun GlassesSessionCore.ioRequestStatus(): Boolean = + ioWriteLauncher(RayNeoIoProtocol.LAUNCHER_GENERAL_STATUS, RayNeoIoProtocol.GENERAL_STATUS_REQUEST) + +/** From the image path (enqueueBrightnessLocked): a visible frame wakes the screen at once. */ +internal fun GlassesSessionCore.ioNoteFrameVisibleLocked(frameVisible: Boolean?) { + if (frameVisible == null) return + if (frameVisible && !io.displayVisible) io.lastBrightnessAtMs = 0 + io.displayVisible = frameVisible +} + +/** + * The writes for one queued CFW message: the shared record (persistent deflate context, as + * on the G2) in `[opt][stream][chunk]` packets, each its own AA55 frame. The stream byte is + * the message's magic, which the firmware echoes in its per-lens ACKs. + */ +internal fun GlassesSessionCore.ioCfwWrites(message: OutboundMessage, mtu: Int): List { + val transport = cfwTransports[0] + if (message.cfwRetries > 0) transport.reset() + val record = transport.encodeRecord(message.message, CfwTransport.BOTH) + return monitor.withLock { + RayNeoIoProtocol.cfwPackets(record, message.magic, io.maxChunk).flatMap { packet -> + RayNeoIoProtocol.writes(RayNeoIoProtocol.encodeFrame(ioNextMessageNumberLocked(), RayNeoIoProtocol.BUSINESS_CFW, packet), mtu) + } + } +} + +/** A message the iO can't run (see [ioSupportsMessage]): never sent, never waited on. */ +internal fun GlassesSessionCore.ioDropUnsupported(message: OutboundMessage) { + monitor.withLock { + inFlightMessages.remove(message) + if (message.magic != 0) magicPool.release(message.sid, message.magic, message.label, "unsupported on RayNeo iO") + } + logDebug("RayNeo iO: dropped unsupported message " + message.label + " sid=" + message.sid) +} + +// --------------------------------------------------------------------------------------------- +// Connect (worker thread) + +private fun GlassesSessionCore.ioAwait(timeoutMs: Long, what: String, ready: () -> Boolean) { + val deadline = now() + timeoutMs + monitor.withLock { + while (true) { + if (ready()) return + if (!running || userDisconnectRequested) throw IllegalStateException("stopped while waiting for $what") + if (!rightConnected) throw IoLinkLostException(what) + val remaining = deadline - now() + if (remaining <= 0) throw IllegalStateException("$what timed out") + monitor.awaitMs(minOf(remaining, 100L)) + } + } +} + +private class IoLinkLostException(what: String) : IllegalStateException("link lost while waiting for $what") + +internal fun GlassesSessionCore.ioConnectLoopOnce() { + monitor.withLock { + wearState = -1 + io.resetLink() + } + setStateDisplay("connecting", "Connecting to the glasses...") + ConnectionCounters.increment("io.connect-attempt") + val address = rightAddress + try { + if (!link.connect(address, ConnectionOptions.ARM_CONNECT_WINDOW_MS)) { + handleTransportFailure("glasses not found", "Can't find the glasses. They may be off, in their case, or out of range.") + return + } + link.requestHighPriority(address) + link.requestMtu(address, RayNeoIoBle.REQUESTED_MTU, ConnectionOptions.CONNECT_TIMEOUT_MS) + if (!link.discoverServices(address, ConnectionOptions.SERVICES_TIMEOUT_MS)) throw IllegalStateException("discoverServices failed: $address") + if (!link.enableNotifications(address, RayNeoIoBle.NOTIFY_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS)) { + throw IllegalStateException("enableNotifications failed: $address") + } + link.requestLe2mPhy(address) + monitor.withLock { + rightConnected = true + leftConnected = true + } + + // Version exchange. Glasses bound to another phone id (or not in pairing mode) + // hang up ~100 ms after this request instead of answering. + val phone = monitor.withLock { io.phoneId.copyOf() } + logDebug("RayNeo iO: phone id " + hex(phone)) + if (!ioWriteFrame(RayNeoIoProtocol.BUSINESS_HANDSHAKE, + RayNeoIoProtocol.versionRequest(phone, io.phoneName, io.manufacturer, io.model))) { + throw IllegalStateException("version request write failed") + } + try { + ioAwait(IoTimings.VERSION_REPLY_MS, "version reply") { io.versionReply != null } + } catch (lost: IoLinkLostException) { + throw IoPairingRefusedException() + } + val reply = monitor.withLock { io.versionReply!! } + if (reply.accountBound) throw IoPairingRefusedException() + logLine("RayNeo iO: glasses " + hex(reply.glassesId) + " serial " + reply.serial + " protocol " + reply.protocolVersion) + + val random = Random.nextBytes(4) + if (!ioWriteFrame(RayNeoIoProtocol.BUSINESS_HANDSHAKE, RayNeoIoProtocol.guestAuthRequest(random, phone, reply.glassesId))) { + throw IllegalStateException("guest auth write failed") + } + ioAwait(IoTimings.AUTH_REPLY_MS, "guest auth reply") { io.authReply != null } + val authReply = monitor.withLock { io.authReply!! } + if (!RayNeoIoProtocol.verifyGuestAuthReply(authReply, phone, reply.glassesId)) { + throw IllegalStateException("guest auth proof mismatch") + } + monitor.withLock { io.refusals = 0 } + + // Battery and the OS version: answers arrive asynchronously; the version only labels + // the firmware info, so a missing one is not fatal. + ioRequestStatus() + ioWriteFrame(RayNeoIoProtocol.BUSINESS_OTA, + RayNeoIoProtocol.encodeEnvelope(RayNeoIoProtocol.Envelope(RayNeoIoProtocol.OTA_VERSION, "{}"))) + try { + ioAwait(IoTimings.OS_VERSION_MS, "OS version") { io.osVersion.isNotEmpty() } + } catch (e: IoLinkLostException) { + throw e + } catch (_: IllegalStateException) { + } + + // Capability: the custom firmware answers QUERY with IDENT; stock firmware stays silent. + ioWriteControl(RayNeoIoProtocol.CTRL_QUERY) + val ident = try { + ioAwait(IoTimings.IDENT_MS, "IDENT") { io.ident != null } + monitor.withLock { io.ident } + } catch (e: IoLinkLostException) { + throw e + } catch (_: IllegalStateException) { + null + } + val os = monitor.withLock { io.osVersion.ifEmpty { "RayNeo iO" } } + val info = BleProtocol.FirmwareInfo(os, os, + if (ident != null && ident.faceclaw) "Faceclaw/" + ident.faceclawRevision else "") + logLine("RayNeo iO: " + os + ", " + (if (ident == null) "no IDENT (stock firmware)" + else ident.name + " " + ident.width + "x" + ident.height + " chunk " + ident.maxChunk + + " flags 0x" + ident.flags.toString(16) + " faceclaw " + ident.faceclawRevision)) + emitFirmwareInfo(info) + if (!info.isCompatible(requiredFirmwareRevision)) { + monitor.withLock { + // The worker loop halts on this and explains it (handleIncompatibleFirmware). + incompatibleFirmware = info + } + return + } + monitor.withLock { + io.maxChunk = ident!!.maxChunk.coerceIn(16, 4000) + io.pageWanted = true + io.pageRequestSentAtMs = now() + } + + ioWriteControl(RayNeoIoProtocol.CTRL_PAGE_OPEN) + try { + ioAwait(IoTimings.PAGE_REPLY_MS, "page open") { io.pageReplies > 0 } + } catch (e: IoLinkLostException) { + throw e + } catch (_: IllegalStateException) { + // The launcher may be busy; ioMaintain keeps asking. + } + + monitor.withLock { + sessionReady = true + shutdownRequested = false + customFirmwareDetected = true + clearAllMessagesLocked("session ready") + fixedLayoutCreated = io.pageState == 1 + displayedFingerprint = "" + lastAckAtMs = now() + lastIncomingAtMs = lastAckAtMs + lastConnectionOrInputAtMs = lastAckAtMs + lastSessionReadyAtMs = lastAckAtMs + imageRetryAfterMs = 0 + consecutiveAckTimeouts = 0 + cfwCleanupDelivered = false + lastCfwCleanupAckMagic = 0 + for (transport in cfwTransports) transport.reset() + io.lastKeepaliveAtMs = lastAckAtMs + io.lastStatusAtMs = lastAckAtMs + } + setStateDisplay("connected", "Connected.") + ConnectionCounters.increment("io.session-ready") + logLine("RayNeo iO session ready (page " + (if (fixedLayoutCreated) "open" else "pending") + ")") + } catch (refused: IoPairingRefusedException) { + val count = monitor.withLock { + io.refusals++ + reconnectAfterMs = now() + IoTimings.PAIRING_RETRY_MS + io.refusals + } + ConnectionCounters.increment("io.pairing-refused") + logLine("RayNeo iO refused this phone (" + count + "); waiting for pairing mode") + link.disconnect(address) + monitor.withLock { + rightConnected = false + leftConnected = false + } + setStateDisplay("retrying", + "The glasses aren't accepting this phone yet. Put them in pairing mode: on the charger, " + + "hold the button about 5 seconds until the light blinks blue.") + } catch (t: Throwable) { + logLine("RayNeo iO connect failed: " + safeMessage(t)) + handleTransportFailure("connect failed") + } +} + +// --------------------------------------------------------------------------------------------- +// Session upkeep (worker thread, from driveSession, outside the monitor) + +/** Page open/close requests, keepalives, status polls and the screen (launcher brightness). */ +internal fun GlassesSessionCore.ioMaintain() { + var ctrl = -1 + var status = false + var brightness = -1 + monitor.withLock { + if (!sessionReady) return + val now = now() + if (io.pageWanted && !fixedLayoutCreated && now - io.pageRequestSentAtMs >= IoTimings.PAGE_RETRY_MS) { + ctrl = RayNeoIoProtocol.CTRL_PAGE_OPEN + io.pageRequestSentAtMs = now + } else if (!io.pageWanted && io.pageState == 1 && now - io.pageRequestSentAtMs >= IoTimings.PAGE_RETRY_MS) { + ctrl = RayNeoIoProtocol.CTRL_PAGE_CLOSE + io.pageRequestSentAtMs = now + } else if (io.pageWanted && fixedLayoutCreated && now - io.lastKeepaliveAtMs >= IoTimings.KEEPALIVE_MS) { + ctrl = RayNeoIoProtocol.CTRL_KEEPALIVE + io.lastKeepaliveAtMs = now + } + if (now - io.lastStatusAtMs >= IoTimings.STATUS_MS) { + status = true + io.lastStatusAtMs = now + } + // Faceclaw decides when the display is dark (blanked frames); while it shows + // content, keep the iO's screen on and at Faceclaw's brightness. + val level = RayNeoIoProtocol.brightnessLevel(brightnessPolicy.target) + if (fixedLayoutCreated && io.pageWanted && io.displayVisible && !shutdownRequested + && (level != io.brightnessSentLevel || now - io.lastBrightnessAtMs >= IoTimings.SCREEN_REFRESH_MS)) { + brightness = level + io.brightnessSentLevel = level + io.lastBrightnessAtMs = now + } + } + if (ctrl >= 0) { + logDebug("RayNeo iO: control $ctrl") + ioWriteControl(ctrl) + } + if (status) ioRequestStatus() + if (brightness > 0) ioWriteLauncher(RayNeoIoProtocol.LAUNCHER_BRIGHTNESS, RayNeoIoProtocol.launcherBrightness(brightness)) +} + +/** Stop drawing and close the page, keeping the BLE link (the EvenHub suspend analogue). */ +internal fun GlassesSessionCore.ioSuspend(): Boolean { + monitor.withLock { + if (!running || !sessionReady) return false + shutdownRequested = true + io.pageWanted = false + io.pageRequestSentAtMs = 0 + clearAllMessagesLocked("RayNeo iO suspend") + displayedFingerprint = "" + } + interruptibleSleep.interrupt() + return true +} + +/** Reopen the page; the drive loop resends the desired frame once it is open. */ +internal fun GlassesSessionCore.ioResume(): Boolean { + monitor.withLock { + if (!running || !sessionReady) return false + shutdownRequested = false + io.pageWanted = true + io.pageRequestSentAtMs = 0 + fixedLayoutCreated = false + clearAllMessagesLocked("RayNeo iO resume") + displayedFingerprint = "" + imageRetryAfterMs = 0 + } + interruptibleSleep.interrupt() + return true +} + +// --------------------------------------------------------------------------------------------- +// Inbound (BLE callback thread) + +internal fun GlassesSessionCore.ioOnNotification(address: String, characteristicUuid: String, data: ByteArray) { + if (RayNeoIoBle.NOTIFY_CHAR_UUID != characteristicUuid || !address.equals(rightAddress, ignoreCase = true)) return + val frames = monitor.withLock { io.reassembler.ingest(data) } + for (frame in frames) { + when (frame.business) { + RayNeoIoProtocol.BUSINESS_HANDSHAKE -> monitor.withLock { + val version = RayNeoIoProtocol.parseVersionReply(frame.payload) + if (version != null) io.versionReply = version + else if (RayNeoIoProtocol.isGuestAuthReply(frame.payload)) io.authReply = frame.payload + monitor.signalAll() + } + RayNeoIoProtocol.BUSINESS_LAUNCHER -> ioHandleLauncher(frame.payload) + RayNeoIoProtocol.BUSINESS_OTA -> { + val envelope = RayNeoIoProtocol.decodeEnvelope(frame.payload) ?: continue + if (envelope.type != RayNeoIoProtocol.OTA_VERSION) continue + val os = try { Json.parse(envelope.json).asObject()?.get("OsVersion").asString() } catch (_: Exception) { null } + if (os != null) monitor.withLock { + io.osVersion = os + monitor.signalAll() + } + } + RayNeoIoProtocol.BUSINESS_CFW -> ioHandleCfw(address, frame) + } + } +} + +private fun GlassesSessionCore.ioHandleLauncher(payload: ByteArray) { + val envelope = RayNeoIoProtocol.decodeEnvelope(payload) ?: return + val screen = RayNeoIoProtocol.screenStatusFromLauncherJson(envelope.json) + if (screen >= 0) { + val changed = monitor.withLock { + val was = io.screenStatus + io.screenStatus = screen + // Woken by the wearer (or the timeout ran out): re-assert promptly if Faceclaw is showing. + if (screen == 0) io.lastBrightnessAtMs = 0 + was != screen + } + if (changed) logLine("RayNeo iO screen " + (if (screen == 1) "on" else "off")) + return + } + val battery = RayNeoIoProtocol.batteryFromLauncherJson(envelope.json) + if (battery < 0) return + val charging = if (envelope.json.contains("\"isCharging\":true")) 1 else if (envelope.json.contains("\"isCharging\":false")) 0 else -1 + var changed = false + monitor.withLock { + lastIncomingAtMs = now() + if (battery != headsetBattery || (charging >= 0 && charging != headsetCharging)) { + headsetBattery = battery + if (charging >= 0) headsetCharging = charging + changed = true + } + } + if (changed) emitBatteryState(headsetBattery, headsetCharging) +} + +private fun GlassesSessionCore.ioHandleCfw(address: String, frame: RayNeoIoProtocol.Frame) { + val payload = frame.payload + if (payload.isEmpty()) return + when (payload[0].toInt() and 255) { + RayNeoIoProtocol.KIND_ACK, RayNeoIoProtocol.KIND_NACK -> { + val ack = RayNeoIoProtocol.parseCfwAck(payload) ?: return + monitor.withLock { + acceptCfwAcksLocked(address, arrayOf(ack), frame.messageNumber and 255, payload) + } + interruptibleSleep.interrupt() + } + RayNeoIoProtocol.KIND_IDENT -> monitor.withLock { + io.ident = RayNeoIoProtocol.parseIdent(payload) + monitor.signalAll() + } + RayNeoIoProtocol.KIND_PAGE -> ioHandlePage(payload) + RayNeoIoProtocol.KIND_GESTURE -> ioHandleGesture(RayNeoIoProtocol.parseGesture(payload) ?: return) + else -> logDebug("RayNeo iO: CFW reply kind " + (payload[0].toInt() and 255) + " " + hex(payload.copyOf(minOf(payload.size, 24)))) + } +} + +private fun GlassesSessionCore.ioHandlePage(payload: ByteArray) { + val state = RayNeoIoProtocol.parsePageState(payload) + val reason = if (payload.size >= 3) payload[2].toInt() and 255 else 0 + var lost = false + monitor.withLock { + io.pageState = state + io.pageReason = reason + io.pageReplies++ + lastIncomingAtMs = now() + if (state == 1) { + if (io.pageWanted && !fixedLayoutCreated && sessionReady) { + // (Re)opened: the drive loop resends the desired frame from scratch. + fixedLayoutCreated = true + displayedFingerprint = "" + imageRetryAfterMs = 0 + io.lastKeepaliveAtMs = now() + io.lastBrightnessAtMs = 0 + } + } else if (state == 0 && fixedLayoutCreated) { + // The page closed under us (lease, the wearer's long press): the firmware freed + // this session's resources, so start over once it reopens. + lost = true + fixedLayoutCreated = false + clearAllMessagesLocked("RayNeo iO page closed (reason $reason)") + displayedFingerprint = "" + if (reason == IoTimings.PAGE_REASON_USER) io.pageWanted = false + io.pageRequestSentAtMs = now() + } + monitor.signalAll() + } + if (lost) logLine("RayNeo iO page closed by the glasses (reason $reason)") + interruptibleSleep.interrupt() +} + +private fun GlassesSessionCore.ioHandleGesture(gesture: RayNeoIoProtocol.Gesture) { + val event: G2Event? = when (gesture.eventType) { + // Same numbering as the G2's OsEventTypeList; head up wakes like the G2 CFW's forward. + BleProtocol.EVENT_HEAD_UP -> G2Event("display-wake", "", BleProtocol.EVENT_HEAD_UP, BleProtocol.EVENT_SOURCE_GLASSES_R, 0) + BleProtocol.EVENT_HEAD_DOWN -> null + else -> G2Event("sys-event", "", gesture.eventType, BleProtocol.EVENT_SOURCE_GLASSES_R, 0) + } + monitor.withLock { + lastIncomingAtMs = now() + if (event != null) lastConnectionOrInputAtMs = lastIncomingAtMs + if (event != null && "sys-event" == event.kind && !io.pageWanted && sessionReady) { + // The wearer touched the glasses after closing our page: take it back. + io.pageWanted = true + shutdownRequested = false + io.pageRequestSentAtMs = 0 + } + } + logLine("RayNeo iO gesture type=" + gesture.eventType + " source=" + gesture.source + (if (event == null) " (ignored)" else "")) + if (event == null) return + val frameId = frameTimings.startFrame("input:" + event.kind + " type=" + event.eventType + " src=" + event.eventSource) + frameTimings.log(frameId, "input event decoded from RayNeo iO notification") + emitRingEvent(event, frameId) +} diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt index c1aa34a2..a935f0ce 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt @@ -44,6 +44,7 @@ internal fun GlassesSessionCore.driveSession(): Long { benchmarkReadyAtMs = now() + 1_000 } } + if (isIo) ioMaintain() var messageToWrite: OutboundMessage? = null var messageToPrewrite: OutboundMessage? = null var heartbeatToWrite: OutboundMessage? = null @@ -64,7 +65,7 @@ internal fun GlassesSessionCore.driveSession(): Long { clearPendingMessagesLocked("after CFW cleanup") return 250 } - if (sessionReady + if (sessionReady && !isIo && now - lastFaceclawFramebufferLeaseQueuedAtMs >= FACECLAW_WAKE_LEASE_RENEW_MS && !hasPendingOrInflightKindLocked("framebuffer-lease-control")) { enqueueFaceclawFramebufferControlLocked( @@ -73,7 +74,7 @@ internal fun GlassesSessionCore.driveSession(): Long { ) } if (faceclawWakeLeaseEnabled - && sessionReady + && sessionReady && !isIo && now - lastFaceclawWakeLeaseQueuedAtMs >= FACECLAW_WAKE_LEASE_RENEW_MS && !hasPendingOrInflightKindLocked("wake-lease-control")) { enqueueFaceclawWakeControlLocked( @@ -148,6 +149,7 @@ internal fun GlassesSessionCore.driveSession(): Long { } } else { if (messageToPrewrite == null + && !isIo // the iO's page lease is ioMaintain's && !shutdownRequested && !fixedLayoutCreated && pendingMessages.isEmpty() @@ -158,14 +160,14 @@ internal fun GlassesSessionCore.driveSession(): Long { // Prewrite outside the lock; the logical message remains pending until // its final BLE frame is sent after the current protocol ACK. } - if (messageToPrewrite == null && !shutdownRequested && fixedLayoutCreated + if (messageToPrewrite == null && !isIo && !shutdownRequested && fixedLayoutCreated && (if (firmwareDebugFlagsEnabled) 2 else 1) != firmwareDebugFlagsLastSent && pendingMessages.isEmpty() && inFlightMessages.isEmpty()) { logLine("enqueueing firmware debug flags " + (if (firmwareDebugFlagsEnabled) "show" else "hide")) enqueueFirmwareDebugFlagsLocked() } - if (messageToPrewrite == null && !shutdownRequested && fixedLayoutCreated + if (messageToPrewrite == null && !isIo && !shutdownRequested && fixedLayoutCreated && (if (compassOwners.isEmpty()) 0 else 1) != compassControlLastSent && pendingMessages.isEmpty() && inFlightMessages.isEmpty()) { val wanted = compassOwners.isNotEmpty() @@ -176,7 +178,7 @@ internal fun GlassesSessionCore.driveSession(): Long { if (benchmarkActive) { maintainBenchmarkLocked(now) } - if (!benchmarkActive) maintainBrightnessLocked(now) + if (!benchmarkActive && !isIo) maintainBrightnessLocked(now) // Up to WINDOW_SIZE messages may be in flight at once (full // pipelining); a slot frees when an ack arrives. An active @@ -319,6 +321,7 @@ internal enum class HeartbeatStep { } internal fun GlassesSessionCore.heartbeatStepLocked(imageWaiting: Boolean): HeartbeatStep { + if (isIo) return HeartbeatStep.NONE val now = now() val heartbeatEligible = !shutdownRequested && fixedLayoutCreated val heartbeatPending = heartbeatEligible && hasPendingOrInflightKindLocked("heartbeat") @@ -369,6 +372,12 @@ internal fun GlassesSessionCore.createHeartbeatMessage(): OutboundMessage { } internal fun GlassesSessionCore.writeMessage(message: OutboundMessage): Boolean { + if (isIo && !ioSupportsMessage(message)) { + // G2-only traffic (EvenHub/settings frames, the G2 hardware CFW modes) that a feature + // queued anyway: the iO would NACK it into the replay limit, so it never goes out. + ioDropUnsupported(message) + return true + } val now = now() message.writeStartedAtMs = now message.sentAtMs = now @@ -398,6 +407,8 @@ internal fun GlassesSessionCore.writeMessage(message: OutboundMessage): Boolean frames = listOf(prewrittenFrames[prewrittenFrames.size - 1]) prewrittenMessage = null prewrittenFrames = emptyList() + } else if (isIo) { + frames = ioCfwWrites(message, link.negotiatedMtu(writeAddress)) } else if (message.sid == CfwTransport.SID) { if (message.cfwRetries > 0) cfwTransports[if (message.isLeftArmMessage) 0 else 1].reset() frames = cfwTransports[if (message.isLeftArmMessage) 0 else 1].encode( @@ -413,9 +424,9 @@ internal fun GlassesSessionCore.writeMessage(message: OutboundMessage): Boolean } val result = link.writeFrames( writeAddress, - BleProtocol.WRITE_CHAR_UUID, + if (isIo) RayNeoIoBle.WRITE_CHAR_UUID else BleProtocol.WRITE_CHAR_UUID, frames, - ConnectionOptions.WRITE_MODE, + if (isIo) GattWriteMode.WITHOUT_RESPONSE else ConnectionOptions.WRITE_MODE, ConnectionOptions.WRITE_TIMEOUT_MS ) @@ -1019,7 +1030,8 @@ internal fun GlassesSessionCore.createAudioControlMessageLocked(enable: Boolean) } internal fun GlassesSessionCore.shouldPollBatteryLocked(now: Long): Boolean { - return !shutdownRequested + return !isIo // the iO's status polls are ioMaintain's + && !shutdownRequested && sessionReady && pendingMessages.isEmpty() && inFlightMessages.isEmpty() diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt new file mode 100644 index 00000000..c525bc15 --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt @@ -0,0 +1,469 @@ +package com.faceclaw.app + +import kotlin.jvm.JvmField +import kotlin.jvm.JvmStatic + +/** + * RayNeo iO wire codecs (stock link plus the Faceclaw custom-firmware link). Pure functions + * and small value types; no I/O, threads or platform APIs. + * + * The iO is one SoC driving both eyes over ONE BLE connection. Everything travels in AA55 + * frames on one write characteristic and one notify characteristic; the frame's "business" + * byte selects the subsystem: 0x10 handshake (TLV), 9 OTA and 13..22 apps (protobuf-style + * envelope + JSON), 0xF0 the custom-firmware link. The CFW link carries Faceclaw's G2 records + * unchanged (see [CfwTransport.encodeRecord]) inside `[opt][stream][chunk]` packets, and the + * firmware answers with the G2's 9-byte ACK body, one ACK per targeted lens. + * + * Protocol knowledge from the MIT-licensed Glassly SDK and CFW (tetramo-labs/glassly, + * tetramo-labs/glassly-rayneo-cfw); the Faceclaw firmware fork documents its additions in + * faceclaw-rayneo-cfw/docs/FACECLAW.md. + */ +object RayNeoIoBle { + const val SERVICE_UUID = "0000b81d-0000-1000-8000-00805f9b34fb" + /** Phone -> glasses, write without response. */ + const val WRITE_CHAR_UUID = "ea8b70d5-2bd3-49ab-9c31-9c38b2c3c4f9" + /** Glasses -> phone, notifications. */ + const val NOTIFY_CHAR_UUID = "7db3e235-3608-41f3-a03c-955fcbd2ea4b" + const val REQUESTED_MTU = 512 + /** Advertised manufacturer data company id; the payload is `[07][MAC x6]...` (not in pairing mode). */ + const val MANUFACTURER_ID = 0x5716 + + @JvmStatic fun matchesName(name: String?): Boolean = name != null && name.contains("rayneo", ignoreCase = true) + + /** The glasses' MAC ("00:6A:5E:5F:33:C2") from manufacturer data, or null. */ + @JvmStatic + fun macFromManufacturerData(data: ByteArray?): String? { + if (data == null || data.size < 7 || data[0].toInt() != 7) return null + return (1..6).joinToString(":") { i -> (data[i].toInt() and 255).toString(16).padStart(2, '0').uppercase() } + } +} + +object RayNeoIoProtocol { + const val BUSINESS_OTA = 9 + const val BUSINESS_LAUNCHER = 15 + const val BUSINESS_HANDSHAKE = 0x10 + const val BUSINESS_CFW = 0xf0 + + const val FRAME_OVERHEAD = 10 + const val MIN_FRAME_BYTES = 10 + + /** Program constant of the stock app's guest authentication (not a secret). */ + private val SALT = byteArrayOf( + 0x07, 0x12, 0xc8.toByte(), 0xad.toByte(), 0x27, 0x74, 0x41, 0x95.toByte(), + 0xde.toByte(), 0x5f, 0xa1.toByte(), 0xea.toByte(), 0x6d, 0x02, 0x5f, 0xb8.toByte(), + ) + + // ---- CRC-16/XMODEM (poly 0x1021, init 0) ----------------------------------------------- + + @JvmStatic + fun crc16Xmodem(bytes: ByteArray, from: Int = 0, to: Int = bytes.size): Int { + var crc = 0 + for (i in from until to) { + crc = crc xor ((bytes[i].toInt() and 255) shl 8) + repeat(8) { crc = if (crc and 0x8000 != 0) ((crc shl 1) xor 0x1021) and 0xffff else (crc shl 1) and 0xffff } + } + return crc + } + + // ---- AA55 frames -------------------------------------------------------------------------- + + class Frame( + @JvmField val messageNumber: Int, + @JvmField val packetType: Int, + @JvmField val business: Int, + @JvmField val payload: ByteArray, + ) + + /** `AA 55 [len u16 BE = total-6] [msg u16 BE] [packetType] [business] payload [crc16 BE of bytes 4..end-2]`. */ + @JvmStatic + fun encodeFrame(messageNumber: Int, business: Int, payload: ByteArray, packetType: Int = 0): ByteArray { + val frame = ByteArray(FRAME_OVERHEAD + payload.size) + val length = frame.size - 6 + frame[0] = 0xaa.toByte() + frame[1] = 0x55 + frame[2] = (length ushr 8).toByte() + frame[3] = length.toByte() + frame[4] = (messageNumber ushr 8).toByte() + frame[5] = messageNumber.toByte() + frame[6] = packetType.toByte() + frame[7] = business.toByte() + payload.copyInto(frame, 8) + val crc = crc16Xmodem(frame, 4, frame.size - 2) + frame[frame.size - 2] = (crc ushr 8).toByte() + frame[frame.size - 1] = crc.toByte() + return frame + } + + /** Split a frame into ATT writes of at most `mtu - 3` bytes. */ + @JvmStatic + fun writes(frame: ByteArray, mtu: Int): List { + val chunk = (mtu - 3).coerceAtLeast(20) + return (frame.indices step chunk).map { frame.copyOfRange(it, minOf(it + chunk, frame.size)) } + } + + @JvmStatic + fun decodeFrame(bytes: ByteArray): Frame? { + if (bytes.size < MIN_FRAME_BYTES || bytes[0] != 0xaa.toByte() || bytes[1] != 0x55.toByte()) return null + val total = (((bytes[2].toInt() and 255) shl 8) or (bytes[3].toInt() and 255)) + 6 + if (total != bytes.size) return null + val crc = ((bytes[total - 2].toInt() and 255) shl 8) or (bytes[total - 1].toInt() and 255) + if (crc != crc16Xmodem(bytes, 4, total - 2)) return null + val number = ((bytes[4].toInt() and 255) shl 8) or (bytes[5].toInt() and 255) + return Frame(number, bytes[6].toInt() and 255, bytes[7].toInt() and 255, bytes.copyOfRange(8, total - 2)) + } + + /** + * Frames from notification chunks: a frame may span several notifications. Bytes before a + * frame head are skipped; a head whose CRC fails is skipped past its magic. + */ + class FrameReassembler { + private var buffer = ByteArray(0) + + fun reset() { + buffer = ByteArray(0) + } + + fun ingest(chunk: ByteArray): List { + buffer += chunk + val out = ArrayList() + var offset = 0 + while (true) { + while (offset + 1 < buffer.size && !(buffer[offset] == 0xaa.toByte() && buffer[offset + 1] == 0x55.toByte())) offset++ + if (buffer.size - offset < 4) break + val total = (((buffer[offset + 2].toInt() and 255) shl 8) or (buffer[offset + 3].toInt() and 255)) + 6 + if (total < MIN_FRAME_BYTES) { offset += 2; continue } + if (buffer.size - offset < total) break + val frame = decodeFrame(buffer.copyOfRange(offset, offset + total)) + if (frame == null) { offset += 2; continue } + out.add(frame) + offset += total + } + buffer = buffer.copyOfRange(minOf(offset, buffer.size), buffer.size) + return out + } + + val pendingBytes: Int get() = buffer.size + } + + // ---- TLV (tag u8, length u16 BE) ------------------------------------------------------------ + + class Tlv(@JvmField val tag: Int, @JvmField val value: ByteArray) + + @JvmStatic + fun tlv(tag: Int, value: ByteArray): ByteArray { + val out = ByteArray(3 + value.size) + out[0] = tag.toByte() + out[1] = (value.size ushr 8).toByte() + out[2] = value.size.toByte() + value.copyInto(out, 3) + return out + } + + @JvmStatic + fun decodeTlvs(bytes: ByteArray): List? { + val out = ArrayList() + var i = 0 + while (i < bytes.size) { + if (bytes.size - i < 3) return null + val len = ((bytes[i + 1].toInt() and 255) shl 8) or (bytes[i + 2].toInt() and 255) + if (bytes.size - i - 3 < len) return null + out.add(Tlv(bytes[i].toInt() and 255, bytes.copyOfRange(i + 3, i + 3 + len))) + i += 3 + len + } + return out + } + + private fun List.value(tag: Int): ByteArray? = firstOrNull { it.tag == tag }?.value + + // ---- Handshake (business 0x10) ---------------------------------------------------------------- + + const val PLATFORM_IOS = 1 + const val PLATFORM_ANDROID = 2 + + /** Version request. `phoneId` is a stable 6-byte protocol identity the glasses bind to. */ + @JvmStatic + fun versionRequest(phoneId: ByteArray, phoneName: String, manufacturer: String, model: String, platform: Int = PLATFORM_ANDROID): ByteArray { + require(phoneId.size == 6) + val inner = tlv(0x10, byteArrayOf(1)) + tlv(0x11, phoneId) + tlv(0x12, phoneName.encodeToByteArray()) + + tlv(0x13, byteArrayOf(platform.toByte())) + tlv(0x16, manufacturer.encodeToByteArray()) + + tlv(0x17, model.encodeToByteArray()) + return tlv(0x11, inner) + } + + class VersionReply( + @JvmField val protocolVersion: Int, + /** The glasses' Bluetooth MAC, which the auth proof covers. */ + @JvmField val glassesId: ByteArray, + @JvmField val serial: String?, + /** Tags 0x19/0x1a: bound to another phone's account; guest auth will not work. */ + @JvmField val accountBound: Boolean, + ) + + @JvmStatic + fun parseVersionReply(payload: ByteArray): VersionReply? { + val body = decodeTlvs(payload)?.value(0x11) ?: return null + val fields = decodeTlvs(body) ?: return null + val id = fields.value(0x11)?.takeIf { it.size == 6 } ?: return null + return VersionReply( + fields.value(0x10)?.firstOrNull()?.toInt()?.and(255) ?: 0, + id, + fields.value(0x14)?.decodeToString()?.trimEnd('\u0000'), + fields.value(0x19) != null || fields.value(0x1a) != null, + ) + } + + /** `SHA-256(random4 ‖ phoneId6 ‖ glassesId6 ‖ SALT)`, both directions. */ + @JvmStatic + fun authProof(random: ByteArray, phoneId: ByteArray, glassesId: ByteArray): ByteArray { + val digest = Sha256Digest() + digest.update(random) + digest.update(phoneId) + digest.update(glassesId) + digest.update(SALT) + return digest.digest() + } + + @JvmStatic + fun guestAuthRequest(random: ByteArray, phoneId: ByteArray, glassesId: ByteArray): ByteArray { + require(random.size == 4 && phoneId.size == 6 && glassesId.size == 6) + return tlv(0x18, tlv(0x10, random) + tlv(0x11, authProof(random, phoneId, glassesId))) + } + + /** The glasses' answer proves they know the same phone and glasses ids. */ + @JvmStatic + fun verifyGuestAuthReply(payload: ByteArray, phoneId: ByteArray, glassesId: ByteArray): Boolean { + val body = decodeTlvs(payload)?.value(0x19) ?: return false + val fields = decodeTlvs(body) ?: return false + val random = fields.value(0x10)?.takeIf { it.size == 4 } ?: return false + val proof = fields.value(0x11)?.takeIf { it.size == 32 } ?: return false + return proof.contentEquals(authProof(random, phoneId, glassesId)) + } + + /** True for a guest-auth reply (outer tag 0x19), valid or not. */ + @JvmStatic fun isGuestAuthReply(payload: ByteArray): Boolean = decodeTlvs(payload)?.value(0x19) != null + + // ---- Business envelope (9, 13..22): 08 version, 10 type, 1A json, 22 bytes, 28 seq, 30 mode ---- + + const val MODE_REQUEST = 1 + const val MODE_REPLY = 2 + const val LAUNCHER_GENERAL_STATUS = 1 + const val LAUNCHER_BRIGHTNESS = 2 + const val OTA_VERSION = 1 + const val GENERAL_STATUS_REQUEST = """{"cmd":"request_general_status","payload":{"data":"","mode":0,"value":0}}""" + + class Envelope( + @JvmField val type: Int, + @JvmField val json: String, + @JvmField val binary: ByteArray? = null, + @JvmField val sequence: Int? = null, + @JvmField val mode: Int? = null, + ) + + private fun varint(out: MutableList, value: Long) { + var v = value + while (v and 0x7fL.inv() != 0L) { out.add(((v and 0x7f) or 0x80).toByte()); v = v ushr 7 } + out.add(v.toByte()) + } + + @JvmStatic + fun encodeEnvelope(e: Envelope): ByteArray { + val out = ArrayList() + out.add(0x08); varint(out, 1) + out.add(0x10); varint(out, e.type.toLong()) + val json = e.json.encodeToByteArray() + out.add(0x1a); varint(out, json.size.toLong()); json.forEach { out.add(it) } + e.binary?.let { b -> out.add(0x22); varint(out, b.size.toLong()); b.forEach { out.add(it) } } + e.sequence?.let { out.add(0x28); varint(out, it.toLong()) } + e.mode?.let { out.add(0x30); varint(out, it.toLong()) } + return out.toByteArray() + } + + @JvmStatic + fun decodeEnvelope(bytes: ByteArray): Envelope? { + var pos = 0 + fun readVarint(): Long? { + var shift = 0 + var result = 0L + while (pos < bytes.size && shift <= 63) { + val b = bytes[pos++].toInt() and 255 + result = result or ((b and 0x7f).toLong() shl shift) + if (b and 0x80 == 0) return result + shift += 7 + } + return null + } + var type: Int? = null + var json = "" + var binary: ByteArray? = null + var sequence: Int? = null + var mode: Int? = null + while (pos < bytes.size) { + val key = readVarint() ?: return null + when ((key and 7).toInt()) { + 0 -> { + val v = readVarint() ?: return null + when ((key ushr 3).toInt()) { 2 -> type = v.toInt(); 5 -> sequence = v.toInt(); 6 -> mode = v.toInt() } + } + 2 -> { + val len = readVarint() ?: return null + if (len < 0 || len > bytes.size - pos) return null + val v = bytes.copyOfRange(pos, pos + len.toInt()) + pos += len.toInt() + when ((key ushr 3).toInt()) { 3 -> json = v.decodeToString(); 4 -> binary = v } + } + 1 -> pos += 8 + 5 -> pos += 4 + else -> return null + } + } + return Envelope(type ?: return null, json, binary, sequence, mode) + } + + /** + * Set the launcher's brightness (1..8). The stock handler also turns the screen on + * (BrightnessMonitor::setBrightness -> turnOnScreenForSetting), which is how the phone + * wakes the iO's display and keeps the stock auto-off from blanking a static page. + */ + @JvmStatic + fun launcherBrightness(level: Int): String = + """{"cmd":"brightness_change","payload":{"value":${level.coerceIn(1, 8)},"mode":0,"data":""}}""" + + /** Faceclaw's 0..100 brightness target on the launcher's 1..8 scale. */ + @JvmStatic fun brightnessLevel(target: Int): Int = maxOf(1, (target.coerceIn(0, 100) * 8 + 50) / 100) + + /** `screen_status` push value (1 on, 0 off), or -1 for anything else. */ + @JvmStatic + fun screenStatusFromLauncherJson(json: String): Int { + val root = try { Json.parse(json).asObject() } catch (_: Exception) { null } ?: return -1 + if (root["cmd"].asString() != "screen_status") return -1 + return root["payload"].asObject()?.get("value").asInt() ?: -1 + } + + /** `generalStatus.battery` from a launcher reply or push, or -1. */ + @JvmStatic + fun batteryFromLauncherJson(json: String): Int { + val root = try { Json.parse(json).asObject() } catch (_: Exception) { null } ?: return -1 + val status = root["generalStatus"].asObject() ?: root["payload"].asObject()?.get("generalStatus").asObject() + status?.get("battery").asInt()?.let { return it } + // pushes: {"cmd":"battery_change","payload":{"value":N,...}} + if (root["cmd"].asString() == "battery_change") return root["payload"].asObject()?.get("value").asInt() ?: -1 + return -1 + } + + // ---- Custom-firmware link (business 0xF0) ----------------------------------------------------- + + const val OPT_LENS = 0x01 + const val OPT_CONTROL = 0x10 + const val OPT_END = 0x40 + const val OPT_RESET = 0x80 + const val CTRL_QUERY = 1 + const val CTRL_PAGE_OPEN = 2 + const val CTRL_PAGE_CLOSE = 3 + const val CTRL_KEEPALIVE = 4 + /** Records up to this many bytes per packet (IDENT reports the firmware's maxChunk). */ + const val DEFAULT_MAX_CHUNK = 240 + /** The page closes this long after the last PAGE_OPEN/KEEPALIVE. */ + const val PAGE_LEASE_MS = 120_000L + + @JvmStatic + fun controlPacket(ctrl: Int, arg: Int? = null): ByteArray = + if (arg == null) byteArrayOf(OPT_CONTROL.toByte(), 0, ctrl.toByte()) + else byteArrayOf(OPT_CONTROL.toByte(), 0, ctrl.toByte(), arg.toByte()) + + /** + * One record (from [CfwTransport.encodeRecord]) as business-0xF0 payloads + * `[opt][stream][chunk]`. `stream` is echoed in the ACKs, so it plays the G2 stream id's role. + */ + @JvmStatic + fun cfwPackets(record: ByteArray, streamId: Int, maxChunk: Int = DEFAULT_MAX_CHUNK): List { + require(streamId in 0..255 && maxChunk > 0) + val out = ArrayList() + var offset = 0 + do { + val end = minOf(offset + maxChunk, record.size) + var opt = OPT_LENS + if (offset == 0) opt = opt or OPT_RESET + if (end >= record.size) opt = opt or OPT_END + val p = ByteArray(2 + end - offset) + p[0] = opt.toByte() + p[1] = streamId.toByte() + record.copyInto(p, 2, offset, end) + out.add(p) + offset = end + } while (offset < record.size) + return out + } + + const val KIND_ACK = 1 + const val KIND_NACK = 3 + const val KIND_REPLY = 5 + const val KIND_GESTURE = 7 + const val KIND_IDENT = 0x11 + const val KIND_PAGE = 0x13 + const val KIND_DIAG = 0x15 + + /** `[01|03][stream][ordinal u16][lens][size u16][crc u16]`: the G2 ACK body, one per lens. */ + @JvmStatic + fun parseCfwAck(payload: ByteArray): CfwTransport.Ack? { + if (payload.size != 9) return null + val kind = payload[0].toInt() and 255 + val lens = payload[4].toInt() and 255 + if ((kind != KIND_ACK && kind != KIND_NACK) || (lens != 1 && lens != 2)) return null + fun u16(o: Int) = (payload[o].toInt() and 255) or ((payload[o + 1].toInt() and 255) shl 8) + return CfwTransport.Ack(kind == KIND_NACK, payload[1].toInt() and 255, u16(2), lens, u16(5), u16(7)) + } + + const val IDENT_FLAG_ZLIB = 0x01 + const val IDENT_FLAG_STEREO = 0x08 + const val IDENT_FLAG_FACECLAW = 0x80 + + class Ident( + @JvmField val width: Int, + @JvmField val height: Int, + @JvmField val maxChunk: Int, + @JvmField val revision: Int, + @JvmField val flags: Int, + @JvmField val name: String, + /** "Faceclaw/" -> n when the firmware runs the Faceclaw display lists, else -1. */ + @JvmField val faceclawRevision: Int, + ) { + val acceptsCompressed: Boolean get() = flags and IDENT_FLAG_ZLIB != 0 + val faceclaw: Boolean get() = flags and IDENT_FLAG_FACECLAW != 0 && faceclawRevision > 0 + } + + /** `[11][ver][w u16][h u16][maxChunk u16][storeKiB u16][rev u16][flags]name\0[lineHeight]["Faceclaw/n"\0]`. */ + @JvmStatic + fun parseIdent(payload: ByteArray): Ident? { + if (payload.size < 13 || payload[0].toInt() != KIND_IDENT) return null + fun u16(o: Int) = (payload[o].toInt() and 255) or ((payload[o + 1].toInt() and 255) shl 8) + var end = 13 + while (end < payload.size && payload[end].toInt() != 0) end++ + val name = payload.copyOfRange(13, end).decodeToString() + var faceclaw = -1 + val extra = end + 2 // NUL, line height + if (extra < payload.size) { + var e = extra + while (e < payload.size && payload[e].toInt() != 0) e++ + val text = payload.copyOfRange(extra, e).decodeToString() + if (text.startsWith("Faceclaw/")) faceclaw = text.removePrefix("Faceclaw/").toIntOrNull() ?: -1 + } + return Ident(u16(2), u16(4), u16(6), u16(10), payload[12].toInt() and 255, name, faceclaw) + } + + /** PAGE `[13][state][reason]`: state 1 open. */ + @JvmStatic fun parsePageState(payload: ByteArray): Int = if (payload.size >= 2 && payload[0].toInt() == KIND_PAGE) payload[1].toInt() and 255 else -1 + + class Gesture(@JvmField val eventType: Int, @JvmField val source: Int, @JvmField val tick: Long) + + /** + * GESTURE `[07][eventType][source][tick u32]`. Event types use the G2's OsEventTypeList numbering: + * 0 single tap, 1 swipe up, 2 swipe down, 3 double tap, 11 tap-then-hold, 12 head up, 15 head down. + */ + @JvmStatic + fun parseGesture(payload: ByteArray): Gesture? { + if (payload.size < 7 || payload[0].toInt() != KIND_GESTURE) return null + val tick = (payload[3].toLong() and 255) or ((payload[4].toLong() and 255) shl 8) or + ((payload[5].toLong() and 255) shl 16) or ((payload[6].toLong() and 255) shl 24) + return Gesture(payload[1].toInt() and 255, payload[2].toInt() and 255, tick) + } +} diff --git a/tests/display-layout-setting.test.cjs b/tests/display-layout-setting.test.cjs index 55e44f71..56bbb17c 100644 --- a/tests/display-layout-setting.test.cjs +++ b/tests/display-layout-setting.test.cjs @@ -64,3 +64,17 @@ test('Full Screen is offered only with a bottom or popup app switcher', () => { assert.deepEqual(Array.from(api.DISPLAY_LAYOUT_VALUES, (value) => api.displayLayoutLabel(value)), ['Band · Top', 'Band · High', 'Band · Middle', 'Band · Low', 'Band · Bottom', 'Tall', 'Full Screen']); }); + +test('a RayNeo iO pins the band to the top and the switcher to the right, leaving the stored choice alone', () => { + const store = new Map([['display.layout', 'band-middle'], ['display.appSwitcherPosition', 'bottom']]); + const api = settingsFixture(store); + assert.equal(api.displayLayoutSetting.get(), 'band-middle'); + assert.equal(api.appSwitcherPositionSetting.get(), 'bottom'); + api.glassesTypeSetting.set('rayneo-io'); + assert.equal(api.displayLayoutSetting.get(), 'band-top'); + assert.equal(api.appSwitcherPositionSetting.get(), 'right'); + assert.equal(store.get('display.layout'), 'band-middle'); + api.glassesTypeSetting.set('g2'); + assert.equal(api.displayLayoutSetting.get(), 'band-middle'); + assert.equal(api.appSwitcherPositionSetting.get(), 'bottom'); +}); diff --git a/tests/even-advertisement.test.cjs b/tests/even-advertisement.test.cjs index 37372daf..c2757d65 100644 --- a/tests/even-advertisement.test.cjs +++ b/tests/even-advertisement.test.cjs @@ -162,3 +162,21 @@ test("a bare R1 substring is not a ring — only the stock EVEN R1 prefix is", ( const ad = classifyAdvertisement(raw({ address: "DA:7F:D2:B5:6E:E2", name: "EVEN R1_B56EE2", manufacturerData: "" })); assert.equal(ad.role, "ring"); }); + +// RayNeo iO-2229 as captured 2026-11-01: company 0x5716 + [07][MAC]; pairing mode omits the data. +test("RayNeo iO advertisements classify as one device with its MAC", () => { + const io = classifyAdvertisement(raw({ + address: "00:6A:5E:5F:33:C2", + name: "RayNeo iO-2229", + manufacturerData: "1657" + "07006a5e5f33c2130000000000000001", + })); + assert.equal(io.role, "rayneo-io"); + assert.equal(io.embeddedMac, "00:6A:5E:5F:33:C2"); + assert.equal(io.embeddedMacMismatch, false); + assert.equal(io.serial, null); + const pairing = classifyAdvertisement(raw({ address: "00:6A:5E:5F:33:C2", name: "RayNeo iO-2229", manufacturerData: "" })); + assert.equal(pairing.role, "rayneo-io"); + assert.equal(pairing.embeddedMac, null); + // G2 advertisements are untouched + assert.equal(classifyAdvertisement(raw({})).role, "left"); +}); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt new file mode 100644 index 00000000..b92b6709 --- /dev/null +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt @@ -0,0 +1,152 @@ +package com.faceclaw.app + +import kotlin.test.* + +/** Vectors are bytes captured from a RayNeo iO (Strix OS 1.0.5.12 / 1.0.4.12 + CFW) on 2026-11-01. */ +class RayNeoIoProtocolTest { + private fun hex(value: String) = value.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + + private val phoneId = hex("fac582dfa91e") + private val glassesId = hex("006a5e5f33c2") + + @Test + fun crcAndFrames() { + assertEquals(0x31c3, RayNeoIoProtocol.crc16Xmodem("123456789".encodeToByteArray())) + val payload = hex("100001") + val frame = RayNeoIoProtocol.encodeFrame(0x1234, RayNeoIoProtocol.BUSINESS_CFW, payload) + assertEquals(13, frame.size) + assertContentEquals(hex("aa55000712340" + "0f0100001"), frame.copyOfRange(0, 11)) + val decoded = RayNeoIoProtocol.decodeFrame(frame)!! + assertEquals(0x1234, decoded.messageNumber) + assertEquals(0xf0, decoded.business) + assertContentEquals(payload, decoded.payload) + frame[9] = 9 + assertNull(RayNeoIoProtocol.decodeFrame(frame)) + } + + @Test + fun reassemblerSpansNotificationsAndSkipsJunk() { + val a = RayNeoIoProtocol.encodeFrame(1, 15, ByteArray(300) { it.toByte() }) + val b = RayNeoIoProtocol.encodeFrame(2, 0xf0, hex("0195000001070024cf")) + val stream = hex("0102") + a + b + val r = RayNeoIoProtocol.FrameReassembler() + val frames = RayNeoIoProtocol.writes(stream, 23).flatMap { r.ingest(it) } + assertEquals(listOf(1, 2), frames.map { it.messageNumber }) + assertEquals(300, frames[0].payload.size) + assertEquals(0, r.pendingBytes) + // a corrupt head is skipped, the next good frame still decodes + val bad = a.copyOf().also { it[20] = (it[20] + 1).toByte() } + assertEquals(listOf(2), r.ingest(bad + b).map { it.messageNumber }) + } + + @Test + fun handshakeMatchesCapture() { + // the Mac harness's request (iOS platform byte, name "Amoli", model "Mac") + assertContentEquals( + hex("11002810000101110006fac582dfa91e120005416d6f6c69130001011600066950686f6e651700034d6163"), + RayNeoIoProtocol.versionRequest(phoneId, "Amoli", "iPhone", "Mac", RayNeoIoProtocol.PLATFORM_IOS), + ) + val reply = RayNeoIoProtocol.parseVersionReply( + hex("11004a10000102110006006a5e5f33c212000e5261794e656f20694f2d323232391300010514000f3030364135453546333343323232391500010518000f303036413545354633334332323239"), + )!! + assertContentEquals(glassesId, reply.glassesId) + assertEquals(2, reply.protocolVersion) + assertEquals("006A5E5F33C2229", reply.serial) + assertFalse(reply.accountBound) + assertContentEquals( + hex("18002a100004875e2013110020efed651a6aacd1834e8023891eaf80ec4a25814db5222e42655b71fdd373ab96"), + RayNeoIoProtocol.guestAuthRequest(hex("875e2013"), phoneId, glassesId), + ) + val authReply = hex("19002a1000042316e62111002082289251b37c1ddb76694d5a4bb4e911a79ad8f2867d7379bb8125f36ae6acac") + assertTrue(RayNeoIoProtocol.isGuestAuthReply(authReply)) + assertTrue(RayNeoIoProtocol.verifyGuestAuthReply(authReply, phoneId, glassesId)) + assertFalse(RayNeoIoProtocol.verifyGuestAuthReply(authReply, hex("fac582dfa91f"), glassesId)) + } + + @Test + fun envelopes() { + assertContentEquals( + hex("080110011a027b7d"), + RayNeoIoProtocol.encodeEnvelope(RayNeoIoProtocol.Envelope(RayNeoIoProtocol.OTA_VERSION, "{}")), + ) + val status = RayNeoIoProtocol.decodeEnvelope(hex(GENERAL_STATUS))!! + assertEquals(1, status.type) + assertEquals(98, RayNeoIoProtocol.batteryFromLauncherJson(status.json)) + assertEquals(100, RayNeoIoProtocol.batteryFromLauncherJson("""{"cmd":"battery_change","payload":{"value":100,"mode":1}}""")) + assertEquals(-1, RayNeoIoProtocol.batteryFromLauncherJson("""{"cmd":"screen_status","payload":{"value":1}}""")) + val request = RayNeoIoProtocol.Envelope(1, RayNeoIoProtocol.GENERAL_STATUS_REQUEST, sequence = 300, mode = RayNeoIoProtocol.MODE_REQUEST) + val back = RayNeoIoProtocol.decodeEnvelope(RayNeoIoProtocol.encodeEnvelope(request))!! + assertEquals(300, back.sequence) + assertEquals(RayNeoIoProtocol.MODE_REQUEST, back.mode) + assertEquals(request.json, back.json) + } + + @Test + fun cfwLink() { + assertContentEquals(hex("100001"), RayNeoIoProtocol.controlPacket(RayNeoIoProtocol.CTRL_QUERY)) + val record = ByteArray(500) { it.toByte() } + val packets = RayNeoIoProtocol.cfwPackets(record, 0x95, 240) + assertEquals(listOf(0x81, 0x01, 0x41), packets.map { it[0].toInt() and 255 }) + assertTrue(packets.all { it[1] == 0x95.toByte() }) + assertContentEquals(record, packets.flatMap { it.drop(2) }.toByteArray()) + assertEquals(0xc1, RayNeoIoProtocol.cfwPackets(ByteArray(5), 1)[0][0].toInt() and 255) + + val ack = RayNeoIoProtocol.parseCfwAck(hex("0195000001070024cf"))!! + assertFalse(ack.nack) + assertEquals(0x95, ack.streamId) + assertEquals(0, ack.messageId) + assertEquals(1, ack.lens) + assertEquals(7, ack.size) + assertEquals(0xcf24, ack.checksum) + assertTrue(RayNeoIoProtocol.parseCfwAck(hex("0395000002070024cf"))!!.nack) + assertNull(RayNeoIoProtocol.parseCfwAck(hex("0195000003070024cf"))) + + // Glassly v13 IDENT, then the Faceclaw fork's with the revision string appended + val v13 = RayNeoIoProtocol.parseIdent(hex("110d1c02dc00f00000010d007f474c4153534c594346572d494f2f31330019"))!! + assertEquals(540, v13.width) + assertEquals(220, v13.height) + assertEquals(240, v13.maxChunk) + assertEquals(13, v13.revision) + assertEquals("GLASSLYCFW-IO/13", v13.name) + assertFalse(v13.faceclaw) + val fc = RayNeoIoProtocol.parseIdent(hex("110d1c02dc00f00000010d00ff474c4153534c594346572d494f2f3133001946616365636c61772f333800"))!! + assertTrue(fc.faceclaw) + assertEquals(38, fc.faceclawRevision) + + assertEquals(1, RayNeoIoProtocol.parsePageState(hex("130100"))) + val g = RayNeoIoProtocol.parseGesture(hex("0703010a000000"))!! + assertEquals(3, g.eventType) + assertEquals(1, g.source) + assertEquals(10L, g.tick) + } + + @Test + fun recordsShareTheG2Encoder() { + // the G2 envelope is unchanged by the record/packet split + val g2 = CfwTransport.frame("123456789abcdef".encodeToByteArray(), 255, 3, 23) + assertContentEquals(hex("aa21ff0c0101f000830b0f0078c331323334862b"), g2[0]) + // an iO record carries the same flags/length/CRC header + val t = CfwTransport(testPlatform()) + val message = ByteArray(64) { (it % 7).toByte() } + val rec = t.encodeRecord(message, CfwTransport.BOTH) + assertEquals(CfwTransport.BOTH or CfwTransport.COMPRESSED or CfwTransport.RESET_CONTEXT, rec[0].toInt()) + assertEquals(CfwTransport.crc(message), (rec[3].toInt() and 255) or ((rec[4].toInt() and 255) shl 8)) + assertContentEquals(message, inflateRecords(listOf(rec))[0]) + // the next record continues the same compression context + val second = t.encodeRecord(message, CfwTransport.BOTH) + assertEquals(CfwTransport.BOTH or CfwTransport.COMPRESSED, second[0].toInt()) + t.close() + } + + @Test + fun advertisement() { + assertEquals("00:6A:5E:5F:33:C2", RayNeoIoBle.macFromManufacturerData(hex("07006a5e5f33c2130000000000000001"))) + assertNull(RayNeoIoBle.macFromManufacturerData(hex("0800"))) + assertTrue(RayNeoIoBle.matchesName("RayNeo iO-2229")) + assertFalse(RayNeoIoBle.matchesName("Even G2_32_L_693CCB")) + } + + private companion object { + const val GENERAL_STATUS = "080110011aa6037b2267656e6572616c537461747573223a7b226175746f6d617469634272696768746e657373223a66616c73652c2262617474657279223a39382c22626174745f74656d70223a33342c22626c7565746f6f746841646472657373223a2230303a36413a35453a35463a33333a4332222c226272696768746e657373223a312c226465766963654e616d65223a225261794e656f20694f2d32323239222c2269734368617267696e67223a747275652c2263686172676554797065223a302c2273637265656e537461747573223a312c2268616c6c537461747573223a302c226d6963537461747573223a302c22666f6375734d6f6465223a7b22656e61626c65223a302c22656e61626c65476c617373436c6f7365223a312c22706f6c696379223a7b226175746f223a312c22626567696e223a2230393a3030222c22656e64223a2231383a3030222c227765656b646179223a5b302c312c322c332c342c352c365d7d7d2c22707265736372697074696f6e223a7b22656e61626c65223a312c22646567726565223a222d332c302c2d322e37352c30222c227064223a223633227d7d7d" + } +} diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt new file mode 100644 index 00000000..80d8ae38 --- /dev/null +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt @@ -0,0 +1,380 @@ +package com.faceclaw.app + +import kotlin.concurrent.Volatile +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +private const val IO = "00:6A:5E:5F:33:C2" +private val PHONE_ID = byteArrayOf(1, 2, 3, 4, 5, 6) + +private class IoClock(private val base: ProtocolPlatform) : ProtocolPlatform by base { + @Volatile var offsetMs = 0L + + override fun elapsedRealtimeMs(): Long = base.elapsedRealtimeMs() + offsetMs +} + +private fun awaitTrue(timeoutMs: Long, condition: () -> Boolean): Boolean { + val platform = testPlatform() + val deadline = platform.elapsedRealtimeMs() + timeoutMs + while (platform.elapsedRealtimeMs() < deadline) { + if (condition()) return true + sleepMs(10) + } + return condition() +} + +/** + * A RayNeo iO running faceclaw-rayneo-cfw, as the phone sees it over GATT: answers the + * handshake, guest auth, launcher status, OS version, QUERY and page controls, reassembles + * and inflates CFW records, and ACKs each lens of every record whose CRC checks out. + */ +private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { + lateinit var core: GlassesSessionCore + private val lock = platform.createLock() + val glassesId = byteArrayOf(0x00, 0x6a, 0x5e, 0x5f, 0x33, 0xc2.toByte()) + /** The phone id the glasses accept; null = pairing mode (they bind to the next one). */ + @Volatile var boundTo: ByteArray? = null + @Volatile var faceclaw = true + @Volatile var pageOpen = false + @Volatile var hangUps = 0 + private val controlsList = ArrayList() + private val messagesList = ArrayList() + private val launcherList = ArrayList() + val launcher: List get() = lock.withLock { launcherList.toList() } + private val records = ArrayList() + private var current = ByteArray(0) + private val inbound = RayNeoIoProtocol.FrameReassembler() + private var number = 1 + + val controls: List get() = lock.withLock { controlsList.toList() } + val messages: List get() = lock.withLock { messagesList.toList() } + + fun notify(business: Int, payload: ByteArray) { + val frame = lock.withLock { RayNeoIoProtocol.encodeFrame(number++, business, payload) } + core.onNotification(IO, RayNeoIoBle.NOTIFY_CHAR_UUID, frame) + } + + fun page(state: Int, reason: Int) = notify(0xf0, byteArrayOf(0x13, state.toByte(), reason.toByte())) + + override fun connect(address: String, timeoutMs: Int): Boolean = true + + override fun isConnected(address: String): Boolean = true + + override fun requestHighPriority(address: String) {} + + override fun requestMtu(address: String, mtu: Int, timeoutMs: Int): Boolean = true + + override fun negotiatedMtu(address: String): Int = 185 + + override fun discoverServices(address: String, timeoutMs: Int): Boolean = true + + override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean = + characteristicUuid == RayNeoIoBle.NOTIFY_CHAR_UUID + + override fun writeFrames(address: String, characteristicUuid: String, frames: List, mode: GattWriteMode, timeoutMs: Int): Boolean { + assertEquals(RayNeoIoBle.WRITE_CHAR_UUID, characteristicUuid) + assertTrue(frames.all { it.size <= 185 - 3 }, "writes must fit the MTU") + val decoded = lock.withLock { frames.flatMap { inbound.ingest(it) } } + for (frame in decoded) handle(frame) + return true + } + + private fun handle(frame: RayNeoIoProtocol.Frame) { + val p = frame.payload + when (frame.business) { + 0x10 -> { + val tlvs = RayNeoIoProtocol.decodeTlvs(p)!! + val version = tlvs.firstOrNull { it.tag == 0x11 } + val auth = tlvs.firstOrNull { it.tag == 0x18 } + if (version != null) { + val phone = RayNeoIoProtocol.decodeTlvs(version.value)!!.first { it.tag == 0x11 }.value + val bound = boundTo + if (bound != null && !bound.contentEquals(phone)) { + hangUps++ + core.onConnectionStateChange(IO, false) + return + } + notify(0x10, RayNeoIoProtocol.tlv(0x11, RayNeoIoProtocol.tlv(0x10, byteArrayOf(2)) + + RayNeoIoProtocol.tlv(0x11, glassesId) + RayNeoIoProtocol.tlv(0x14, "006A5E5F33C2229".encodeToByteArray()))) + } else if (auth != null) { + val fields = RayNeoIoProtocol.decodeTlvs(auth.value)!! + val phoneRandom = fields.first { it.tag == 0x10 }.value + val phone = PHONE_ID + assertTrue(RayNeoIoProtocol.authProof(phoneRandom, phone, glassesId).contentEquals(fields.first { it.tag == 0x11 }.value)) + boundTo = phone + val random = byteArrayOf(9, 8, 7, 6) + notify(0x10, RayNeoIoProtocol.tlv(0x19, RayNeoIoProtocol.tlv(0x10, random) + + RayNeoIoProtocol.tlv(0x11, RayNeoIoProtocol.authProof(random, phone, glassesId)))) + } + } + 15 -> { + lock.withLock { launcherList.add(RayNeoIoProtocol.decodeEnvelope(p)!!.json) } + notify(15, RayNeoIoProtocol.encodeEnvelope(RayNeoIoProtocol.Envelope(1, + """{"generalStatus":{"battery":77,"isCharging":false}}""", sequence = RayNeoIoProtocol.decodeEnvelope(p)!!.sequence, mode = 2))) + } + 9 -> notify(9, RayNeoIoProtocol.encodeEnvelope(RayNeoIoProtocol.Envelope(1, """{"OsVersion":"Strix OS 1.0.4.12"}"""))) + 0xf0 -> cfw(p) + } + } + + private fun cfw(p: ByteArray) { + val opt = p[0].toInt() and 255 + val stream = p[1].toInt() and 255 + if (opt and RayNeoIoProtocol.OPT_CONTROL != 0) { + val ctrl = p[2].toInt() and 255 + lock.withLock { controlsList.add(ctrl) } + when (ctrl) { + RayNeoIoProtocol.CTRL_QUERY -> if (faceclaw) notify(0xf0, ident()) + RayNeoIoProtocol.CTRL_PAGE_OPEN, RayNeoIoProtocol.CTRL_KEEPALIVE -> { pageOpen = true; page(1, 0) } + RayNeoIoProtocol.CTRL_PAGE_CLOSE -> { pageOpen = false; page(0, 0) } + } + return + } + val complete = lock.withLock { + if (opt and RayNeoIoProtocol.OPT_RESET != 0) current = ByteArray(0) + current += p.copyOfRange(2, p.size) + val len = if (current.size >= 5) (current[1].toInt() and 255) or ((current[2].toInt() and 255) shl 8) else -1 + if (len >= 0 && current.size == 5 + len) current.also { records.add(it); current = ByteArray(0) } else null + } ?: return + val message = lock.withLock { inflateRecords(records).last() } + val crc = (complete[3].toInt() and 255) or ((complete[4].toInt() and 255) shl 8) + val ok = pageOpen && CfwTransport.crc(message) == crc && ioSupportsCfwType(message[0].toInt() and 255) + if (ok) lock.withLock { messagesList.add(message) } + for (lens in 1..2) { + notify(0xf0, byteArrayOf(if (ok) 1 else 3, stream.toByte(), 0, 0, lens.toByte(), + message.size.toByte(), (message.size ushr 8).toByte(), crc.toByte(), (crc ushr 8).toByte())) + } + } + + private fun ident(): ByteArray { + val name = "GLASSLYCFW-IO/13".encodeToByteArray() + return byteArrayOf(0x11, 13, 0x1c, 0x02, 0xdc.toByte(), 0x00, 0xf0.toByte(), 0x00, 0x00, 0x01, 0x0d, 0x00, 0xff.toByte()) + + name + byteArrayOf(0, 25) + "Faceclaw/38".encodeToByteArray() + byteArrayOf(0) + } + + override fun disconnect(address: String) {} + + override fun close() {} + + override fun isBonded(address: String): Boolean = false + + override fun prepareBenchmarkLink(address: String, mode: Int) {} + + override fun recordDisplayFrameSent() {} +} + +private class IoListener : FaceclawBleCommunicatorListener { + val phases = ArrayList() + @Volatile var lastStatus = "" + val events = ArrayList() + val batteries = ArrayList() + val firmware = ArrayList() + + override fun onStateChange(phase: String?, status: String?) { + phases.add(phase ?: "") + lastStatus = status ?: "" + } + + override fun onRingEvent(kind: String?, containerName: String?, eventType: Int, eventSource: Int, systemExitReasonCode: Int, frameId: Int, ringTick: Long, ringType: Int, ringAux: Int, ringSpeed: Int) { + events.add("$kind:$eventType:$eventSource") + } + + override fun onBatteryState(headsetBattery: Int, headsetCharging: Int, ringBattery: Int, ringCharging: Int) { + batteries.add("$headsetBattery/$headsetCharging") + } + + override fun onSilentMode(silent: Boolean) {} + + override fun onWearState(wearing: Boolean) {} + + override fun onPhoneLockState(locked: Boolean) {} + + override fun onEvenAppConflict(message: String?) {} + + override fun onFrameMetrics(paintMs: Int, transmitMs: Int, tileCount: Int) {} + + override fun onFrameFinished(frameId: Int, outcome: String?) {} + + override fun onFirmwareInfo(leftVersion: String?, rightVersion: String?, extension: String?) { + firmware.add("$leftVersion|$extension") + } +} + +private class IoSession { + val platform = IoClock(testPlatform()) + val glasses = FakeIoGlasses(platform) + private val host = object : SessionHost { + private val lock = platform.createLock() + private val lines = ArrayList() + private var done: Latch? = null + + fun logs(): List = lock.withLock { lines.toList() } + + override fun postToMain(action: () -> Unit) = action() + + override fun currentThreadDispatcher(): SessionDispatcher = SessionDispatcher { it() } + + override fun isPhoneLocked(): Boolean = false + + override fun setScreenWakeLock(on: Boolean) {} + + override fun isEvenAppActive(): Boolean = false + + override fun startWorker(body: () -> Unit) { + val latch = Latch(1, platform) + done = latch + startThread("io-test-session", true) { + try { + body() + } finally { + latch.countDown() + } + } + } + + override fun joinWorker(timeoutMs: Long) { + done?.await(timeoutMs) + } + + override fun log(level: SessionLogLevel, tag: String, message: String, error: Throwable?) { + lock.withLock { lines.add("$level $tag: $message") } + } + } + val listener = IoListener() + val core = GlassesSessionCore(glasses, host, FrameTimingsCore(platform), platform, IO, IO, "") + + init { + glasses.core = core + core.setListener(listener) + core.setRequiredFirmwareRevision(38) + core.useRayNeoIo(PHONE_ID, "Pixel", "Google", "Pixel 11") + } + + fun pageUp(): Boolean = core.monitor.withLock { core.sessionReady && core.fixedLayoutCreated } + + fun displayedMatchesDesired(): Boolean = core.monitor.withLock { + core.desiredTilesLock.locked { core.desiredFingerprint.isNotEmpty() && core.desiredFingerprint == core.displayedFingerprint } + } + + fun submitFrame(value: Byte, frameId: Int) { + val pixels = ByteArray(64 * 32) { if (it % 7 == 0) value else 0 } + core.submitSurfaceFrame(ArrayByteReader(pixels), "s", 0, 0, 64, 32, "content-$value", 0, frameId, null) + } + + fun tail(): String = host.logs().takeLast(25).joinToString("\n") +} + +class RayNeoIoSessionTest { + @Test + fun connectsAuthenticatesOpensThePageAndPresentsFrames() { + val s = IoSession() + s.core.configureBrightness(false, 70, 2, 100, "0:0,1000:100", 280) + s.core.configureCompositorScreen(540, 220) + s.core.configureSurface("s", 0, 0, 64, 32, 0, SurfaceCompositor.TRANSPARENCY_OPAQUE) + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.pageUp() }, "page never opened:\n" + s.tail()) + assertTrue(s.core.isRayNeoIo()) + assertTrue(s.listener.firmware.contains("Strix OS 1.0.4.12|Faceclaw/38"), s.listener.firmware.toString()) + assertTrue(awaitTrue(2_000) { s.listener.batteries.contains("77/0") }, s.listener.batteries.toString()) + assertEquals(listOf(RayNeoIoProtocol.CTRL_QUERY, RayNeoIoProtocol.CTRL_PAGE_OPEN), s.glasses.controls.take(2)) + + s.submitFrame(0x7f, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, "frame never displayed:\n" + s.tail()) + val types = s.glasses.messages.map { it[0].toInt() and 255 } + assertTrue(types.contains(CFW_MSG_PRESENT), types.toString()) + // nothing G2-only (brightness 30, ENTER_EVENHUB 31, debug flags 7, ...) reaches the iO + assertTrue(types.all { ioSupportsCfwType(it) }, types.toString()) + // a visible frame wakes the screen through the launcher's brightness (70% -> level 6) + assertTrue(awaitTrue(3_000) { s.glasses.launcher.any { it.contains("brightness_change") && it.contains("\"value\":6") } }, + s.glasses.launcher.toString()) + + // a second, different frame goes out as an update + val before = s.glasses.messages.size + s.submitFrame(0x30, 2) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() && s.glasses.messages.size > before }) + } finally { + s.core.close() + } + // disconnect closes the page so the glasses go back to their own UI at once + assertEquals(RayNeoIoProtocol.CTRL_PAGE_CLOSE, s.glasses.controls.last()) + } + + @Test + fun refusalAsksForPairingModeAndConnectsOnceItIsOn() { + val s = IoSession() + s.glasses.boundTo = byteArrayOf(9, 9, 9, 9, 9, 9) + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.glasses.hangUps >= 1 && s.listener.lastStatus.contains("pairing mode") }, + "no pairing-mode prompt:\n" + s.tail()) + assertFalse(s.pageUp()) + s.glasses.boundTo = null // the wearer held the button + s.platform.offsetMs += 5_000 + s.core.interruptibleSleep.interrupt() + assertTrue(awaitTrue(5_000) { s.pageUp() }, "never connected after pairing mode:\n" + s.tail()) + assertTrue(s.glasses.boundTo!!.contentEquals(PHONE_ID)) + } finally { + s.core.close() + } + } + + @Test + fun stockFirmwareIsIncompatible() { + val s = IoSession() + s.glasses.faceclaw = false + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(8_000) { s.listener.phases.contains("incompatible-firmware") }, "not halted:\n" + s.tail()) + assertTrue(s.listener.firmware.contains("Strix OS 1.0.4.12|")) + assertFalse(s.glasses.controls.contains(RayNeoIoProtocol.CTRL_PAGE_OPEN)) + } finally { + s.core.close() + } + } + + @Test + fun gesturesPageLossAndKeepalive() { + val s = IoSession() + s.core.configureCompositorScreen(540, 220) + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.pageUp() }, s.tail()) + // taps/crown arrive as G2 sys-events from the right temple; head up wakes; head down is dropped + s.glasses.notify(0xf0, byteArrayOf(7, 3, 1, 0, 0, 0, 0)) + s.glasses.notify(0xf0, byteArrayOf(7, 1, 0, 0, 0, 0, 0)) + s.glasses.notify(0xf0, byteArrayOf(7, 12, 2, 0, 0, 0, 0)) + s.glasses.notify(0xf0, byteArrayOf(7, 15, 2, 0, 0, 0, 0)) + assertEquals(listOf("sys-event:3:1", "sys-event:1:1", "display-wake:12:1"), s.listener.events) + + // the lease ran out on the glasses: the session reopens the page + s.glasses.pageOpen = false + s.glasses.page(0, 3) + assertFalse(s.pageUp()) + s.platform.offsetMs += 4_000 + s.core.interruptibleSleep.interrupt() + assertTrue(awaitTrue(5_000) { s.pageUp() }, "page not reopened:\n" + s.tail()) + + // keepalives well inside the 120 s lease + val keepalives = s.glasses.controls.count { it == RayNeoIoProtocol.CTRL_KEEPALIVE } + s.platform.offsetMs += 31_000 + s.core.interruptibleSleep.interrupt() + assertTrue(awaitTrue(5_000) { s.glasses.controls.count { it == RayNeoIoProtocol.CTRL_KEEPALIVE } > keepalives }) + + // the wearer closed it: stay closed until they touch the glasses again + s.glasses.pageOpen = false + s.glasses.page(0, 4) + s.platform.offsetMs += 4_000 + s.core.interruptibleSleep.interrupt() + sleepMs(300) + assertFalse(s.pageUp()) + s.glasses.notify(0xf0, byteArrayOf(7, 0, 1, 0, 0, 0, 0)) + s.core.interruptibleSleep.interrupt() + assertTrue(awaitTrue(5_000) { s.pageUp() }, "touch did not reopen:\n" + s.tail()) + } finally { + s.core.close() + } + } +} diff --git a/tests/pairing-candidates.test.cjs b/tests/pairing-candidates.test.cjs index 204fe622..50d860fe 100644 --- a/tests/pairing-candidates.test.cjs +++ b/tests/pairing-candidates.test.cjs @@ -12,6 +12,7 @@ const { isPreviouslyPaired, glassesRow, ringRow, + rayneoRow, DEFAULT_STALE_AFTER_MS, } = require("../.test-build/app/g2/pairing-candidates.js"); const { requiredArtworkFileNames, glassesImagePath, GENERIC_G2_IMAGE_PATH } = require("../.test-build/app/g2/glasses-artwork.js"); @@ -289,3 +290,19 @@ test("every artwork file the resolver claims is bundled exists on disk", () => { assert.ok(fs.existsSync(path.join(dir, name)), `missing app/images/glasses/${name}`); } }); + +test("a RayNeo iO is its own candidate, never half of a G2 pair", () => { + const aggregator = new DiscoveryAggregator(); + aggregator.ingest({ + address: "00:6A:5E:5F:33:C2", name: "RayNeo iO-2229", manufacturerData: "1657" + "07006a5e5f33c2130000000000000001", + rssi: -50, txPower: null, connectable: true, bonded: false, source: "scan", seenAtMs: 1000, + }); + assert.equal(aggregator.pairs().length, 0); + assert.equal(aggregator.rings().length, 0); + const found = aggregator.rayneos(); + assert.equal(found.length, 1); + const row = rayneoRow(found[0], { pairedAddress: "00:6a:5e:5f:33:c2" }); + assert.equal(row.kind, "rayneo-io"); + assert.equal(row.canSelect, true); + assert.equal(row.isPreviouslyPaired, true); +}); From dee60bbcd2d4dc0c0e881b1cadf4221dc0e52a57 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Sun, 1 Nov 2026 19:02:05 -0800 Subject: [PATCH 02/34] Adapt layouts for Rayneo screen resolution --- app/apps/onboarding/layout-diagram.ts | 33 ++++++---- app/apps/onboarding/layout-page.ts | 45 +++++++------ app/apps/onboarding/text-size-page.ts | 10 +-- app/g2/dashboard-controller.ts | 58 +++++++++------- app/g2/lock-screen.ts | 13 ++-- app/g2/phone-preview-crop.ts | 9 ++- app/graphics/screen-size.ts | 27 ++++++++ app/graphics/ui-fonts.ts | 20 ++++-- app/phone-ui/main-view-model.ts | 13 ++-- app/ui/dashboard-settings.ts | 43 ++++++------ app/ui/dashboard/settings-panel.ts | 26 +++++++- app/ui/font-picker.ts | 41 +++++++++--- app/ui/layers.ts | 7 +- app/ui/menu.ts | 17 +++-- app/ui/shell/brightness-picker-layer.ts | 20 ++++-- app/ui/shell/chrome-layer.ts | 35 +++++----- app/ui/shell/geometry.ts | 58 +++++++++------- app/ui/shell/in-process-window.ts | 1 + app/ui/shell/input-dialog.ts | 37 +++++++---- app/ui/shell/shell.ts | 23 +++++-- app/ui/shell/worker-window.ts | 9 ++- tests/ai-chat.test.cjs | 2 + tests/app-layout.test.cjs | 79 +++++++++++++++++++++- tests/brightness-picker.test.cjs | 19 +++++- tests/display-layout-setting.test.cjs | 21 ++++-- tests/font-picker.test.cjs | 88 +++++++++++++++++++++++++ tests/icon-grid.test.cjs | 1 + tests/lock-screen.test.cjs | 29 ++++++++ tests/menu-display-list.test.cjs | 8 +-- tests/music-settings.test.cjs | 2 +- tests/notification-filter.test.cjs | 2 +- tests/onboarding-layout.test.cjs | 58 ++++++++++++++-- tests/settings-panel.test.cjs | 24 ++++++- tests/ui-fonts-default.test.cjs | 45 +++++++++++++ 34 files changed, 721 insertions(+), 202 deletions(-) create mode 100644 app/graphics/screen-size.ts create mode 100644 tests/font-picker.test.cjs create mode 100644 tests/lock-screen.test.cjs create mode 100644 tests/ui-fonts-default.test.cjs diff --git a/app/apps/onboarding/layout-diagram.ts b/app/apps/onboarding/layout-diagram.ts index 3ade4108..c92bda21 100644 --- a/app/apps/onboarding/layout-diagram.ts +++ b/app/apps/onboarding/layout-diagram.ts @@ -3,9 +3,9 @@ * page: to scale in real-display pixels, simplified, and drawn brighter * than the real chrome, which they shrink to a few pixels. */ -import { G2_LENS_WIDTH, type GrayImage } from "../../graphics/image"; +import type { GrayImage } from "../../graphics/image"; import { statusBarPositionSetting, type AppSwitcherPosition } from "../../ui/dashboard-settings"; -import { SIDEBAR_WIDTH, SWITCHER_ROW_HEIGHT, MIN_WINDOW_HEIGHT, TOP_BAR_HEIGHT } from "../../ui/shell/geometry"; +import { MIN_WINDOW_HEIGHT, screenHeight, screenWidth, SIDEBAR_WIDTH, SWITCHER_ROW_HEIGHT, TOP_BAR_HEIGHT } from "../../ui/shell/geometry"; export const AREA_OUTLINE = 30; const CHROME_LINE = 100; @@ -80,14 +80,14 @@ export function drawLayout(d: Diagram, position: AppSwitcherPosition, band: Diag switch (position) { case "left": case "right": { - const stripLeft = position === "left" ? 0 : G2_LENS_WIDTH - SIDEBAR_WIDTH; + const stripLeft = position === "left" ? 0 : screenWidth() - SIDEBAR_WIDTH; const contentLeft = position === "left" ? SIDEBAR_WIDTH : 0; - const windowWidth = G2_LENS_WIDTH - SIDEBAR_WIDTH; + const windowWidth = screenWidth() - SIDEBAR_WIDTH; drawStatusBar(d, contentLeft, top, windowWidth, TOP_BAR_HEIGHT - 1); drawContent(d, contentLeft, top + TOP_BAR_HEIGHT, windowWidth, height - TOP_BAR_HEIGHT, 1); - // The strip keeps to the 288px band's height, even beside taller windows. + // The strip keeps to the min band's height (288px, or the whole short screen), even beside taller windows. const separator = position === "left" ? SIDEBAR_WIDTH - 1 : stripLeft; - d.vline(separator, top + TOP_BAR_HEIGHT, MIN_WINDOW_HEIGHT - TOP_BAR_HEIGHT, CHROME_LINE); + d.vline(separator, top + TOP_BAR_HEIGHT, diagramBandHeight("left") - TOP_BAR_HEIGHT, CHROME_LINE); // One column of icons against the separator. const column = position === "left" ? SIDEBAR_WIDTH - 36 : stripLeft; for (let slot = 0; slot < 4; slot++) drawIcon(d, column + 2, top + TOP_BAR_HEIGHT + 10 + slot * 40, slot === 0); @@ -131,11 +131,11 @@ export function drawLayout(d: Diagram, position: AppSwitcherPosition, band: Diag } } -/** A bottom row or popup layout's window: centred at 576 wide and framed, or the panel's width without a frame. */ +/** A bottom row or popup layout's window: centred, SIDEBAR_WIDTH narrower, framed; or the screen's width without a frame. */ function windowSpan(band: DiagramBand): { left: number; width: number; framed: boolean } { return band.fullWidth - ? { left: 0, width: G2_LENS_WIDTH, framed: false } - : { left: SIDEBAR_WIDTH / 2, width: G2_LENS_WIDTH - SIDEBAR_WIDTH, framed: true }; + ? { left: 0, width: screenWidth(), framed: false } + : { left: SIDEBAR_WIDTH / 2, width: screenWidth() - SIDEBAR_WIDTH, framed: true }; } /** @@ -173,5 +173,16 @@ function drawContent(d: Diagram, x: number, y: number, width: number, height: nu } } -/** Real-display rows the Layout page's diagrams cover: a 288px band and a bottom switcher row under it. */ -export const LAYOUT_AREA_HEIGHT = MIN_WINDOW_HEIGHT + SWITCHER_ROW_HEIGHT; +/** + * Real-display rows the Layout page's diagrams cover: a 288px band and a + * bottom switcher row under it, or the whole screen where that is shorter + * (the RayNeo iO's 220 rows). + */ +export function layoutAreaHeight(): number { + return Math.min(MIN_WINDOW_HEIGHT + SWITCHER_ROW_HEIGHT, screenHeight()); +} + +/** A layout's min-height band within the diagram area: 288px, less a bottom row where the screen is short. */ +export function diagramBandHeight(position: AppSwitcherPosition): number { + return Math.min(MIN_WINDOW_HEIGHT, layoutAreaHeight() - (position === "bottom" ? SWITCHER_ROW_HEIGHT : 0)); +} diff --git a/app/apps/onboarding/layout-page.ts b/app/apps/onboarding/layout-page.ts index 0d2eae6c..50411469 100644 --- a/app/apps/onboarding/layout-page.ts +++ b/app/apps/onboarding/layout-page.ts @@ -1,9 +1,9 @@ -import { G2_LENS_WIDTH, type GrayImage, type UiFont } from "../../graphics/image"; -import { appSwitcherPositionSetting, type AppSwitcherPosition } from "../../ui/dashboard-settings"; +import type { GrayImage, UiFont } from "../../graphics/image"; +import { appSwitcherPositionSetting, glassesTypeSetting, type AppSwitcherPosition } from "../../ui/dashboard-settings"; import type { InputEvent } from "../../ui/gestures"; import { MENU_HIGHLIGHT_FILL, MENU_HIGHLIGHT_STROKE } from "../../ui/menu-core"; -import { MIN_WINDOW_HEIGHT } from "../../ui/shell/geometry"; -import { AREA_OUTLINE, Diagram, drawLayout, LAYOUT_AREA_HEIGHT } from "./layout-diagram"; +import { screenWidth } from "../../ui/shell/geometry"; +import { AREA_OUTLINE, Diagram, diagramBandHeight, drawLayout, layoutAreaHeight } from "./layout-diagram"; import { onboardingFont } from "./onboarding-fonts"; import { drawPageHeading, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; @@ -19,8 +19,13 @@ const ROW_GAP = 6; const DEPTH_SUBTITLE = "Customizable Depth"; /** Grid order, in rows of two: the layouts with depth on top. */ const LAYOUT_ORDER: readonly AppSwitcherPosition[] = ["bottom", "popup", "left", "right"]; -/** Selected on the first visit, and marked. */ -const RECOMMENDED_LAYOUT: AppSwitcherPosition = "bottom"; +/** + * Selected on the first visit, and marked: Bottom on the G2, whose 480 rows + * leave room for the row; a side strip on the RayNeo iO, whose 220 can't. + */ +export function recommendedLayout(): AppSwitcherPosition { + return glassesTypeSetting.get() === "rayneo-io" ? "left" : "bottom"; +} /** Whether a layout leaves the side margins the display's stereo depth shifts into (geometry.ts uiDepth). */ export function layoutHasDepth(position: AppSwitcherPosition): boolean { @@ -29,7 +34,7 @@ export function layoutHasDepth(position: AppSwitcherPosition): boolean { /** * The app switcher position, as a 2×2 grid of captioned diagrams of each - * layout, Bottom (recommended, and selected at first) and Popup on top; + * layout, Bottom and Popup on top, the recommended one selected at first; * swipes move through them in reading order, a tap saves the selected one. * The page is immersive, so the diagrams get 40% of the display's width * each. Choosing a layout reflows open windows (the dashboard controller @@ -38,7 +43,7 @@ export function layoutHasDepth(position: AppSwitcherPosition): boolean { export class LayoutPage implements OnboardingPage { readonly immersive = true; /** Kept across visits, so going back returns to the last choice. */ - private selected = LAYOUT_ORDER.indexOf(RECOMMENDED_LAYOUT); + private selected = LAYOUT_ORDER.indexOf(recommendedLayout()); paint(image: GrayImage, focused: boolean): void { const top = drawPageHeading( @@ -53,11 +58,11 @@ export class LayoutPage implements OnboardingPage { // Short of DIAGRAM_SCALE only where two rows of cells wouldn't fit. const scale = Math.min( DIAGRAM_SCALE, - ((available - ROW_GAP) / 2 - 2 * CELL_PADDING - captionHeight) / LAYOUT_AREA_HEIGHT, - ((image.width - COLUMN_GAP) / 2 - 2 * CELL_PADDING) / G2_LENS_WIDTH, + ((available - ROW_GAP) / 2 - 2 * CELL_PADDING - captionHeight) / layoutAreaHeight(), + ((image.width - COLUMN_GAP) / 2 - 2 * CELL_PADDING) / screenWidth(), ); - const diagramWidth = Math.round(G2_LENS_WIDTH * scale); - const diagramHeight = Math.round(LAYOUT_AREA_HEIGHT * scale); + const diagramWidth = Math.round(screenWidth() * scale); + const diagramHeight = Math.round(layoutAreaHeight() * scale); const cellWidth = diagramWidth + 2 * CELL_PADDING; const cellHeight = diagramHeight + 2 * CELL_PADDING + captionHeight; const left = Math.round((image.width - 2 * cellWidth - COLUMN_GAP) / 2); @@ -75,7 +80,7 @@ export class LayoutPage implements OnboardingPage { image.drawText(font, x + Math.round((cellWidth - font.measureText(text)) / 2), textY, text, value); const captionTop = y + CELL_PADDING + diagramHeight + CAPTION_GAP; const name = appSwitcherPositionSetting.displayValue(position); - const caption = position === RECOMMENDED_LAYOUT ? `${name} (Recommended)` : name; + const caption = position === recommendedLayout() ? `${name} (Recommended)` : name; centre(caption, title, captionTop, selected ? 255 : 190); if (layoutHasDepth(position)) { centre(DEPTH_SUBTITLE, subtitle, captionTop + title.lineHeight, selected ? 210 : 150); @@ -103,12 +108,14 @@ export class LayoutPage implements OnboardingPage { } /** - * A layout's diagram: the 288px band, with the popup switcher open. Only a - * bottom switcher row takes rows under the band; without one, the band sits - * centred in their place, as the band and row share the screen's slack. + * A layout's diagram: the min-height band, with the popup switcher open. + * Only a bottom switcher row takes rows under the band; without one, the + * band sits centred in their place, as the band and row share the screen's + * slack (none on a screen as short as the RayNeo iO's: the band fills it). */ function drawLayoutDiagram(d: Diagram, position: AppSwitcherPosition): void { - d.outline(0, 0, G2_LENS_WIDTH, LAYOUT_AREA_HEIGHT, AREA_OUTLINE, 12); - const top = position === "bottom" ? 0 : (LAYOUT_AREA_HEIGHT - MIN_WINDOW_HEIGHT) / 2; - drawLayout(d, position, { top, height: MIN_WINDOW_HEIGHT, fullWidth: false }, true); + d.outline(0, 0, screenWidth(), layoutAreaHeight(), AREA_OUTLINE, 12); + const height = diagramBandHeight(position); + const top = position === "bottom" ? 0 : (layoutAreaHeight() - height) / 2; + drawLayout(d, position, { top, height, fullWidth: false }, true); } diff --git a/app/apps/onboarding/text-size-page.ts b/app/apps/onboarding/text-size-page.ts index 46498f45..485691b7 100644 --- a/app/apps/onboarding/text-size-page.ts +++ b/app/apps/onboarding/text-size-page.ts @@ -3,6 +3,7 @@ import { installedFontPath } from "../../graphics/installed-fonts"; import { wrapText } from "../../graphics/textwrap"; import { TtfFont } from "../../graphics/ttf-font"; import { + defaultUiFontSize, fontSelectionLabel, getDefaultSmallFont, getUiFontSelection, @@ -25,8 +26,6 @@ const ROW_GAP = 2; const NOTE_GAP = 8; /** The sizes offered here; Settings has the full range. */ const SIZE_CHOICES = FONT_SIZE_CHOICES.filter((size) => size >= 12 && size <= 18); -/** Selected on the first visit, and marked. */ -const RECOMMENDED_SIZE = 16; const RECOMMENDED_NOTE = "Recommended"; /** Drawn while they fit, so smaller sizes visibly show more words. */ const PREVIEW_PARAGRAPHS = [ @@ -41,7 +40,8 @@ type Face = | { kind: "fixed"; label: string }; /** - * The UI font's size, 12 to 18px (16 recommended, and selected at first), + * The UI font's size, 12 to 18px (the default size recommended, and + * selected at first: 16px, or 14px on the RayNeo iO), * beside a preview of text in the selected size. The face and weight stay * as they are (they live in the Settings font picker); a bitmap face has * only one size, so the page just says so. The size is saved on tap, not @@ -67,7 +67,7 @@ export class TextSizePage implements OnboardingPage { if (sizes.length) { this.face = { kind: "sized", file: selection.file, path, sizes }; // The recommended size the first time; on a return, what was left selected. - this.sizeMenu.setItems(sizes, nearestIndex(sizes, this.sizeMenu.selectedItem ?? RECOMMENDED_SIZE)); + this.sizeMenu.setItems(sizes, nearestIndex(sizes, this.sizeMenu.selectedItem ?? defaultUiFontSize())); return; } } @@ -137,7 +137,7 @@ export class TextSizePage implements OnboardingPage { const body = onboardingFont("body"); const label = sizeLabel(size); image.drawText(body, x + 10, y + LIST_ROW_TEXT_INSET, label, selected ? 255 : 190); - if (size !== RECOMMENDED_SIZE) return; + if (size !== defaultUiFontSize()) return; const detail = onboardingFont("detail"); const noteY = y + Math.round((height - detail.lineHeight) / 2); image.drawText(detail, x + 10 + body.measureText(label) + NOTE_GAP, noteY, RECOMMENDED_NOTE, selected ? 210 : 150); diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index 83f976db..52d732a4 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -56,7 +56,7 @@ import { claimGlassesOnboardingAutoLaunch, ONBOARDING_APP_ID } from "../apps/onb import { beginRenderPass, endRenderPass } from "../util/render-freshness"; import { voiceControlBridge } from "../native/voice-control"; import { voiceActivity } from "../ui/shell/voice-activity"; -import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage, RAYNEO_IO_HEIGHT, RAYNEO_IO_WIDTH } from "../graphics/image"; +import { GrayImage } from "../graphics/image"; import { flattenPlanesWithDraws, planesFingerprint, type Plane } from "../graphics/plane"; import { prepareFrameDraws } from "../graphics/glyph-wire"; import { createLockScreenImage, LOCK_SCREEN_SURFACE_ID } from "./lock-screen"; @@ -75,7 +75,7 @@ import { ALL_APPS } from "../apps/all-apps"; import { type AppContext, type AppDefinition, type AppLaunchParams, type TextEditorHost } from "../apps/app-definition"; import { type InProcessAppOptions, type InProcessWindow } from "../ui/shell/in-process-window"; import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-apps-persistence"; -import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible, type ScreenRect, type WindowHeightMode } from "../ui/shell/geometry"; +import { appViewportRect, isOnSwitcherEdge, screenHeight, screenWidth, sidebarStripVisible, type ScreenRect, type WindowHeightMode } from "../ui/shell/geometry"; import { type ContinuousCaptureOptions, type LayerActions, type TextSettingsEditToggle, type TranscriptionChoice } from "../ui/layers"; import { type KeyboardInputSession } from "../ui/shell/keyboard-input"; import { appSwitcherPositionSetting, glassesTypeSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayLayoutSetting, navigateDisplayLayoutSetting, terminalDisplayLayoutSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, whisperServerApiKeySetting, whisperServerLanguageSetting, whisperServerModelSetting, whisperServerUrlSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, type RingConnectionMode, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; @@ -191,8 +191,8 @@ const EVEN_APP_DETECTED_MESSAGE = const LAUNCHABLE_APPS = ALL_APPS.filter((app) => app.showInLauncher !== false); /** - * The global settings window viewport sizes depend on: the display mode's - * size (a band's position only moves windows), whether the app switcher + * The global settings window viewport sizes depend on: the paired glasses' + * screen, the display mode's size (a band's position only moves windows), whether the app switcher * takes width beside windows, height below them or neither (a popup), and * the chrome rows each window loses to it: below them, whether the status * bar joins the row (dropping the top bar); with a popup, whether the @@ -205,7 +205,7 @@ function viewportSizesKey(): string { : position === "popup" ? `popup|${statusBarVisibilitySetting.get()}|${windowBorderSetting.get()}` : "strip"; const layout = displayLayoutSetting.get(); - return `${layout.startsWith("band-") ? "band" : layout}|${switcher}`; + return `${screenWidth()}x${screenHeight()}|${layout.startsWith("band-") ? "band" : layout}|${switcher}`; } /** The global settings that move window surfaces without resizing them. */ @@ -214,7 +214,7 @@ function windowPlacementKey(): string { } function createInitialDisplayPreview(): ImageSource | null { - return grayImageToPreviewSource(new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0)); + return grayImageToPreviewSource(new GrayImage(screenWidth(), screenHeight(), 0)); } /** Echo the controller's appendLog() trace to the console. */ @@ -609,14 +609,28 @@ class DashboardController { * are. Windows that can't resize keep the surface they have, the switcher * covering any of it that it now overlaps, rather than being relaunched * for it. + * + * A window is judged by its own size as well as its surface's rect: other + * paths (connect, a launch) configure surfaces from the geometry without + * resizing windows, so a window laid out before the row's height was known + * (restored at startup, at the default height) can sit behind a surface + * that already matches, and its frames would not fit it. */ private applySwitcherBarHeight(): void { void (async () => { for (const window of Array.from(shell.getWindows())) { - const rect = JSON.stringify(appViewportRect(window.heightMode, window.appId)); - if (!window.relayout || this.windowSurfaceRects.get(window.surfaceId) === rect) continue; - window.relayout(); - await this.configureWindowSurface(window.surfaceId, this.isForegroundWindow(window.windowId), window.heightMode); + if (!window.relayout) continue; + const rect = appViewportRect(window.heightMode, window.appId); + const size = window.layoutSize?.(); + const resized = !!size && (size.width !== rect.width || size.height !== rect.height); + if (!resized && this.windowSurfaceRects.get(window.surfaceId) === JSON.stringify(rect)) continue; + try { + window.relayout(); + await this.configureWindowSurface(window.surfaceId, this.isForegroundWindow(window.windowId), window.heightMode); + } catch (error) { + // The rest still need to follow the row. + this.appendLog(`switcher height change failed for ${window.windowId}: ${this.formatError(error)}`); + } } shell.foregroundWindow()?.requestRender(); this.requestShellRender(); @@ -807,8 +821,8 @@ class DashboardController { await communicator.configureSurface(LOCK_SCREEN_SURFACE_ID, { x: 0, y: 0, - width: G2_LENS_WIDTH, - height: G2_LENS_HEIGHT, + width: screenWidth(), + height: screenHeight(), zOrder: 1000, transparency: "opaque", }); @@ -1386,12 +1400,12 @@ class DashboardController { // is in place before any real render can reach the compositor. this.previewTarget = target; try { - await target.configureCompositorScreen(G2_LENS_WIDTH, G2_LENS_HEIGHT); + await target.configureCompositorScreen(screenWidth(), screenHeight()); await target.configureSurface(SHELL_SURFACE_ID, { x: 0, y: 0, - width: G2_LENS_WIDTH, - height: G2_LENS_HEIGHT, + width: screenWidth(), + height: screenHeight(), zOrder: SHELL_SURFACE_Z_ORDER, transparency: "color-key", }); @@ -1517,10 +1531,8 @@ class DashboardController { // configure their surfaces through this.communicator, and the Java call // queue is FIFO, so enqueuing the screen size first guarantees it lands // ahead of them. Mirrors ensurePreviewDisplay. - // The iO shows 540x220: the layout stays the G2's and is cropped at the right and - // bottom (geometry.ts pins the band to the top-left while an iO is configured). - if (glassesType === "rayneo-io") await communicator.configureCompositorScreen(RAYNEO_IO_WIDTH, RAYNEO_IO_HEIGHT); - else await communicator.configureCompositorScreen(G2_LENS_WIDTH, G2_LENS_HEIGHT); + // The paired glasses' screen: the G2's 640x480 or the RayNeo iO's 540x220. + await communicator.configureCompositorScreen(screenWidth(), screenHeight()); await communicator.configureBrightness(getBrightnessPreferences()); this.offState = communicator.onStateChange((state) => { if (state.phase !== "connected") resetRingInputFilter(); @@ -1702,8 +1714,8 @@ class DashboardController { await communicator.configureSurface(SHELL_SURFACE_ID, { x: 0, y: 0, - width: G2_LENS_WIDTH, - height: G2_LENS_HEIGHT, + width: screenWidth(), + height: screenHeight(), zOrder: SHELL_SURFACE_Z_ORDER, transparency: "color-key", }); @@ -2006,8 +2018,8 @@ class DashboardController { return; } const at = mirrorToPanelFraction(this.displayPreviewCrop, nx, ny); - const x = Math.round(Math.min(1, Math.max(0, at.nx)) * G2_LENS_WIDTH); - const y = Math.round(Math.min(1, Math.max(0, at.ny)) * G2_LENS_HEIGHT); + const x = Math.round(Math.min(1, Math.max(0, at.nx)) * screenWidth()); + const y = Math.round(Math.min(1, Math.max(0, at.ny)) * screenHeight()); const foreground = shell.foregroundWindow(); const stripShown = sidebarStripVisible(shell.getFocus(), foreground?.appId); this.appendLog(`mirror tap at ${x},${y}`); diff --git a/app/g2/lock-screen.ts b/app/g2/lock-screen.ts index 485504bd..7f140eeb 100644 --- a/app/g2/lock-screen.ts +++ b/app/g2/lock-screen.ts @@ -1,23 +1,26 @@ -import { GrayImage, G2_LENS_WIDTH, G2_LENS_HEIGHT } from "../graphics/image"; +import { GrayImage } from "../graphics/image"; +import { screenHeight, screenWidth } from "../graphics/screen-size"; import { getDefaultMediumFont } from "../graphics/ui-fonts"; import { wrapText } from "../graphics/textwrap"; export const LOCK_SCREEN_SURFACE_ID = "lock-screen"; const LOCK_SCREEN_MESSAGE = "Glasses locked; unlock the phone to unlock the glasses."; +/** The paired glasses' whole screen, black, with the message in a box at its centre. */ export function createLockScreenImage(): GrayImage { - const image = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); + const width = screenWidth(), height = screenHeight(); + const image = new GrayImage(width, height, 0); const font = getDefaultMediumFont(); const boxWidth = 480; const boxHeight = 150; - const boxX = Math.round((G2_LENS_WIDTH - boxWidth) / 2); - const boxY = Math.round((G2_LENS_HEIGHT - boxHeight) / 2); + const boxX = Math.round((width - boxWidth) / 2); + const boxY = Math.round((height - boxHeight) / 2); image.drawRoundedRect(boxX, boxY, boxWidth, boxHeight, 150, 12); const lines = wrapText(font, LOCK_SCREEN_MESSAGE, boxWidth - 64); const textHeight = lines.length * font.lineHeight; const firstY = boxY + Math.round((boxHeight - textHeight) / 2); lines.forEach((line, index) => { - const x = Math.round((G2_LENS_WIDTH - font.measureText(line)) / 2); + const x = Math.round((width - font.measureText(line)) / 2); image.drawText(font, x, firstY + index * font.lineHeight, line, 230); }); return image; diff --git a/app/g2/phone-preview-crop.ts b/app/g2/phone-preview-crop.ts index 2eafaa51..b0138414 100644 --- a/app/g2/phone-preview-crop.ts +++ b/app/g2/phone-preview-crop.ts @@ -1,6 +1,5 @@ -import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../graphics/image"; import { previewScalingSetting } from "../ui/dashboard-settings"; -import { phonePreviewRect, usedScreenRect, type ScreenRect } from "../ui/shell/geometry"; +import { phonePreviewRect, screenHeight, screenWidth, usedScreenRect, type ScreenRect } from "../ui/shell/geometry"; import { shell } from "../ui/shell/shell"; /** @@ -14,7 +13,7 @@ export function phonePreviewCrop(locked: boolean, glanceRect: ScreenRect | null) if (locked || previewScalingSetting.get() === "raw") return null; const window = shell.foregroundWindow(); const crop = phonePreviewRect(glanceRect ?? usedScreenRect(window?.heightMode ?? "min", window?.appId)); - const wholePanel = crop.x === 0 && crop.y === 0 && crop.width === G2_LENS_WIDTH && crop.height === G2_LENS_HEIGHT; + const wholePanel = crop.x === 0 && crop.y === 0 && crop.width === screenWidth() && crop.height === screenHeight(); return wholePanel ? null : crop; } @@ -27,7 +26,7 @@ export function phonePreviewCrop(locked: boolean, glanceRect: ScreenRect | null) export function mirrorToPanelFraction(crop: ScreenRect | null, nx: number, ny: number): { nx: number; ny: number } { if (!crop) return { nx, ny }; return { - nx: (crop.x + nx * crop.width) / G2_LENS_WIDTH, - ny: (crop.y + ny * crop.height) / G2_LENS_HEIGHT, + nx: (crop.x + nx * crop.width) / screenWidth(), + ny: (crop.y + ny * crop.height) / screenHeight(), }; } diff --git a/app/graphics/screen-size.ts b/app/graphics/screen-size.ts new file mode 100644 index 00000000..c5d7621f --- /dev/null +++ b/app/graphics/screen-size.ts @@ -0,0 +1,27 @@ +/** + * The paired glasses' screen (per eye), which the shell and UI lay out in: + * the G2's 640x480, or the RayNeo iO's 540x220 with the Faceclaw firmware. + * + * Read straight from the settings store (the key dashboard-settings.ts's + * glassesTypeSetting writes), so this stays a leaf that UI primitives can + * import without pulling in the settings module, and every isolate (the + * main one, app workers, the phone preview) agrees with the session. + */ +import { getStringSetting } from "../native/settings-store"; +import { G2_LENS_HEIGHT, G2_LENS_WIDTH, RAYNEO_IO_HEIGHT, RAYNEO_IO_WIDTH } from "./image"; + +/** Settings key of the paired glasses' type: "g2" (default) or "rayneo-io". */ +export const GLASSES_TYPE_KEY = "deviceType"; + +/** Whether the paired glasses are a RayNeo iO. */ +export function isRayNeoIoConfigured(): boolean { + return getStringSetting(GLASSES_TYPE_KEY, "g2") === "rayneo-io"; +} + +export function screenWidth(): number { + return isRayNeoIoConfigured() ? RAYNEO_IO_WIDTH : G2_LENS_WIDTH; +} + +export function screenHeight(): number { + return isRayNeoIoConfigured() ? RAYNEO_IO_HEIGHT : G2_LENS_HEIGHT; +} diff --git a/app/graphics/ui-fonts.ts b/app/graphics/ui-fonts.ts index bcf5e786..62f4b3e3 100644 --- a/app/graphics/ui-fonts.ts +++ b/app/graphics/ui-fonts.ts @@ -13,6 +13,7 @@ import type { UiFont } from "./image"; import { TtfFont } from "./ttf-font"; import { ensurePreinstalledFonts, getInstalledFont, installedFontPath } from "./installed-fonts"; import { getStringSetting, onSettingsStoreChanged, setStringSetting } from "../native/settings-store"; +import { GLASSES_TYPE_KEY, isRayNeoIoConfigured } from "./screen-size"; export type BitmapFace = "terminus" | "terminusv"; @@ -72,8 +73,18 @@ export function parseFontSelection(raw: string): UiFontSelection | null { return null; } -/** Default UI font when the user has never picked one. */ -const DEFAULT_UI_FONT: UiFontSelection = { kind: "ttf", file: "Roboto-Light.ttf", size: 16 }; +/** + * The default UI font's size, which onboarding recommends: 16, or 14 on the + * RayNeo iO, whose 540x220 screen fits fewer rows. + */ +export function defaultUiFontSize(): number { + return isRayNeoIoConfigured() ? 14 : 16; +} + +/** Default UI font when the user has never picked one: Roboto Light at the default size. */ +function defaultUiFont(): UiFontSelection { + return { kind: "ttf", file: "Roboto-Light.ttf", size: defaultUiFontSize() }; +} export function getUiFontSelection(): UiFontSelection { const parsed = parseFontSelection(getStringSetting(UI_FONT_SELECTION_KEY, "")); @@ -84,7 +95,7 @@ export function getUiFontSelection(): UiFontSelection { if (legacy === "terminus" || legacy === "terminusv") { return { kind: "bitmap", face: legacy }; } - return DEFAULT_UI_FONT; + return defaultUiFont(); } export function setUiFontSelection(selection: UiFontSelection): void { @@ -113,7 +124,8 @@ export function fontSelectionLabel(selection: UiFontSelection): string { type UiFontRole = "small" | "medium" | "large"; -const UI_FONT_KEYS: readonly string[] = [UI_FONT_SELECTION_KEY, LEGACY_UI_FONT_KEY]; +/** Keys whose change re-resolves the UI fonts (the glasses type picks the default size). */ +const UI_FONT_KEYS: readonly string[] = [UI_FONT_SELECTION_KEY, LEGACY_UI_FONT_KEY, GLASSES_TYPE_KEY]; /** * The three role fonts for one selection source, resolved lazily and cached diff --git a/app/phone-ui/main-view-model.ts b/app/phone-ui/main-view-model.ts index 78495514..3e76904f 100644 --- a/app/phone-ui/main-view-model.ts +++ b/app/phone-ui/main-view-model.ts @@ -25,10 +25,13 @@ import { isValidMacAddress, loadDeviceAddresses } from "../g2/device-addresses"; import { isAutoReconnectSuppressed, resumeAutoReconnect } from "../g2/reconnect-policy"; import { isPreviewOnlyMode } from "./onboarding-state"; import { formatErrorMessage } from "../util/format-error"; -import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../graphics/image"; +import { screenHeight, screenWidth } from "../ui/shell/geometry"; import { type PhoneUiButton } from "../apps/evenhub/manager"; -const LENS_ASPECT_RATIO = G2_LENS_WIDTH / G2_LENS_HEIGHT; +/** The paired glasses' screen aspect (4:3 on the G2, 27:11 on the RayNeo iO). */ +function lensAspectRatio(): number { + return screenWidth() / screenHeight(); +} type LayoutOrientation = "portrait" | "landscape"; @@ -228,7 +231,7 @@ export class MainViewModel extends RemoteControlsViewModel { } get displayPreviewHeight(): number { - return Screen.mainScreen.widthDIPs / LENS_ASPECT_RATIO; + return Screen.mainScreen.widthDIPs / lensAspectRatio(); } get landscapeDisplayPreviewWidth(): number { @@ -244,8 +247,8 @@ export class MainViewModel extends RemoteControlsViewModel { // and controls, and updates for rotation, split-screen, and the keyboard. const { width, height } = args.object.getActualSize(); if (width <= 0 || height <= 0) return; - const previewHeight = Math.min(height, width / LENS_ASPECT_RATIO); - const previewWidth = previewHeight * LENS_ASPECT_RATIO; + const previewHeight = Math.min(height, width / lensAspectRatio()); + const previewWidth = previewHeight * lensAspectRatio(); if (previewWidth === this._landscapePreviewWidth && previewHeight === this._landscapePreviewHeight) return; this._landscapePreviewWidth = previewWidth; this._landscapePreviewHeight = previewHeight; diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index b158c3fb..280668ba 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -153,37 +153,40 @@ type ConfigSettingEnumOptions = Confi normalize?: (value: string | null | undefined) => TValue; /** Dynamic availability check used by enum picker rows. */ isDisabled?: (value: TValue) => boolean; - /** A value forced regardless of storage while it returns one (stored choice untouched). */ - pinned?: () => TValue | undefined; + /** The default while nothing is stored, when it depends on context (else `defaultValue`). */ + dynamicDefault?: () => TValue | undefined; }; export class ConfigSettingEnum extends ConfigSetting { readonly values: readonly TValue[]; private readonly normalizer: (value: string | null | undefined) => TValue; private readonly disabledPredicate: (value: TValue) => boolean; - protected readonly pinned: (() => TValue | undefined) | undefined; + private readonly dynamicDefault: (() => TValue | undefined) | undefined; constructor(options: ConfigSettingEnumOptions) { super(options); - this.pinned = options.pinned; + this.dynamicDefault = options.dynamicDefault; if (options.reportInAnalytics !== false) fixedChoiceSettings.set(options.storageKey, this); this.values = options.values; this.disabledPredicate = options.isDisabled ?? (() => false); if (options.normalize) { this.normalizer = (value: string | null | undefined) => { const normalized = options.normalize(value) as TValue|undefined; - if (normalized === undefined) return this.defaultValue; + if (normalized === undefined) return this.currentDefault(); return normalized; } } else { - this.normalizer = (value) => this.values.includes(value as TValue) ? value as TValue : this.defaultValue; + this.normalizer = (value) => this.values.includes(value as TValue) ? value as TValue : this.currentDefault(); } } + /** What an unset (or invalid) value reads as now. */ + protected currentDefault(): TValue { + return this.dynamicDefault?.() ?? this.defaultValue; + } + get(): TValue { - const pinned = this.pinned?.(); - if (pinned !== undefined) return pinned; - return this.normalizer(getStringSetting(this.storageKey, this.defaultValue)); + return this.normalizer(getStringSetting(this.storageKey, this.currentDefault())); } set(value: TValue): TValue { @@ -379,7 +382,7 @@ export type GlassesType = "g2" | "rayneo-io"; export const glassesTypeSetting = new ConfigSettingEnum({ id: "glasses-type", label: "Glasses", - storageKey: "deviceType", + storageKey: "deviceType", // graphics/screen-size.ts GLASSES_TYPE_KEY reads it directly defaultValue: "g2", values: ["g2", "rayneo-io"], reportInAnalytics: false, @@ -398,8 +401,8 @@ export const appSwitcherPositionSetting = new ConfigSettingEnum (glassesTypeSetting.get() === "rayneo-io" ? "right" : undefined), + // The RayNeo iO's 220 rows can't spare a bottom row: a side strip by default there. + dynamicDefault: () => (glassesTypeSetting.get() === "rayneo-io" ? "left" : undefined), formatValue: (value) => APP_SWITCHER_POSITION_LABELS[value] ?? value, description: "Where the open-app icons go. Left and right take a column beside windows; bottom puts a row beneath the window, which makes full-height windows a little shorter; popup shows them only while you're in the app switcher, in a box over the dimmed window. Bottom and popup leave room at the sides to set the display's depth. Open apps reopen at their new size when a change resizes windows.", @@ -415,8 +418,6 @@ class ConfigSettingEnumWithLegacy extends ConfigSettingEn } get(): TValue { - const pinned = this.pinned?.(); - if (pinned !== undefined) return pinned; return getStringSetting(this.storageKey, "") === "" ? this.legacyValue() : super.get(); } } @@ -478,8 +479,6 @@ export const displayLayoutSetting = new ConfigSettingEnumWithLegacy (glassesTypeSetting.get() === "rayneo-io" ? "band-top" : undefined), formatValue: displayLayoutLabel, isDisabled: (value) => value === "fullscreen" && !fullScreenAvailable(), description: @@ -1683,11 +1682,17 @@ export class EditTextSettingLayer implements Layer { for (let index = 0; index < message.length; index++) { image.drawText(font, 22, messageTop + index * step, message[index]!, 200); } - image.drawText(font, 22, messageTop + (message.length + 2) * step, truncateSetting(this.setting.get(), 52), 220); + const valueY = messageTop + (message.length + 2) * step; + image.drawText(font, 22, valueY, truncateSetting(this.setting.get(), 52), 220); const error = this.setting.validationError(); - if (error) wrapText(font, error, width - 48).forEach((line, index) => + const errorLines = error ? wrapText(font, error, width - 48) : []; + errorLines.forEach((line, index) => image.drawText(font, 22, messageTop + (message.length + 4 + index) * step, line, 180)); - image.drawText(font, 22, height - 24 - font.lineHeight, `${GESTURE_DOUBLE_CLICK} back`, 110); + // The back hint at the bottom, unless a short window (the RayNeo iO's) + // leaves it no room under the value and error. + const contentBottom = errorLines.length ? messageTop + (message.length + 4 + errorLines.length) * step : valueY + step; + const hintY = height - 24 - font.lineHeight; + if (hintY >= contentBottom) image.drawText(font, 22, hintY, `${GESTURE_DOUBLE_CLICK} back`, 110); return image; } diff --git a/app/ui/dashboard/settings-panel.ts b/app/ui/dashboard/settings-panel.ts index 687c3f97..1e0bcf40 100644 --- a/app/ui/dashboard/settings-panel.ts +++ b/app/ui/dashboard/settings-panel.ts @@ -36,6 +36,8 @@ const ROW_GAP = 2; /** Horizontal inset of row text (and custom row content) from its selection box. */ const ROW_TEXT_X = 10; const MAX_DESCRIPTION_LINES = 3; +/** Rows a section's list keeps beside its detail while focus is in it (see detailCrowdsList). */ +const MIN_LIST_ROWS = 3; // A throwaway menu to satisfy MenuItem.onSelect's second parameter; the // settings items never use it (they act via ctx only). const NO_MENU = new MenuLayer(null, []); @@ -134,7 +136,7 @@ export class SettingsPanelLayer implements Layer { const rightX = divX + 14; const rightW = width - rightX - PAD; let rightTop = top; - if (section.renderDetail) { + if (section.renderDetail && !this.detailCrowdsList(section, ctx, font, { x: rightX, y: top, width: rightW, height: listBottom - top })) { const used = section.renderDetail({ image, x: rightX, y: top, width: rightW, height: listBottom - top, ctx }); rightTop = typeof used === "number" ? Math.min(top + used, listBottom) : listBottom; } @@ -157,6 +159,28 @@ export class SettingsPanelLayer implements Layer { return image; } + /** + * Whether the section's detail (About's blurb, the watch status) would + * leave its rows less than MIN_LIST_ROWS while focus is in them, as on a + * short screen (the RayNeo iO's): the list then takes the whole pane, the + * detail staying in the preview. Measured by drawing the detail on a + * scratch image. + */ + private detailCrowdsList( + section: SettingsSection, + ctx: LayerContext, + font: UiFont, + pane: { x: number; y: number; width: number; height: number }, + ): boolean { + if (this.focus !== "right" || !section.items.length || !section.renderDetail) return false; + const scratch = new GrayImage(pane.x + pane.width, pane.y + pane.height, 0); + const used = section.renderDetail({ image: scratch, ...pane, ctx }); + if (typeof used !== "number") return false; + const rows = Math.min(MIN_LIST_ROWS, section.items.length); + const room = pane.height - used - this.descriptionHeight(font, pane.width); + return room < rows * (listRowHeight(font) + ROW_GAP); + } + /** The selected item's wrapped help text, or [] when none applies. */ private descriptionLines(font: UiFont, rightW: number): string[] { if (this.focus !== "right") return []; diff --git a/app/ui/font-picker.ts b/app/ui/font-picker.ts index f9fdac7c..7698904c 100644 --- a/app/ui/font-picker.ts +++ b/app/ui/font-picker.ts @@ -13,6 +13,7 @@ import { getFont } from "../graphics/bdffont"; import { GrayImage, type UiFont } from "../graphics/image"; import { TtfFont } from "../graphics/ttf-font"; import { listInstalledFonts, type InstalledFont } from "../graphics/installed-fonts"; +import { wrapText } from "../graphics/textwrap"; import { fontSelectionLabel, getDefaultSmallFont, @@ -140,18 +141,40 @@ export class FontPickerLayer implements Layer { const rowWidth = width - 2 * rowX; const rowHeight = listRowHeight(font); const rowsTop = 24 + font.lineHeight; - this.menu.paint(image, { x: rowX - 10, y: rowsTop, width: rowWidth + 20, height: ROWS.length * rowHeight }, focused); - - // Preview: a separator, then the sample line in the draft font. - const previewTop = rowsTop + ROWS.length * rowHeight + 10; - image.drawLine(rowX - 10, previewTop, rowX + rowWidth + 10, previewTop, 60); + const rowsHeight = ROWS.length * rowHeight; const preview = this.previewFont(); - const sample = - preview.measureText(PREVIEW_TEXT) <= rowWidth + 20 ? PREVIEW_TEXT : "The quick brown fox 0123"; - preview.drawText(image, rowX - 4, previewTop + 8, sample, 230); const info = `Line height: ${preview.lineHeight}px`; - image.drawText(font, rowX - 4, previewTop + 8 + preview.lineHeight + 6, info, 110); + // Preview under the rows, where its sample line and the info line fit + // (the G2's window): a separator, then the sample line in the draft font. + const previewTop = rowsTop + rowsHeight + 10; + if (previewTop + 8 + preview.lineHeight + 6 + font.lineHeight <= height) { + this.menu.paint(image, { x: rowX - 10, y: rowsTop, width: rowWidth + 20, height: rowsHeight }, focused); + image.drawLine(rowX - 10, previewTop, rowX + rowWidth + 10, previewTop, 60); + const sample = + preview.measureText(PREVIEW_TEXT) <= rowWidth + 20 ? PREVIEW_TEXT : "The quick brown fox 0123"; + preview.drawText(image, rowX - 4, previewTop + 8, sample, 230); + image.drawText(font, rowX - 4, previewTop + 8 + preview.lineHeight + 6, info, 110); + return image; + } + + // Else beside them (a short window, as on the RayNeo iO), the sample + // wrapped to the column, as many lines as fit above the info line. + const columnWidth = Math.round(rowWidth / 2); + const bottom = height - 8; + this.menu.paint(image, { x: rowX - 10, y: rowsTop, width: columnWidth + 20, height: Math.min(rowsHeight, bottom - rowsTop) }, focused); + const dividerX = rowX + columnWidth + 20; + image.drawLine(dividerX, rowsTop, dividerX, Math.min(rowsTop + rowsHeight, bottom), 60); + const previewX = dividerX + 12; + const lines = wrapText(preview, PREVIEW_TEXT, width - previewX - 12); + const infoY = bottom - font.lineHeight; + let y = rowsTop + 4; + for (const line of lines) { + if (y + preview.lineHeight > infoY - 6) break; + preview.drawText(image, previewX, y, line, 230); + y += preview.lineHeight; + } + image.drawText(font, previewX, Math.min(infoY, y + 6), info, 110); return image; } diff --git a/app/ui/layers.ts b/app/ui/layers.ts index 1553216d..a16a98ff 100644 --- a/app/ui/layers.ts +++ b/app/ui/layers.ts @@ -1,4 +1,5 @@ -import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage } from "../graphics/image"; +import { GrayImage } from "../graphics/image"; +import { screenHeight, screenWidth } from "../graphics/screen-size"; import { dimPlanes, type Plane } from "../graphics/plane"; import { spanCurrent } from "../native/frame-timings"; import { type ConfigSettingBoolean, type ConfigSettingString, type VoiceProvider } from "./dashboard-settings"; @@ -172,8 +173,8 @@ export class LayerStack { stack: this, actions, }; - this.baseWidth = baseSize?.width ?? G2_LENS_WIDTH; - this.baseHeight = baseSize?.height ?? G2_LENS_HEIGHT; + this.baseWidth = baseSize?.width ?? screenWidth(); + this.baseHeight = baseSize?.height ?? screenHeight(); this.focusedFn = isFocused; } diff --git a/app/ui/menu.ts b/app/ui/menu.ts index e8205418..104b3925 100644 --- a/app/ui/menu.ts +++ b/app/ui/menu.ts @@ -1,4 +1,5 @@ -import { G2_LENS_HEIGHT, GrayImage, type UiFont } from "../graphics/image"; +import { GrayImage, type UiFont } from "../graphics/image"; +import { screenHeight } from "../graphics/screen-size"; import { wrapText } from "../graphics/textwrap"; import { getDefaultSmallFont } from "../graphics/ui-fonts"; import { getStringSetting } from "../native/settings-store"; @@ -18,9 +19,14 @@ setMenuAnimationReader(() => normalizeAnimationSpeed(getStringSetting(MENU_ANIMA const DEFAULT_MENU_X = 8; const DEFAULT_MENU_Y = 8; const DEFAULT_MENU_WIDTH = 272; +/** Windows shorter than this (the RayNeo iO's, not the G2's) get tighter modal margins. */ +const SHORT_WINDOW_HEIGHT = 200; // Menus grow with their item count, from half the screen (matching the old // fixed quarter-screen-era look) up to the full screen, then scroll. -const DEFAULT_MENU_MIN_HEIGHT = G2_LENS_HEIGHT / 2 - 2 * DEFAULT_MENU_Y; +/** Half the screen, less the menu's top and bottom offsets. */ +function defaultMenuMinHeight(): number { + return screenHeight() / 2 - 2 * DEFAULT_MENU_Y; +} const MENU_BODY_PADDING = 8; /** Gap between the last item row and a footer hint line. */ const MENU_FOOTER_GAP = 8; @@ -302,7 +308,7 @@ export class MenuLayer implements Layer { const { y, width } = this.layout; const x = this.layout.x === "center" ? ((image.width - width) / 2) | 0 : this.layout.x; const chromeTop = (this.title ? menuTitleHeight(font) : 0) + MENU_BODY_PADDING; - const minHeight = this.layout.minHeight ?? DEFAULT_MENU_MIN_HEIGHT; + const minHeight = this.layout.minHeight ?? defaultMenuMinHeight(); // Cap to the surface being painted on: a window's stack image may be much // shorter than the full screen (min-height windows). const maxHeight = Math.min( @@ -376,7 +382,10 @@ export function openModalMenu( const font = getDefaultSmallFont(); const menuWidth = Math.min(320, width - 40); const naturalHeight = menuTitleHeight(font) + 2 * MENU_BODY_PADDING + items.length * listRowHeight(font); - const menuHeight = Math.min(naturalHeight, height - 40); + // 20px clear above and below, or 8 in a short window (the RayNeo iO's), + // where those rows are worth more than the margin. + const marginY = height < SHORT_WINDOW_HEIGHT ? 8 : 20; + const menuHeight = Math.min(naturalHeight, height - 2 * marginY); const layout: MenuLayout = { x: ((width - menuWidth) / 2) | 0, y: ((height - menuHeight) / 2) | 0, diff --git a/app/ui/shell/brightness-picker-layer.ts b/app/ui/shell/brightness-picker-layer.ts index f735b0ab..cb7ee08f 100644 --- a/app/ui/shell/brightness-picker-layer.ts +++ b/app/ui/shell/brightness-picker-layer.ts @@ -8,7 +8,11 @@ import { appViewportRect, SHELL_OPAQUE_BLACK } from "./geometry"; const DIALOG_WIDTH = 272; const BAR_WIDTH = 12; +/** The bar's height where the window has room (the G2's); it shrinks to fit a shorter one, down to MIN_BAR_HEIGHT. */ const BAR_HEIGHT = 100; +const MIN_BAR_HEIGHT = 24; +/** Clear space kept above and below the dialog in the window. */ +const MARGIN_Y = 4; /** Manual brightness changes apply immediately so the wearer can judge the level. */ export class BrightnessPickerLayer implements Layer { @@ -22,7 +26,9 @@ export class BrightnessPickerLayer implements Layer { const image = paintBelow(); const font = getDefaultSmallFont(); const viewport = appViewportRect("min"); - const height = BAR_HEIGHT + 3 * font.lineHeight + 56; + const chrome = 3 * font.lineHeight + 56; + const barHeight = clamp(viewport.height - 2 * MARGIN_Y - chrome, MIN_BAR_HEIGHT, BAR_HEIGHT); + const height = barHeight + chrome; const left = viewport.x + Math.round((viewport.width - DIALOG_WIDTH) / 2); const top = viewport.y + Math.round((viewport.height - height) / 2); image.fillRect(left, top, DIALOG_WIDTH, height, SHELL_OPAQUE_BLACK); @@ -35,14 +41,14 @@ export class BrightnessPickerLayer implements Layer { const barX = left + Math.round((DIALOG_WIDTH - BAR_WIDTH) / 2); const barY = top + font.lineHeight + 24; const level = brightnessSettingToLevel(brightnessSetting.get()); - image.drawRect(barX - 2, barY - 2, BAR_WIDTH + 4, BAR_HEIGHT + 4, 150); - const filledHeight = Math.round(BAR_HEIGHT * (level ?? 0) / 100); - image.fillRect(barX, barY + BAR_HEIGHT - filledHeight, BAR_WIDTH, filledHeight, 255); - image.drawText(font, barX + BAR_WIDTH + 12, barY + Math.round((BAR_HEIGHT - font.lineHeight) / 2), + image.drawRect(barX - 2, barY - 2, BAR_WIDTH + 4, barHeight + 4, 150); + const filledHeight = Math.round(barHeight * (level ?? 0) / 100); + image.fillRect(barX, barY + barHeight - filledHeight, BAR_WIDTH, filledHeight, 255); + image.drawText(font, barX + BAR_WIDTH + 12, barY + Math.round((barHeight - font.lineHeight) / 2), level === null ? "Auto" : `${level}%`, 235); - centeredText(gestureHints([[GESTURE_SCROLL, "adjust"]]), barY + BAR_HEIGHT + 12, 150); + centeredText(gestureHints([[GESTURE_SCROLL, "adjust"]]), barY + barHeight + 12, 150); centeredText(gestureHints([[`${GESTURE_CLICK} / ${GESTURE_DOUBLE_CLICK}`, "confirm"]]), - barY + BAR_HEIGHT + font.lineHeight + 16, 150); + barY + barHeight + font.lineHeight + 16, 150); return image; } diff --git a/app/ui/shell/chrome-layer.ts b/app/ui/shell/chrome-layer.ts index 33c2c211..72d1ae17 100644 --- a/app/ui/shell/chrome-layer.ts +++ b/app/ui/shell/chrome-layer.ts @@ -1,7 +1,7 @@ import { shellCrop } from "../../graphics/shell-scene"; import type { Plane } from "../../graphics/plane"; import { DrawOp, type ListCall, type ListClip } from "../../graphics/display-list"; -import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage, grayToNibble } from "../../graphics/image"; +import { GrayImage, grayToNibble } from "../../graphics/image"; import { getDefaultMediumFont, getDefaultSmallFont } from "../../graphics/ui-fonts"; import { truncateText } from "../../graphics/textwrap"; import { activeAmbientCards } from "./ambient-cards"; @@ -29,7 +29,9 @@ import { lineStep } from "../metrics"; import { appViewportRect, isImmersive, - MIN_WINDOW_HEIGHT, + minWindowHeight, + screenHeight, + screenWidth, minWindowTop, setSwitcherBarHeight, SHELL_OPAQUE_BLACK, @@ -68,7 +70,10 @@ const TWO_COLUMN: SidebarVariant = { columns: 2, columnWidth: 32, iconSize: 28 } const ICON_SPACING = 8; /** Icon list top/bottom margins within the sidebar band, below the top bar (and a bottom row's end margins). */ const LIST_MARGIN = 10; -const LIST_HEIGHT = MIN_WINDOW_HEIGHT - TOP_BAR_HEIGHT - 2 * LIST_MARGIN; +/** Height of the sidebar's icon list: the min-height band less its top bar and margins. */ +function listHeight(appId?: string): number { + return minWindowHeight(appId) - TOP_BAR_HEIGHT - 2 * LIST_MARGIN; +} /** Bottom-row icons: one tall tab's worth of row, the icon inset 2px all round. */ const ROW_ICON_SIZE = SWITCHER_ROW_HEIGHT - 4; @@ -123,7 +128,7 @@ const POPUP_DIM = 0.5; /** Icon rows that fit in one sidebar column. */ function rowsPerColumn(variant: SidebarVariant): number { - return Math.max(1, ((LIST_HEIGHT + ICON_SPACING) / (variant.iconSize + ICON_SPACING)) | 0); + return Math.max(1, ((listHeight() + ICON_SPACING) / (variant.iconSize + ICON_SPACING)) | 0); } function sidebarVariant(windowCount: number): SidebarVariant { @@ -136,7 +141,7 @@ function sidebarVariant(windowCount: number): SidebarVariant { */ function columnLeft(variant: SidebarVariant, column: number, position: AppSwitcherPosition): number { return position === "right" - ? G2_LENS_WIDTH - SIDEBAR_WIDTH + column * variant.columnWidth + ? screenWidth() - SIDEBAR_WIDTH + column * variant.columnWidth : SIDEBAR_WIDTH - (column + 1) * variant.columnWidth; } @@ -382,7 +387,7 @@ export function sidebarContentSpan(windowCount: number): { left: number; right: const variant = sidebarVariant(windowCount); const width = variant.columns * variant.columnWidth; return switcherPosition() === "right" - ? { left: G2_LENS_WIDTH - SIDEBAR_WIDTH, right: G2_LENS_WIDTH - SIDEBAR_WIDTH + width } + ? { left: screenWidth() - SIDEBAR_WIDTH, right: screenWidth() - SIDEBAR_WIDTH + width } : { left: SIDEBAR_WIDTH - width, right: SIDEBAR_WIDTH }; } @@ -396,7 +401,7 @@ function topBarSpan(state: ShellChromeState): { left: number; right: number } { if (sidebarStripVisible(state.focus, state.foregroundAppId)) { const position = switcherPosition(); if (position === "left") left = Math.max(left, SIDEBAR_WIDTH); - if (position === "right") right = Math.min(right, G2_LENS_WIDTH - SIDEBAR_WIDTH); + if (position === "right") right = Math.min(right, screenWidth() - SIDEBAR_WIDTH); } return { left, right }; } @@ -624,7 +629,7 @@ export class ShellChromeLayer implements Layer { ) {} paint(): GrayImage { - const image = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); + const image = new GrayImage(screenWidth(), screenHeight(), 0); const state = this.getState(); this.statusEntries = []; this.bottomBar = this.layoutBottomBar(state); @@ -651,7 +656,7 @@ export class ShellChromeLayer implements Layer { this.statusEntries = []; this.bottomBar = this.layoutBottomBar(state); const statusInRow = statusInSwitcherRow(state.foregroundAppId); - const canvas = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); + const canvas = new GrayImage(screenWidth(), screenHeight(), 0); const span = topBarSpan(state); const bar = statusBarPlacement(state); if (bar) { @@ -664,7 +669,7 @@ export class ShellChromeLayer implements Layer { return parts; } if (switcherShown) { - const stripCanvas = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); + const stripCanvas = new GrayImage(screenWidth(), screenHeight(), 0); const statusLeft = this.drawSidebar(stripCanvas, state, statusInRow ? canvas : undefined); // The window frame rides on the switcher row, whose top edge is its // bottom side, and so replays after any top bar, whose bottom row is @@ -704,14 +709,14 @@ export class ShellChromeLayer implements Layer { // to be sent at all, so the frame rides on one at its top-left corner, // outside its curve, which it paints black anyway. As in the bottom // row's case, it plays at the screen's own depth. - const frameCanvas = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); + const frameCanvas = new GrayImage(screenWidth(), screenHeight(), 0); frameCanvas.fillRect(frame.x, frame.y, 1, 1, SHELL_OPAQUE_BLACK); drawWindowFrame(frameCanvas, frame, false, true); parts.push(shellCrop(frameCanvas, frame.x, frame.y, 1, 1, 1)); } drawAmbientCards(canvas, topBarSpan(state).right, parts); if (!switcherShown) return; - const popupCanvas = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); + const popupCanvas = new GrayImage(screenWidth(), screenHeight(), 0); const box = this.drawPopup(popupCanvas, state); this.popupKey ??= LayerStack.allocateShellKey(); parts.push({ ...shellCrop(popupCanvas, box.x, box.y, box.width, box.height, this.popupKey), depth: POPUP_DEPTH }); @@ -892,8 +897,8 @@ export class ShellChromeLayer implements Layer { const batteries = batteryItems(state); if (batteries.length) { // Measured by drawing it: each battery style lays itself out as it draws. - const scratch = new GrayImage(G2_LENS_WIDTH, TOP_BAR_HEIGHT, 0); - const width = G2_LENS_WIDTH - BATTERY_BLOCK_RIGHT_MARGIN - drawBatteryBlock(scratch, batteries, 0, G2_LENS_WIDTH); + const scratch = new GrayImage(screenWidth(), TOP_BAR_HEIGHT, 0); + const width = screenWidth() - BATTERY_BLOCK_RIGHT_MARGIN - drawBatteryBlock(scratch, batteries, 0, screenWidth()); // The block keeps its usual right margin inside the edge it's given. items.push({ kind: "batteries", width, draw: (image, x, top) => drawBatteryBlock(image, batteries, top, x + width + BATTERY_BLOCK_RIGHT_MARGIN) }); @@ -1237,7 +1242,7 @@ function drawAmbientCards(image: GrayImage, right: number, parts?: Plane[]): voi if (!cards.length) return; const font = getDefaultSmallFont(); const bandTop = minWindowTop(); - const bandBottom = bandTop + MIN_WINDOW_HEIGHT - windowFooterHeight(); + const bandBottom = bandTop + minWindowHeight() - windowFooterHeight(); // Right-aligned with the top bar: clear of a right-hand sidebar. const x = right - AMBIENT_CARD_WIDTH - AMBIENT_CARD_MARGIN; const textWidth = AMBIENT_CARD_WIDTH - 2 * AMBIENT_CARD_PADDING_X; diff --git a/app/ui/shell/geometry.ts b/app/ui/shell/geometry.ts index b3b0c75e..f1deb9d4 100644 --- a/app/ui/shell/geometry.ts +++ b/app/ui/shell/geometry.ts @@ -1,4 +1,4 @@ -import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../../graphics/image"; +import { screenHeight, screenWidth } from "../../graphics/screen-size"; import { appSwitcherPositionSetting, type AppSwitcherPosition, @@ -12,6 +12,9 @@ import { windowBorderSetting, } from "../dashboard-settings"; +/** The paired glasses' screen, which the shell lays out in (graphics/screen-size.ts). */ +export { screenHeight, screenWidth }; + /** Top bar: 24px notification icons plus a little padding. */ export const TOP_BAR_HEIGHT = 28; /** @@ -174,15 +177,15 @@ export function switcherRect(heightMode: WindowHeightMode, appId?: string): { x: const height = reserved || switcherBarHeights.overlay; return { x: appViewportLeft(appId), - y: reserved > 0 ? windowTop(heightMode, appId) + windowBandHeight(heightMode, appId) : G2_LENS_HEIGHT - height, + y: reserved > 0 ? windowTop(heightMode, appId) + windowBandHeight(heightMode, appId) : screenHeight() - height, width: appViewportWidth(appId), height, }; } case "right": - return { x: G2_LENS_WIDTH - SIDEBAR_WIDTH, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: MIN_WINDOW_HEIGHT }; + return { x: screenWidth() - SIDEBAR_WIDTH, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: minWindowHeight(appId) }; default: - return { x: 0, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: MIN_WINDOW_HEIGHT }; + return { x: 0, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: minWindowHeight(appId) }; } } @@ -293,15 +296,15 @@ export function isOnSwitcherEdge(x: number, y: number, heightMode: WindowHeightM case "bottom": return y >= switcherRect(heightMode, appId).y; case "right": - return x >= G2_LENS_WIDTH - SIDEBAR_WIDTH; + return x >= screenWidth() - SIDEBAR_WIDTH; default: return x < SIDEBAR_WIDTH; } } -/** Width of app windows: the panel's when Full Screen or immersive, else 576 (see SIDEBAR_WIDTH). */ +/** Width of app windows: the screen's when Full Screen or immersive, else SIDEBAR_WIDTH less (576 on the G2). */ function appViewportWidth(appId?: string): number { - return fullWidth(appId) ? G2_LENS_WIDTH : G2_LENS_WIDTH - SIDEBAR_WIDTH; + return fullWidth(appId) ? screenWidth() : screenWidth() - SIDEBAR_WIDTH; } /** @@ -353,7 +356,7 @@ export function effectiveHeightMode(mode: WindowHeightMode, appId?: string): Win * rather than use the viewport's own centre. */ export function screenCenterInViewportX(): number { - return Math.round(G2_LENS_WIDTH / 2) - appViewportLeft(); + return Math.round(screenWidth() / 2) - appViewportLeft(); } /** @@ -374,15 +377,23 @@ export const SHELL_OPAQUE_BLACK = 1; */ export type WindowHeightMode = "min" | "medium" | "max"; -/** Total height (header + content) of a min-height window. */ +/** Total height (header + content) of a min-height window on a screen with room for it: the G2's stock band. */ export const MIN_WINDOW_HEIGHT = 288; +/** + * Total height of a min-height window here: the stock 288px band, or the + * whole window area on a screen too short for it (the RayNeo iO's 220 rows). + */ +export function minWindowHeight(appId?: string): number { + return Math.min(MIN_WINDOW_HEIGHT, windowAreaHeight(appId)); +} + /** * Height of the screen area windows are placed in: the whole screen, less * a bottom switcher's height. */ function windowAreaHeight(appId?: string): number { - return G2_LENS_HEIGHT - switcherRowHeight(appId); + return screenHeight() - switcherRowHeight(appId); } /** Total height (header + content + footer) of a window's band in the given mode. */ @@ -391,9 +402,9 @@ export function windowBandHeight(mode: WindowHeightMode, appId?: string): number case "max": return windowAreaHeight(appId); case "medium": - return MIN_WINDOW_HEIGHT + windowHeaderHeight(appId) + windowFooterHeight(appId); + return Math.min(windowAreaHeight(appId), minWindowHeight(appId) + windowHeaderHeight(appId) + windowFooterHeight(appId)); default: - return MIN_WINDOW_HEIGHT; + return minWindowHeight(appId); } } @@ -425,7 +436,7 @@ export function minWindowTop(appId?: string): number { */ export function windowTop(mode: WindowHeightMode, appId?: string): number { const band = windowBandHeight(mode, appId); - const oneRowArea = G2_LENS_HEIGHT - (switcherRowHeight(appId) > 0 ? SWITCHER_ROW_HEIGHT : 0); + const oneRowArea = screenHeight() - (switcherRowHeight(appId) > 0 ? SWITCHER_ROW_HEIGHT : 0); const top = Math.round((oneRowArea - band) * verticalPositionFraction(appId)); return Math.min(top, windowAreaHeight(appId) - band); } @@ -473,13 +484,13 @@ function unionRect(a: ScreenRect, b: ScreenRect): ScreenRect { * the whole panel. The phone mirror's Scaled preview zooms to this. */ export function usedScreenRect(heightMode: WindowHeightMode, appId?: string): ScreenRect { - if (isImmersive(appId)) return { x: 0, y: 0, width: G2_LENS_WIDTH, height: G2_LENS_HEIGHT }; + if (isImmersive(appId)) return { x: 0, y: 0, width: screenWidth(), height: screenHeight() }; const frame = windowFramed(appId) ? 1 : 0; const x = appViewportLeft(appId) - frame; const width = appViewportWidth(appId) + 2 * frame; let used = unionRect( { x, y: windowTop(heightMode, appId), width, height: windowBandHeight(heightMode, appId) }, - { x, y: minWindowTop(appId), width, height: MIN_WINDOW_HEIGHT }, + { x, y: minWindowTop(appId), width, height: minWindowHeight(appId) }, ); if (switcherPosition() !== "popup") used = unionRect(used, switcherRect(heightMode, appId)); return used; @@ -487,15 +498,18 @@ export function usedScreenRect(heightMode: WindowHeightMode, appId?: string): Sc /** * The screen area the phone mirror shows to present `used` as large as it - * fits, centred, at the panel's own 4:3 aspect (so the mirror keeps its - * shape whatever the display mode): `used` grown along one axis, past the - * panel's edges if need be (the mirror shows black there). + * fits, centred, at the screen's own aspect (4:3 on the G2, 27:11 on the iO), + * so the mirror keeps its shape whatever the display mode: `used` grown along + * one axis, past the screen's edges if need be (the mirror shows black there). */ export function phonePreviewRect(used: ScreenRect): ScreenRect { - // Whole 4:3 units, so the aspect is exact. - const units = Math.ceil(Math.max(used.width / 4, used.height / 3)); - const width = units * 4; - const height = units * 3; + // Whole aspect units, so the aspect is exact. + const gcd = (a: number, b: number): number => (b ? gcd(b, a % b) : a); + const unit = gcd(screenWidth(), screenHeight()); + const aspectW = screenWidth() / unit, aspectH = screenHeight() / unit; + const units = Math.ceil(Math.max(used.width / aspectW, used.height / aspectH)); + const width = units * aspectW; + const height = units * aspectH; return { x: Math.round(used.x + (used.width - width) / 2), y: Math.round(used.y + (used.height - height) / 2), diff --git a/app/ui/shell/in-process-window.ts b/app/ui/shell/in-process-window.ts index d51e1f5f..dc5a25e3 100644 --- a/app/ui/shell/in-process-window.ts +++ b/app/ui/shell/in-process-window.ts @@ -226,6 +226,7 @@ export function createInProcessWindow(options: InProcessWindowOptions): InProces options.reconfigureSurface?.(heightMode); requestRender(); }, + layoutSize: () => stack.getBaseSize(), hitTest: async (x, y) => { const handled = await stack.hitTest(x, y); if (handled) requestRender(); diff --git a/app/ui/shell/input-dialog.ts b/app/ui/shell/input-dialog.ts index c2cdb6cd..6d8f3855 100644 --- a/app/ui/shell/input-dialog.ts +++ b/app/ui/shell/input-dialog.ts @@ -1,9 +1,9 @@ -import { G2_LENS_WIDTH, GrayImage, type UiFont } from "../../graphics/image"; +import { GrayImage, type UiFont } from "../../graphics/image"; import { wrapText, truncateText } from "../../graphics/textwrap"; import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { Menu, type MenuDrawArgs } from "../menu-core"; import { listRowHeight, textInkBounds } from "../metrics"; -import { MIN_WINDOW_HEIGHT, minWindowTop } from "./geometry"; +import { minWindowHeight, minWindowTop, screenWidth } from "./geometry"; /** * The shared look of the shell's text dialogs (voice input, phone keyboard @@ -13,17 +13,26 @@ import { MIN_WINDOW_HEIGHT, minWindowTop } from "./geometry"; */ const DIALOG_X = 40; -const DIALOG_W = G2_LENS_WIDTH - 80; +/** The screen less DIALOG_X on each side. */ +function dialogW(): number { + return screenWidth() - 2 * DIALOG_X; +} // The dialog fits inside the min-height window band (like the other shell // overlays), wherever the vertical position setting puts it. const DIALOG_MARGIN_Y = 28; -const DIALOG_H = MIN_WINDOW_HEIGHT - 2 * DIALOG_MARGIN_Y; -const TEXT_MAX_WIDTH = DIALOG_W - 32; +function dialogH(): number { + return minWindowHeight() - 2 * DIALOG_MARGIN_Y; +} +function textMaxWidth(): number { + return dialogW() - 32; +} const TEXT_LEFT = DIALOG_X + 16; // Menu row boxes: 4px left of the text column, 2px shorter than the row // pitch, with each row's label inset 8px / 4px into its box. const MENU_X = TEXT_LEFT - 4; -const MENU_W = DIALOG_W - 24; +function menuW(): number { + return dialogW() - 24; +} const MENU_ROW_GAP = 2; const MENU_LABEL_INSET_X = 8; const MENU_LABEL_INSET_Y = 4; @@ -89,28 +98,28 @@ export function paintInputDialog(image: GrayImage, con // Solid dialog box over the underlying UI. Fill 1, not 0: identical after // 4bpp quantization, but 0 is transparent on the color-key shell surface. - image.fillRect(DIALOG_X, top, DIALOG_W, DIALOG_H, 1); - image.drawRect(DIALOG_X, top, DIALOG_W, DIALOG_H, 90); + image.fillRect(DIALOG_X, top, dialogW(), dialogH(), 1); + image.drawRect(DIALOG_X, top, dialogW(), dialogH(), 90); // Title and status share one header line, the status in the space after the title. const left = TEXT_LEFT; const headerY = top + 12; image.drawText(font, left, headerY, content.title, 220); const statusLeft = left + Math.ceil(font.measureText(content.title)) + HEADER_STATUS_GAP; - const statusWidth = TEXT_LEFT + TEXT_MAX_WIDTH - statusLeft; + const statusWidth = TEXT_LEFT + textMaxWidth() - statusLeft; image.drawText(font, statusLeft, headerY, truncateText(font, content.status, statusWidth), content.statusValue ?? 130); const menu = content.menu; const rowCount = menu?.items.length ?? 0; // Reserve space for the actual number of rows this menu has, or one row for the hint. const reservedRows = rowCount > 0 ? rowCount : content.hint ? 1 : 0; - const textBottom = top + DIALOG_H - reservedRows * menuRowH - 8; + const textBottom = top + dialogH() - reservedRows * menuRowH - 8; const textTop = headerY + font.lineHeight + 12; const maxLines = Math.max(1, ((textBottom - textTop) / 16) | 0); // The tail of a long message stays in view: it is what was said last (or // where the phone keyboard is typing). - const wrapped = wrapText(font, content.text, TEXT_MAX_WIDTH); + const wrapped = wrapText(font, content.text, textMaxWidth()); const firstLine = Math.max(0, wrapped.length - maxLines); for (let index = firstLine; index < wrapped.length; index++) { image.drawText(font, left, textTop + (index - firstLine) * 16, wrapped[index]!, 235); @@ -118,11 +127,11 @@ export function paintInputDialog(image: GrayImage, con if (menu && rowCount > 0) { // Row boxes are one pitch apart, the last ending 6px above the dialog's bottom edge. - const menuTop = top + DIALOG_H - rowCount * menuRowH - 4; - menu.paint(image, { x: MENU_X, y: menuTop, width: MENU_W, height: rowCount * menuRowH - MENU_ROW_GAP }, true); + const menuTop = top + dialogH() - rowCount * menuRowH - 4; + menu.paint(image, { x: MENU_X, y: menuTop, width: menuW(), height: rowCount * menuRowH - MENU_ROW_GAP }, true); } else if (content.hint) { // On the line the last menu row's label would occupy, floating in front of the dialog. - drawDepthText(image, font, truncateText(font, content.hint, TEXT_MAX_WIDTH), left, top + DIALOG_H - menuRowH, HINT_VALUE, HINT_DEPTH); + drawDepthText(image, font, truncateText(font, content.hint, textMaxWidth()), left, top + dialogH() - menuRowH, HINT_VALUE, HINT_DEPTH); } } diff --git a/app/ui/shell/shell.ts b/app/ui/shell/shell.ts index 10338fab..a8112acb 100644 --- a/app/ui/shell/shell.ts +++ b/app/ui/shell/shell.ts @@ -1,5 +1,5 @@ import { encodeShellScene } from "../../graphics/shell-scene"; -import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage } from "../../graphics/image"; +import { GrayImage } from "../../graphics/image"; import { singlePlane, type Plane } from "../../graphics/plane"; import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { EvenAIStatus, EventSourceType, OsEventTypeList, WatchGestureType } from "../../g2/events"; @@ -82,6 +82,8 @@ import { windowFramed, windowTop, type WindowHeightMode, + screenHeight, + screenWidth, } from "./geometry"; import type { AppSwitcherPosition } from "../dashboard-settings"; @@ -163,6 +165,12 @@ export type ShellWindow = { * they opened with when the bottom switcher changes height. */ relayout?: () => void; + /** + * The viewport size the window is laid out at (it changes on relayout), so + * the controller can tell a window whose size fell behind the geometry from + * one whose surface merely moved. + */ + layoutSize?: () => { width: number; height: number }; /** * A touch from the phone's mirror at (x, y) in app-viewport coordinates. * True if the window acted on it; otherwise the controller sends a select. @@ -354,7 +362,10 @@ class ShellOverlayMenuLayer extends MenuLayer { /** How long a show_alert popup stays before auto-dismissing. */ const ALERT_DISMISS_MS = 6000; const ALERT_X = 40; -const ALERT_W = G2_LENS_WIDTH - 80; +/** Alert width: the screen less ALERT_X on each side. */ +function alertW(): number { + return screenWidth() - 2 * ALERT_X; +} const ALERT_Y = 96; const ALERT_H = 96; @@ -378,14 +389,14 @@ class ShellAlertLayer implements Layer { const font = getDefaultSmallFont(); // Positioned within the min-height window band, like the other shell overlays. const alertY = minWindowTop() + ALERT_Y; - image.fillRect(ALERT_X, alertY, ALERT_W, ALERT_H, 1); - image.drawRect(ALERT_X, alertY, ALERT_W, ALERT_H, 90); + image.fillRect(ALERT_X, alertY, alertW(), ALERT_H, 1); + image.drawRect(ALERT_X, alertY, alertW(), ALERT_H, 90); image.drawText(font, ALERT_X + 16, alertY + 12, "Assistant", 200); image.drawTextWrapped({ font, x: ALERT_X + 16, y: alertY + 18 + font.lineHeight + 4, - width: ALERT_W - 32, + width: alertW() - 32, text: this.text, value: 235, }); @@ -965,7 +976,7 @@ class Shell { paintSurface(): Plane[] { if (!this.screenOn) { - return singlePlane(new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0)); + return singlePlane(new GrayImage(screenWidth(), screenHeight(), 0)); } return this.stack.paint(); } diff --git a/app/ui/shell/worker-window.ts b/app/ui/shell/worker-window.ts index 79cb3799..5b1b010a 100644 --- a/app/ui/shell/worker-window.ts +++ b/app/ui/shell/worker-window.ts @@ -445,12 +445,13 @@ export class WorkerAppHost { const surfaceId = `window:${spec.windowId}`; const heightMode = spec.heightMode ?? "min"; this.openWindows.add(spec.windowId); + let viewport = appViewportSize(heightMode, this.options.appId); this.post({ type: "open-window", windowId: spec.windowId, surfaceId, title: spec.title, - viewport: appViewportSize(heightMode, this.options.appId), + viewport, }); const window: ShellWindow = { appId: this.options.appId, @@ -463,7 +464,11 @@ export class WorkerAppHost { // Every app worker resizes its live content in place, keeping its state // (a game in progress, a route): the bottom switcher's height changes // with what it holds, and full-height windows give way to it. - relayout: () => this.post({ type: "resize-window", windowId: spec.windowId, viewport: appViewportSize(heightMode, this.options.appId) }), + relayout: () => { + viewport = appViewportSize(heightMode, this.options.appId); + this.post({ type: "resize-window", windowId: spec.windowId, viewport }); + }, + layoutSize: () => viewport, hasAppMenu: () => this.windowGestures.get(spec.windowId)?.hasAppMenu ?? false, claimsLongPress: () => this.windowGestures.get(spec.windowId)?.claimsLongPress ?? false, close: () => { diff --git a/tests/ai-chat.test.cjs b/tests/ai-chat.test.cjs index 635ce280..88f0d6db 100644 --- a/tests/ai-chat.test.cjs +++ b/tests/ai-chat.test.cjs @@ -258,6 +258,7 @@ function shellEnv({ wakeAction = 'voice-input', skipConfirmation = false } = {}) const layers = load('app/ui/layers.ts', { '../graphics/image': images, '../graphics/plane': { dimPlanes: (planes) => planes }, '../native/frame-timings': timings, './gestures': gestures, + '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, }); class Menu { constructor(title, items) { this.title = title; this.items = items; this.selectedIndex = 0; } @@ -285,6 +286,7 @@ function shellEnv({ wakeAction = 'voice-input', skipConfirmation = false } = {}) '../../native/notification-icons': {}, '../../native/notification-sources': {}, '../../assistant/tool-registry': {}, './geometry': { sidebarWidth: () => 64, minWindowTop: () => 96, switcherPosition: () => 'left', uiDepth: () => 0, + screenWidth: () => 640, screenHeight: () => 480, appViewportRect: () => ({ x: 64, y: 124, width: 576, height: 260 }), }, }); diff --git a/tests/app-layout.test.cjs b/tests/app-layout.test.cjs index 533ae0e8..aa238318 100644 --- a/tests/app-layout.test.cjs +++ b/tests/app-layout.test.cjs @@ -9,20 +9,21 @@ const js = (source) => ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, }).outputText; -function geometry() { +// The shell geometry over a G2's 640x480 screen, or `screen` (a RayNeo iO is 540x220). +function geometry(screen = { width: 640, height: 480 }) { const settings = Object.fromEntries(Object.entries({ displayLayoutSetting: 'band-middle', navigateDisplayLayoutSetting: 'global', terminalDisplayLayoutSetting: 'default', appSwitcherPositionSetting: 'left', uiDepthSetting: '0', statusBarPositionSetting: 'top', statusBarVisibilitySetting: 'always', windowBorderSetting: true, }).map(([name, value]) => [name, { value, get() { return this.value; } }])); const context = { exports: {}, require: (name) => { - if (name === '../../graphics/image') return { G2_LENS_WIDTH: 640, G2_LENS_HEIGHT: 480 }; + if (name === '../../graphics/screen-size') return { screenWidth: () => screen.width, screenHeight: () => screen.height }; assert.equal(name, '../dashboard-settings'); return settings; } }; vm.runInNewContext(js(read('app/ui/shell/geometry.ts')), context); const rect = (mode, appId) => ({ ...context.exports.appViewportRect(mode, appId) }); - return { ...context.exports, settings, rect }; + return { ...context.exports, settings, screen, rect }; } const LAYOUTS = ['band-top', 'band-high', 'band-middle', 'band-low', 'band-bottom', 'tall', 'fullscreen']; @@ -263,6 +264,78 @@ test('an immersive app fills the panel without chrome rows, frame or depth, in a } }); +test('on a RayNeo iO\'s 540x220 screen windows take every row under the bar, beside the strip or over the row', () => { + const g = geometry({ width: 540, height: 220 }); + const panel = { x: 0, y: 0, width: 540, height: 220 }; + // A band is the whole screen's height, so every band position is the same. + for (const layout of LAYOUTS) { + g.settings.displayLayoutSetting.value = layout; + g.settings.appSwitcherPositionSetting.value = 'left'; + assert.equal(g.minWindowHeight(), 220); + assert.equal(g.minWindowTop(), 0); + for (const mode of ['min', 'medium', 'max']) assert.deepEqual(g.rect(mode), { x: 64, y: 28, width: 476, height: 192 }, layout); + assert.deepEqual({ ...g.switcherRect('min') }, { x: 0, y: 0, width: 64, height: 220 }); + g.settings.appSwitcherPositionSetting.value = 'right'; + assert.deepEqual(g.rect('min'), { x: 0, y: 28, width: 476, height: 192 }); + assert.deepEqual({ ...g.switcherRect('min') }, { x: 476, y: 0, width: 64, height: 220 }); + } + assert.equal(g.isOnSwitcherEdge(500, 10, 'min'), true); + assert.equal(g.screenCenterInViewportX(), 270); + // A bottom row: the window centred above it, its sides room for the deepest shift. + g.settings.appSwitcherPositionSetting.value = 'bottom'; + g.settings.displayLayoutSetting.value = 'band-middle'; + assert.deepEqual(g.rect('min'), { x: 32, y: 28, width: 476, height: 156 }); + assert.deepEqual({ ...g.switcherRect('min') }, { x: 32, y: 184, width: 476, height: 36 }); + g.settings.displayLayoutSetting.value = 'fullscreen'; + assert.deepEqual(g.rect('min'), { x: 0, y: 28, width: 540, height: 156 }); + // The phone mirror shows the whole screen, at its 27:11. + g.settings.displayLayoutSetting.value = 'band-middle'; + for (const position of ['left', 'bottom', 'popup']) { + g.settings.appSwitcherPositionSetting.value = position; + assert.deepEqual({ ...g.phonePreviewRect({ ...g.usedScreenRect('min') }) }, panel, position); + } + // Every layout stays on the screen. + g.settings.uiDepthSetting.value = '62'; + for (const switcher of ['left', 'right', 'bottom', 'popup']) { + g.settings.appSwitcherPositionSetting.value = switcher; + for (const statusBar of ['top', 'bottom']) { + g.settings.statusBarPositionSetting.value = statusBar; + for (const layout of LAYOUTS) { + g.settings.displayLayoutSetting.value = layout; + for (const mode of ['min', 'medium', 'max']) { + const rect = g.rect(mode), row = g.switcherRect(mode); + const where = `${switcher} ${statusBar} ${layout} ${mode}`; + assert.ok(rect.x >= 0 && rect.y >= 0 && rect.x + rect.width <= 540 && rect.y + rect.height <= 220, where); + assert.ok(row.y >= 0 && row.y + row.height <= 220, where); + if (g.windowFramed()) assert.ok(rect.x - 1 - 31 >= 0 && rect.x + rect.width + 31 < 540, where); + } + } + } + } + // The G2's band is unchanged. + assert.equal(geometry().minWindowHeight(), 288); +}); + +test('on a RayNeo iO the chrome paints the screen\'s size, its strip and row within it', () => { + for (const position of ['left', 'right', 'bottom', 'popup']) { + const g = geometry({ width: 540, height: 220 }); + g.settings.appSwitcherPositionSetting.value = position; + const { chrome, state } = chromeLayer(g, { windows: 3, notifications: 2, phoneBattery: 80 }); + state.focus = 'sidebar'; + const image = chrome.paint(); + assert.deepEqual([image.width, image.height], [540, 220], position); + const parts = chrome.paintParts(); + assert.ok(parts.length > 0, position); + for (const part of parts) { + assert.ok(part.x >= 0 && part.y >= 0 && part.x + part.image.width <= 540 && part.y + part.image.height <= 220, + `${position} part ${part.shellKey} at ${[part.x, part.y, part.image.width, part.image.height]}`); + } + // And it draws something there. + const lit = (x0, y0, w, h) => { for (let y = y0; y < y0 + h; y++) for (let x = x0; x < x0 + w; x++) if (image.pixels[y * 540 + x]) return true; return false; }; + assert.ok(lit(0, 0, 540, 220), position); + } +}); + test('the phone mirror zooms to the area the shell uses, centred at the panel\'s 4:3', () => { const g = geometry(); const preview = (mode, appId) => { diff --git a/tests/brightness-picker.test.cjs b/tests/brightness-picker.test.cjs index bc212b57..1052869b 100644 --- a/tests/brightness-picker.test.cjs +++ b/tests/brightness-picker.test.cjs @@ -25,9 +25,10 @@ const fonts = { getDefaultSmallFont: () => font }; const layers = load('app/ui/layers.ts', { '../graphics/image': graphics, '../graphics/plane': plane, './gestures': gestures, '../native/frame-timings': { spanCurrent: (_name, paint) => paint() }, + '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, }); const menu = load('app/ui/menu.ts', { - './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, + './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, './menu-highlight-motion': require('../.test-build/app/ui/menu-highlight-motion.js'), '../graphics/menu-scroll-list': require('../.test-build/app/graphics/menu-scroll-list.js'), './menu-scroll-motion': require('../.test-build/app/ui/menu-scroll-motion.js'), '../graphics/draw-expression': require('../.test-build/app/graphics/draw-expression.js'), '../graphics/image': graphics, '../graphics/ui-fonts': fonts, '../graphics/textwrap': textwrap, '../util/numeric-util': numeric, './gestures': gestures, './metrics': load('app/ui/metrics.ts'), @@ -108,6 +109,22 @@ test('the thin bar fills upward in proportion to brightness in each viewport', ( } }); +test('in a short window (a RayNeo iO\'s) the bar shrinks so the dialog stays inside it', () => { + for (const viewport of [{ x: 64, y: 28, width: 476, height: 192 }, { x: 32, y: 1, width: 476, height: 155 }]) { + const f = fixture('100', viewport); + const image = f.stack.paint().at(-1).image; + // The dialog's border (110) and the full bar (255), all within the window. + let top = Infinity, bottom = -1, fill = 0; + for (let y = 0; y < image.height; y++) for (let x = 0; x < image.width; x++) { + const value = image.getPixel(x, y); + if (value === 110) { top = Math.min(top, y); bottom = Math.max(bottom, y); } + if (value === 255) fill++; + } + assert.ok(top >= viewport.y && bottom < viewport.y + viewport.height, `dialog ${top}..${bottom} in ${JSON.stringify(viewport)}`); + assert.ok(fill > 0 && fill < 12 * 100, 'a shorter bar, still drawn'); + } +}); + test('system menu hides brightness in Auto and opens its picker between Voice input and Debug', async () => { const f = fixture('auto'); const { shell } = load('app/ui/shell/shell.ts', { diff --git a/tests/display-layout-setting.test.cjs b/tests/display-layout-setting.test.cjs index 56bbb17c..55e9f60b 100644 --- a/tests/display-layout-setting.test.cjs +++ b/tests/display-layout-setting.test.cjs @@ -65,16 +65,23 @@ test('Full Screen is offered only with a bottom or popup app switcher', () => { ['Band · Top', 'Band · High', 'Band · Middle', 'Band · Low', 'Band · Bottom', 'Tall', 'Full Screen']); }); -test('a RayNeo iO pins the band to the top and the switcher to the right, leaving the stored choice alone', () => { - const store = new Map([['display.layout', 'band-middle'], ['display.appSwitcherPosition', 'bottom']]); +test('a RayNeo iO defaults the app switcher to the left, and keeps a chosen position and the band', () => { + const store = new Map(); const api = settingsFixture(store); - assert.equal(api.displayLayoutSetting.get(), 'band-middle'); assert.equal(api.appSwitcherPositionSetting.get(), 'bottom'); api.glassesTypeSetting.set('rayneo-io'); - assert.equal(api.displayLayoutSetting.get(), 'band-top'); - assert.equal(api.appSwitcherPositionSetting.get(), 'right'); - assert.equal(store.get('display.layout'), 'band-middle'); - api.glassesTypeSetting.set('g2'); + assert.equal(api.appSwitcherPositionSetting.get(), 'left'); assert.equal(api.displayLayoutSetting.get(), 'band-middle'); + assert.equal(store.has('display.appSwitcherPosition'), false); + // A stored position is the user's, on either glasses. + api.appSwitcherPositionSetting.set('right'); + assert.equal(api.appSwitcherPositionSetting.get(), 'right'); + api.glassesTypeSetting.set('g2'); + assert.equal(api.appSwitcherPositionSetting.get(), 'right'); + store.delete('display.appSwitcherPosition'); assert.equal(api.appSwitcherPositionSetting.get(), 'bottom'); + // An unknown stored value falls back to the glasses' default. + store.set('display.appSwitcherPosition', 'sideways'); + api.glassesTypeSetting.set('rayneo-io'); + assert.equal(api.appSwitcherPositionSetting.get(), 'left'); }); diff --git a/tests/font-picker.test.cjs b/tests/font-picker.test.cjs new file mode 100644 index 00000000..5f890b99 --- /dev/null +++ b/tests/font-picker.test.cjs @@ -0,0 +1,88 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const vm = require('node:vm'); +const ts = require('typescript'); + +function load(file, modules) { + const source = fs.readFileSync(path.join(__dirname, '..', file), 'utf8'); + const context = { exports: {}, console, require(name) { assert.ok(name in modules, `${file}: ${name}`); return modules[name]; } }; + vm.runInNewContext(ts.transpileModule(source, { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText, context); + return context.exports; +} + +const build = (name) => require(`../.test-build/app/${name}.js`); +const graphics = build('graphics/image'); +const metrics = build('ui/metrics'); +const { BdfFont } = load('app/graphics/bdffont.ts', { '@nativescript/core': {} }); +const bdf = (size) => BdfFont.parse(fs.readFileSync(path.join(__dirname, `../app/fonts/terminus/ter-u${size}n.bdf`), 'utf8')); +const font = bdf(14); +const textwrap = load('app/graphics/textwrap.ts', {}); +const coreDeps = { + '../graphics/image': graphics, './menu-highlight-motion': build('ui/menu-highlight-motion'), + '../graphics/menu-scroll-list': build('graphics/menu-scroll-list'), './menu-scroll-motion': build('ui/menu-scroll-motion'), + '../graphics/draw-expression': build('graphics/draw-expression'), +}; +const menuCore = load('app/ui/menu-core.ts', coreDeps); +const menu = load('app/ui/menu.ts', { + ...coreDeps, './menu-animation-pref': build('ui/menu-animation-pref'), './animation-speed': build('ui/animation-speed'), + '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, + '../graphics/screen-size': { screenWidth: () => 540, screenHeight: () => 220 }, + '../graphics/textwrap': textwrap, '../graphics/ui-fonts': { getDefaultSmallFont: () => font }, + '../util/numeric-util': { clamp: (n, lo, hi) => Math.max(lo, Math.min(hi, n)) }, './gestures': {}, './metrics': metrics, './menu-core': menuCore, +}); +// The UI font picker on Roboto Light 20, drawn in Terminus (TTF rendering is native). +const preview = bdf(20); +const picker = load('app/ui/font-picker.ts', { + '../graphics/bdffont': { getFont: () => font }, '../graphics/image': graphics, '../graphics/textwrap': textwrap, + '../graphics/ttf-font': { TtfFont: { load: () => preview } }, + '../graphics/installed-fonts': { listInstalledFonts: () => [{ path: '/fonts/Roboto-Light.ttf', fileName: 'Roboto-Light.ttf', + family: 'Roboto', style: 'Light', weightOrder: 300, monospace: false }] }, + '../graphics/ui-fonts': { fontSelectionLabel: () => 'Roboto Light 20', getDefaultSmallFont: () => font, uiFontSizeAllowed: () => true, + getTerminalFontSelection: () => null, getUiFontSelection: () => ({ kind: 'ttf', file: 'Roboto-Light.ttf', size: 20 }), + setTerminalFontSelection() {}, setUiFontSelection() {} }, + './gestures': {}, './menu': menu, './menu-core': menuCore, './metrics': metrics, +}); + +function stackOf(size) { + const layers = []; + return { layers, ctx: { stack: { getBaseSize: () => size, isFocused: () => true, push: (layer) => layers.push(layer) } } }; +} +const glyphRuns = (image, f) => image.draws.filter((d) => d.kind === 'glyph' && d.font === f); + +test('the font picker previews under its rows where they fit, else beside them, on the window either way', () => { + // At 192 rows either fits, by the font's metrics: only the bounds are checked. + for (const [size, beside] of [[{ width: 576, height: 260 }, false], [{ width: 476, height: 192 }, null], [{ width: 476, height: 155 }, true]]) { + const { layers, ctx } = stackOf(size); + picker.uiFontPickerMenuItem().onSelect(ctx); + const image = layers[0].paint(ctx); + const sample = glyphRuns(image, preview); + // The rows' labels and values (255 selected, 200 not; the title is 220, the info line 110). + const rows = glyphRuns(image, font).filter((d) => d.value === 255 || d.value === 200); + assert.ok(sample.length > 20, `the sample is drawn at ${size.height}`); + for (const d of image.draws) { + if (d.kind !== 'glyph') continue; + assert.ok(d.x >= 0 && d.y >= 0 && d.x + d.glyph.bbxWidth <= size.width && d.y + d.font.lineHeight <= size.height, + `glyph at ${d.x},${d.y} outside ${size.width}x${size.height}`); + } + const rowsRight = Math.max(...rows.map((d) => d.x)), rowsBottom = Math.max(...rows.map((d) => d.y)); + if (beside === true) assert.ok(Math.min(...sample.map((d) => d.x)) > rowsRight, 'the sample right of the rows'); + if (beside === false) assert.ok(Math.min(...sample.map((d) => d.y)) > rowsBottom, 'the sample under the rows'); + } +}); + +test('a modal menu in a short window (a RayNeo iO\'s) keeps narrow margins, so four choices all show', () => { + const items = ['Left', 'Right', 'Bottom', 'Popup'].map((label) => ({ label, onSelect() {} })); + for (const [size, margin] of [[{ width: 576, height: 260 }, 20], [{ width: 476, height: 155 }, 8]]) { + const { layers, ctx } = stackOf(size); + menu.openModalMenu(ctx, 'App switcher position', items, 0); + const { layout } = layers[0]; + assert.ok(layout.y >= margin && layout.y + layout.maxHeight <= size.height - margin, `${size.height}: ${layout.y}+${layout.maxHeight}`); + // Title, body padding (8 above and below) and the four rows. + const natural = metrics.menuTitleHeight(font) + 2 * 8 + items.length * metrics.listRowHeight(font); + assert.equal(layout.maxHeight, natural, `${size.height}: every row fits`); + } +}); diff --git a/tests/icon-grid.test.cjs b/tests/icon-grid.test.cjs index 634b9570..fc1e784f 100644 --- a/tests/icon-grid.test.cjs +++ b/tests/icon-grid.test.cjs @@ -65,6 +65,7 @@ function loadIconGrid({ lastInputWasWatch = false } = {}) { './menu-animation-pref': build('ui/menu-animation-pref'), './animation-speed': build('ui/animation-speed'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, + '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, }); const grid = load('app/ui/icon-grid.ts', { ...common, diff --git a/tests/lock-screen.test.cjs b/tests/lock-screen.test.cjs new file mode 100644 index 00000000..81655546 --- /dev/null +++ b/tests/lock-screen.test.cjs @@ -0,0 +1,29 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const { loader } = require('./helpers/load-typescript.cjs'); +const graphics = require('../.test-build/app/graphics/image.js'); + +// lock-screen.ts on a screen of the given size; the text is not drawn. +function lockScreen(width, height) { + const font = { lineHeight: 20, measureText: (text) => text.length * 10, drawText() {} }; + const load = loader({}, { + '../graphics/image': graphics, + '../graphics/screen-size': { screenWidth: () => width, screenHeight: () => height }, + '../graphics/ui-fonts': { getDefaultMediumFont: () => font }, + '../graphics/textwrap': { wrapText: (_font, text) => [text] }, + }); + return load('app/g2/lock-screen.ts').createLockScreenImage(); +} + +// The lock surface is the screen's size, so its frame must be too. +test('the lock screen fills the paired glasses\' screen, its box centred on it', () => { + for (const [width, height] of [[640, 480], [540, 220]]) { + const image = lockScreen(width, height); + assert.deepEqual([image.width, image.height], [width, height]); + const lit = []; + for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) if (image.pixels[y * width + x]) lit.push([x, y]); + const xs = lit.map(([x]) => x), ys = lit.map(([, y]) => y); + const box = [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)]; + assert.deepEqual(box, [(width - 480) / 2, (height - 150) / 2, (width + 480) / 2 - 1, (height + 150) / 2 - 1], `${width}x${height}`); + } +}); diff --git a/tests/menu-display-list.test.cjs b/tests/menu-display-list.test.cjs index 4cf41711..3e97d1a6 100644 --- a/tests/menu-display-list.test.cjs +++ b/tests/menu-display-list.test.cjs @@ -18,7 +18,7 @@ const menuCore=load('app/ui/menu-core.ts',{ '../graphics/image':graphics,'./menu-highlight-motion': require('../.test-build/app/ui/menu-highlight-motion.js'), '../graphics/menu-scroll-list': require('../.test-build/app/graphics/menu-scroll-list.js'), './menu-scroll-motion': require('../.test-build/app/ui/menu-scroll-motion.js'), '../graphics/draw-expression': require('../.test-build/app/graphics/draw-expression.js'), }); const {MenuLayer,TextPageLayer}=load('app/ui/menu.ts',{ - './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, + './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, '../graphics/image':graphics,'../graphics/textwrap':{wrapText:(_font,text)=>text.split('\n')},'../graphics/ui-fonts':{getDefaultSmallFont:()=>font}, '../util/numeric-util':{clamp:(n,a,b)=>Math.max(a,Math.min(b,n))},'./gestures':{}, './menu-highlight-motion': require('../.test-build/app/ui/menu-highlight-motion.js'), '../graphics/menu-scroll-list': require('../.test-build/app/graphics/menu-scroll-list.js'), './menu-scroll-motion': require('../.test-build/app/ui/menu-scroll-motion.js'), '../graphics/draw-expression': require('../.test-build/app/graphics/draw-expression.js'), @@ -50,7 +50,7 @@ test('later opaque planes add an occlusion to a replayed selection',()=>{ }); const {LayerStack,noopLayerActions}=load('app/ui/layers.ts',{ - '../graphics/image':graphics,'../graphics/plane':planes,'../native/frame-timings':{spanCurrent:(_name,fn)=>fn()},'./gestures':{}, + '../graphics/image':graphics,'../graphics/plane':planes,'../native/frame-timings':{spanCurrent:(_name,fn)=>fn()},'../graphics/screen-size':{screenWidth:()=>640,screenHeight:()=>480},'./gestures':{}, }); test('context menu surface and selected row both use +4 without changing the app screen',()=>{ const base=new graphics.GrayImage(100,90,96); @@ -104,7 +104,7 @@ test('unselected sidebar icons retain -2 depth through shell cropping, including '../../native/notification-icons':{},'../../native/notification-types':require('../.test-build/app/native/notification-types.js'),'../../native/phone-battery':{},'../../util/render-freshness':{}, '../../graphics/icons':{},'../dashboard-settings':{},'../clock-format':{},'../../graphics/bdffont':{}, '../layers':{LayerStack},'../menu':{scrollToKeepSelectionVisible:()=>0},'../metrics':{}, - './geometry':{MIN_WINDOW_HEIGHT:280,minWindowTop:()=>0,windowTop:()=>0,SHELL_OPAQUE_BLACK:1,SIDEBAR_WIDTH:64,TOP_BAR_HEIGHT:24, + './geometry':{MIN_WINDOW_HEIGHT:280,minWindowHeight:()=>280,screenWidth:()=>640,screenHeight:()=>480,minWindowTop:()=>0,windowTop:()=>0,SHELL_OPAQUE_BLACK:1,SIDEBAR_WIDTH:64,TOP_BAR_HEIGHT:24, SWITCHER_ROW_HEIGHT:36,switcherPosition:()=>'left',switcherRect:()=>({x:0,y:0,width:64,height:280})}, }); const state={selectedIndex:0,focus:'sidebar',windows:[0,1,2].map(n=>({attention:n===1,drawIcon:(image,x,y)=>image.fillRect(x,y,4,4,240)}))}; @@ -122,7 +122,7 @@ test('unselected sidebar icons retain -2 depth through shell cropping, including test('shell modal carries its inner menu highlight animation instead of baking its first frame',async()=>{ const {ShellModalLayer}=load('app/ui/shell/modal-layer.ts',{ '../../graphics/image':graphics,'../../graphics/plane':planes,'../gestures':{},'../layers':load('app/ui/layers.ts',{ - '../graphics/image':graphics,'../graphics/plane':planes,'../native/frame-timings':{spanCurrent:(_name,fn)=>fn()}, + '../graphics/image':graphics,'../graphics/plane':planes,'../native/frame-timings':{spanCurrent:(_name,fn)=>fn()},'../graphics/screen-size':{screenWidth:()=>640,screenHeight:()=>480}, './gestures':{isDirectionalInput:()=>false}, }), './geometry':{appViewportSize:()=>({width:120,height:110}),appViewportRect:()=>({x:10,y:20,width:120,height:110}),SHELL_OPAQUE_BLACK:1}, diff --git a/tests/music-settings.test.cjs b/tests/music-settings.test.cjs index cba059b4..fdcfa1d8 100644 --- a/tests/music-settings.test.cjs +++ b/tests/music-settings.test.cjs @@ -161,7 +161,7 @@ test('Music settings keeps toggles and selection when a new app arrives and supp '../util/numeric-util': { clamp: (n, lo, hi) => Math.max(lo, Math.min(hi, n)) }, './menu-highlight-motion': require('../.test-build/app/ui/menu-highlight-motion.js'), '../graphics/menu-scroll-list': require('../.test-build/app/graphics/menu-scroll-list.js'), './menu-scroll-motion': require('../.test-build/app/ui/menu-scroll-motion.js'), '../graphics/draw-expression': require('../.test-build/app/graphics/draw-expression.js'), './metrics': load('app/ui/metrics.ts'), './gestures': {}, - './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, + './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, }; deps['./menu-core'] = load('app/ui/menu-core.ts', (name) => deps[name]); const menu = load('app/ui/menu.ts', (name) => deps[name]); diff --git a/tests/notification-filter.test.cjs b/tests/notification-filter.test.cjs index 40cda7c6..e046b704 100644 --- a/tests/notification-filter.test.cjs +++ b/tests/notification-filter.test.cjs @@ -87,7 +87,7 @@ function ui(fontSize = 12) { '../util/render-freshness': { renderPassAllowsStaleData: () => false }, './menu-highlight-motion': require('../.test-build/app/ui/menu-highlight-motion.js'), '../graphics/menu-scroll-list': require('../.test-build/app/graphics/menu-scroll-list.js'), './menu-scroll-motion': require('../.test-build/app/ui/menu-scroll-motion.js'), '../graphics/draw-expression': require('../.test-build/app/graphics/draw-expression.js'), './metrics': load('app/ui/metrics.ts'), - './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, + './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, './gestures': {}, }; const requireModule = (name) => { diff --git a/tests/onboarding-layout.test.cjs b/tests/onboarding-layout.test.cjs index 976fb11e..55e0e070 100644 --- a/tests/onboarding-layout.test.cjs +++ b/tests/onboarding-layout.test.cjs @@ -11,19 +11,22 @@ function setting(value, values) { writes: [], displayValue: (v) => v[0].toUpperCase() + v.slice(1) }; } -function harness() { +// The onboarding pages over G2 glasses (640x480), or a RayNeo iO's 540x220 screen. +function harness(glasses = 'g2') { + const screen = glasses === 'rayneo-io' ? { width: 540, height: 220 } : { width: 640, height: 480 }; const settings = { + glassesTypeSetting: setting(glasses, ['g2', 'rayneo-io']), appSwitcherPositionSetting: setting('bottom', ['left', 'right', 'bottom', 'popup']), statusBarPositionSetting: setting('bottom', ['top', 'bottom']), uiDepthSetting: setting('48', ['-62', '-48', '-32', '-16', '0', '16', '32', '48', '62']), }; const load = loader({}, { './onboarding-fonts': { onboardingFont: font }, - '../../graphics/image': { G2_LENS_WIDTH: 640 }, '../../ui/dashboard-settings': settings, - '../../ui/shell/geometry': { MIN_WINDOW_HEIGHT: 288, SIDEBAR_WIDTH: 64, SWITCHER_ROW_HEIGHT: 36, TOP_BAR_HEIGHT: 28 }, + '../../ui/shell/geometry': { MIN_WINDOW_HEIGHT: 288, SIDEBAR_WIDTH: 64, SWITCHER_ROW_HEIGHT: 36, TOP_BAR_HEIGHT: 28, + screenWidth: () => screen.width, screenHeight: () => screen.height }, }); - return { settings, load }; + return { settings, screen, load }; } /** An image that records what is drawn, checking it all lands on the image. */ @@ -111,7 +114,7 @@ test('the text size page offers 12 to 18px, starts on the recommended 16px, and './onboarding-fonts': { onboardingFont: font }, '../../graphics/installed-fonts': { installedFontPath: (file) => `/fonts/${file}` }, '../../graphics/ttf-font': { TtfFont: { load: (path, size) => font(size === 12 ? 'title' : 'detail') } }, - '../../graphics/ui-fonts': { fontSelectionLabel: () => 'Terminus', getDefaultSmallFont: () => font('detail'), + '../../graphics/ui-fonts': { defaultUiFontSize: () => 16, fontSelectionLabel: () => 'Terminus', getDefaultSmallFont: () => font('detail'), getUiFontSelection: () => selection, setUiFontSelection: (value) => { selection = value; saved.push(value.size); }, uiFontSizeAllowed: (path, size) => size !== 13 }, '../../ui/font-picker': { FONT_SIZE_CHOICES: [8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 24] }, @@ -148,6 +151,51 @@ test('the text size page offers 12 to 18px, starts on the recommended 16px, and assert.equal(menu.selectedItem, 15); }); +test('on a RayNeo iO the text size page recommends and starts on 14px, its default', () => { + const menu = { selected: null, items: [], setItems(items, index) { this.items = items; this.selected = index; }, + get selectedItem() { return this.items[this.selected] ?? null; }, paint(image, box) { this.box = box; } }; + let menuOptions; + const load = loader({}, { + './onboarding-fonts': { onboardingFont: font }, + '../../graphics/installed-fonts': { installedFontPath: (file) => `/fonts/${file}` }, + '../../graphics/ttf-font': { TtfFont: { load: () => font('detail') } }, + '../../graphics/ui-fonts': { defaultUiFontSize: () => 14, fontSelectionLabel: () => 'Terminus', getDefaultSmallFont: () => font('detail'), + getUiFontSelection: () => ({ kind: 'ttf', file: 'Roboto-Light.ttf', size: 14 }), setUiFontSelection: () => assert.fail('nothing to save'), + uiFontSizeAllowed: () => true }, + '../../ui/font-picker': { FONT_SIZE_CHOICES: [8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 24] }, + '../../ui/menu-core': { Menu: class { constructor(options) { menuOptions = options; return menu; } } }, + '../../ui/metrics': { LIST_ROW_TEXT_INSET: 4, listRowHeight: (f) => f.lineHeight + 8 }, + }); + const { TextSizePage } = load('app/apps/onboarding/text-size-page.ts'); + const page = new TextSizePage(); + page.enter(); + assert.equal(menu.selectedItem, 14); + const notes = menu.items.filter((size) => { + const row = recorder(200, 32); + menuOptions.draw({ image: row, item: size, x: 0, y: 0, width: 200, height: 32, selected: false }); + return row.calls.some((call) => call.text === 'Recommended'); + }); + assert.deepEqual(notes, [14]); + // Taking the default leaves the size unset, so it keeps following the glasses. + page.handleInput({ type: 'click' }, { next: () => {} }); +}); + +test('on a RayNeo iO the layout page recommends and starts on Left, and fits the 540x220 screen', () => { + const { load, settings } = harness('rayneo-io'); + const { LayoutPage, recommendedLayout } = load('app/apps/onboarding/layout-page.ts'); + assert.equal(recommendedLayout(), 'left'); + const page = new LayoutPage(); + const image = recorder(540, 220); + page.paint(image, true); + const captions = image.calls.filter((call) => call.kind === 'text').map((call) => call.text); + assert.ok(captions.includes('Left (Recommended)')); + assert.ok(captions.includes('Bottom')); + page.handleInput({ type: 'click' }, { next() {} }); + assert.deepEqual(settings.appSwitcherPositionSetting.writes, ['left']); + // The G2 still recommends Bottom. + assert.equal(harness().load('app/apps/onboarding/layout-page.ts').recommendedLayout(), 'bottom'); +}); + test('the depth page follows layouts that have depth, sits in the layout, and applies depth as it scrolls', () => { const { load, settings } = harness(); const menu = { selected: 0, items: [], select(index) { this.selected = index; }, diff --git a/tests/settings-panel.test.cjs b/tests/settings-panel.test.cjs index e846488a..0ccefd00 100644 --- a/tests/settings-panel.test.cjs +++ b/tests/settings-panel.test.cjs @@ -22,7 +22,7 @@ const font = BdfFont.parse(fs.readFileSync(path.join(__dirname, '../app/fonts/te const textwrap = load('app/graphics/textwrap.ts', {}); const fonts = { getDefaultSmallFont: () => font }; const menu = load('app/ui/menu.ts', { - './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, + './menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 }, '../graphics/image': graphics, '../graphics/textwrap': textwrap, '../graphics/ui-fonts': fonts, '../util/numeric-util': { clamp: (n, lo, hi) => Math.max(lo, Math.min(hi, n)) }, './gestures': {}, './metrics': metrics, './menu-core': menuCore, @@ -111,3 +111,25 @@ test('the selected row stays clear of its description band', async () => { assert.ok(row.y + row.source.height <= bandTop, `row ends at ${row.y + row.source.height}, band starts at ${bandTop}`); assert.ok(row.y + row.source.height > bandTop - 30, 'the last item scrolled down to just above the band'); }); + +test('a section\'s detail gives its rows the pane while focus is in them, where the two don\'t fit (a RayNeo iO\'s window)', async () => { + const docs = ['README', 'License', 'Privacy policy', 'Acknowledgements']; + const detailDraws = []; + // About's blurb under its 72px logo: about 145px. + const about = { label: 'About', items: docs.map((label) => ({ label, onSelect() {} })), + renderDetail: ({ image, x, y }) => { detailDraws.push(image); image.fillRect(x, y, 72, 72, 90); return 145; } }; + for (const [size, keeps] of [[{ width: 576, height: 260 }, true], [{ width: 476, height: 192 }, false], [{ width: 476, height: 155 }, false]]) { + const layer = new SettingsPanelLayer([about]); + const ctx = { stack: { getBaseSize: () => size, isFocused: () => true } }; + const paint = () => { detailDraws.length = 0; const image = layer.paint(ctx); return { image, drawn: detailDraws.includes(image) }; }; + // The preview (focus in the left column) always shows the detail. + assert.equal(paint().drawn, true, `preview at ${size.height}`); + await layer.handleInput({ type: 'click', timestampMs: 0 }, ctx); + const { image, drawn } = paint(); + assert.equal(drawn, keeps, `focused at ${size.height}`); + const row = selections(image)[1]; + if (keeps) assert.ok(row.y >= 8 + 145, 'the rows under the detail'); + else assert.equal(row.y, 8, 'the first row at the top of the pane'); + assert.ok(row.y + row.source.height <= size.height - 8); + } +}); diff --git a/tests/ui-fonts-default.test.cjs b/tests/ui-fonts-default.test.cjs new file mode 100644 index 00000000..87a1f563 --- /dev/null +++ b/tests/ui-fonts-default.test.cjs @@ -0,0 +1,45 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const { loader } = require('./helpers/load-typescript.cjs'); + +// ui-fonts.ts and screen-size.ts over an in-memory settings store, with each +// TTF "loaded" as its path and size. +function fixture(entries = []) { + const store = new Map(entries); + const listeners = []; + const load = loader({}, { + '../native/settings-store': { + getStringSetting: (key, fallback) => store.get(key) ?? fallback, + setStringSetting: (key, value) => { store.set(key, value); for (const listener of listeners) listener(key); }, + onSettingsStoreChanged: (listener) => listeners.push(listener), + }, + './image': { G2_LENS_WIDTH: 640, G2_LENS_HEIGHT: 480, RAYNEO_IO_WIDTH: 540, RAYNEO_IO_HEIGHT: 220 }, + './bdffont': { getFont: (name) => ({ name }) }, + './ttf-font': { TtfFont: { load: (path, size) => ({ path, size, lineHeight: size + 4 }) } }, + './installed-fonts': { ensurePreinstalledFonts() {}, getInstalledFont: () => null, installedFontPath: (file) => `/fonts/${file}` }, + }); + return { fonts: load('app/graphics/ui-fonts.ts'), screen: load('app/graphics/screen-size.ts'), store, listeners }; +} + +test('the screen and the default UI font follow the paired glasses: 640x480 at 16px, or a RayNeo iO\'s 540x220 at 14px', () => { + const { fonts, screen, store, listeners } = fixture(); + assert.deepEqual([screen.screenWidth(), screen.screenHeight(), screen.isRayNeoIoConfigured()], [640, 480, false]); + assert.equal(fonts.defaultUiFontSize(), 16); + assert.deepEqual({ ...fonts.getUiFontSelection() }, { kind: 'ttf', file: 'Roboto-Light.ttf', size: 16 }); + assert.equal(fonts.getDefaultSmallFont().size, 16); + // Pairing a RayNeo iO: the cached fonts re-resolve at its size. + store.set(screen.GLASSES_TYPE_KEY, 'rayneo-io'); + for (const listener of listeners) listener(screen.GLASSES_TYPE_KEY); + assert.deepEqual([screen.screenWidth(), screen.screenHeight(), screen.isRayNeoIoConfigured()], [540, 220, true]); + assert.equal(fonts.defaultUiFontSize(), 14); + assert.deepEqual({ ...fonts.getUiFontSelection() }, { kind: 'ttf', file: 'Roboto-Light.ttf', size: 14 }); + assert.equal(fonts.getDefaultSmallFont().size, 14); +}); + +test('a chosen UI font keeps its size on either glasses', () => { + const { fonts, screen, store } = fixture([['deviceType', 'rayneo-io']]); + fonts.setUiFontSelection({ kind: 'ttf', file: 'Roboto-Light.ttf', size: 17 }); + assert.equal(fonts.getUiFontSelection().size, 17); + store.set(screen.GLASSES_TYPE_KEY, 'g2'); + assert.equal(fonts.getUiFontSelection().size, 17); +}); From fde847a31a81d7cfd7c7430f4dad4687d0ca7173 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Sun, 1 Nov 2026 19:37:55 -0800 Subject: [PATCH 03/34] Add support for using RayNeo iO together with an R1 ring --- app/apps/developer/ring-status.ts | 4 +- app/g2/dashboard-controller.ts | 27 +++---- app/phone-ui/pairing-view-model.ts | 35 +++++----- app/ui/dashboard-settings.ts | 11 ++- app/ui/dashboard/settings-menus.ts | 21 +++++- .../g2protocol/session/GlassesSessionCore.kt | 10 +-- .../g2protocol/session/GlassesSessionIo.kt | 18 +++-- .../g2protocol/session/GlassesSessionRing.kt | 10 +++ tests/display-layout-setting.test.cjs | 13 ++++ .../com/faceclaw/app/RayNeoIoSessionTest.kt | 70 +++++++++++++++++-- 10 files changed, 172 insertions(+), 47 deletions(-) diff --git a/app/apps/developer/ring-status.ts b/app/apps/developer/ring-status.ts index 876aa506..a680a3dc 100644 --- a/app/apps/developer/ring-status.ts +++ b/app/apps/developer/ring-status.ts @@ -4,7 +4,7 @@ import { type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; import { shell } from "../../ui/shell/shell"; import { MenuLayer, type MenuItem } from "../../ui/menu"; -import { ringConnectionModeSetting } from "../../ui/dashboard-settings"; +import { effectiveRingConnectionMode, ringConnectionModeSetting } from "../../ui/dashboard-settings"; import { loadDeviceAddresses } from "../../g2/device-addresses"; import { getRingSessionStatus, @@ -146,7 +146,7 @@ export class RingStatusLayer implements Layer { } if (!s.directEnabled) { - const pending = ringConnectionModeSetting.get() !== "glasses"; + const pending = effectiveRingConnectionMode() !== "glasses"; rows.push({ label: "Direct link", value: pending ? "on after glasses reconnect" : "off (only via glasses)", dim: true }); } else { const state = s.directNotificationsReady ? "subscribed" diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index 52d732a4..a3d53c01 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -78,7 +78,7 @@ import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-a import { appViewportRect, isOnSwitcherEdge, screenHeight, screenWidth, sidebarStripVisible, type ScreenRect, type WindowHeightMode } from "../ui/shell/geometry"; import { type ContinuousCaptureOptions, type LayerActions, type TextSettingsEditToggle, type TranscriptionChoice } from "../ui/layers"; import { type KeyboardInputSession } from "../ui/shell/keyboard-input"; -import { appSwitcherPositionSetting, glassesTypeSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayLayoutSetting, navigateDisplayLayoutSetting, terminalDisplayLayoutSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, whisperServerApiKeySetting, whisperServerLanguageSetting, whisperServerModelSetting, whisperServerUrlSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, type RingConnectionMode, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; +import { appSwitcherPositionSetting, glassesTypeSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayLayoutSetting, navigateDisplayLayoutSetting, terminalDisplayLayoutSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, whisperServerApiKeySetting, whisperServerLanguageSetting, whisperServerModelSetting, whisperServerUrlSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, effectiveRingConnectionMode, type RingConnectionMode, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization"; import { getInstalledEvenHubAppById, @@ -1047,9 +1047,11 @@ class DashboardController { /** * A Direct-mode session may have unpaired the R1 from the glasses (see - * GlassesSessionRing.releaseRingFromGlassesLocked). The first session in - * another mode asks the glasses to connect to it again; the ring's own - * glasses targets were cleared, so it accepts them. Called on connect. + * GlassesSessionRing.releaseRingFromGlassesLocked), and a RayNeo iO + * session (always Direct) may have cleared the ring's glasses targets. + * The first G2 session in another mode asks the glasses to connect to it + * again; the ring's own glasses targets were cleared, so it accepts them. + * Called on connect. */ private handRingBackToGlassesIfNeeded(): void { if (this.ringModeAtConnect === "direct" || !getBooleanSetting(RING_TAKEN_FROM_GLASSES_KEY, false)) return; @@ -1488,20 +1490,21 @@ class DashboardController { this.refreshEvenAppStatus(); this.setPhase("connecting"); this.setStatus("Connecting to the glasses..."); - // "Only via glasses" (the default) means the phone never opens its own - // link to the ring: the glasses relay its gestures to us anyway. An empty - // address disables every direct-ring code path in the communicator. - const ringMode = ringConnectionModeSetting.get(); + // "Only via glasses" (the G2's default) means the phone never opens its + // own link to the ring: the glasses relay its gestures to us anyway. An + // empty address disables every direct-ring code path in the communicator. + // A RayNeo iO (one link, its address in both arm slots) can't relay a + // ring, so with one the phone always takes the ring directly. + const ringMode = effectiveRingConnectionMode(); this.ringModeAtConnect = ringMode; - // A RayNeo iO is one link (its address in both arm slots) and has no ring. const glassesType = glassesTypeSetting.get(); - const ringAddress = ringMode !== "glasses" && glassesType === "g2" ? addresses.ring : ""; + const ringAddress = ringMode !== "glasses" ? addresses.ring : ""; // Direct mode may unpair the ring from the glasses; remember to hand it // back once a later session runs in another mode. if (ringMode === "direct" && ringAddress) setBooleanSetting(RING_TAKEN_FROM_GLASSES_KEY, true); - this.appendLog(glassesType === "rayneo-io" + this.appendLog((glassesType === "rayneo-io" ? `Using configured RayNeo iO: ${addresses.right}` - : `Using configured arms: R=${addresses.right} L=${addresses.left}${ringAddress ? ` ring=${ringAddress}` : ""}`, + : `Using configured arms: R=${addresses.right} L=${addresses.left}`) + (ringAddress ? ` ring=${ringAddress}` : ""), ); let communicator: FaceclawCommunicatorBridge | null = null; diff --git a/app/phone-ui/pairing-view-model.ts b/app/phone-ui/pairing-view-model.ts index 7336f44e..ba7d17e3 100644 --- a/app/phone-ui/pairing-view-model.ts +++ b/app/phone-ui/pairing-view-model.ts @@ -68,7 +68,7 @@ export class PairingViewModel extends Observable { private _ringRows: PairingRowItem[] = []; private selectedPair: GlassesPairCandidate | null = null; private selectedRing: RingCandidate | null = null; - /** A RayNeo iO instead of a G2 pair (the two are exclusive). */ + /** A RayNeo iO instead of a G2 pair (the two are exclusive; either takes a ring). */ private selectedIo: RayNeoCandidate | null = null; private readonly previouslyPairedSerial: string | null; private readonly previouslyPairedRing: string; @@ -186,7 +186,7 @@ export class PairingViewModel extends Observable { get instructions(): string { return ( - "Select your G2 glasses and R1 ring, or your RayNeo iO, below. Wear the glasses or take them out of the case, " + + "Select your G2 glasses or RayNeo iO, and your R1 ring if you have one, below. Wear the glasses or take them out of the case, " + "and keep the glasses and phone nearby. If your glasses are not detected, make sure no other " + "apps are connected." ); @@ -298,10 +298,7 @@ export class PairingViewModel extends Observable { if (row.kind === "rayneo-io") { const io = this.aggregator.rayneos().find((candidate) => candidate.id === row.id) ?? null; this.selectedIo = this.selectedIo?.id === io?.id ? null : io; - if (this.selectedIo) { - this.selectedPair = null; - this.selectedRing = null; - } + if (this.selectedIo) this.selectedPair = null; } else if (row.kind === "glasses") { const pair = this.aggregator.pairs().find((candidate) => candidate.id === row.id) ?? null; if (!pair) return; @@ -314,17 +311,24 @@ export class PairingViewModel extends Observable { } else { const ring = this.aggregator.rings().find((candidate) => candidate.id === row.id) ?? null; this.selectedRing = this.selectedRing?.id === ring?.id ? null : ring; - if (this.selectedRing) this.selectedIo = null; } this.refresh(); }; onPrimaryTap(): void { const io = this.selectedIo; + const pair = this.selectedPair; + const ring = this.selectedRing; + const existing = loadDeviceAddresses(); + // Glasses saved without a ring selected keep the ring paired before. + const ringAddress = ring?.advertisement.address ?? existing.ring; + const ringName = ring?.advertisement.name ?? + (ringAddress === existing.ring ? (loadPairedGlassesIdentity()?.ringName ?? "") : ""); if (io) { - // One link: the same address stands for both arms; no ring. + // One link: the same address stands for both arms. The iO can't relay a + // ring, so the session connects to it directly (Direct ring mode). const address = io.advertisement.address; - saveDeviceAddresses({ right: address, left: address, ring: "" }); + saveDeviceAddresses({ right: address, left: address, ring: ringAddress }); glassesTypeSetting.set("rayneo-io"); savePairedGlassesIdentity({ serial: io.advertisement.embeddedMac ?? address, @@ -332,8 +336,8 @@ export class PairingViewModel extends Observable { rightName: io.advertisement.name, leftAddress: address, rightAddress: address, - ringName: "", - ringAddress: "", + ringName, + ringAddress, pairedAtMs: Date.now(), }); this.dispose(); @@ -343,18 +347,15 @@ export class PairingViewModel extends Observable { finishOnboardingNavigation(); return; } - 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 ? pair.right!.address : existing.right, left: pair ? pair.left!.address : existing.left, - ring: ring?.advertisement.address ?? existing.ring, + ring: ringAddress, }; saveDeviceAddresses(addresses); if (pair) glassesTypeSetting.set("g2"); @@ -365,8 +366,8 @@ export class PairingViewModel extends Observable { 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, + ringName, + ringAddress, pairedAtMs: Date.now(), }); } else if (ring) { diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 280668ba..80168597 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -874,9 +874,18 @@ export const ringConnectionModeSetting = new ConfigSettingEnum value === "direct" ? "Direct to phone" : value === "health" ? "Via glasses + health sync" : "Only via glasses", description: - "How the R1 ring reaches the phone. Only via glasses: the glasses relay the ring's gestures and the phone never connects to it. Via glasses + health sync: the same, plus the phone connects to the ring to sync health data. Direct to phone (experimental): the phone takes the ring over from the glasses and gets its gestures and battery itself; the glasses lose ring input. Health still syncs, but each sync (on opening Health, and at :01 and :31) pauses ring gestures for up to a minute while the phone briefly reconnects to the ring in its health role. Leaving Direct hands the ring back to the glasses. Takes effect on the next connection to the glasses.", + "How the R1 ring reaches the phone. Only via glasses: the glasses relay the ring's gestures and the phone never connects to it. Via glasses + health sync: the same, plus the phone connects to the ring to sync health data. Direct to phone (experimental): the phone takes the ring over from the glasses and gets its gestures and battery itself; the glasses lose ring input. Health still syncs, but each sync (on opening Health, and at :01 and :31) pauses ring gestures for up to a minute while the phone briefly reconnects to the ring in its health role. Leaving Direct hands the ring back to the glasses. A RayNeo iO has no ring link of its own, so with one the phone always connects to the ring directly. Takes effect on the next connection to the glasses.", }); +/** + * The ring connection in effect: the setting with G2 glasses; Direct with a + * RayNeo iO, which cannot relay a ring, so the phone holds the ring's + * glasses role itself (gestures, battery; health in brief phone-role windows). + */ +export function effectiveRingConnectionMode(): RingConnectionMode { + return glassesTypeSetting.get() === "rayneo-io" ? "direct" : ringConnectionModeSetting.get(); +} + // "whisper" (no "onboard-" prefix) is OpenAI's CLOUD realtime model // (gpt-realtime-whisper); "onboard-whisper" is the on-device sherpa-onnx // Whisper backend. Same underlying model family, two different places it diff --git a/app/ui/dashboard/settings-menus.ts b/app/ui/dashboard/settings-menus.ts index ff57b84a..d4cc0719 100644 --- a/app/ui/dashboard/settings-menus.ts +++ b/app/ui/dashboard/settings-menus.ts @@ -67,6 +67,7 @@ import { previewScalingSetting, phoneRotationSetting, ringConnectionModeSetting, + glassesTypeSetting, sonioxApiKeySetting, saveTranscribeAudioSetting, whisperServerApiKeySetting, @@ -224,7 +225,7 @@ function settingsSections(): SettingsSection[] { items: [ // Whether and how the phone opens its own BLE link to the R1 ring. // Applied at connect time. - enumSettingMenuItem(ringConnectionModeSetting), + ringConnectionMenuItem(), toggleSettingMenuItem(saveVoiceRecordingsSetting), toggleSettingMenuItem(firmwareDebugFlagsSetting), toggleSettingMenuItem(suspendEvenHubWhenScreenOffSetting), @@ -598,6 +599,24 @@ function readBundledDoc(fileName: string): string { } } +/** + * Developer > Ring connection: the setting, except with a RayNeo iO, which + * always takes the ring directly (effectiveRingConnectionMode): then a fixed, + * disabled "Direct" row, the stored choice kept for G2 glasses. + */ +function ringConnectionMenuItem(): MenuItem { + const item = enumSettingMenuItem(ringConnectionModeSetting); + const io = () => glassesTypeSetting.get() === "rayneo-io"; + return { + ...item, + disabled: io, + render: (args) => { + if (!io()) return item.render?.(args); + drawRightValueMenuItem(args.image, getDefaultSmallFont(), args.x, args.y, args.width, item.label, "Direct (RayNeo iO)"); + }, + }; +} + function renderWatchStatus(args: { image: GrayImage; x: number; y: number; width: number }): number { const { image, x, y, width } = args; const font = getDefaultSmallFont(); diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index a471bc4c..23832ed1 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -1792,14 +1792,15 @@ class GlassesSessionCore( return } val uuid = characteristicUuid.lowercase() - if (isIo) { - ioOnNotification(address, uuid, data) - return - } + // The phone's own R1 link, beside either glasses (the iO's ring is always direct). if (isDirectRingNotification(address, uuid)) { handleDirectRingNotification(uuid, data) return } + if (isIo) { + ioOnNotification(address, uuid, data) + return + } if (BleProtocol.RENDER_NOTIFY_UUID == uuid) { handleRenderNotification(address, data) return @@ -2100,6 +2101,7 @@ class GlassesSessionCore( lastConnectionOrInputAtMs = arrivalMs lastDirectRingInputAtMs = arrivalMs lastDirectRingInputLabel = decoded.label + " " + decoded.detail + if (isIo) ioReclaimPageOnInputLocked() } logLine("direct ring " + decoded.label + " " + decoded.detail + " raw=" + hex(data)) val frameId = frameTimings.startFrame("input:ring:" + decoded.label) diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt index eb4c83d1..6f22bfc1 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt @@ -519,6 +519,17 @@ private fun GlassesSessionCore.ioHandlePage(payload: ByteArray) { interruptibleSleep.interrupt() } +/** + * The wearer gave input (a temple touch, or the R1's) after closing our page: + * take it back. Caller holds `monitor`. + */ +internal fun GlassesSessionCore.ioReclaimPageOnInputLocked() { + if (io.pageWanted || !sessionReady) return + io.pageWanted = true + shutdownRequested = false + io.pageRequestSentAtMs = 0 +} + private fun GlassesSessionCore.ioHandleGesture(gesture: RayNeoIoProtocol.Gesture) { val event: G2Event? = when (gesture.eventType) { // Same numbering as the G2's OsEventTypeList; head up wakes like the G2 CFW's forward. @@ -529,12 +540,7 @@ private fun GlassesSessionCore.ioHandleGesture(gesture: RayNeoIoProtocol.Gesture monitor.withLock { lastIncomingAtMs = now() if (event != null) lastConnectionOrInputAtMs = lastIncomingAtMs - if (event != null && "sys-event" == event.kind && !io.pageWanted && sessionReady) { - // The wearer touched the glasses after closing our page: take it back. - io.pageWanted = true - shutdownRequested = false - io.pageRequestSentAtMs = 0 - } + if (event != null && "sys-event" == event.kind) ioReclaimPageOnInputLocked() } logLine("RayNeo iO gesture type=" + gesture.eventType + " source=" + gesture.source + (if (event == null) " (ignored)" else "")) if (event == null) return diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt index 63b46f7b..779c891c 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt @@ -971,6 +971,13 @@ internal fun macWireBytes(address: String): ByteArray? { internal fun GlassesSessionCore.queueGlassesRingLinkCommandLocked( action: String, fallbackAddress: String, fallbackName: String, ): Boolean { + if (isIo) { + // A RayNeo iO has no ring link of its own; the phone holds the ring directly. + lastRingLinkCommand = "$action: not applicable (RayNeo iO)" + lastRingLinkCommandAtMs = now() + logLine("glasses ring $action skipped: RayNeo iO glasses have no ring link") + return false + } val reported = glassesRingMac val mac = reported ?: macWireBytes(fallbackAddress) if (mac == null) { @@ -1091,6 +1098,9 @@ internal fun GlassesSessionCore.queueRingConfigCommandLocked( frame = RingProtocol.buildPairAuth(seq) } "targets-glasses" -> { + // The iO never connects to the ring: naming it would make the ring drop + // the phone's glasses-role link (the advStart check, ~20 s later). + if (isIo) return "not sent: RayNeo iO glasses don't hold the ring" val right = macWireBytes(rightAddress) val left = macWireBytes(leftAddress) if (right == null || left == null) return "not sent: glasses addresses unparseable" diff --git a/tests/display-layout-setting.test.cjs b/tests/display-layout-setting.test.cjs index 55e9f60b..d17d5666 100644 --- a/tests/display-layout-setting.test.cjs +++ b/tests/display-layout-setting.test.cjs @@ -85,3 +85,16 @@ test('a RayNeo iO defaults the app switcher to the left, and keeps a chosen posi api.glassesTypeSetting.set('rayneo-io'); assert.equal(api.appSwitcherPositionSetting.get(), 'left'); }); + +test('a RayNeo iO always takes the R1 directly, leaving the G2\'s ring connection setting alone', () => { + const store = new Map(); + const api = settingsFixture(store); + assert.equal(api.effectiveRingConnectionMode(), 'glasses'); + api.ringConnectionModeSetting.set('health'); + assert.equal(api.effectiveRingConnectionMode(), 'health'); + api.glassesTypeSetting.set('rayneo-io'); + assert.equal(api.effectiveRingConnectionMode(), 'direct'); + assert.equal(api.ringConnectionModeSetting.get(), 'health'); + api.glassesTypeSetting.set('g2'); + assert.equal(api.effectiveRingConnectionMode(), 'health'); +}); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt index 80d8ae38..01b087fc 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt @@ -7,6 +7,7 @@ import kotlin.test.assertFalse import kotlin.test.assertTrue private const val IO = "00:6A:5E:5F:33:C2" +private const val RING = "FF:AA:F1:F6:7E:28" private val PHONE_ID = byteArrayOf(1, 2, 3, 4, 5, 6) private class IoClock(private val base: ProtocolPlatform) : ProtocolPlatform by base { @@ -50,6 +51,14 @@ private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { val controls: List get() = lock.withLock { controlsList.toList() } val messages: List get() = lock.withLock { messagesList.toList() } + /** Writes to the R1 on [RING] (characteristic, bytes), and the CCCDs the session enabled on it. */ + private val ringWritesList = ArrayList>() + private val ringCccdsList = ArrayList() + val ringWrites: List> get() = lock.withLock { ringWritesList.toList() } + val ringCccds: List get() = lock.withLock { ringCccdsList.toList() } + + /** A notification from the R1, as its link delivers it. */ + fun ringNotify(characteristicUuid: String, data: ByteArray) = core.onNotification(RING, characteristicUuid, data) fun notify(business: Int, payload: ByteArray) { val frame = lock.withLock { RayNeoIoProtocol.encodeFrame(number++, business, payload) } @@ -70,10 +79,19 @@ private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { override fun discoverServices(address: String, timeoutMs: Int): Boolean = true - override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean = - characteristicUuid == RayNeoIoBle.NOTIFY_CHAR_UUID + override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean { + if (address == RING) { + lock.withLock { ringCccdsList.add(characteristicUuid) } + return true + } + return characteristicUuid == RayNeoIoBle.NOTIFY_CHAR_UUID + } override fun writeFrames(address: String, characteristicUuid: String, frames: List, mode: GattWriteMode, timeoutMs: Int): Boolean { + if (address == RING) { + lock.withLock { for (frame in frames) ringWritesList.add(characteristicUuid to frame) } + return true + } assertEquals(RayNeoIoBle.WRITE_CHAR_UUID, characteristicUuid) assertTrue(frames.all { it.size <= 185 - 3 }, "writes must fit the MTU") val decoded = lock.withLock { frames.flatMap { inbound.ingest(it) } } @@ -170,6 +188,7 @@ private class IoListener : FaceclawBleCommunicatorListener { @Volatile var lastStatus = "" val events = ArrayList() val batteries = ArrayList() + val ringBatteries = ArrayList() val firmware = ArrayList() override fun onStateChange(phase: String?, status: String?) { @@ -183,6 +202,7 @@ private class IoListener : FaceclawBleCommunicatorListener { override fun onBatteryState(headsetBattery: Int, headsetCharging: Int, ringBattery: Int, ringCharging: Int) { batteries.add("$headsetBattery/$headsetCharging") + if (ringBattery >= 0) ringBatteries.add("$ringBattery/$ringCharging") } override fun onSilentMode(silent: Boolean) {} @@ -202,7 +222,8 @@ private class IoListener : FaceclawBleCommunicatorListener { } } -private class IoSession { +/** An iO session; with [ring], also the phone's own link to an R1 in the glasses role (Direct). */ +private class IoSession(ring: String = "") { val platform = IoClock(testPlatform()) val glasses = FakeIoGlasses(platform) private val host = object : SessionHost { @@ -243,13 +264,14 @@ private class IoSession { } } val listener = IoListener() - val core = GlassesSessionCore(glasses, host, FrameTimingsCore(platform), platform, IO, IO, "") + val core = GlassesSessionCore(glasses, host, FrameTimingsCore(platform), platform, IO, IO, ring) init { glasses.core = core core.setListener(listener) core.setRequiredFirmwareRevision(38) core.useRayNeoIo(PHONE_ID, "Pixel", "Google", "Pixel 11") + if (ring.isNotEmpty()) core.setDirectRingRole("glasses") } fun pageUp(): Boolean = core.monitor.withLock { core.sessionReady && core.fixedLayoutCreated } @@ -377,4 +399,44 @@ class RayNeoIoSessionTest { s.core.close() } } + + @Test + fun anR1BesideTheIoIsTheSessionsOwnRingInput() { + val s = IoSession(RING) + s.core.configureCompositorScreen(540, 220) + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.pageUp() }, s.tail()) + // The phone takes the ring's glasses role itself: legacy CCCD, the glasses + // pair-auth, then the touch source on, all on the ring's link. + assertTrue(awaitTrue(5_000) { s.glasses.ringWrites.size >= 2 }, "ring setup not sent:\n" + s.tail()) + assertTrue(BleProtocol.R1_LEGACY_NOTIFY_CHAR_UUID in s.glasses.ringCccds) + val (authChar, auth) = s.glasses.ringWrites[0] + assertEquals(BleProtocol.R1_LEGACY_WRITE_CHAR_UUID, authChar) + assertTrue(auth.contentEquals(RingProtocol.LEGACY_GLASSES_PAIR_AUTH)) + + // Its battery and gestures reach the listener as they do beside a G2, + // not the iO's protocol parser. + s.glasses.ringNotify(BleProtocol.R1_LEGACY_NOTIFY_CHAR_UUID, byteArrayOf(0x00, 0x09, 0x8b.toByte(), 0x00, 64, 1)) + assertTrue(awaitTrue(2_000) { "64/1" in s.listener.ringBatteries }, s.listener.ringBatteries.toString()) + val swipe = byteArrayOf(0x00, 0x09, 0x61, 0x00, 0x04, 0x35, 0x00, 0x09, 0xcc.toByte(), 0x00, 0x00) + s.glasses.ringNotify(BleProtocol.R1_LEGACY_NOTIFY_CHAR_UUID, swipe) + assertTrue(awaitTrue(2_000) { s.listener.events.isNotEmpty() }, s.tail()) + val expected = FaceclawRingEventDecoder.decode(swipe)!!.event + assertEquals("${expected.kind}:${expected.eventType}:${expected.eventSource}", s.listener.events.single()) + + // The wearer closed the page: a ring gesture takes it back, as a temple touch does. + s.glasses.pageOpen = false + s.glasses.page(0, 4) + s.platform.offsetMs += 4_000 + s.core.interruptibleSleep.interrupt() + sleepMs(300) + assertFalse(s.pageUp()) + s.glasses.ringNotify(BleProtocol.R1_LEGACY_NOTIFY_CHAR_UUID, byteArrayOf(0x00, 0x09, 0x61, 0x00, 0x01, 0x00, 0x00, 0x10, 0xcc.toByte(), 0x00, 0x00)) + s.core.interruptibleSleep.interrupt() + assertTrue(awaitTrue(5_000) { s.pageUp() }, "ring input did not reopen:\n" + s.tail()) + } finally { + s.core.close() + } + } } From 9ddd4c4d031547d983343ca1e5709ec3349a6727 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Sun, 1 Nov 2026 21:08:25 -0800 Subject: [PATCH 04/34] Add microphone support on RayNeo iO --- App_Resources/Android/app.gradle | 3 + .../com/faceclaw/app/AndroidSpeechEngines.kt | 38 ++++ .../faceclaw/app/FaceclawBleCommunicator.kt | 3 + .../faceclaw/app/FaceclawVoiceController.kt | 4 +- app/g2/dashboard-controller.ts | 21 ++ app/native/faceclaw-communicator.ios.ts | 3 + app/native/faceclaw-communicator.ts | 8 + .../faceclaw/app/audio/VoiceCaptureSession.kt | 5 +- .../com/faceclaw/app/audio/VoicePorts.kt | 11 +- .../g2protocol/session/GlassesSessionCore.kt | 14 ++ .../g2protocol/session/GlassesSessionIo.kt | 183 +++++++++++++++++- .../faceclaw/app/rayneo/RayNeoIoProtocol.kt | 42 ++++ .../com/faceclaw/app/RayNeoIoSessionTest.kt | 77 ++++++++ 13 files changed, 407 insertions(+), 5 deletions(-) diff --git a/App_Resources/Android/app.gradle b/App_Resources/Android/app.gradle index 997e1f4d..99e36fe3 100644 --- a/App_Resources/Android/app.gradle +++ b/App_Resources/Android/app.gradle @@ -19,6 +19,9 @@ dependencies { // app's captions (translation models download on demand, per language). implementation 'com.google.mlkit:language-id:17.0.6' implementation 'com.google.mlkit:translate:17.0.3' + // Pure-Java Opus decoder for the RayNeo iO's microphone (16 kHz mono Opus over + // BLE); the same one Glassly uses. See AndroidSpeechEngines.OpusDecoderAdapter. + implementation 'io.github.jaredmdobson:concentus:1.0.1' } def faceclawSherpaOnnxVersion = "1.13.0" diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt index 2b149f09..83357d08 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt @@ -94,6 +94,44 @@ internal object AndroidSpeechEngines { override fun close() = decoder.close() } + /** + * The RayNeo iO's microphone: one 16 kHz mono Opus packet per BLE message (its remote + * audio stream, GlassesSessionIo), decoded with Concentus. No G2 DSP metadata; packets + * carry no counter, so "missing" stays 0 and a lost one is just a gap. + */ + class OpusDecoderAdapter : AudioPacketDecoder { + private val decoder = io.github.jaredmdobson.OpusDecoder(RayNeoIoProtocol.VOICE_SAMPLE_RATE, 1) + private var packets = 0L + private var errors = 0L + + override fun decodePacket(packet: ByteArray?, pcmOut: ShortArray?): Int { + if (packet == null || packet.isEmpty() || pcmOut == null) return 0 + return try { + val count = decoder.decode(packet, 0, packet.size, pcmOut, 0, pcmOut.size, false) + packets++ + count + } catch (e: io.github.jaredmdobson.OpusException) { + errors++ + if (errors == 1L || errors % 100 == 0L) { + android.util.Log.w("FaceclawVoice", "Opus decode error ($errors so far): ${e.message}") + } + 0 + } + } + + /** 120 ms, Opus's longest frame. */ + override val maxSamplesPerPacket: Int get() = RayNeoIoProtocol.VOICE_SAMPLE_RATE * 120 / 1000 + override val hasFrameMeta: Boolean get() = false + override val lastAngleDegrees: Int get() = 0 + override val lastSsr: Int get() = 0 + override val realPackets: Long get() = packets + override val duplicatePackets: Long get() = 0 + override val missingPackets: Long get() = 0 + override val decodeErrors: Long get() = errors + + override fun close() = decoder.resetState() + } + /** * Open the phone's own microphone at the pipeline's native format (16 kHz * mono PCM16), or null when it cannot start — the permission is missing diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt index 5089a039..eb75263a 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt @@ -254,6 +254,9 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun setFaceclawWakeLeaseEnabled(enabled: Boolean): Boolean = core.setFaceclawWakeLeaseEnabled(enabled) + /** See [GlassesSessionCore.setVoiceWakeEnabled]. */ + fun setVoiceWakeEnabled(enabled: Boolean) = core.setVoiceWakeEnabled(enabled) + fun awaitEvenHubSessionReady(timeoutMs: Int): Boolean = core.awaitEvenHubSessionReady(timeoutMs) fun setImuReportEnabled(enable: Boolean, reportFrq: Int) = core.setImuReportEnabled(enable, reportFrq) diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt index ad0531bb..ec143d1a 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt @@ -114,7 +114,9 @@ class FaceclawVoiceController(context: Context) { } } - override fun createPacketDecoder(): AudioPacketDecoder = AndroidSpeechEngines.Lc3DecoderAdapter() + override fun createPacketDecoder(): AudioPacketDecoder = + if (communicator?.isRayNeoIo() == true) AndroidSpeechEngines.OpusDecoderAdapter() + else AndroidSpeechEngines.Lc3DecoderAdapter() override fun openPhoneMic(): PcmAudioSource? = AndroidSpeechEngines.openPhoneMic(PHONE_MIC_CHUNK_SAMPLES) diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index a3d53c01..ca9fe7b5 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -468,6 +468,7 @@ class DashboardController { this.pushFirmwareDebugFlags(); this.pushBrightness(); this.syncEvenHubScreenOffSetting(); + this.syncVoiceWake(); // Display mode size first: a reflow repositions every surface too, so // the band-position check after it then has nothing left to do. this.applyDisplayModeIfChanged(); @@ -930,6 +931,24 @@ class DashboardController { return applied; } + /** What the communicator was last told about the glasses' own wake word (null: not yet). */ + private voiceWakeSent: boolean | null = null; + + /** + * The glasses' own wake word follows the wake action: on a RayNeo iO, its + * "Hey RayNeo" switch (G2 glasses use the wake lease, syncFaceclawWakeLease). + */ + private syncVoiceWake(communicator = this.communicator): void { + if (!communicator) return; + const enabled = wakeWordActionSetting.get() !== "off"; + if (this.voiceWakeSent === enabled) return; + this.voiceWakeSent = enabled; + void communicator.setVoiceWakeEnabled(enabled).catch((error) => { + this.voiceWakeSent = null; + this.appendLog(`wake word sync failed: ${this.formatError(error)}`); + }); + } + private syncEvenHubScreenOffSetting(): void { void this.syncFaceclawWakeLease().catch((error) => { this.appendLog(`wake takeover lease sync failed: ${this.formatError(error)}`); @@ -1537,6 +1556,8 @@ class DashboardController { // The paired glasses' screen: the G2's 640x480 or the RayNeo iO's 540x220. await communicator.configureCompositorScreen(screenWidth(), screenHeight()); await communicator.configureBrightness(getBrightnessPreferences()); + this.voiceWakeSent = null; + this.syncVoiceWake(communicator); this.offState = communicator.onStateChange((state) => { if (state.phase !== "connected") resetRingInputFilter(); if (isHaltedSessionPhase(state.phase)) { diff --git a/app/native/faceclaw-communicator.ios.ts b/app/native/faceclaw-communicator.ios.ts index 712a4da0..de99072a 100644 --- a/app/native/faceclaw-communicator.ios.ts +++ b/app/native/faceclaw-communicator.ios.ts @@ -679,6 +679,9 @@ export class FaceclawCommunicatorBridge { return this.enqueueNativeCall(() => Boolean(this.communicator.setFaceclawWakeLeaseEnabledEnabled(Boolean(enabled)))); } + /** The RayNeo iO's wake word; iOS doesn't drive an iO, so nothing to do. */ + async setVoiceWakeEnabled(_enabled: boolean): Promise {} + async awaitEvenHubSessionReady(timeoutMs: number): Promise { return this.enqueueNativeCall(() => Boolean(this.communicator.awaitEvenHubSessionReadyTimeoutMs(Math.round(nonNegativeNumber(timeoutMs))))); } diff --git a/app/native/faceclaw-communicator.ts b/app/native/faceclaw-communicator.ts index 80d13b24..8dc7d86f 100644 --- a/app/native/faceclaw-communicator.ts +++ b/app/native/faceclaw-communicator.ts @@ -734,6 +734,14 @@ export class FaceclawCommunicatorBridge { ); } + /** + * Whether the glasses' own wake word reaches Faceclaw: on a RayNeo iO, its + * "Hey RayNeo" switch (G2 glasses use the wake lease above instead). + */ + async setVoiceWakeEnabled(enabled: boolean): Promise { + await this.enqueueJavaCall(() => this.communicator.setVoiceWakeEnabled(enabled)); + } + /** * Resolve only once the recreated layout and retained frame * are visible. CFW's deferred-dashboard READY is emitted from this barrier. diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoiceCaptureSession.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoiceCaptureSession.kt index 33c81cf1..3a68f866 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoiceCaptureSession.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoiceCaptureSession.kt @@ -449,9 +449,10 @@ class VoiceCaptureSession( } private fun processG2Audio() { - val pcm = ShortArray(PACKET_SAMPLES) + var pcm = ShortArray(PACKET_SAMPLES) while (started) { val currentDecoder = packetDecoder ?: return + if (pcm.size < currentDecoder.maxSamplesPerPacket) pcm = ShortArray(currentDecoder.maxSamplesPerPacket) val packet = takeAudioPacket() if (packet == null) { continue @@ -474,7 +475,7 @@ class VoiceCaptureSession( maybeEmitAudioStats(false) continue } - processPcmChunk(pcm, count, angleDegrees, ssr, true) + processPcmChunk(pcm, count, angleDegrees, ssr, currentDecoder.hasFrameMeta) maybeEmitAudioStats(false) } } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoicePorts.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoicePorts.kt index 148c68a4..1844459a 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoicePorts.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/audio/VoicePorts.kt @@ -39,10 +39,19 @@ fun interface RecordingSink { fun save(pcm16le: ByteArray, sampleRate: Int) } -/** A G2 microphone packet decoder (the shared [Lc3PacketFramer] over a platform LC3 codec). */ +/** + * A glasses microphone packet decoder to 16 kHz mono PCM: the G2's LC3 (the shared + * [Lc3PacketFramer] over a platform LC3 codec) or the RayNeo iO's Opus. + */ interface AudioPacketDecoder { fun decodePacket(packet: ByteArray?, pcmOut: ShortArray?): Int + /** The most samples one packet decodes to: the size [decodePacket]'s pcmOut needs. */ + val maxSamplesPerPacket: Int get() = Lc3PacketFramer.SAMPLES_PER_PACKET + + /** Whether packets carry the G2 firmware's DSP metadata ([lastAngleDegrees], [lastSsr]). */ + val hasFrameMeta: Boolean get() = true + val lastAngleDegrees: Int val lastSsr: Int val realPackets: Long diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index 23832ed1..d15710d9 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -670,6 +670,8 @@ class GlassesSessionCore( if (listener == null) { throw IllegalArgumentException("listener is required") } + // The iO's packets are Opus from its remote audio stream (see ioStartAudioCapture). + if (isIo) return ioStartAudioCapture(listener) var magic = 0 monitor.withLock { if (!running || !sessionReady || shutdownRequested || !fixedLayoutCreated) { @@ -687,6 +689,7 @@ class GlassesSessionCore( } fun stopG2AudioCapture() { + if (isIo) return ioStopAudioCapture() var magic = 0 monitor.withLock { audioPacketListener = null @@ -794,6 +797,15 @@ class GlassesSessionCore( * that track a capture across those events must check this rather than * assume their earlier enable still holds. */ + /** + * Whether the glasses' own wake word should reach Faceclaw (its configured wake action). + * RayNeo iO: the launcher's "Hey RayNeo" switch, and the stock session it opens is + * ended in favor of Faceclaw's. G2 glasses use the wake lease instead (no-op here). + */ + fun setVoiceWakeEnabled(enabled: Boolean) { + if (isIo) ioSetVoiceWakeEnabled(enabled) + } + fun isAudioCaptureActive(): Boolean { monitor.withLock { return running && sessionReady && !shutdownRequested && audioCaptureActive @@ -810,6 +822,8 @@ class GlassesSessionCore( val generation: Int monitor.withLock { faceclawWakeLeaseEnabled = enabled + // A G2 firmware lease; the iO's wake word is setVoiceWakeEnabled. + if (isIo) return true if (!running || !sessionReady) { return !enabled } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt index 6f22bfc1..9dd54d91 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt @@ -52,6 +52,23 @@ internal class IoSessionState { /** Last `screen_status` push: 1 on, 0 off, -1 unknown. */ var screenStatus = -1 + /** Whether Faceclaw answers "Hey RayNeo" (null until the dashboard says); what this link was last told. */ + var voiceWakeWanted: Boolean? = null + var voiceWakeSent = -1 + /** The stock assistant opened a session (wake word): end it, it must not take the display. */ + var voiceAbortPending = false + /** Ask for the launcher's general settings (logged: the wake-word preferences among them). */ + var settingsRequestPending = true + /** When a wake was last reported: one phrase can wake twice (fast and second stage). */ + var lastVoiceWakeAtMs = 0L + + /** A capture wants the remote mic stream; whether this link was asked to open it, and when. */ + var micWanted = false + var micStreamOpen = false + var micStartSentAtMs = 0L + var micPackets = 0L + var lastMicPacketAtMs = 0L + fun resetLink() { reassembler.reset() versionReply = null @@ -65,6 +82,11 @@ internal class IoSessionState { brightnessSentLevel = -1 lastBrightnessAtMs = 0 screenStatus = -1 + voiceWakeSent = -1 + voiceAbortPending = false + settingsRequestPending = true + micStreamOpen = false + micStartSentAtMs = 0 } } @@ -83,6 +105,10 @@ internal object IoTimings { const val PAGE_REASON_USER = 4 /** While Faceclaw shows content, re-assert the screen this often (the stock auto-off is short). */ const val SCREEN_REFRESH_MS = 5_000L + /** A wanted mic stream that hasn't delivered a packet this long is asked for again. */ + const val MIC_RETRY_MS = 3_000L + /** Wakes this close to a reported one are the same phrase (fast stage, then second stage). */ + const val VOICE_WAKE_DEDUP_MS = 3_000L } /** The glasses hung up at the version request: bound to another phone id, or not in pairing mode. */ @@ -341,9 +367,38 @@ internal fun GlassesSessionCore.ioMaintain() { var ctrl = -1 var status = false var brightness = -1 + var wakeword = -1 + var micRc = -1 + var abortVoice = false + var settings = false monitor.withLock { if (!sessionReady) return val now = now() + val wake = io.voiceWakeWanted + if (wake != null && io.voiceWakeSent != (if (wake) 1 else 0)) { + wakeword = if (wake) 1 else 0 + io.voiceWakeSent = wakeword + // Read back what the switch did. + io.settingsRequestPending = true + } + if (io.settingsRequestPending) { + settings = true + io.settingsRequestPending = false + } + if (io.voiceAbortPending) { + abortVoice = true + io.voiceAbortPending = false + } + if (io.micWanted && (!io.micStreamOpen + || (io.lastMicPacketAtMs < io.micStartSentAtMs && now - io.micStartSentAtMs >= IoTimings.MIC_RETRY_MS))) { + // Not yet asked on this link, a voice session took the recorder, or the ask was lost. + micRc = RayNeoIoProtocol.VOICE_RC_START + io.micStreamOpen = true + io.micStartSentAtMs = now + } else if (!io.micWanted && io.micStreamOpen) { + micRc = RayNeoIoProtocol.VOICE_RC_STOP + io.micStreamOpen = false + } if (io.pageWanted && !fixedLayoutCreated && now - io.pageRequestSentAtMs >= IoTimings.PAGE_RETRY_MS) { ctrl = RayNeoIoProtocol.CTRL_PAGE_OPEN io.pageRequestSentAtMs = now @@ -374,6 +429,60 @@ internal fun GlassesSessionCore.ioMaintain() { } if (status) ioRequestStatus() if (brightness > 0) ioWriteLauncher(RayNeoIoProtocol.LAUNCHER_BRIGHTNESS, RayNeoIoProtocol.launcherBrightness(brightness)) + if (wakeword >= 0) { + logLine("RayNeo iO: wake word " + (if (wakeword == 1) "on" else "off")) + ioWriteLauncher(RayNeoIoProtocol.LAUNCHER_AI_VOICE_WAKEUP, RayNeoIoProtocol.launcherSetAiVoiceWakeup(wakeword == 1)) + } + if (settings) ioWriteLauncher(RayNeoIoProtocol.LAUNCHER_GENERAL_SETTINGS, RayNeoIoProtocol.GENERAL_SETTINGS_REQUEST) + if (abortVoice) { + // As Glassly does: decline the stock session, then abort it, so its page goes. + ioWriteFrame(RayNeoIoProtocol.BUSINESS_VOICE, RayNeoIoProtocol.voiceRc(RayNeoIoProtocol.VOICE_RC, RayNeoIoProtocol.VOICE_RC_STOP)) + ioWriteFrame(RayNeoIoProtocol.BUSINESS_VOICE, RayNeoIoProtocol.voiceRc(RayNeoIoProtocol.VOICE_ABORT, RayNeoIoProtocol.VOICE_RC_START)) + } + if (micRc > 0) { + logLine("RayNeo iO mic: " + (if (micRc == RayNeoIoProtocol.VOICE_RC_START) "open" else "close") + " the remote audio stream") + ioWriteFrame(RayNeoIoProtocol.BUSINESS_VOICE, RayNeoIoProtocol.voiceRc(RayNeoIoProtocol.VOICE_STREAM_CONTROL, micRc)) + } +} + +/** + * The glasses' mic for a voice capture: the remote audio stream (16 kHz mono Opus packets to + * [listener]), which needs IDENT_FLAG_MIC firmware. ioMaintain sends the open (and repeats it + * while no packet comes); a voice session or a call can take the recorder meanwhile. + */ +internal fun GlassesSessionCore.ioStartAudioCapture(listener: FaceclawAudioPacketListener): Boolean { + monitor.withLock { + if (!running || !sessionReady || shutdownRequested) { + logLine("skip RayNeo iO mic: session not ready") + return false + } + if (io.ident?.micStream != true) { + logLine("skip RayNeo iO mic: the firmware has no remote audio stream (IDENT flag 0x20)") + return false + } + audioPacketListener = listener + audioCaptureActive = true + io.micWanted = true + io.micStreamOpen = false + io.micPackets = 0 + } + interruptibleSleep.interrupt() + return true +} + +internal fun GlassesSessionCore.ioStopAudioCapture() { + monitor.withLock { + audioPacketListener = null + audioCaptureActive = false + io.micWanted = false + } + interruptibleSleep.interrupt() +} + +/** Whether "Hey RayNeo" should reach Faceclaw (the launcher's wake-word switch). */ +internal fun GlassesSessionCore.ioSetVoiceWakeEnabled(enabled: Boolean) { + monitor.withLock { io.voiceWakeWanted = enabled } + interruptibleSleep.interrupt() } /** Stop drawing and close the page, keeping the BLE link (the EvenHub suspend analogue). */ @@ -421,6 +530,7 @@ internal fun GlassesSessionCore.ioOnNotification(address: String, characteristic monitor.signalAll() } RayNeoIoProtocol.BUSINESS_LAUNCHER -> ioHandleLauncher(frame.payload) + RayNeoIoProtocol.BUSINESS_VOICE -> ioHandleVoice(frame.payload) RayNeoIoProtocol.BUSINESS_OTA -> { val envelope = RayNeoIoProtocol.decodeEnvelope(frame.payload) ?: continue if (envelope.type != RayNeoIoProtocol.OTA_VERSION) continue @@ -450,7 +560,11 @@ private fun GlassesSessionCore.ioHandleLauncher(payload: ByteArray) { return } val battery = RayNeoIoProtocol.batteryFromLauncherJson(envelope.json) - if (battery < 0) return + if (battery < 0) { + // Replies to our commands and settings (the wake word's among them): logged for now. + logLine("RayNeo iO launcher type " + envelope.type + ": " + envelope.json.take(400)) + return + } val charging = if (envelope.json.contains("\"isCharging\":true")) 1 else if (envelope.json.contains("\"isCharging\":false")) 0 else -1 var changed = false monitor.withLock { @@ -464,6 +578,73 @@ private fun GlassesSessionCore.ioHandleLauncher(payload: ByteArray) { if (changed) emitBatteryState(headsetBattery, headsetCharging) } +/** The voice channel (business 13): mic packets, and the stock assistant's wake word. */ +private fun GlassesSessionCore.ioHandleVoice(payload: ByteArray) { + val envelope = RayNeoIoProtocol.decodeEnvelope(payload) ?: return + when (envelope.type) { + RayNeoIoProtocol.VOICE_STREAM_AUDIO, RayNeoIoProtocol.VOICE_AUDIO -> { + val opus = envelope.binary ?: return + val arrivalMs = now() + var first = false + val listener = monitor.withLock { + lastIncomingAtMs = arrivalMs + io.micPackets++ + first = io.micPackets == 1L + io.lastMicPacketAtMs = arrivalMs + if (audioCaptureActive) audioPacketListener else null + } + if (first) logLine("RayNeo iO mic: first audio packet (type " + envelope.type + ", " + opus.size + " bytes)") + if (listener == null) return + try { + listener.onAudioPacket(opus, "R", arrivalMs) + } catch (t: Throwable) { + logLine("RayNeo iO mic packet listener failed: " + safeMessage(t)) + } + } + RayNeoIoProtocol.VOICE_WAKE -> { + // The stock assistant heard "Hey RayNeo" and opened its session. Faceclaw's own + // assistant answers instead: end the stock one, and report the wake word as the + // G2's (sid 0x07 EVEN_AI_WAKE_UP), which the dashboard routes to its wake action. + var repeat = false + val forward = monitor.withLock { + val now = now() + io.voiceAbortPending = true + lastIncomingAtMs = now + lastConnectionOrInputAtMs = now + repeat = io.lastVoiceWakeAtMs != 0L && now - io.lastVoiceWakeAtMs < IoTimings.VOICE_WAKE_DEDUP_MS + val wanted = io.voiceWakeWanted == true && sessionReady + if (wanted && !repeat) { + io.lastVoiceWakeAtMs = now + ioReclaimPageOnInputLocked() + } + wanted && !repeat + } + interruptibleSleep.interrupt() + logLine("RayNeo iO: voice wake " + envelope.json + when { + forward -> "" + repeat -> " (same phrase as the last wake)" + else -> " (not forwarded: wake word off)" + }) + if (!forward) return + val event = G2Event("even-ai", "", BleProtocol.EVEN_AI_STATUS_WAKE_UP, 0, 0) + val frameId = frameTimings.startFrame("input:even-ai wake") + frameTimings.log(frameId, "wake word from the RayNeo iO's voice channel") + emitRingEvent(event, frameId) + } + RayNeoIoProtocol.VOICE_EXITED -> { + // A voice session that held the recorder ended: ask for the stream again. + val reopen = monitor.withLock { + if (io.micWanted) io.micStreamOpen = false + io.micWanted + } + if (reopen) interruptibleSleep.interrupt() + logLine("RayNeo iO: voice session exited " + envelope.json + (if (reopen) "; reopening the mic stream" else "")) + } + RayNeoIoProtocol.VOICE_VAD -> logDebug("RayNeo iO: voice VAD " + envelope.json) + else -> logLine("RayNeo iO: voice message type " + envelope.type + " " + envelope.json.take(160)) + } +} + private fun GlassesSessionCore.ioHandleCfw(address: String, frame: RayNeoIoProtocol.Frame) { val payload = frame.payload if (payload.isEmpty()) return diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt index c525bc15..d0cd42ae 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt @@ -40,6 +40,7 @@ object RayNeoIoBle { object RayNeoIoProtocol { const val BUSINESS_OTA = 9 + const val BUSINESS_VOICE = 13 const val BUSINESS_LAUNCHER = 15 const val BUSINESS_HANDSHAKE = 0x10 const val BUSINESS_CFW = 0xf0 @@ -248,8 +249,46 @@ object RayNeoIoProtocol { const val MODE_REPLY = 2 const val LAUNCHER_GENERAL_STATUS = 1 const val LAUNCHER_BRIGHTNESS = 2 + const val LAUNCHER_GENERAL_SETTINGS = 4 + const val LAUNCHER_AI_VOICE_WAKEUP = 16 const val OTA_VERSION = 1 const val GENERAL_STATUS_REQUEST = """{"cmd":"request_general_status","payload":{"data":"","mode":0,"value":0}}""" + /** The reply (type 4) carries `generalSettings`, among them the wake-word preferences. */ + const val GENERAL_SETTINGS_REQUEST = """{"cmd":"request_general_settings","payload":{"value":0,"mode":0,"data":""}}""" + + /** + * The launcher's wake-word switch. Every `set_ai_*` handler takes the new value from + * `mode` and ignores `value` (RnLinkMsgProcessor::handleAssistantSettingCommand, see + * notes/rayneo-io-wakeword-re.md): mode 1 on, 0 off. + */ + @JvmStatic + fun launcherSetAiVoiceWakeup(enabled: Boolean): String = + """{"cmd":"set_ai_voice_wakeup","payload":{"value":0,"mode":${if (enabled) 1 else 0},"data":""}}""" + + // ---- Voice assistant (business 13), as Glassly's RayNeoIOProtocol maps it ---- + // The stock assistant: the wake word (or a temple long/double press) opens a session + // and sends VOICE_WAKE; the phone answers VOICE_RC {"rc":1} for Opus as VOICE_AUDIO, + // or {"rc":2} plus VOICE_ABORT to end it; VOICE_EXITED reports it gone. The remote + // stream (VOICE_STREAM_CONTROL {"rc":1|2}, packets as VOICE_STREAM_AUDIO) needs + // IDENT_FLAG_MIC firmware and runs without a session or its page, until a session, + // a call, SCO or a recording takes the recorder. Packets are 16 kHz mono Opus in + // the envelope's bytes field. + + const val VOICE_WAKE = 1 + const val VOICE_RC = 2 + const val VOICE_AUDIO = 3 + const val VOICE_VAD = 4 + const val VOICE_ABORT = 7 + const val VOICE_EXITED = 8 + const val VOICE_STREAM_CONTROL = 58 + const val VOICE_STREAM_AUDIO = 59 + const val VOICE_RC_START = 1 + const val VOICE_RC_STOP = 2 + const val VOICE_SAMPLE_RATE = 16_000 + + /** A voice-channel message: `{"rc":n}` as [type] (VOICE_RC, VOICE_STREAM_CONTROL or VOICE_ABORT). */ + @JvmStatic + fun voiceRc(type: Int, rc: Int): ByteArray = encodeEnvelope(Envelope(type, """{"rc":$rc}""")) class Envelope( @JvmField val type: Int, @@ -415,6 +454,8 @@ object RayNeoIoProtocol { const val IDENT_FLAG_ZLIB = 0x01 const val IDENT_FLAG_STEREO = 0x08 + /** The assistant's remote audio stream (type 58/59 below) is allowed (CFW revision 10). */ + const val IDENT_FLAG_MIC = 0x20 const val IDENT_FLAG_FACECLAW = 0x80 class Ident( @@ -428,6 +469,7 @@ object RayNeoIoProtocol { @JvmField val faceclawRevision: Int, ) { val acceptsCompressed: Boolean get() = flags and IDENT_FLAG_ZLIB != 0 + val micStream: Boolean get() = flags and IDENT_FLAG_MIC != 0 val faceclaw: Boolean get() = flags and IDENT_FLAG_FACECLAW != 0 && faceclawRevision > 0 } diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt index 01b087fc..9e140ac3 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt @@ -44,6 +44,13 @@ private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { private val messagesList = ArrayList() private val launcherList = ArrayList() val launcher: List get() = lock.withLock { launcherList.toList() } + /** Voice-channel (business 13) messages from the phone: type to JSON. */ + private val voiceList = ArrayList>() + val voice: List> get() = lock.withLock { voiceList.toList() } + + /** A voice-channel message from the glasses. */ + fun voiceNotify(type: Int, json: String = "{}", binary: ByteArray? = null) = + notify(13, RayNeoIoProtocol.encodeEnvelope(RayNeoIoProtocol.Envelope(type, json, binary))) private val records = ArrayList() private var current = ByteArray(0) private val inbound = RayNeoIoProtocol.FrameReassembler() @@ -133,6 +140,10 @@ private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { """{"generalStatus":{"battery":77,"isCharging":false}}""", sequence = RayNeoIoProtocol.decodeEnvelope(p)!!.sequence, mode = 2))) } 9 -> notify(9, RayNeoIoProtocol.encodeEnvelope(RayNeoIoProtocol.Envelope(1, """{"OsVersion":"Strix OS 1.0.4.12"}"""))) + 13 -> { + val envelope = RayNeoIoProtocol.decodeEnvelope(p)!! + lock.withLock { voiceList.add(envelope.type to envelope.json) } + } 0xf0 -> cfw(p) } } @@ -439,4 +450,70 @@ class RayNeoIoSessionTest { s.core.close() } } + + @Test + fun theWakeWordAndTheMicStream() { + val s = IoSession() + s.core.configureCompositorScreen(540, 220) + val lock = s.platform.createLock() + val packets = ArrayList() + val listener = object : FaceclawAudioPacketListener { + override fun onAudioPacket(data: ByteArray?, arm: String?, arrivalMs: Long) { + lock.withLock { packets.add(data!!) } + } + } + val count = { lock.withLock { packets.size } } + fun sent(type: Int, json: String) = s.glasses.voice.count { it == type to json } + val start = """{"rc":1}""" + val stop = """{"rc":2}""" + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.pageUp() }, s.tail()) + + // "Hey RayNeo" goes to Faceclaw: the launcher's switch on, then each wake ends the + // stock session (declined, then aborted) and arrives as the G2's EVEN_AI_WAKE_UP. + s.core.setVoiceWakeEnabled(true) + // The firmware reads the switch from "mode", not "value". + assertTrue(awaitTrue(3_000) { s.glasses.launcher.any { "set_ai_voice_wakeup" in it && "\"mode\":1" in it } }, s.tail()) + s.glasses.voiceNotify(RayNeoIoProtocol.VOICE_WAKE, """{"rc":2,"mode":2,"linkType":0}""") + assertTrue(awaitTrue(2_000) { "even-ai:${BleProtocol.EVEN_AI_STATUS_WAKE_UP}:0" in s.listener.events }, s.listener.events.toString()) + // The same phrase's second-stage wake is not a second wake. + s.glasses.voiceNotify(RayNeoIoProtocol.VOICE_WAKE, """{"rc":2,"mode":3,"linkType":0}""") + sleepMs(200) + assertEquals(1, s.listener.events.count { it.startsWith("even-ai:") }) + assertTrue(awaitTrue(2_000) { + sent(RayNeoIoProtocol.VOICE_RC, stop) >= 1 && sent(RayNeoIoProtocol.VOICE_ABORT, start) >= 1 + }, s.glasses.voice.toString()) + + // The mic: capture opens the remote stream, its Opus packets go to the listener as + // they came, and stopping closes it. + assertTrue(s.core.startG2AudioCapture(listener)) + assertTrue(awaitTrue(2_000) { sent(RayNeoIoProtocol.VOICE_STREAM_CONTROL, start) == 1 }, s.tail()) + s.glasses.voiceNotify(RayNeoIoProtocol.VOICE_STREAM_AUDIO, binary = byteArrayOf(0x78, 1, 2, 3)) + assertTrue(awaitTrue(2_000) { count() == 1 }) + assertTrue(lock.withLock { packets[0] }.contentEquals(byteArrayOf(0x78, 1, 2, 3))) + assertTrue(s.core.isAudioCaptureActive()) + // A voice session that took the recorder ended: the stream is asked for again. + s.glasses.voiceNotify(RayNeoIoProtocol.VOICE_EXITED) + assertTrue(awaitTrue(2_000) { sent(RayNeoIoProtocol.VOICE_STREAM_CONTROL, start) == 2 }, s.tail()) + s.core.stopG2AudioCapture() + assertTrue(awaitTrue(2_000) { sent(RayNeoIoProtocol.VOICE_STREAM_CONTROL, stop) == 1 }, s.tail()) + assertFalse(s.core.isAudioCaptureActive()) + s.glasses.voiceNotify(RayNeoIoProtocol.VOICE_STREAM_AUDIO, binary = byteArrayOf(9)) + sleepMs(200) + assertEquals(1, count()) + + // With the wake action off: the switch follows, and a wake is ended but not reported. + s.core.setVoiceWakeEnabled(false) + assertTrue(awaitTrue(3_000) { s.glasses.launcher.any { "set_ai_voice_wakeup" in it && "\"mode\":0" in it } }, s.tail()) + val events = s.listener.events.size + val aborts = sent(RayNeoIoProtocol.VOICE_ABORT, start) + s.platform.offsetMs += 5_000 + s.glasses.voiceNotify(RayNeoIoProtocol.VOICE_WAKE) + assertTrue(awaitTrue(2_000) { sent(RayNeoIoProtocol.VOICE_ABORT, start) > aborts }, s.glasses.voice.toString()) + assertEquals(events, s.listener.events.size) + } finally { + s.core.close() + } + } } From dff8608a636b8497f0ce767d03bc1a03eb6850f9 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Sun, 1 Nov 2026 23:43:32 -0800 Subject: [PATCH 05/34] Fix size of the notification modal after switching glasses-model mid-session --- app/ui/layers.ts | 19 +++++++++++-------- tests/menu-display-list.test.cjs | 22 ++++++++++++++++++++++ 2 files changed, 33 insertions(+), 8 deletions(-) diff --git a/app/ui/layers.ts b/app/ui/layers.ts index a16a98ff..e55502b4 100644 --- a/app/ui/layers.ts +++ b/app/ui/layers.ts @@ -154,8 +154,12 @@ export class LayerStack { } private readonly shellKeys = new WeakMap(); private readonly ctx: LayerContext; - private baseWidth: number; - private baseHeight: number; + /** + * The base viewport's size, or null to follow the paired glasses' screen + * as it is now: the shell's own stack lives for the whole process, and + * re-pairing with the other glasses type changes the screen under it. + */ + private baseSize: { width: number; height: number } | null; private readonly focusedFn: () => boolean; private lastBaseDim: number | false = 1; @@ -173,8 +177,7 @@ export class LayerStack { stack: this, actions, }; - this.baseWidth = baseSize?.width ?? screenWidth(); - this.baseHeight = baseSize?.height ?? screenHeight(); + this.baseSize = baseSize ? { width: baseSize.width, height: baseSize.height } : null; this.focusedFn = isFocused; } @@ -245,13 +248,12 @@ export class LayerStack { } getBaseSize(): { width: number; height: number } { - return { width: this.baseWidth, height: this.baseHeight }; + return this.baseSize ? { ...this.baseSize } : { width: screenWidth(), height: screenHeight() }; } /** Resize the base viewport (e.g. an EvenHub window switching to the tall canvas). */ setBaseSize(size: { width: number; height: number }): void { - this.baseWidth = size.width; - this.baseHeight = size.height; + this.baseSize = { width: size.width, height: size.height }; } setActions(actions: Partial): void { @@ -322,7 +324,8 @@ export class LayerStack { layer.paint(this.ctx, () => { belowRequested = true; if (!canvas) { - canvas = new GrayImage(this.baseWidth, this.baseHeight, 0); + const { width, height } = this.getBaseSize(); + canvas = new GrayImage(width, height, 0); } return canvas; }), diff --git a/tests/menu-display-list.test.cjs b/tests/menu-display-list.test.cjs index 3e97d1a6..f8e25202 100644 --- a/tests/menu-display-list.test.cjs +++ b/tests/menu-display-list.test.cjs @@ -141,3 +141,25 @@ test('shell crop widens a fractional rect (TTF-measured status bar) to whole pix assert.deepEqual([crop.x,crop.y,crop.image.width,crop.image.height],[400,250,176,15]); assert.ok(crop.image.pixels.every(v=>v===7)); }); + +test('a stack without its own size follows the screen when the glasses type changes',()=>{ + // The shell's stack is built once per process; re-pairing a G2 after a + // RayNeo iO must not leave its overlays painting on a 540x220 canvas. + const screen={width:540,height:220}; + const {LayerStack}=load('app/ui/layers.ts',{ + '../graphics/image':graphics,'../graphics/plane':planes,'../native/frame-timings':{spanCurrent:(_name,fn)=>fn()}, + '../graphics/screen-size':{screenWidth:()=>screen.width,screenHeight:()=>screen.height},'./gestures':{}, + }); + const stack=new LayerStack({paint:()=>new graphics.GrayImage(screen.width,screen.height,0)},noopLayerActions); + stack.push({paint:(_ctx,below)=>below(),handleInput:async()=>{}}); + // JSON: the stack's arrays and objects come from the vm's realm. + const sizes=()=>JSON.parse(JSON.stringify(stack.paint().map(p=>[p.image.width,p.image.height]))); + assert.deepEqual(sizes(),[[540,220],[540,220]]); + screen.width=640;screen.height=480; + assert.deepEqual({...stack.getBaseSize()},{width:640,height:480}); + assert.deepEqual(sizes(),[[640,480],[640,480]]); + // An explicit size (a window's viewport, the modal's interior) stays put. + const sized=new LayerStack({paint:()=>new graphics.GrayImage(100,90,0)},noopLayerActions,{width:100,height:90}); + screen.width=540;screen.height=220; + assert.deepEqual({...sized.getBaseSize()},{width:100,height:90}); +}); From f803f4212c8473a49b68d8a8f216cb6612885248 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Thu, 5 Nov 2026 11:18:17 -0800 Subject: [PATCH 06/34] Brightness control --- app/g2/brightness-curve.ts | 7 ++ app/ui/dashboard-settings.ts | 17 +++- .../session/GlassesSessionBrightness.kt | 12 ++- .../g2protocol/session/GlassesSessionIo.kt | 61 ++++++++++-- .../g2protocol/session/GlassesSessionSend.kt | 4 +- .../faceclaw/app/rayneo/RayNeoIoProtocol.kt | 33 ++++++- tests/brightness-curve.test.cjs | 14 ++- .../com/faceclaw/app/RayNeoIoProtocolTest.kt | 15 +++ .../com/faceclaw/app/RayNeoIoSessionTest.kt | 93 ++++++++++++++++++- 9 files changed, 233 insertions(+), 23 deletions(-) diff --git a/app/g2/brightness-curve.ts b/app/g2/brightness-curve.ts index 1695ae8d..357c76de 100644 --- a/app/g2/brightness-curve.ts +++ b/app/g2/brightness-curve.ts @@ -1,5 +1,12 @@ export const DEFAULT_BRIGHTNESS_CURVE = "0:0,0.2:7,1.5:33,5:100"; const PREVIOUS_DEFAULT_CURVE = "0:0,1:10,10:30,100:65,1000:100"; +/** + * The RayNeo iO's sensor reads real lux, far above the G2's behind-the-lens values, so the + * G2's curve would sit at maximum in any lit room. These knots put the default 20–100 range on + * the stock firmware's own scene levels: 29, 41, 41, 53, 65, 76, 94 and 100 percent at 3, 10, + * 200, 300, 600, 1000, 4000 and 5000 lux. + */ +export const RAYNEO_IO_BRIGHTNESS_CURVE = "0:0,3:11,10:26,200:26,300:41,600:56,1000:70,4000:93,5000:100"; /** Percent of the configured range; defaults (20–100) give 20/26/46/100. */ export function brightnessCurveError(value: string): string | null { diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 2c6670c5..5a758d0b 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -1,6 +1,6 @@ import { normalizeNightscoutThreshold, type NightscoutThresholds } from "../apps/nightscout/nightscout-alerts"; import { GESTURE_DOUBLE_CLICK, InputEvent } from "./gestures"; -import { DEFAULT_BRIGHTNESS_CURVE, normalizeBrightnessCurve, brightnessCurveError } from "../g2/brightness-curve"; +import { DEFAULT_BRIGHTNESS_CURVE, RAYNEO_IO_BRIGHTNESS_CURVE, normalizeBrightnessCurve, brightnessCurveError } from "../g2/brightness-curve"; import { getBooleanSetting, getStringSetting, @@ -215,6 +215,8 @@ type ConfigSettingStringOptions = ConfigSettingOptions string; validate?: (value: string) => string | null; + /** The default while nothing is stored, when it depends on context (else `defaultValue`). */ + dynamicDefault?: () => string | undefined; }; // Every string setting by id, so isolates that can only pass an id over a @@ -232,6 +234,7 @@ export class ConfigSettingString extends ConfigSett readonly inputKind: "text" | "email" | "password"; private readonly normalizer: (value: string | null | undefined) => string; private readonly validator?: (value: string) => string | null; + private readonly dynamicDefault: (() => string | undefined) | undefined; constructor(options: ConfigSettingStringOptions) { super(options); @@ -240,11 +243,16 @@ export class ConfigSettingString extends ConfigSett this.inputKind = options.inputKind ?? "text"; this.normalizer = options.normalize ?? ((value) => value ?? ""); this.validator = options.validate; + this.dynamicDefault = options.dynamicDefault; stringSettingsById.set(this.id, this); } + private currentDefault(): string { + return this.dynamicDefault?.() ?? this.defaultValue; + } + get(): string { - return this.normalizer(getStringSetting(this.storageKey, this.defaultValue)); + return this.normalizer(getStringSetting(this.storageKey, this.currentDefault())); } set(value: string): string { @@ -263,8 +271,8 @@ export class ConfigSettingString extends ConfigSett getValidValue(): string { const value = this.get(); if (!this.validationError(value)) return value; - const saved = this.normalizer(getStringSetting(this.storageKey + ".valid", this.defaultValue)); - return this.validationError(saved) ? this.defaultValue : saved; + const saved = this.normalizer(getStringSetting(this.storageKey + ".valid", this.currentDefault())); + return this.validationError(saved) ? this.currentDefault() : saved; } } @@ -592,6 +600,7 @@ export const autoBrightnessMaxSetting = new ConfigSettingEnum({ export const autoBrightnessCurveSetting = new ConfigSettingString({ id: "autoBrightnessCurve", label: "Auto light curve", storageKey: "display.autoBrightnessCurve", defaultValue: DEFAULT_BRIGHTNESS_CURVE, normalize: normalizeBrightnessCurve, validate: brightnessCurveError, + dynamicDefault: () => (glassesTypeSetting.get() === "rayneo-io" ? RAYNEO_IO_BRIGHTNESS_CURVE : undefined), description: "2–16 lux:percent pairs, separated by commas. Percent is within your minimum–maximum range. Start at 0:0, end at 100%, and increase lux without decreasing percent. Incomplete edits stay in the preview; brightness keeps using the last valid curve.", }); /** The screen on/off fade at Normal speed. */ diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt index 3e9a4463..97065349 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt @@ -5,9 +5,9 @@ package com.faceclaw.app * frames, so wake starts on the intended PRESENT, never on an older black frame. */ internal fun GlassesSessionCore.enqueueBrightnessLocked(frameVisible: Boolean? = null) { if (isIo) { - // The iO has no CFW brightness; ioMaintain drives the launcher's (and the screen) instead. ioNoteFrameVisibleLocked(frameVisible) - return + // Older iO firmware has no message 30; ioMaintain drives the launcher's (and the screen) instead. + if (!ioFirmwareOwnsBrightness) return } if (!customFirmwareDetected || !sessionReady || !fixedLayoutCreated || shutdownRequested) return val visible = frameVisible ?: brightnessSentVisible ?: return @@ -30,18 +30,22 @@ internal fun GlassesSessionCore.enqueueBrightnessLocked(frameVisible: Boolean? = pendingMessages.addLast(message) brightnessSentLevel = target brightnessSentVisible = visible + if (isIo) io.lastBrightnessAtMs = now() } internal fun GlassesSessionCore.maintainBrightnessLocked(now: Long) { if (!customFirmwareDetected || !sessionReady || !fixedLayoutCreated || shutdownRequested) return // Passive polling owns stock ALS even in manual mode. Slower manual polling // keeps stock from writing the panel without needlessly streaming samples. - if (now - brightnessAlsStartedAt >= 2000 && !hasPendingOrInflightKindLocked("als-control")) { - val interval = if (brightnessDemoPolling) 250 else if (brightnessPolicy.automatic) 500 else 5000 + val interval = if (brightnessDemoPolling) 250 else if (brightnessPolicy.automatic) 500 else 5000 + // The G2's stock can close the sensor, so it hears this again; the iO's polling lasts as long as the page. + val alsDue = if (isIo) interval != io.alsIntervalSent else now - brightnessAlsStartedAt >= 2000 + if (alsDue && !hasPendingOrInflightKindLocked("als-control")) { val payload = byteArrayOf(CFW_MSG_AMBIENT_LIGHT.toByte(), 1, 1, interval.toByte(), (interval shr 8).toByte(), 0, 0, 0xe8.toByte(), 3) enqueueAmbientLightControlLocked(payload, "brightness passive ALS", false) brightnessAlsStartedAt = now + if (isIo) io.alsIntervalSent = interval } enqueueBrightnessLocked() } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt index 9dd54d91..ff8de59a 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt @@ -49,6 +49,8 @@ internal class IoSessionState { var displayVisible = false var brightnessSentLevel = -1 var lastBrightnessAtMs = 0L + /** The light sensor poll interval this page was last asked for ([ioFirmwareOwnsBrightness]), -1 none. */ + var alsIntervalSent = -1 /** Last `screen_status` push: 1 on, 0 off, -1 unknown. */ var screenStatus = -1 @@ -81,6 +83,7 @@ internal class IoSessionState { lastStatusAtMs = 0 brightnessSentLevel = -1 lastBrightnessAtMs = 0 + alsIntervalSent = -1 screenStatus = -1 voiceWakeSent = -1 voiceAbortPending = false @@ -122,9 +125,29 @@ internal fun ioSupportsCfwType(type: Int): Boolean = internal val GlassesSessionCore.isIo: Boolean get() = glassesType == GlassesType.RAYNEO_IO -/** Messages the iO cannot take (stock EvenHub/settings traffic, the G2's hardware CFW modes). */ -internal fun GlassesSessionCore.ioSupportsMessage(message: OutboundMessage): Boolean = - message.sid == CfwTransport.SID && message.message.isNotEmpty() && ioSupportsCfwType(message.message[0].toInt() and 255) +/** + * The firmware runs message 30 and the light sensor (faceclaw-rayneo-cfw bright.c), with the G2's + * wire formats, so the shared brightness code drives it. Older firmware gets the launcher's + * brightness command, which is all it has (see [ioMaintain]). + */ +internal val GlassesSessionCore.ioFirmwareOwnsBrightness: Boolean get() = io.ident?.brightnessControl == true + +/** Messages the iO cannot take (stock EvenHub/settings traffic, the G2's other hardware CFW modes). */ +internal fun GlassesSessionCore.ioSupportsMessage(message: OutboundMessage): Boolean { + if (message.sid != CfwTransport.SID || message.message.isEmpty()) return false + val type = message.message[0].toInt() and 255 + return ioSupportsCfwType(type) || + (ioFirmwareOwnsBrightness && (type == CFW_MSG_BRIGHTNESS || type == CFW_MSG_AMBIENT_LIGHT)) +} + +/** A page opened (or reopened): the firmware gave brightness back when the last one closed. */ +private fun GlassesSessionCore.ioResetBrightnessLocked() { + brightnessSentVisible = null + brightnessSentLevel = -1 + brightnessAlsStartedAt = -2000 + brightnessPolicy.resetSamples() + io.alsIntervalSent = -1 +} // --------------------------------------------------------------------------------------------- // Writes @@ -333,6 +356,7 @@ internal fun GlassesSessionCore.ioConnectLoopOnce() { for (transport in cfwTransports) transport.reset() io.lastKeepaliveAtMs = lastAckAtMs io.lastStatusAtMs = lastAckAtMs + ioResetBrightnessLocked() } setStateDisplay("connected", "Connected.") ConnectionCounters.increment("io.session-ready") @@ -415,12 +439,21 @@ internal fun GlassesSessionCore.ioMaintain() { } // Faceclaw decides when the display is dark (blanked frames); while it shows // content, keep the iO's screen on and at Faceclaw's brightness. - val level = RayNeoIoProtocol.brightnessLevel(brightnessPolicy.target) - if (fixedLayoutCreated && io.pageWanted && io.displayVisible && !shutdownRequested - && (level != io.brightnessSentLevel || now - io.lastBrightnessAtMs >= IoTimings.SCREEN_REFRESH_MS)) { - brightness = level - io.brightnessSentLevel = level - io.lastBrightnessAtMs = now + val showing = fixedLayoutCreated && io.pageWanted && io.displayVisible && !shutdownRequested + if (ioFirmwareOwnsBrightness) { + // Repeating message 30 starts no fade; visible=1 is what holds the screen on. + if (showing && now - io.lastBrightnessAtMs >= IoTimings.SCREEN_REFRESH_MS) { + io.lastBrightnessAtMs = now + brightnessSentLevel = -1 + enqueueBrightnessLocked() + } + } else { + val level = RayNeoIoProtocol.brightnessLevel(brightnessPolicy.target) + if (showing && (level != io.brightnessSentLevel || now - io.lastBrightnessAtMs >= IoTimings.SCREEN_REFRESH_MS)) { + brightness = level + io.brightnessSentLevel = level + io.lastBrightnessAtMs = now + } } } if (ctrl >= 0) { @@ -660,6 +693,15 @@ private fun GlassesSessionCore.ioHandleCfw(address: String, frame: RayNeoIoProto io.ident = RayNeoIoProtocol.parseIdent(payload) monitor.signalAll() } + RayNeoIoProtocol.KIND_ALS -> { + val body = RayNeoIoProtocol.parseAlsReport(payload) ?: return + monitor.withLock { + lastIncomingAtMs = now() + brightnessPolicy.sample(body, lastIncomingAtMs) + } + emitAmbientLight(body) + interruptibleSleep.interrupt() + } RayNeoIoProtocol.KIND_PAGE -> ioHandlePage(payload) RayNeoIoProtocol.KIND_GESTURE -> ioHandleGesture(RayNeoIoProtocol.parseGesture(payload) ?: return) else -> logDebug("RayNeo iO: CFW reply kind " + (payload[0].toInt() and 255) + " " + hex(payload.copyOf(minOf(payload.size, 24)))) @@ -683,6 +725,7 @@ private fun GlassesSessionCore.ioHandlePage(payload: ByteArray) { imageRetryAfterMs = 0 io.lastKeepaliveAtMs = now() io.lastBrightnessAtMs = 0 + ioResetBrightnessLocked() } } else if (state == 0 && fixedLayoutCreated) { // The page closed under us (lease, the wearer's long press): the firmware freed diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt index 1eaafa53..7de25932 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt @@ -196,7 +196,7 @@ internal fun GlassesSessionCore.driveSession(): Long { if (benchmarkActive) { maintainBenchmarkLocked(now) } - if (!benchmarkActive && !isIo) maintainBrightnessLocked(now) + if (!benchmarkActive && (!isIo || ioFirmwareOwnsBrightness)) maintainBrightnessLocked(now) // Up to WINDOW_SIZE messages may be in flight at once (full // pipelining); a slot frees when an ack arrives. An active @@ -1363,6 +1363,7 @@ internal fun GlassesSessionCore.clearAllMessagesLocked(reason: String) { brightnessSentVisible = null brightnessSentLevel = -1 brightnessAlsStartedAt = -2000 + io.alsIntervalSent = -1 clearPendingMessagesLocked(reason) clearInFlightMessagesLocked(reason) // The image pipeline is gone: drop the pipelined delta base so the next @@ -1384,6 +1385,7 @@ internal fun GlassesSessionCore.clearAllMessagesPreservingWakeLeaseLocked(reason brightnessSentVisible = null brightnessSentLevel = -1 brightnessAlsStartedAt = -2000 + io.alsIntervalSent = -1 val pendingIterator = pendingMessages.iterator() while (pendingIterator.hasNext()) { val message = pendingIterator.next() diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt index d0cd42ae..95874185 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/rayneo/RayNeoIoProtocol.kt @@ -362,6 +362,8 @@ object RayNeoIoProtocol { * Set the launcher's brightness (1..8). The stock handler also turns the screen on * (BrightnessMonitor::setBrightness -> turnOnScreenForSetting), which is how the phone * wakes the iO's display and keeps the stock auto-off from blanking a static page. + * Only for firmware without [Ident.brightnessControl]: stock auto-brightness soon + * replaces the level, and each one writes the glasses' preferences. */ @JvmStatic fun launcherBrightness(level: Int): String = @@ -440,6 +442,7 @@ object RayNeoIoProtocol { const val KIND_IDENT = 0x11 const val KIND_PAGE = 0x13 const val KIND_DIAG = 0x15 + const val KIND_ALS = 0x1f /** `[01|03][stream][ordinal u16][lens][size u16][crc u16]`: the G2 ACK body, one per lens. */ @JvmStatic @@ -457,6 +460,10 @@ object RayNeoIoProtocol { /** The assistant's remote audio stream (type 58/59 below) is allowed (CFW revision 10). */ const val IDENT_FLAG_MIC = 0x20 const val IDENT_FLAG_FACECLAW = 0x80 + /** Message 30: the firmware sets the panel level and runs fades, with stock auto-brightness off. */ + const val FEATURE_BRIGHTNESS = "bright30" + /** Message 16: the firmware reads the light sensor and sends [KIND_ALS] reports. */ + const val FEATURE_ALS = "als16" class Ident( @JvmField val width: Int, @@ -467,13 +474,17 @@ object RayNeoIoProtocol { @JvmField val name: String, /** "Faceclaw/" -> n when the firmware runs the Faceclaw display lists, else -1. */ @JvmField val faceclawRevision: Int, + /** What the firmware adds to the display lists (a third string in IDENT). */ + @JvmField val features: List = emptyList(), ) { val acceptsCompressed: Boolean get() = flags and IDENT_FLAG_ZLIB != 0 val micStream: Boolean get() = flags and IDENT_FLAG_MIC != 0 val faceclaw: Boolean get() = flags and IDENT_FLAG_FACECLAW != 0 && faceclawRevision > 0 + /** Faceclaw owns brightness and the light sensor, as on the G2 custom firmware. */ + val brightnessControl: Boolean get() = faceclaw && FEATURE_BRIGHTNESS in features && FEATURE_ALS in features } - /** `[11][ver][w u16][h u16][maxChunk u16][storeKiB u16][rev u16][flags]name\0[lineHeight]["Faceclaw/n"\0]`. */ + /** `[11][ver][w u16][h u16][maxChunk u16][storeKiB u16][rev u16][flags]name\0[lineHeight]["Faceclaw/n"\0["features"\0]]`. */ @JvmStatic fun parseIdent(payload: ByteArray): Ident? { if (payload.size < 13 || payload[0].toInt() != KIND_IDENT) return null @@ -482,14 +493,32 @@ object RayNeoIoProtocol { while (end < payload.size && payload[end].toInt() != 0) end++ val name = payload.copyOfRange(13, end).decodeToString() var faceclaw = -1 + var features = emptyList() val extra = end + 2 // NUL, line height if (extra < payload.size) { var e = extra while (e < payload.size && payload[e].toInt() != 0) e++ val text = payload.copyOfRange(extra, e).decodeToString() if (text.startsWith("Faceclaw/")) faceclaw = text.removePrefix("Faceclaw/").toIntOrNull() ?: -1 + val more = e + 1 + if (more < payload.size) { + var f = more + while (f < payload.size && payload[f].toInt() != 0) f++ + features = payload.copyOfRange(more, f).decodeToString().split(' ').filter { it.isNotEmpty() } + } } - return Ident(u16(2), u16(4), u16(6), u16(10), payload[12].toInt() and 255, name, faceclaw) + return Ident(u16(2), u16(4), u16(6), u16(10), payload[12].toInt() and 255, name, faceclaw, features) + } + + /** + * `[1f]` + the 24-byte `['A','L',1,reason,...]` body the G2 custom firmware sends as settings + * field 105 (value in tenths of a lux), or null. The body goes to the same consumers. + */ + @JvmStatic + fun parseAlsReport(payload: ByteArray): ByteArray? { + if (payload.size < 25 || (payload[0].toInt() and 255) != KIND_ALS) return null + val body = payload.copyOfRange(1, 25) + return if (body[0].toInt() == 65 && body[1].toInt() == 76 && body[2].toInt() == 1) body else null } /** PAGE `[13][state][reason]`: state 1 open. */ diff --git a/tests/brightness-curve.test.cjs b/tests/brightness-curve.test.cjs index 0d4c2aa9..1136e068 100644 --- a/tests/brightness-curve.test.cjs +++ b/tests/brightness-curve.test.cjs @@ -1,6 +1,6 @@ const { test } = require('node:test'); const assert = require('node:assert/strict'); -const { normalizeBrightnessCurve, brightnessCurveError, DEFAULT_BRIGHTNESS_CURVE } = require('../.test-build/app/g2/brightness-curve.js'); +const { normalizeBrightnessCurve, brightnessCurveError, DEFAULT_BRIGHTNESS_CURVE, RAYNEO_IO_BRIGHTNESS_CURVE } = require('../.test-build/app/g2/brightness-curve.js'); test('brightness curve accepts monotone knots and canonicalizes spacing', () => { assert.equal(normalizeBrightnessCurve(' 0:0, 2.5:20,1000:100 '), '0:0,2.5:20,1000:100'); }); @@ -43,6 +43,18 @@ test('the screen fade speed scales the 280 ms on/off fade, or makes it instant', const fadeAt = (speed) => { api.screenFadeSetting.set(speed); return api.getBrightnessPreferences().fadeMs; }; assert.deepEqual(['very-fast', 'fast', 'normal', 'slow', 'disabled'].map(fadeAt), [56, 140, 280, 560, 0]); }); +test('an unset curve follows the paired glasses; a chosen one stays', () => { + const store = new Map(); + const api = settingsFixture(store); + assert.equal(api.getBrightnessPreferences().curve, DEFAULT_BRIGHTNESS_CURVE); + store.set('deviceType', 'rayneo-io'); + assert.equal(api.getBrightnessPreferences().curve, RAYNEO_IO_BRIGHTNESS_CURVE); + assert.equal(brightnessCurveError(RAYNEO_IO_BRIGHTNESS_CURVE), null); + api.autoBrightnessCurveSetting.set('0:0,2:50,8:100'); + assert.equal(api.getBrightnessPreferences().curve, '0:0,2:50,8:100'); + store.set('deviceType', 'g2'); + assert.equal(api.getBrightnessPreferences().curve, '0:0,2:50,8:100'); +}); test('curve drafts preview exactly while brightness keeps the previous valid saved curve', () => { const store = new Map([['display.autoBrightnessCurve', '0:0,2:50,8:100']]); let api = settingsFixture(store), curve = api.autoBrightnessCurveSetting; diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt index b92b6709..c86d14dd 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoProtocolTest.kt @@ -112,6 +112,21 @@ class RayNeoIoProtocolTest { val fc = RayNeoIoProtocol.parseIdent(hex("110d1c02dc00f00000010d00ff474c4153534c594346572d494f2f3133001946616365636c61772f333800"))!! assertTrue(fc.faceclaw) assertEquals(38, fc.faceclawRevision) + assertFalse(fc.brightnessControl) + val bright = RayNeoIoProtocol.parseIdent(hex("110d1c02dc00f00000010d00ff474c4153534c594346572d494f2f3133001946616365636c61772f33380062726967687433302061" + "6c73313600"))!! + assertEquals(listOf("bright30", "als16"), bright.features) + assertEquals(38, bright.faceclawRevision) + assertTrue(bright.brightnessControl) + // a Glassly build with no display lists has no brightness control, whatever else it says + assertFalse(RayNeoIoProtocol.Ident(540, 220, 240, 13, 0x7f, "x", -1, listOf("bright30", "als16")).brightnessControl) + + val als = ByteArray(25) + als[0] = 0x1f; als[1] = 65; als[2] = 76; als[3] = 1 + assertEquals(24, RayNeoIoProtocol.parseAlsReport(als)!!.size) + assertEquals(65, RayNeoIoProtocol.parseAlsReport(als)!![0].toInt()) + assertNull(RayNeoIoProtocol.parseAlsReport(als.copyOf(24))) + assertNull(RayNeoIoProtocol.parseAlsReport(als.copyOf().also { it[3] = 2 })) + assertNull(RayNeoIoProtocol.parseAlsReport(als.copyOf().also { it[0] = 0x15 })) assertEquals(1, RayNeoIoProtocol.parsePageState(hex("130100"))) val g = RayNeoIoProtocol.parseGesture(hex("0703010a000000"))!! diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt index 9e140ac3..5d61596a 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RayNeoIoSessionTest.kt @@ -38,6 +38,8 @@ private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { /** The phone id the glasses accept; null = pairing mode (they bind to the next one). */ @Volatile var boundTo: ByteArray? = null @Volatile var faceclaw = true + /** Firmware with message 30 and the light sensor (IDENT's features string). */ + @Volatile var brightnessFirmware = false @Volatile var pageOpen = false @Volatile var hangUps = 0 private val controlsList = ArrayList() @@ -169,7 +171,9 @@ private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { } ?: return val message = lock.withLock { inflateRecords(records).last() } val crc = (complete[3].toInt() and 255) or ((complete[4].toInt() and 255) shl 8) - val ok = pageOpen && CfwTransport.crc(message) == crc && ioSupportsCfwType(message[0].toInt() and 255) + val type = message[0].toInt() and 255 + val ok = pageOpen && CfwTransport.crc(message) == crc && + (ioSupportsCfwType(type) || (brightnessFirmware && (type == CFW_MSG_BRIGHTNESS || type == CFW_MSG_AMBIENT_LIGHT))) if (ok) lock.withLock { messagesList.add(message) } for (lens in 1..2) { notify(0xf0, byteArrayOf(if (ok) 1 else 3, stream.toByte(), 0, 0, lens.toByte(), @@ -180,7 +184,22 @@ private class FakeIoGlasses(platform: ProtocolPlatform) : SessionLink { private fun ident(): ByteArray { val name = "GLASSLYCFW-IO/13".encodeToByteArray() return byteArrayOf(0x11, 13, 0x1c, 0x02, 0xdc.toByte(), 0x00, 0xf0.toByte(), 0x00, 0x00, 0x01, 0x0d, 0x00, 0xff.toByte()) + - name + byteArrayOf(0, 25) + "Faceclaw/38".encodeToByteArray() + byteArrayOf(0) + name + byteArrayOf(0, 25) + "Faceclaw/38".encodeToByteArray() + byteArrayOf(0) + + (if (brightnessFirmware) "bright30 als16".encodeToByteArray() + byteArrayOf(0) else ByteArray(0)) + } + + /** RPL_ALS as the firmware sends it: a poll of [tenths] of a lux from a healthy sensor. */ + fun alsPoll(tenths: Int) { + val report = ByteArray(25) + report[0] = 0x1f + report[1] = 65 + report[2] = 76 + report[3] = 1 + report[4] = 2 // poll + report[5] = 0x0b // opened, passive, read ok + report[6] = 3 + for (i in 0..3) report[7 + i] = (tenths ushr (8 * i)).toByte() + notify(0xf0, report) } override fun disconnect(address: String) {} @@ -222,6 +241,8 @@ private class IoListener : FaceclawBleCommunicatorListener { override fun onPhoneLockState(locked: Boolean) {} + override fun onCaseState(caseBattery: Int, caseCharging: Int, caseDocked: Boolean) {} + override fun onEvenAppConflict(message: String?) {} override fun onFrameMetrics(paintMs: Int, transmitMs: Int, tileCount: Int) {} @@ -335,6 +356,74 @@ class RayNeoIoSessionTest { assertEquals(RayNeoIoProtocol.CTRL_PAGE_CLOSE, s.glasses.controls.last()) } + @Test + fun firmwareWithBrightnessControlGetsTheG2Messages() { + val s = IoSession() + s.glasses.brightnessFirmware = true + s.core.configureBrightness(false, 70, 2, 100, "0:0,1000:100", 280) + s.core.configureCompositorScreen(540, 220) + s.core.configureSurface("s", 0, 0, 64, 32, 0, SurfaceCompositor.TRANSPARENCY_OPAQUE) + val reportLock = s.platform.createLock() + val reports = ArrayList() + s.core.addAmbientLightListener(object : FaceclawAmbientLightListener { + override fun onAmbientLight(body: ByteArray?) { reportLock.withLock { reports.add(body!!) } } + }) + fun ofType(type: Int) = s.glasses.messages.filter { (it[0].toInt() and 255) == type } + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.pageUp() }, "page never opened:\n" + s.tail()) + s.submitFrame(0x7f, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, "frame never displayed:\n" + s.tail()) + + // visible at 70%, fading over the configured 280 ms, ahead of the frame it fades in + val wake = byteArrayOf(30, 1, 70, 1, 0x18, 0x01) + assertTrue(awaitTrue(3_000) { ofType(CFW_MSG_BRIGHTNESS).isNotEmpty() }, s.tail()) + assertTrue(ofType(CFW_MSG_BRIGHTNESS).first().contentEquals(wake)) + val order = s.glasses.messages.map { it[0].toInt() and 255 } + assertTrue(order.indexOf(CFW_MSG_BRIGHTNESS) < order.indexOf(CFW_MSG_PRESENT), order.toString()) + // the launcher's command writes preferences and loses to stock auto: not used + assertTrue(s.glasses.launcher.none { "brightness_change" in it }, s.glasses.launcher.toString()) + + // the light sensor, at the manual rate; the iO needs telling only once + assertTrue(awaitTrue(3_000) { ofType(CFW_MSG_AMBIENT_LIGHT).isNotEmpty() }, s.tail()) + val poll = ofType(CFW_MSG_AMBIENT_LIGHT).first() + assertEquals(listOf(16, 1), poll.take(2).map { it.toInt() }) + assertEquals(5000, (poll[3].toInt() and 255) or ((poll[4].toInt() and 255) shl 8)) + + // each 5 s the same command, as the screen keepalive + val sent = ofType(CFW_MSG_BRIGHTNESS).size + s.platform.offsetMs += IoTimings.SCREEN_REFRESH_MS + 1 + assertTrue(awaitTrue(3_000) { ofType(CFW_MSG_BRIGHTNESS).size > sent }, s.tail()) + assertTrue(ofType(CFW_MSG_BRIGHTNESS).last().let { it[2].toInt() == 70 && it[3].toInt() == 1 }) + assertEquals(1, ofType(CFW_MSG_AMBIENT_LIGHT).size) + + // Auto: reports reach the policy and listeners, the sample rate follows, a target goes out + s.core.configureBrightness(true, 70, 20, 100, "0:0,100:100", 280) + assertTrue(awaitTrue(3_000) { ofType(CFW_MSG_AMBIENT_LIGHT).size == 2 }, s.tail()) + assertEquals(500, ofType(CFW_MSG_AMBIENT_LIGHT).last().let { (it[3].toInt() and 255) or ((it[4].toInt() and 255) shl 8) }) + s.glasses.alsPoll(1000) // 100 lux, the curve's top + assertTrue(awaitTrue(3_000) { ofType(CFW_MSG_BRIGHTNESS).last()[2].toInt() == 100 }, s.tail()) + assertTrue(awaitTrue(1_000) { reportLock.withLock { reports.isNotEmpty() } }) + assertEquals(65, reportLock.withLock { reports.first()[0].toInt() }) + + // A request dropped with the queue before it was written goes out again + s.core.monitor.withLock { s.core.clearAllMessagesLocked("test") } + val queued = ofType(CFW_MSG_AMBIENT_LIGHT).size + s.glasses.alsPoll(1000) + assertTrue(awaitTrue(3_000) { ofType(CFW_MSG_AMBIENT_LIGHT).size > queued }, s.tail()) + + // A reopened page starts over: the firmware gave brightness back when it closed + val before = ofType(CFW_MSG_AMBIENT_LIGHT).size + s.glasses.pageOpen = false + s.glasses.page(0, 3) + assertTrue(awaitTrue(5_000) { s.glasses.pageOpen && s.pageUp() }, s.tail()) + s.submitFrame(0x30, 2) + assertTrue(awaitTrue(5_000) { ofType(CFW_MSG_AMBIENT_LIGHT).size > before }, s.tail()) + } finally { + s.core.close() + } + } + @Test fun refusalAsksForPairingModeAndConnectsOnceItIsOn() { val s = IoSession() From 67aff1992384a702e561240e5654463cf5afb6f3 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Fri, 6 Nov 2026 00:12:23 -0800 Subject: [PATCH 07/34] Faceclaw support for G1s Relies on the glasses having the firmware from https://github.com/jimrandomh/scouter_kit, based on Mafik's Scouter Kit. --- .../com/faceclaw/app/AndroidSessionLink.kt | 2 + .../faceclaw/app/FaceclawBleCommunicator.kt | 3 + .../com/faceclaw/app/FaceclawBleManager.kt | 15 + .../faceclaw/app/FaceclawDeviceDiscovery.kt | 4 +- app/g2/even-advertisement.ts | 65 ++ app/g2/pairing-candidates.ts | 54 +- app/native/faceclaw-communicator.ios.ts | 1 + app/native/faceclaw-communicator.ts | 2 + app/phone-ui/pairing-view-model.ts | 15 +- app/ui/dashboard-settings.ts | 8 +- app/ui/dashboard/settings-menus.ts | 4 +- .../com/faceclaw/app/g1/G1FramePlanner.kt | 57 ++ .../kotlin/com/faceclaw/app/g1/G1Protocol.kt | 148 ++++ .../app/g2protocol/CfwMessageWindow.kt | 4 +- .../app/g2protocol/OutboundMessage.kt | 6 +- .../session/GlassesSessionBrightness.kt | 13 +- .../g2protocol/session/GlassesSessionCore.kt | 39 +- .../g2protocol/session/GlassesSessionG1.kt | 553 +++++++++++++ .../g2protocol/session/GlassesSessionIo.kt | 6 +- .../g2protocol/session/GlassesSessionRing.kt | 10 +- .../g2protocol/session/GlassesSessionSend.kt | 45 +- .../app/g2protocol/session/SessionPorts.kt | 3 + .../com/faceclaw/app/graphics/ShellScene.kt | 15 + .../com/faceclaw/app/ble/IosGlassesSession.kt | 3 + tests/even-advertisement.test.cjs | 40 + .../kotlin/com/faceclaw/app/G1SessionTest.kt | 777 ++++++++++++++++++ tests/pairing-candidates.test.cjs | 55 ++ 27 files changed, 1902 insertions(+), 45 deletions(-) create mode 100644 native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1FramePlanner.kt create mode 100644 native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt create mode 100644 native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt create mode 100644 tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt index 2921e222..d303880b 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt @@ -46,6 +46,8 @@ class AndroidSessionLink(private val bleManager: FaceclawBleManager) : SessionLi override fun isBonded(address: String): Boolean = bleManager.isBonded(address) + override fun requestBond(address: String) = bleManager.requestBond(address) + override fun prepareBenchmarkLink(address: String, mode: Int) = bleManager.prepareBenchmarkLink(address, mode) override fun recordDisplayFrameSent() = FaceclawBleManager.recordDisplayFrameSent() diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt index eb75263a..9f0e47e5 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt @@ -208,6 +208,9 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun isRayNeoIo(): Boolean = core.isRayNeoIo() + /** Drive an Even G1 on g1v0 (two arms, as a G2 pair's addresses). */ + fun useG1() = core.useG1() + fun start() { if (core.start()) { activeInstance = this diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt index fd303744..46c47993 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt @@ -160,6 +160,21 @@ class FaceclawBleManager(context: Context) { } } + /** Start bonding, without waiting: the OS may ask the user, and [isBonded] tells when it is done. */ + fun requestBond(address: String?) { + if (address == null || address.trim().isEmpty()) { + return + } + try { + val device = bluetoothAdapter.getRemoteDevice(address) + if (device.bondState == BluetoothDevice.BOND_NONE) { + Log.i(TAG, "requestBond " + address + ": " + device.createBond()) + } + } catch (t: Throwable) { + Log.w(TAG, "requestBond failed: " + address, t) + } + } + /** * Android's bond state for this address (BluetoothDevice.BOND_NONE / * BOND_BONDING / BOND_BONDED), or -1 when it cannot be determined. diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt index 5cc8f369..5440806d 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt @@ -141,7 +141,9 @@ class FaceclawDeviceDiscovery(context: Context) { val upper = name.uppercase() // 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") || upper.startsWith("RAYNEO") + // Even G1: its stock name, or g1v0's G1v0_L / G1v0S_R (safe mode). + return upper.contains("G2") || upper.startsWith("EVEN R1") || upper.startsWith("RAYNEO") || + upper.startsWith("EVEN G1") || upper.startsWith("G1V0") } private fun buildJson( diff --git a/app/g2/even-advertisement.ts b/app/g2/even-advertisement.ts index d974c87e..d20912fb 100644 --- a/app/g2/even-advertisement.ts +++ b/app/g2/even-advertisement.ts @@ -32,6 +32,9 @@ export const EVEN_COMPANY_IDENTIFIER = 0x5245; export type EvenDeviceRole = "left" | "right" | "ring" | "rayneo-io"; +/** The firmware an Even G1 arm's name shows: Even's, or g1v0 (in safe mode: only updates work). */ +export type G1Firmware = "stock" | "g1v0" | "g1v0-safe"; + /** 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; @@ -71,6 +74,42 @@ export function extractG2AdvertisementFlag(mfg: Uint8Array): number | null { return mfg[22]!; } +/** + * ## Even G1 arm + * + * On Even's firmware the name is `Even G1___` and the manufacturer data `[01 right | 02 left]` + + * the ASCII serial, zero-padded (the first two bytes read as a "company id" that differs per arm). On g1v0 the name + * is `G1v0_L` or `G1v0_R` (`G1v0S_…` in safe mode) and the scan response holds company 0xFFFF, a format byte (1), a + * flags byte, and the pair ID in ASCII: the frame serial, the same on both arms. + */ +export function g1FromName(name: string | null | undefined): { side: "left" | "right"; firmware: G1Firmware } | null { + if (!name) return null; + const g1v0 = /^G1V0(S?)_([LR])$/i.exec(name.trim()); + if (g1v0) { + return { + side: g1v0[2]!.toUpperCase() === "L" ? "left" : "right", + firmware: g1v0[1] ? "g1v0-safe" : "g1v0", + }; + } + if (!/^EVEN G1_/i.test(name.trim())) return null; + const side = g2SideFromName(name); + return side ? { side, firmware: "stock" } : null; +} + +/** The pair's serial from an arm's manufacturer data, on either firmware; null when absent. */ +export function extractG1Serial(mfg: Uint8Array, firmware: G1Firmware): string | null { + const start = firmware === "stock" ? 1 : mfg.length >= 4 && mfg[0] === 0xff && mfg[1] === 0xff && mfg[2] === 1 ? 4 : -1; + if (start < 0 || mfg.length <= start) return null; + let serial = ""; + for (let i = start; i < mfg.length; i++) { + const byte = mfg[i]!; + if (byte === 0) break; + if (byte < 0x20 || byte > 0x7e) return null; + serial += String.fromCharCode(byte); + } + return serial.length ? serial : null; +} + /** RayNeo iO manufacturer data (company 0x5716, little-endian first): `[07][MAC x6]...`, outside pairing mode. */ export const RAYNEO_COMPANY_IDENTIFIER = 0x5716; @@ -218,6 +257,8 @@ export type EvenAdvertisement = { manufacturerData: string; /** Why an otherwise Even-looking advertisement could not be fully parsed. */ note: string | null; + /** Set on an Even G1 arm (role left or right): its firmware. */ + g1Firmware?: G1Firmware; }; /** @@ -241,6 +282,30 @@ export function classifyAdvertisement(raw: RawAdvertisement): EvenAdvertisement const rayneoMac = extractRayNeoMac(mfg); const looksLikeRayNeo = upper.startsWith("RAYNEO") || rayneoMac !== null; + const g1 = g1FromName(name); + if (g1) { + const serial = extractG1Serial(mfg, g1.firmware); + return { + address: normalizeMacAddress(raw.address), + name, + role: g1.side, + serial, + embeddedMac: null, + embeddedMacMismatch: false, + flag: null, + ringSerialSuffix: null, + rssi: raw.rssi, + txPower: raw.txPower, + connectable: raw.connectable, + bonded: raw.bonded, + source: raw.source, + seenAtMs: raw.seenAtMs, + manufacturerData: raw.manufacturerData ?? "", + note: serial ? null : "no serial in the advertisement (it may still be arriving)", + g1Firmware: g1.firmware, + }; + } + if (!looksLikeRing && !looksLikeG2 && !hasSignature && !looksLikeRayNeo) return null; if (looksLikeRayNeo && !hasSignature) { diff --git a/app/g2/pairing-candidates.ts b/app/g2/pairing-candidates.ts index 05076a5b..e8c3256c 100644 --- a/app/g2/pairing-candidates.ts +++ b/app/g2/pairing-candidates.ts @@ -20,7 +20,7 @@ import { type ProximityEstimate, type ProximityZone, } from "./ble-proximity"; -import { classifyAdvertisement, normalizeMacAddress, type EvenAdvertisement, type RawAdvertisement } from "./even-advertisement"; +import { classifyAdvertisement, normalizeMacAddress, type EvenAdvertisement, type G1Firmware, type RawAdvertisement } from "./even-advertisement"; import { GENERIC_G2_IMAGE_PATH, glassesImagePath, R1_IMAGE_PATH } from "./glasses-artwork"; import { colorwayDisplayName, @@ -48,6 +48,8 @@ export type GlassesPairCandidate = { rssi: number | null; proximity: ProximityEstimate | null; lastSeenMs: number; + /** An Even G1 pair: the arms' firmware, the "lower" of the two (stock, then safe mode). Absent on a G2. */ + g1Firmware?: G1Firmware; /** * 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. @@ -187,7 +189,8 @@ export class DiscoveryAggregator { for (const record of this.byAddress.values()) { if (record.role === "ring" || record.role === "rayneo-io") continue; const canonical = serialKey(record.serial); - const key = canonical ? `serial:${canonical}` : `arm:${record.address}`; + const family = record.g1Firmware ? "g1:" : ""; + const key = canonical ? `${family}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]; @@ -208,7 +211,9 @@ export class DiscoveryAggregator { pairs.push({ id: serialKey(serial) ?? `arm:${any.address}`, serial, - identity: GlassesHardwareIdentity.decode(serial), + // Even's G2 serial scheme; a G1's says nothing to it. + identity: any.g1Firmware ? null : GlassesHardwareIdentity.decode(serial), + ...(any.g1Firmware ? { g1Firmware: g1PairFirmware(left, right) } : {}), left: left ? stripSmoothing(left) : null, right: right ? stripSmoothing(right) : null, completeness: left && right ? "complete" : left ? "left-only" : "right-only", @@ -367,7 +372,50 @@ function embeddedMacMismatchWarning(subject: string, ad: EvenAdvertisement | nul return `${subject} advertised address ${ad.embeddedMac} differs from its radio address ${ad.address}.`; } +/** The pair can only do what its less capable arm can. */ +function g1PairFirmware(left: EvenAdvertisement | null, right: EvenAdvertisement | null): G1Firmware { + const firmwares = [left?.g1Firmware, right?.g1Firmware]; + if (firmwares.includes("stock")) return "stock"; + return firmwares.includes("g1v0-safe") ? "g1v0-safe" : "g1v0"; +} + +export function g1Row(pair: GlassesPairCandidate, context: RowContext = {}): PairingRowPresentation { + const isPreviouslyPairedRow = isPreviouslyPaired(pair.serial, context.pairedSerial); + const isNearest = !!context.nearestId && context.nearestId === pair.id; + const warnings: string[] = []; + if (pair.mismatchWarning) warnings.push(pair.mismatchWarning); + let armsSummary: string; + let canSelect = false; + if (pair.g1Firmware === "stock") { + armsSummary = "Needs the Faceclaw firmware for the G1, which is installed from a computer"; + } else if (pair.g1Firmware === "g1v0-safe") { + armsSummary = "In safe mode: the firmware restarted repeatedly. Reinstall it from a computer"; + } else if (pair.completeness !== "complete") { + armsSummary = pair.completeness === "left-only" + ? "Only the left arm has been seen — waiting for the right" + : "Only the right arm has been seen — waiting for the left"; + } else { + armsSummary = "Left + right arms found. To pair, keep them in the case with the lid open"; + canSelect = true; + } + return { + id: pair.id, + kind: "glasses", + modelTitle: "Even Realities G1", + deviceName: pair.serial ?? (pair.left ?? pair.right)!.name, + variantSummary: null, + colorway: null, + swatchHex: null, + imagePath: GENERIC_G2_IMAGE_PATH, + hasVariantImage: false, + ...presentationBase(pair.proximity, isNearest, isPreviouslyPairedRow, warnings), + armsSummary, + canSelect, + }; +} + export function glassesRow(pair: GlassesPairCandidate, context: RowContext = {}): PairingRowPresentation { + if (pair.g1Firmware) return g1Row(pair, context); const identity = pair.identity; const imagePath = glassesImagePath(identity); const isPreviouslyPairedRow = isPreviouslyPaired(pair.serial, context.pairedSerial); diff --git a/app/native/faceclaw-communicator.ios.ts b/app/native/faceclaw-communicator.ios.ts index f1c28161..971e2c7a 100644 --- a/app/native/faceclaw-communicator.ios.ts +++ b/app/native/faceclaw-communicator.ios.ts @@ -260,6 +260,7 @@ export class FaceclawCommunicatorBridge { ); // The shared session halts on any other firmware ("incompatible-firmware"). this.communicator.setRequiredFirmwareRevisionRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION); + if (addresses.glassesType === "g1") this.communicator.useG1(); // Guarded: an older framework build may not export it yet. if (addresses.ringRole && typeof this.communicator.setDirectRingRoleRole === "function") { this.communicator.setDirectRingRoleRole(addresses.ringRole); diff --git a/app/native/faceclaw-communicator.ts b/app/native/faceclaw-communicator.ts index deb22b2e..51dd92ee 100644 --- a/app/native/faceclaw-communicator.ts +++ b/app/native/faceclaw-communicator.ts @@ -184,6 +184,8 @@ export class FaceclawCommunicatorBridge { this.communicator.setRequiredFirmwareRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION); // RayNeo iO: one link (its address in both arm slots), its own handshake and page lease. if (addresses.glassesType === "rayneo-io") this.communicator.useRayNeoIo(); + // Even G1 on g1v0: two links, like a G2's arms, but frames composed here and sent to each arm. + if (addresses.glassesType === "g1") this.communicator.useG1(); // Which R1 role the direct ring link claims; only matters with a ring address. if (addresses.ringRole) this.communicator.setDirectRingRole(addresses.ringRole); this.listenerProxy = new com.faceclaw.app.FaceclawBleCommunicatorListener({ diff --git a/app/phone-ui/pairing-view-model.ts b/app/phone-ui/pairing-view-model.ts index ba7d17e3..82309f18 100644 --- a/app/phone-ui/pairing-view-model.ts +++ b/app/phone-ui/pairing-view-model.ts @@ -186,9 +186,9 @@ export class PairingViewModel extends Observable { get instructions(): string { return ( - "Select your G2 glasses or RayNeo iO, and your R1 ring if you have one, below. Wear the glasses or take them out of the case, " + - "and keep the glasses and phone nearby. If your glasses are not detected, make sure no other " + - "apps are connected." + "Select your G2 or G1 glasses or RayNeo iO, and your R1 ring if you have one, below. Wear the glasses or take them out of the case " + + "(a G1 pairs only in its case, with the lid open), and keep the glasses and phone nearby. If your glasses are not detected, " + + "make sure no other apps are connected." ); } @@ -358,7 +358,8 @@ export class PairingViewModel extends Observable { ring: ringAddress, }; saveDeviceAddresses(addresses); - if (pair) glassesTypeSetting.set("g2"); + const g1 = !!pair?.g1Firmware; + if (pair) glassesTypeSetting.set(g1 ? "g1" : "g2"); if (pair) { savePairedGlassesIdentity({ serial: pair.serial ?? "", @@ -385,6 +386,12 @@ export class PairingViewModel extends Observable { this.dispose(); if (this.onboarding) { setPreviewOnlyMode(false); + if (g1) { + // The G2 firmware check and flash pages don't apply: a G1's firmware is installed from a + // computer, and the session reports incompatible firmware if it lacks the display path. + finishOnboardingNavigation(); + return; + } // Continue the onboarding chain: check the glasses' firmware next. Frame.topmost()?.navigate({ moduleName: "phone-ui/onboarding-firmware-check-page" }); return; diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 5a758d0b..ac40fdf4 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -385,14 +385,14 @@ export const distanceUnitSetting = new ConfigSettingEnum({ export type AppSwitcherPosition = "left" | "right" | "bottom" | "popup"; /** Which glasses the saved addresses belong to (set by pairing; see g2/device-addresses.ts). */ -export type GlassesType = "g2" | "rayneo-io"; +export type GlassesType = "g2" | "rayneo-io" | "g1"; export const glassesTypeSetting = new ConfigSettingEnum({ id: "glasses-type", label: "Glasses", storageKey: "deviceType", // graphics/screen-size.ts GLASSES_TYPE_KEY reads it directly defaultValue: "g2", - values: ["g2", "rayneo-io"], + values: ["g2", "rayneo-io", "g1"], reportInAnalytics: false, }); @@ -909,11 +909,11 @@ export const ringConnectionModeSetting = new ConfigSettingEnum glassesTypeSetting.get() === "rayneo-io"; + const io = () => glassesTypeSetting.get() !== "g2"; return { ...item, disabled: io, render: (args) => { if (!io()) return item.render?.(args); - drawRightValueMenuItem(args.image, getDefaultSmallFont(), args.x, args.y, args.width, item.label, "Direct (RayNeo iO)"); + drawRightValueMenuItem(args.image, getDefaultSmallFont(), args.x, args.y, args.width, item.label, glassesTypeSetting.get() === "g1" ? "Direct (Even G1)" : "Direct (RayNeo iO)"); }, }; } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1FramePlanner.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1FramePlanner.kt new file mode 100644 index 00000000..d1ff0abc --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1FramePlanner.kt @@ -0,0 +1,57 @@ +package com.faceclaw.app + +/** + * One lens's update on an Even G1: the rectangles that differ from what the arm's frame holds, as RLE bbox calls + * in draw messages. The transport's deflate runs over these messages, as on the G2; there is no resource cache, + * so everything visible arrives as pixels. + */ +object G1FramePlanner { + /** The firmware's limit on a decoded message is 16384 bytes (scouter_kit fc.c MAX_MESSAGE). */ + const val MAX_MESSAGE = 16000 + + /** A big rectangle goes out in bands, so that one noisy area doesn't need a long binary split. */ + private const val BAND_ROWS = 32 + private const val MAX_RECTS = ConnectionOptions.MULTI_RECT_MAX_RECTS + + /** [previous] null or of another size: a full frame. Empty when nothing changed. */ + fun plan(previous: ByteArray?, next: ByteArray, width: Int, height: Int): List { + val stride = (width + 1) / 2 + require(next.size == stride * height) + val rects = changedRects(previous, next, width, height) + if (rects.isEmpty()) return emptyList() + val calls = ArrayList() + for (r in rects) { + var top = r[1] + val bottom = r[1] + r[3] + while (top < bottom) { + val rows = minOf(BAND_ROWS, bottom - top) + addRect(calls, next, stride, r[0], top, r[2], rows) + top += rows + } + } + return DrawProtocol.messages(calls, MAX_MESSAGE) + } + + private fun changedRects(previous: ByteArray?, next: ByteArray, width: Int, height: Int): List { + if (previous == null || previous.size != next.size) return listOf(intArrayOf(0, 0, width, height)) + BleImageOptimizer.computeChangedRects(previous, next, width, height, MAX_RECTS)?.let { return it } + return listOfNotNull(BleImageOptimizer.computeChangedBox(previous, next, width, height)) + } + + /** Splits until the call fits a message; a single pixel always does. */ + private fun addRect(calls: MutableList, packed: ByteArray, stride: Int, x: Int, y: Int, w: Int, h: Int) { + val call = DrawProtocol.bbox(packed, stride, x, y, w, h) + if (call.size + MESSAGE_OVERHEAD <= MAX_MESSAGE) { + calls.add(call) + } else if (h > 1) { + addRect(calls, packed, stride, x, y, w, h / 2) + addRect(calls, packed, stride, x, y + h / 2, w, h - h / 2) + } else { + addRect(calls, packed, stride, x, y, w / 2, h) + addRect(calls, packed, stride, x + w / 2, y, w - w / 2, h) + } + } + + /** The message type, the call count and the call's length (DrawProtocol.sequence). */ + private const val MESSAGE_OVERHEAD = 5 +} diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt new file mode 100644 index 00000000..1df1a24a --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt @@ -0,0 +1,148 @@ +package com.faceclaw.app + +import kotlin.jvm.JvmField + +/** The GATT service of g1v0, the firmware of an Even G1 (scouter_kit g1_firmware/docs/VM.md §6.1). */ +object G1Ble { + const val CTRL_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4402" + const val EVT_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4403" + /** Readable and writable only on an encrypted link: a write with response makes the OS pair, then proves the link is encrypted. */ + const val PAIR_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4404" + /** Faceclaw's records (VM.md §6.11). */ + const val FC_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4405" + const val REQUESTED_MTU = 247 +} + +/** + * The wire formats of an Even G1 on g1v0: control requests and events (VM.md §6.3, §6.4), which Faceclaw uses as they + * are, and the display path's packets and answers (§6.11). No VM instruction is sent; the records inside the packets + * are [CfwTransport]'s, the same as on the G2. + */ +object G1Protocol { + const val OP_HELLO = 0x01 + const val OP_HEALTH_OK = 0x07 + const val OP_PROPS = 0x0A + const val OP_EVENTS = 0x14 + const val OP_FC_INFO = 0x1D + + const val EV_INPUT = 0x07 + const val EV_FC_ACK = 0x08 + private const val EV_REPLY = 0x80 + private const val EVENT_HEADER = 9 + private const val OPT_START = 0x80 + private const val OPT_END = 0x40 + private const val MAX_PACKET = 244 + private const val PACKET_HEADER = 2 + + const val TRIGGER_BATTERY = 5 + const val TRIGGER_CASE = 6 + const val TRIGGER_WEAR = 7 + const val TRIGGER_TOUCH = 8 + const val EVENTS_MASK = (1 shl TRIGGER_BATTERY) or (1 shl TRIGGER_CASE) or (1 shl TRIGGER_WEAR) or (1 shl TRIGGER_TOUCH) + + const val PROP_BATT_PCT = 0x11 + const val PROP_CHARGE = 0x12 + const val PROP_IN_CASE = 0x13 + const val PROP_WORN = 0x14 + /** A property without a value yet (VM_UNKNOWN). */ + const val UNKNOWN = Int.MIN_VALUE + + const val CHARGE_CHARGING = 1 + + const val GESTURE_TAP = 1 + const val GESTURE_DOUBLE_TAP = 2 + const val GESTURE_TRIPLE_TAP = 3 + const val GESTURE_LONG_START = 4 + const val GESTURE_LONG_END = 5 + + /** The packets of one record: `[0x80 first | 0x40 last][stream][the next bytes]`. */ + fun packets(record: ByteArray, stream: Int, mtu: Int): List { + val chunk = minOf(mtu - 3, MAX_PACKET) - PACKET_HEADER + require(record.isNotEmpty() && chunk >= 5 && stream in 0..255) + val packets = ArrayList(record.size / chunk + 1) + var offset = 0 + while (offset < record.size) { + val count = minOf(chunk, record.size - offset) + val packet = ByteArray(PACKET_HEADER + count) + packet[0] = ((if (offset == 0) OPT_START else 0) or (if (offset + count == record.size) OPT_END else 0)).toByte() + packet[1] = stream.toByte() + record.copyInto(packet, PACKET_HEADER, offset, offset + count) + packets.add(packet) + offset += count + } + return packets + } + + fun control(op: Int, tag: Int, body: ByteArray = ByteArray(0)): ByteArray = + byteArrayOf(op.toByte(), tag.toByte()) + body + + fun eventsRequest(mask: Int): ByteArray = byteArrayOf(mask.toByte(), (mask ushr 8).toByte()) + + /** An event's type, or -1 for bytes too short to be one. */ + fun eventType(data: ByteArray): Int = if (data.size >= EVENT_HEADER) data[0].toInt() and 255 else -1 + + class Reply(@JvmField val op: Int, @JvmField val tag: Int, @JvmField val status: Int, @JvmField val body: ByteArray) + + fun parseReply(data: ByteArray): Reply? { + val type = eventType(data) + if (type < EV_REPLY || data.size < EVENT_HEADER + 2) return null + return Reply(type and 0x7f, data[EVENT_HEADER].toInt() and 255, data[EVENT_HEADER + 1].toInt() and 255, + data.copyOfRange(EVENT_HEADER + 2, data.size)) + } + + /** Same shape as [CfwTransport.parseAcks]'s, so the shared window takes it. */ + fun parseFcAck(data: ByteArray): CfwTransport.Ack? { + if (eventType(data) != EV_FC_ACK || data.size < EVENT_HEADER + 9) return null + val kind = data[EVENT_HEADER].toInt() and 255 + if (kind != 1 && kind != 3) return null + return CfwTransport.Ack(kind == 3, data[EVENT_HEADER + 1].toInt() and 255, u16(data, EVENT_HEADER + 2), + data[EVENT_HEADER + 4].toInt() and 255, u16(data, EVENT_HEADER + 5), u16(data, EVENT_HEADER + 7)) + } + + class Input(@JvmField val trigger: Int, @JvmField val value: Int) + + fun parseInput(data: ByteArray): Input? { + if (eventType(data) != EV_INPUT || data.size < EVENT_HEADER + 7) return null + return Input(data[EVENT_HEADER + 2].toInt() and 255, u32(data, EVENT_HEADER + 3)) + } + + class Hello( + @JvmField val version: String, + @JvmField val leftArm: Boolean, + @JvmField val safeMode: Boolean, + @JvmField val panelOk: Boolean, + @JvmField val encrypted: Boolean, + @JvmField val inCase: Boolean, + ) + + fun parseHello(body: ByteArray): Hello? { + if (body.size < 7 || body[0].toInt() != 5) return null + val flags = body[5].toInt() and 255 + return Hello("${body[1].toInt() and 255}.${body[2].toInt() and 255}.${body[3].toInt() and 255}", + body[4].toInt() == 1, flags and 1 != 0, flags and 2 != 0, flags and 64 != 0, flags and 128 != 0) + } + + /** The display path's version, or -1 for a body that isn't FC_INFO's. */ + fun parseFcVersion(body: ByteArray): Int = if (body.size >= 14) body[0].toInt() and 255 else -1 + + /** One value per requested property, or null if the reply is short. */ + fun parseProps(body: ByteArray, count: Int): IntArray? = + if (body.size < 4 * count) null else IntArray(count) { u32(body, 4 * it) } + + /** + * What a TouchBar gesture means to Faceclaw, which expects a G2's temple: a tap, a double tap and two slides. A + * G1's TouchBar cannot slide, but it has one per arm, so a tap moves (left up, right down), a double tap selects + * and a triple tap or long press goes back. Null: no event. With the display [dark] nothing can scroll: a tap is + * the G2's tap, which shows the Glanceboard, and the session reports a double tap as a wake. + */ + fun gestureEventType(gesture: Int, leftArm: Boolean, dark: Boolean = false): Int? = when (gesture) { + GESTURE_TAP -> if (dark) BleProtocol.EVENT_CLICK else if (leftArm) BleProtocol.EVENT_SCROLL_TOP else BleProtocol.EVENT_SCROLL_BOTTOM + GESTURE_DOUBLE_TAP -> if (dark) BleProtocol.EVENT_DOUBLE_CLICK else BleProtocol.EVENT_CLICK + GESTURE_TRIPLE_TAP, GESTURE_LONG_START -> BleProtocol.EVENT_DOUBLE_CLICK + else -> null + } + + private fun u16(b: ByteArray, p: Int): Int = (b[p].toInt() and 255) or ((b[p + 1].toInt() and 255) shl 8) + + private fun u32(b: ByteArray, p: Int): Int = u16(b, p) or (u16(b, p + 2) shl 16) +} diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwMessageWindow.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwMessageWindow.kt index 73b9e79e..bdc2a32c 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwMessageWindow.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/CfwMessageWindow.kt @@ -33,7 +33,7 @@ class CfwMessageWindow private constructor() { fun acknowledgedHead(messages: Iterable): OutboundMessage? { for (message in messages) { if (message.sid != CfwTransport.SID) continue - return if (!message.cfwRetryPending && message.cfwAckLenses == CfwTransport.BOTH) + return if (!message.cfwRetryPending && message.isCfwAcked) message else null } @@ -49,7 +49,7 @@ class CfwMessageWindow private constructor() { failed = failed || message.cfwRetryPending || - (message.cfwAckLenses != CfwTransport.BOTH && + (!message.isCfwAcked && message.ackDeadlineAtMs > 0 && message.ackDeadlineAtMs <= nowMs) replay.add(message) diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/OutboundMessage.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/OutboundMessage.kt index 43ee91db..425bfbdb 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/OutboundMessage.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/OutboundMessage.kt @@ -18,6 +18,8 @@ class OutboundMessage( @JvmField val cfwChecksum: Int = if (sid == CfwTransport.SID) CfwTransport.crc(this.message) else 0 @JvmField var cfwAckLenses = 0 + /** The lenses that must ACK this attempt: both on a G2, whichever the message went to on a G1. */ + @JvmField var cfwRequiredLenses = CfwTransport.BOTH @JvmField var cfwRetries = 0 @JvmField var cfwRetryPending = false @JvmField var imageUpdateId = 0 @@ -47,9 +49,11 @@ class OutboundMessage( } if (message.size != ack.size || cfwChecksum != ack.checksum) return false cfwAckLenses = cfwAckLenses or ack.lens - return !cfwRetryPending && cfwAckLenses == CfwTransport.BOTH + return !cfwRetryPending && isCfwAcked } + val isCfwAcked: Boolean get() = cfwAckLenses and cfwRequiredLenses == cfwRequiredLenses + /** Replace an attempt atomically under the communicator lock. */ fun prepareCfwReplay(streamId: Int) { magic = streamId diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt index 97065349..2b0b034f 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionBrightness.kt @@ -19,15 +19,20 @@ internal fun GlassesSessionCore.enqueueBrightnessLocked(frameVisible: Boolean? = else if (brightnessPolicy.automatic) 1200 else 120 val payload = byteArrayOf(CFW_MSG_BRIGHTNESS.toByte(), 1, target.toByte(), (if (visible) 1 else 0).toByte(), duration.toByte(), (duration shr 8).toByte()) - val message = messageBuilder.customMessage("brightness-output", payload, - "brightness target=$target visible=$visible fade=$duration", -1, connectionOptions.sendImagesToLeft) - message.onTimeout = MessageCallback { + val label = "brightness target=$target visible=$visible fade=$duration" + val retry = MessageCallback { brightnessSentLevel = -1 brightnessSentVisible = null // Retry with a PRESENT even if the scene did not change during recovery. lastEnqueuedFingerprint = "" } - pendingMessages.addLast(message) + if (isG1) { + g1EnqueueBrightnessLocked(payload, label, brightnessSentVisible != visible, retry) + } else { + val message = messageBuilder.customMessage("brightness-output", payload, label, -1, connectionOptions.sendImagesToLeft) + message.onTimeout = retry + pendingMessages.addLast(message) + } brightnessSentLevel = target brightnessSentVisible = visible if (isIo) io.lastBrightnessAtMs = now() diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index 54b97c07..d7ee3663 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -111,6 +111,8 @@ class GlassesSessionCore( @Volatile internal var glassesType = GlassesType.G2 /** RayNeo iO link state (GlassesSessionIo.kt); guarded by [monitor]. */ internal val io = IoSessionState() + /** Even G1 link state (GlassesSessionG1.kt); guarded by [monitor]. */ + internal val g1 = G1SessionState() /** * Optional tap for relay frames the session does not interpret: notifications on the @@ -578,6 +580,14 @@ class GlassesSessionCore( } } + /** Drive an Even G1 on g1v0 instead of a G2 (see [G1SessionState]). Before [start]. */ + fun useG1() { + monitor.withLock { glassesType = GlassesType.G1 } + } + + /** True when this session drives an Even G1. */ + fun isEvenG1(): Boolean = isG1 + /** True when this session drives a RayNeo iO. */ fun isRayNeoIo(): Boolean = isIo @@ -613,7 +623,7 @@ class GlassesSessionCore( * quiescing its producers. Also cover direct/early close callers here; * a successful cleanup must remain the final BLE message. Older CFWs * fall back to the standalone framebuffer-lease release. */ - if (!cfwCleanupDelivered && !sendCfwCleanup() && !isIo) { + if (!cfwCleanupDelivered && !sendCfwCleanup() && isG2) { releaseFaceclawFramebufferLease() } monitor.withLock { @@ -683,6 +693,10 @@ class GlassesSessionCore( } // The iO's packets are Opus from its remote audio stream (see ioStartAudioCapture). if (isIo) return ioStartAudioCapture(listener) + if (isG1) { + logLine("skip G1 mic: not in this version") + return false + } var magic = 0 monitor.withLock { if (!running || !sessionReady || shutdownRequested || !fixedLayoutCreated) { @@ -701,6 +715,7 @@ class GlassesSessionCore( fun stopG2AudioCapture() { if (isIo) return ioStopAudioCapture() + if (isG1) return var magic = 0 monitor.withLock { audioPacketListener = null @@ -834,7 +849,7 @@ class GlassesSessionCore( monitor.withLock { faceclawWakeLeaseEnabled = enabled // A G2 firmware lease; the iO's wake word is setVoiceWakeEnabled. - if (isIo) return true + if (!isG2) return true if (!running || !sessionReady) { return !enabled } @@ -1594,6 +1609,7 @@ class GlassesSessionCore( fun sendShutdown(exitMode: Int): Boolean { if (isIo) return ioSuspend() + if (isG1) return g1Suspend() return sendShutdownInternal(exitMode, true) } @@ -1604,6 +1620,17 @@ class GlassesSessionCore( * can use the legacy shutdown-and-lease-release path. */ fun sendCfwCleanup(): Boolean { + if (isG1) { + // Fire and forget: the firmware keeps no session that could outlive the link. + monitor.withLock { + if (cfwCleanupDelivered) return true + shutdownRequested = true + cfwCleanupDelivered = true + clearPendingMessagesLocked("G1 cleanup") + } + g1HideBeforeDisconnect() + return true + } val magic: Int monitor.withLock { if (cfwCleanupDelivered) { @@ -1686,6 +1713,7 @@ class GlassesSessionCore( */ fun suspendEvenHubSession(): Boolean { if (isIo) return ioSuspend() + if (isG1) return g1Suspend() // Ending the plugin task releases the fb lease, which frees the // on-glasses resource cache; forget it phone-side either way (a lost // ack may still have taken effect). @@ -1710,6 +1738,7 @@ class GlassesSessionCore( */ fun resumeEvenHubSession(): Boolean { if (isIo) return ioResume() + if (isG1) return g1Resume() var claimGeneration = 0 monitor.withLock { if (!running || !sessionReady || chargingMode) { @@ -1790,7 +1819,7 @@ class GlassesSessionCore( continue } logWarn("Attempting to connect") - if (isIo) ioConnectLoopOnce() else connectLoopOnce() + if (isIo) ioConnectLoopOnce() else if (isG1) g1ConnectLoopOnce() else connectLoopOnce() continue } @@ -1826,6 +1855,10 @@ class GlassesSessionCore( ioOnNotification(address, uuid, data) return } + if (isG1) { + g1OnNotification(address, uuid, data) + return + } if (BleProtocol.RENDER_NOTIFY_UUID == uuid) { handleRenderNotification(address, data) return diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt new file mode 100644 index 00000000..3f692742 --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt @@ -0,0 +1,553 @@ +package com.faceclaw.app + +import com.faceclaw.app.GlassesSessionCore.Companion.DASHBOARD_TILE +import com.faceclaw.app.GlassesSessionCore.Companion.safeMessage + +/** Bytes of the arm's frame once everything queued for it has run, and what each arm last reported. */ +internal class G1ArmState { + var hello: G1Protocol.Hello? = null + var battery = -1 + var charge = -1 + var inCase = -1 + var worn = -1 + + /** Null: unknown, so the next update is a full frame. */ + var frame: ByteArray? = null + + fun resetLink() { + hello = null + battery = -1 + charge = -1 + inCase = -1 + worn = -1 + frame = null + } +} + +/** + * Even G1 session state ([GlassesSessionCore.g1]); guarded by the core's monitor. + * + * A G1 is two independent devices on two BLE links, and neither hears what the other is sent. Each arm has its own + * deflate stream (cfwTransports) and frame, each message goes to one arm and only that lens ACKs it, and the phone + * composes each lens: the firmware has no display lists, so the shell scene is drawn here in its settled state. + * Firmware: scouter_kit's g1v0 (g1_firmware/docs/VM.md §6.11, firmware/src/fc.c). + */ +internal class G1SessionState { + val arms = arrayOf(G1ArmState(), G1ArmState()) + private var tag = 0 + val replies = HashMap() + var lastPropsAtMs = 0L + + /** The panel may be blank: the next update ends in PRESENT even with no pixels to send. */ + var presentPending = false + + fun nextTag(): Int { + tag = tag % 255 + 1 + return tag + } + + fun resetLink() { + for (arm in arms) arm.resetLink() + replies.clear() + lastPropsAtMs = 0 + presentPending = true + } +} + +internal object G1Timings { + const val CONTROL_REPLY_MS = 1_500L + const val CONTROL_TRIES = 4 + /** The OS may be showing its pairing dialog. */ + const val PAIRING_MS = 30_000 + const val PROPS_MS = 60_000L + const val LENS_LEFT = 1 + const val LENS_RIGHT = 2 +} + +private val G1_PROPS = intArrayOf(G1Protocol.PROP_BATT_PCT, G1Protocol.PROP_CHARGE, G1Protocol.PROP_IN_CASE, G1Protocol.PROP_WORN) + +internal val GlassesSessionCore.isG1: Boolean get() = glassesType == GlassesType.G1 + +internal val GlassesSessionCore.isG2: Boolean get() = glassesType == GlassesType.G2 + +/** What the display path takes (fc.c); anything else a shared feature queues never goes out. */ +internal fun g1SupportsMessage(message: OutboundMessage): Boolean { + if (message.sid != CfwTransport.SID || message.message.isEmpty()) return false + return when (message.message[0].toInt() and CFW_MSG_TYPE_MASK) { + CFW_MSG_DRAW_CALLS, CFW_MSG_PRESENT, CFW_MSG_BRIGHTNESS -> true + else -> false + } +} + +private fun GlassesSessionCore.g1ArmAddress(arm: Int): String = if (arm == 0) leftAddress else rightAddress + +private fun g1Lens(arm: Int): Int = if (arm == 0) G1Timings.LENS_LEFT else G1Timings.LENS_RIGHT + +// --------------------------------------------------------------------------------------------- +// Writes + +/** The packets of one queued message, its record from this arm's persistent deflate stream. */ +internal fun GlassesSessionCore.g1CfwWrites(message: OutboundMessage, mtu: Int): List { + val arm = if (message.isLeftArmMessage) 0 else 1 + val transport = cfwTransports[arm] + if (message.cfwRetries > 0) transport.reset() + return G1Protocol.packets(transport.encodeRecord(message.message, g1Lens(arm)), message.magic, mtu) +} + +private fun GlassesSessionCore.g1WriteControl(address: String, op: Int, tag: Int, body: ByteArray): Boolean = + link.writeFrames(address, G1Ble.CTRL_CHAR_UUID, listOf(G1Protocol.control(op, tag, body)), + GattWriteMode.WITHOUT_RESPONSE, ConnectionOptions.WRITE_TIMEOUT_MS) + +/** + * A control request and its reply; worker thread, outside the monitor. Writes on a link the arm doesn't yet obey + * (out of the case, before encryption) are ignored and control requests can be lost, so it asks again. + */ +private fun GlassesSessionCore.g1Control(arm: Int, op: Int, body: ByteArray = ByteArray(0)): G1Protocol.Reply { + val address = g1ArmAddress(arm) + repeat(G1Timings.CONTROL_TRIES) { + val tag = monitor.withLock { g1.nextTag() } + val key = arm * 256 + tag + if (!g1WriteControl(address, op, tag, body)) throw IllegalStateException("control $op write failed") + val deadline = now() + G1Timings.CONTROL_REPLY_MS + monitor.withLock { + while (true) { + g1.replies.remove(key)?.let { return it } + if (!running || userDisconnectRequested) throw IllegalStateException("stopped while waiting for control $op") + if (!(if (arm == 0) leftConnected else rightConnected)) throw IllegalStateException("link lost waiting for control $op") + val remaining = deadline - now() + if (remaining <= 0) break + monitor.awaitMs(minOf(remaining, 100L)) + } + } + } + throw IllegalStateException("no reply to control $op from the " + (if (arm == 0) "left" else "right") + " arm") +} + +private fun GlassesSessionCore.g1RequestProps(arm: Int) { + val tag = monitor.withLock { g1.nextTag() } + g1WriteControl(g1ArmAddress(arm), G1Protocol.OP_PROPS, tag, ByteArray(G1_PROPS.size) { G1_PROPS[it].toByte() }) +} + +/** Nothing here keeps a lease; this only refreshes the battery. Worker thread, outside the monitor. */ +internal fun GlassesSessionCore.g1Maintain() { + val due = monitor.withLock { + val now = now() + val due = sessionReady && now - g1.lastPropsAtMs >= G1Timings.PROPS_MS + if (due) g1.lastPropsAtMs = now + due + } + if (due) { + g1RequestProps(0) + g1RequestProps(1) + } +} + +// --------------------------------------------------------------------------------------------- +// Frames (under the monitor, from enqueueDesiredImageLocked) + +/** Whatever was queued is gone, so what the arms' frames will hold is unknown. */ +internal fun GlassesSessionCore.g1ForgetFramesLocked() { + if (!isG1) return + for (arm in g1.arms) arm.frame = null + g1.presentPending = true + for (transport in cfwTransports) transport.reset() +} + +/** + * Compose each lens in the frame's settled state, send what changed against the arm's frame, and end with PRESENT. + * The two arms' messages alternate so that neither eye runs far ahead, and the PRESENTs go out last and side by side. + * A blanked frame sends nothing: the panel waits in standby with the last picture in the arm's frame, and the next + * visible frame is a delta against it. + */ +internal fun GlassesSessionCore.g1EnqueueFrameLocked( + packed: ByteArray, width: Int, height: Int, scene: ShellScene, fingerprint: String, paintMs: Int, frameId: Int, +) { + if (fingerprint.startsWith("blanked:")) { + lastEnqueuedFingerprint = fingerprint + displayedFingerprint = fingerprint + finishFrame(frameId, "blanked: the panel is in standby") + return + } + frameTimings.spanStart(frameId, "compose-lenses") + val updates: List> + val composed: Array + try { + val left = scene.composed(packed, width, height, false) + val right = if (scene.hasStereoDepth) scene.composed(packed, width, height, true) else left + composed = arrayOf(left, right) + updates = List(2) { arm -> G1FramePlanner.plan(g1.arms[arm].frame, composed[arm], width, height) } + } catch (e: Exception) { + // As in the G2's path: this frame would fail the same way after a reconnect (#42), so drop it. + lastEnqueuedFingerprint = fingerprint + logLine("frame plan failed; frame dropped: " + safeMessage(e)) + finishFrame(frameId, "discarded: frame plan failed") + return + } + frameTimings.spanEnd(frameId, "compose-lenses") + val force = g1.presentPending + val queues = List(2) { arm -> + ArrayDeque(updates[arm]).also { if (it.isNotEmpty() || force) it.addLast(byteArrayOf(CFW_MSG_PRESENT.toByte())) } + } + g1.presentPending = false + for (arm in 0..1) g1.arms[arm].frame = composed[arm] + lastEnqueuedFingerprint = fingerprint + val messageCount = queues.sumOf { it.size } + if (messageCount == 0) { + displayedFingerprint = fingerprint + finishFrame(frameId, "no change on either lens") + return + } + val updateId = nextImageUpdateId++ + imageUpdateStats[updateId] = BleImageOptimizer.ImageUpdateStats(paintMs, 1, frameId) + var number = 0 + var payloadBytes = 0 + var arm = 0 + while (queues[0].isNotEmpty() || queues[1].isNotEmpty()) { + // The other arm's turn once this one is down to its PRESENT, so that both PRESENTs come last. + val other = 1 - arm + val waiting = queues[arm].size == 1 && queues[other].size > 1 + if (queues[arm].isEmpty() || waiting) { + arm = other + continue + } + val payload = queues[arm].removeFirst() + payloadBytes += payload.size + number++ + val plan = BleImageOptimizer.TileImagePlan(arm, DASHBOARD_TILE, composed[arm], width, height, nextMapSessionId(), payload) + enqueueCustomImageLocked(plan, payload, fingerprint, updateId, number, messageCount, arm == 0, g1Lens(arm)) + arm = other + } + frameTimings.log(frameId, "queued image update#$updateId messages=$messageCount payload=${payloadBytes}B") + logLine("queue image update#$updateId fingerprint=$fingerprint messages=$messageCount") +} + +/** Message 30 for both arms, its visibility ordered with the frames around it. */ +internal fun GlassesSessionCore.g1EnqueueBrightnessLocked(payload: ByteArray, label: String, visibleChanged: Boolean, onTimeout: MessageCallback) { + for (arm in 0..1) { + val message = messageBuilder.customMessage("brightness-output", payload, label, -1, arm == 0) + message.cfwRequiredLenses = g1Lens(arm) + message.onTimeout = onTimeout + pendingMessages.addLast(message) + } + if (visibleChanged) g1.presentPending = true +} + +private fun GlassesSessionCore.g1HidePayload(): ByteArray = + byteArrayOf(CFW_MSG_BRIGHTNESS.toByte(), 1, brightnessPolicy.target.coerceIn(0, 100).toByte(), 0, 0, 0) + +/** Stop drawing, keeping the links and the arms' frames: the panels wait in standby (the EvenHub suspend analogue). */ +internal fun GlassesSessionCore.g1Suspend(): Boolean { + monitor.withLock { + if (!running || !sessionReady) return false + val idle = pendingMessages.isEmpty() && inFlightMessages.isEmpty() + val frames = g1.arms.map { it.frame } + shutdownRequested = true + clearAllMessagesLocked("G1 suspend") + // Nothing was lost, so the arms still hold what the phone thinks and a wake is a delta. + if (idle) for (arm in 0..1) g1.arms[arm].frame = frames[arm] + g1EnqueueBrightnessLocked(g1HidePayload(), "suspend: hide", true) { } + brightnessSentVisible = false + displayedFingerprint = "" + } + interruptibleSleep.interrupt() + return true +} + +/** The drive loop resends the desired frame; its PRESENT brings the panels back. */ +internal fun GlassesSessionCore.g1Resume(): Boolean { + monitor.withLock { + if (!running || !sessionReady) return false + shutdownRequested = false + displayedFingerprint = "" + lastEnqueuedFingerprint = "" + imageRetryAfterMs = 0 + g1.presentPending = true + } + interruptibleSleep.interrupt() + return true +} + +/** + * At the end of a session: the panels off now rather than 30 s from now, when the firmware's own rule would do it. + * A raw record that resets the stream, not waited on; nothing follows it. + */ +internal fun GlassesSessionCore.g1HideBeforeDisconnect() { + val message = g1HidePayload() + val record = CfwTransport.record(message, CfwTransport.crc(message), CfwTransport.BOTH or CfwTransport.RESET_CONTEXT) + for (arm in 0..1) { + val address = g1ArmAddress(arm) + if (!link.isConnected(address)) continue + try { + link.writeFrames(address, G1Ble.FC_CHAR_UUID, G1Protocol.packets(record, 0, link.negotiatedMtu(address)), + GattWriteMode.WITHOUT_RESPONSE, ConnectionOptions.WRITE_TIMEOUT_MS) + } catch (t: Throwable) { + logLine("G1 hide failed: " + safeMessage(t)) + } + } +} + +// --------------------------------------------------------------------------------------------- +// Connect (worker thread) + +private fun GlassesSessionCore.g1ConnectArm(arm: Int, deadlineMs: Long) { + val address = g1ArmAddress(arm) + val timeoutMs = maxOf(deadlineMs - now(), ConnectionOptions.CONNECT_TIMEOUT_MS.toLong()) + if (!link.connect(address, timeoutMs.toInt())) { + throw ArmUnreachableException(if (arm == 0) "left" else "right", address) + } + link.requestHighPriority(address) + link.requestMtu(address, G1Ble.REQUESTED_MTU, ConnectionOptions.CONNECT_TIMEOUT_MS) + if (!link.discoverServices(address, ConnectionOptions.SERVICES_TIMEOUT_MS)) { + throw IllegalStateException("discoverServices failed: $address") + } + if (!link.enableNotifications(address, G1Ble.EVT_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS)) { + throw IllegalStateException("no event characteristic on $address: not g1v0 firmware?") + } + link.requestLe2mPhy(address) + monitor.withLock { + if (arm == 0) leftConnected = true else rightConnected = true + } +} + +/** + * A write with response to PAIR needs an encrypted link. A bonded arm gets one at once; an arm in the case bonds here, + * through whatever the OS does (Android's dialog, iOS's); out of the case the arm refuses a new bond and the write fails. + * Either way this is where the link is known to be encrypted, so the arm obeys everything that follows. + */ +private fun GlassesSessionCore.g1Pair(arm: Int) { + val address = g1ArmAddress(arm) + if (!link.isBonded(address)) { + logLine("G1 " + (if (arm == 0) "left" else "right") + " arm: asking the OS to pair") + setStateDisplay("connecting", "Pairing with the glasses...") + link.requestBond(address) + val deadline = now() + G1Timings.PAIRING_MS + while (!link.isBonded(address) && now() < deadline) { + interruptibleSleep.sleep(200) + if (!monitor.withLock { running && !userDisconnectRequested }) throw IllegalStateException("stopped while pairing") + } + } + if (!link.writeFrames(address, G1Ble.PAIR_CHAR_UUID, listOf(byteArrayOf(1)), GattWriteMode.WITH_RESPONSE, G1Timings.PAIRING_MS)) { + throw IllegalStateException("no encrypted link to the " + (if (arm == 0) "left" else "right") + " arm") + } +} + +internal fun GlassesSessionCore.g1ConnectLoopOnce() { + monitor.withLock { + wearState = -1 + g1.resetLink() + } + setStateDisplay("connecting", "Connecting to the glasses...") + ConnectionCounters.increment("g1.connect-attempt") + try { + val deadlineMs = now() + ConnectionOptions.ARM_CONNECT_WINDOW_MS + link.beginConnect(rightAddress, false) + link.beginConnect(leftAddress, false) + // The left first, as the arms were installed; each stands alone. + g1ConnectArm(0, deadlineMs) + g1ConnectArm(1, deadlineMs) + g1Pair(0) + g1Pair(1) + + val versions = arrayOf("", "") + var compatible = true + for (arm in 0..1) { + val reply = g1Control(arm, G1Protocol.OP_HELLO) + val hello = G1Protocol.parseHello(reply.body) ?: throw IllegalStateException("bad HELLO from arm $arm") + monitor.withLock { g1.arms[arm].hello = hello } + versions[arm] = "g1v0 " + hello.version + (if (hello.safeMode) " (safe mode)" else "") + if (hello.leftArm != (arm == 0)) { + logWarn("G1: the arm paired as " + (if (arm == 0) "left" else "right") + " says it is the other one; its lens gets the other eye's frame") + } + val info = g1Control(arm, G1Protocol.OP_FC_INFO) + val fcVersion = if (info.status == 0) G1Protocol.parseFcVersion(info.body) else -1 + logLine("G1 " + (if (arm == 0) "left" else "right") + " arm: " + versions[arm] + + " display path " + fcVersion + " encrypted=" + hello.encrypted + " inCase=" + hello.inCase + + " panelOk=" + hello.panelOk + " phy=" + link.describePhy(g1ArmAddress(arm))) + compatible = compatible && fcVersion >= 1 + } + // The firmware's own number, not the G2 custom firmware's: the path has one version so far, and TS compares this. + val firmware = BleProtocol.FirmwareInfo(versions[0], versions[1], + if (compatible) BleProtocol.FirmwareInfo.FACECLAW_EXTENSION_PREFIX + requiredFirmwareRevision else "") + emitFirmwareInfo(firmware) + if (!compatible) { + monitor.withLock { incompatibleFirmware = firmware } + return + } + for (arm in 0..1) { + val events = g1Control(arm, G1Protocol.OP_EVENTS, G1Protocol.eventsRequest(G1Protocol.EVENTS_MASK)) + if (events.status != 0) throw IllegalStateException("EVENTS refused: " + events.status) + // The arm counts a boot healthy only after a host has said so (VM.md §6.4, safe mode). + g1Control(arm, G1Protocol.OP_HEALTH_OK) + } + monitor.withLock { + sessionReady = true + shutdownRequested = false + customFirmwareDetected = true + clearAllMessagesLocked("session ready") + fixedLayoutCreated = true + displayedFingerprint = "" + lastAckAtMs = now() + lastIncomingAtMs = lastAckAtMs + lastConnectionOrInputAtMs = lastAckAtMs + lastSessionReadyAtMs = lastAckAtMs + imageRetryAfterMs = 0 + consecutiveAckTimeouts = 0 + cfwCleanupDelivered = false + lastCfwCleanupAckMagic = 0 + g1.lastPropsAtMs = 0 + monitor.signalAll() + } + setStateDisplay("connected", "Connected.") + interruptibleSleep.interrupt() + } catch (t: Throwable) { + logLine("G1 connect failed: " + safeMessage(t)) + val unpaired = firstUnpairedArm() + if (unpaired != null) { + logError("G1 connect failed and $unpaired is not paired; suspending reconnect") + ConnectionCounters.increment("g1.unpaired") + monitor.withLock { haltReconnectLocked("arm not paired: $unpaired") } + if (!userDisconnectRequested) { + setStateDisplay("unpaired", "The glasses are not paired with this phone. Put them in their charging case" + + " with the lid open, then connect: they only pair in the case.") + } + interruptibleSleep.interrupt() + } else if (t is ArmUnreachableException) { + val other = if (t.side == "left") rightAddress else leftAddress + if (link.isConnected(other)) { + handleTransportFailure(t.side + " arm not found", "Can't reach the " + t.side + " arm of the glasses." + + " It may be connected to another device, or be off or out of range.") + } else { + handleTransportFailure("glasses not found", "Can't find the glasses. They may be off or out of range.") + } + } else { + handleTransportFailure("connect failed") + } + } +} + +// --------------------------------------------------------------------------------------------- +// Inbound (BLE callback thread) + +internal fun GlassesSessionCore.g1OnNotification(address: String, characteristicUuid: String, data: ByteArray) { + if (G1Ble.EVT_CHAR_UUID != characteristicUuid) return + val arm = armIndex(address) + if (arm < 0) return + when (val type = G1Protocol.eventType(data)) { + G1Protocol.EV_FC_ACK -> { + val ack = G1Protocol.parseFcAck(data) ?: return + monitor.withLock { acceptCfwAcksLocked(address, arrayOf(ack), 0, data) } + interruptibleSleep.interrupt() + } + G1Protocol.EV_INPUT -> g1HandleInput(arm, G1Protocol.parseInput(data) ?: return) + else -> if (type >= 0x80) { + val reply = G1Protocol.parseReply(data) ?: return + if (reply.op == G1Protocol.OP_PROPS) { + if (reply.status == 0) G1Protocol.parseProps(reply.body, G1_PROPS.size)?.let { g1HandleProps(arm, it) } + return + } + monitor.withLock { + lastIncomingAtMs = now() + g1.replies[arm * 256 + reply.tag] = reply + monitor.signalAll() + } + } + } +} + +private fun GlassesSessionCore.g1HandleInput(arm: Int, input: G1Protocol.Input) { + when (input.trigger) { + G1Protocol.TRIGGER_TOUCH -> g1HandleGesture(arm, input.value) + G1Protocol.TRIGGER_BATTERY -> g1HandleProps(arm, intArrayOf(input.value, G1Protocol.UNKNOWN, G1Protocol.UNKNOWN, G1Protocol.UNKNOWN), true) + G1Protocol.TRIGGER_WEAR -> g1HandleProps(arm, intArrayOf(G1Protocol.UNKNOWN, G1Protocol.UNKNOWN, G1Protocol.UNKNOWN, input.value)) + G1Protocol.TRIGGER_CASE -> g1HandleProps(arm, intArrayOf(G1Protocol.UNKNOWN, G1Protocol.UNKNOWN, input.value and 1, G1Protocol.UNKNOWN)) + } +} + +private fun GlassesSessionCore.g1HandleGesture(arm: Int, gesture: Int) { + val leftArm = arm == 0 + val dark = monitor.withLock { shutdownRequested || brightnessSentVisible == false } + val eventType = G1Protocol.gestureEventType(gesture, leftArm, dark) + monitor.withLock { + lastIncomingAtMs = now() + if (eventType != null) lastConnectionOrInputAtMs = lastIncomingAtMs + } + logLine("G1 gesture " + gesture + " on the " + (if (leftArm) "left" else "right") + " arm" + (if (eventType == null) " (ignored)" else "")) + if (eventType == null) return + val source = if (leftArm) BleProtocol.EVENT_SOURCE_GLASSES_L else BleProtocol.EVENT_SOURCE_GLASSES_R + // As the G2's firmware reports its own double tap on a dark display: it can only wake, whatever the delay. + val event = if (dark && gesture == G1Protocol.GESTURE_DOUBLE_TAP) G2Event("display-wake", "", eventType, 0, 0) + else G2Event("sys-event", "", eventType, source, 0) + val frameId = frameTimings.startFrame("input:" + event.kind + " type=$eventType src=$source") + frameTimings.log(frameId, "input event decoded from G1 notification") + emitRingEvent(event, frameId) + interruptibleSleep.interrupt() +} + +/** + * New values in the order of [G1_PROPS], [G1Protocol.UNKNOWN] for those it doesn't say. The pair's battery is the lower + * arm's, the pair is charging if either arm is, worn if either arm says so, and in the case when both are. + * [batteryChanged]: a BATTERY event, which may also mean CHARGE changed, so that is read again. + */ +private fun GlassesSessionCore.g1HandleProps(arm: Int, values: IntArray, batteryChanged: Boolean = false) { + var batteryEmit = false + var wearEmit = -1 + var putOn = false + val state = g1.arms[arm] + monitor.withLock { + lastIncomingAtMs = now() + if (values[0] != G1Protocol.UNKNOWN) state.battery = values[0] + if (values[1] != G1Protocol.UNKNOWN) state.charge = values[1] + if (values[2] != G1Protocol.UNKNOWN) state.inCase = values[2] + if (values[3] != G1Protocol.UNKNOWN) state.worn = values[3] + + val batteries = g1.arms.map { it.battery }.filter { it >= 0 } + val battery = if (batteries.isEmpty()) -1 else batteries.min() + val charging = if (g1.arms.any { it.charge == G1Protocol.CHARGE_CHARGING }) 1 else if (g1.arms.all { it.charge < 0 }) -1 else 0 + if (battery != headsetBattery || charging != headsetCharging) { + headsetBattery = battery + headsetCharging = charging + batteryEmit = true + } + val worn = if (g1.arms.any { it.worn == 1 }) 1 else if (g1.arms.all { it.worn < 0 }) -1 else 0 + if (worn >= 0 && worn != wearState) { + putOn = chargingMode && wearState == 0 && worn == 1 + wearState = worn + wearEmit = worn + } + if (sessionReady) { + val inCase = g1.arms.all { it.inCase == 1 } + if (putOn) { + endChargingModeLocked("glasses put on") + } else if (inCase != chargingMode && g1.arms.all { it.inCase >= 0 }) { + g1SetInCaseLocked(inCase, battery) + } + } + } + if (batteryEmit) emitBatteryState(headsetBattery, headsetCharging) + if (wearEmit >= 0) emitWearState(wearEmit == 1) + if (batteryChanged) g1RequestPropsLater() + interruptibleSleep.interrupt() +} + +private fun GlassesSessionCore.g1RequestPropsLater() { + monitor.withLock { g1.lastPropsAtMs = 0 } +} + +/** + * In the case nobody can see the panels, and lit pixels disturb the case's charging link: they go dark and frames stop. + * Leaving the case reconnects, as on a G2, which also picks up a firmware the arms got meanwhile. + */ +private fun GlassesSessionCore.g1SetInCaseLocked(inCase: Boolean, battery: Int) { + if (inCase) { + chargingMode = true + clearAllMessagesLocked("glasses in the case") + fixedLayoutCreated = false + displayedFingerprint = "" + g1EnqueueBrightnessLocked(g1HidePayload(), "in the case: hide", true) { } + finishDesiredFrameLocked("discarded: glasses in the case") + logLine("glasses are in the case; pausing display communication") + setStateDisplay("charging", GlassesSessionCore.chargingStatusText(battery)) + } else { + endChargingModeLocked("glasses out of the case") + } +} diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt index ff8de59a..ba8a00ee 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionIo.kt @@ -5,7 +5,7 @@ import com.faceclaw.app.GlassesSessionCore.Companion.safeMessage import kotlin.random.Random /** Which glasses a session drives. Set before [GlassesSessionCore.start]; see [GlassesSessionCore.useRayNeoIo]. */ -enum class GlassesType { G2, RAYNEO_IO } +enum class GlassesType { G2, RAYNEO_IO, G1 } /** * RayNeo iO session state ([GlassesSessionCore.io]); guarded by the core's monitor. @@ -210,9 +210,9 @@ internal fun GlassesSessionCore.ioCfwWrites(message: OutboundMessage, mtu: Int): internal fun GlassesSessionCore.ioDropUnsupported(message: OutboundMessage) { monitor.withLock { inFlightMessages.remove(message) - if (message.magic != 0) magicPool.release(message.sid, message.magic, message.label, "unsupported on RayNeo iO") + if (message.magic != 0) magicPool.release(message.sid, message.magic, message.label, "unsupported on these glasses") } - logDebug("RayNeo iO: dropped unsupported message " + message.label + " sid=" + message.sid) + logDebug("dropped a message these glasses don't take: " + message.label + " sid=" + message.sid) } // --------------------------------------------------------------------------------------------- diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt index 779c891c..9388abce 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt @@ -971,11 +971,11 @@ internal fun macWireBytes(address: String): ByteArray? { internal fun GlassesSessionCore.queueGlassesRingLinkCommandLocked( action: String, fallbackAddress: String, fallbackName: String, ): Boolean { - if (isIo) { - // A RayNeo iO has no ring link of its own; the phone holds the ring directly. - lastRingLinkCommand = "$action: not applicable (RayNeo iO)" + if (!isG2) { + // A RayNeo iO or a G1 has no ring link of its own; the phone holds the ring directly. + lastRingLinkCommand = "$action: not applicable ($glassesType)" lastRingLinkCommandAtMs = now() - logLine("glasses ring $action skipped: RayNeo iO glasses have no ring link") + logLine("glasses ring $action skipped: $glassesType glasses have no ring link") return false } val reported = glassesRingMac @@ -1100,7 +1100,7 @@ internal fun GlassesSessionCore.queueRingConfigCommandLocked( "targets-glasses" -> { // The iO never connects to the ring: naming it would make the ring drop // the phone's glasses-role link (the advStart check, ~20 s later). - if (isIo) return "not sent: RayNeo iO glasses don't hold the ring" + if (!isG2) return "not sent: these glasses don't hold the ring" val right = macWireBytes(rightAddress) val left = macWireBytes(leftAddress) if (right == null || left == null) return "not sent: glasses addresses unparseable" diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt index 7de25932..e1da052e 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt @@ -45,6 +45,7 @@ internal fun GlassesSessionCore.driveSession(): Long { } } if (isIo) ioMaintain() + if (isG1) g1Maintain() var messageToWrite: OutboundMessage? = null var messageToPrewrite: OutboundMessage? = null var heartbeatToWrite: OutboundMessage? = null @@ -75,7 +76,7 @@ internal fun GlassesSessionCore.driveSession(): Long { clearPendingMessagesLocked("after CFW cleanup") return 250 } - if (sessionReady && !isIo + if (sessionReady && isG2 && now - lastFaceclawFramebufferLeaseQueuedAtMs >= FACECLAW_WAKE_LEASE_RENEW_MS && !hasPendingOrInflightKindLocked("framebuffer-lease-control")) { enqueueFaceclawFramebufferControlLocked( @@ -84,7 +85,7 @@ internal fun GlassesSessionCore.driveSession(): Long { ) } if (faceclawWakeLeaseEnabled - && sessionReady && !isIo + && sessionReady && isG2 && now - lastFaceclawWakeLeaseQueuedAtMs >= FACECLAW_WAKE_LEASE_RENEW_MS && !hasPendingOrInflightKindLocked("wake-lease-control")) { enqueueFaceclawWakeControlLocked( @@ -159,7 +160,7 @@ internal fun GlassesSessionCore.driveSession(): Long { } } else { if (messageToPrewrite == null - && !isIo // the iO's page lease is ioMaintain's + && isG2 // the iO's page lease is ioMaintain's; a G1 has none && !shutdownRequested && !fixedLayoutCreated && pendingMessages.isEmpty() @@ -170,14 +171,14 @@ internal fun GlassesSessionCore.driveSession(): Long { // Prewrite outside the lock; the logical message remains pending until // its final BLE frame is sent after the current protocol ACK. } - if (messageToPrewrite == null && !isIo && !shutdownRequested && fixedLayoutCreated + if (messageToPrewrite == null && isG2 && !shutdownRequested && fixedLayoutCreated && (if (firmwareDebugFlagsEnabled) 2 else 1) != firmwareDebugFlagsLastSent && pendingMessages.isEmpty() && inFlightMessages.isEmpty()) { logLine("enqueueing firmware debug flags " + (if (firmwareDebugFlagsEnabled) "show" else "hide")) enqueueFirmwareDebugFlagsLocked() } - if (messageToPrewrite == null && !isIo && !shutdownRequested && fixedLayoutCreated + if (messageToPrewrite == null && isG2 && !shutdownRequested && fixedLayoutCreated && caseInfoReadPending && pendingMessages.isEmpty() && inFlightMessages.isEmpty()) { caseInfoReadPending = false @@ -185,7 +186,7 @@ internal fun GlassesSessionCore.driveSession(): Long { pendingMessages.addLast(messageBuilder.caseInfoQuery()) } - if (messageToPrewrite == null && !isIo && !shutdownRequested && fixedLayoutCreated + if (messageToPrewrite == null && isG2 && !shutdownRequested && fixedLayoutCreated && (if (compassOwners.isEmpty()) 0 else 1) != compassControlLastSent && pendingMessages.isEmpty() && inFlightMessages.isEmpty()) { val wanted = compassOwners.isNotEmpty() @@ -196,7 +197,9 @@ internal fun GlassesSessionCore.driveSession(): Long { if (benchmarkActive) { maintainBenchmarkLocked(now) } - if (!benchmarkActive && (!isIo || ioFirmwareOwnsBrightness)) maintainBrightnessLocked(now) + // A G1's brightness follows the policy's target; its light sensor isn't wired up yet. + if (!benchmarkActive && isG1) enqueueBrightnessLocked() + else if (!benchmarkActive && (!isIo || ioFirmwareOwnsBrightness)) maintainBrightnessLocked(now) // Up to WINDOW_SIZE messages may be in flight at once (full // pipelining); a slot frees when an ack arrives. An active @@ -339,7 +342,7 @@ internal enum class HeartbeatStep { } internal fun GlassesSessionCore.heartbeatStepLocked(imageWaiting: Boolean): HeartbeatStep { - if (isIo) return HeartbeatStep.NONE + if (!isG2) return HeartbeatStep.NONE val now = now() val heartbeatEligible = !shutdownRequested && fixedLayoutCreated val heartbeatPending = heartbeatEligible && hasPendingOrInflightKindLocked("heartbeat") @@ -390,6 +393,11 @@ internal fun GlassesSessionCore.createHeartbeatMessage(): OutboundMessage { } internal fun GlassesSessionCore.writeMessage(message: OutboundMessage): Boolean { + if (isG1 && !g1SupportsMessage(message)) { + // G2-only traffic a shared feature queued anyway: it would only wait for an ACK that never comes. + ioDropUnsupported(message) + return true + } if (isIo && !ioSupportsMessage(message)) { // G2-only traffic (EvenHub/settings frames, the G2 hardware CFW modes) that a feature // queued anyway: the iO would NACK it into the replay limit, so it never goes out. @@ -427,6 +435,8 @@ internal fun GlassesSessionCore.writeMessage(message: OutboundMessage): Boolean prewrittenFrames = emptyList() } else if (isIo) { frames = ioCfwWrites(message, link.negotiatedMtu(writeAddress)) + } else if (isG1) { + frames = g1CfwWrites(message, link.negotiatedMtu(writeAddress)) } else if (message.sid == CfwTransport.SID) { if (message.cfwRetries > 0) cfwTransports[if (message.isLeftArmMessage) 0 else 1].reset() frames = cfwTransports[if (message.isLeftArmMessage) 0 else 1].encode( @@ -442,9 +452,9 @@ internal fun GlassesSessionCore.writeMessage(message: OutboundMessage): Boolean } val result = link.writeFrames( writeAddress, - if (isIo) RayNeoIoBle.WRITE_CHAR_UUID else BleProtocol.WRITE_CHAR_UUID, + if (isIo) RayNeoIoBle.WRITE_CHAR_UUID else if (isG1) G1Ble.FC_CHAR_UUID else BleProtocol.WRITE_CHAR_UUID, frames, - if (isIo) GattWriteMode.WITHOUT_RESPONSE else ConnectionOptions.WRITE_MODE, + if (isIo || isG1) GattWriteMode.WITHOUT_RESPONSE else ConnectionOptions.WRITE_MODE, ConnectionOptions.WRITE_TIMEOUT_MS ) @@ -847,6 +857,10 @@ internal fun GlassesSessionCore.enqueueDesiredImageLocked() { frameTimings.spanEnd(frameId, "pack-4bpp") // Visibility belongs to this immutable composite, not the latest UI request. enqueueBrightnessLocked(!fingerprint.startsWith("blanked:")) + if (isG1 && packedFrame.size > 0) { + g1EnqueueFrameLocked(packedFrame, width, height, scene, fingerprint, paintMs, frameId) + return + } if (customFirmwareDetected && packedFrame.size > 0) { val rendered = try { scenePlanner.plan(packedFrame, width, height, draws, scene, nextImageFrameId, @@ -992,10 +1006,13 @@ internal fun GlassesSessionCore.enqueueCustomImageLocked( fingerprint: String, updateId: Int, messageNumber: Int, - messageCount: Int + messageCount: Int, + leftArm: Boolean = connectionOptions.sendImagesToLeft, + requiredLenses: Int = CfwTransport.BOTH, ) { val message = messageBuilder.customMessage("image", payload, - "image " + plan.tile.name + "#" + messageNumber, plan.tileIndex, connectionOptions.sendImagesToLeft) + "image " + plan.tile.name + "#" + messageNumber, plan.tileIndex, leftArm) + message.cfwRequiredLenses = requiredLenses message.setImageUpdatePosition(updateId, messageNumber, messageCount) message.onAck = MessageCallback { imageRetryAfterMs = 0 @@ -1048,7 +1065,7 @@ internal fun GlassesSessionCore.createAudioControlMessageLocked(enable: Boolean) } internal fun GlassesSessionCore.shouldPollBatteryLocked(now: Long): Boolean { - return !isIo // the iO's status polls are ioMaintain's + return isG2 // the others' status polls are their own maintain's && !shutdownRequested && sessionReady && pendingMessages.isEmpty() @@ -1356,6 +1373,7 @@ internal fun GlassesSessionCore.clearMessagesOfKindLocked(kind: String) { // drop the pipelined delta base so the next image is a full keyframe. lastEnqueuedPacked = ByteArray(0) lastEnqueuedFingerprint = "" + g1ForgetFramesLocked() } } @@ -1370,6 +1388,7 @@ internal fun GlassesSessionCore.clearAllMessagesLocked(reason: String) { // image is a full keyframe rather than a delta onto a stale base. lastEnqueuedPacked = ByteArray(0) lastEnqueuedFingerprint = "" + g1ForgetFramesLocked() // Queued resource commands (if any) were dropped with the rest, and the // session churn behind a full clear may have freed the on-glasses // cache; forget it phone-side so glyphs re-upload lazily. diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt index 94f5e0d2..aaa4b57a 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt @@ -68,6 +68,9 @@ interface SessionLink { /** Whether the OS still holds a pairing bond for the address (iOS: always true). */ fun isBonded(address: String): Boolean + /** Ask the OS to bond with a connected device, without waiting. A no-op where it pairs on demand only (CoreBluetooth). */ + fun requestBond(address: String) {} + /** Bandwidth-benchmark link tuning; 0: current link, 1: HIGH priority, 2: 2M PHY, 3: both. */ fun prepareBenchmarkLink(address: String, mode: Int) diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt index 7818e75d..b98a7368 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt @@ -64,6 +64,21 @@ class ShellScene(val layers: List, val selections: List return output } + /** Whether the lenses differ: stereo depth somewhere in the scene. */ + val hasStereoDepth: Boolean get() = screenDepth != 0 || layers.any { it.depth != 0 } || allSelections.isNotEmpty() + + /** + * What one lens shows of [screen] (packed 4bpp) with this scene over it and every animation settled, for + * glasses that have no display lists (a G1). [screen] itself when there is no scene. + */ + fun composed(screen: ByteArray, width: Int, height: Int, rightLens: Boolean): ByteArray { + if (layers.isEmpty() && selections.isEmpty() && screenDepth == 0) return screen + val output = ByteArray(screen.size) + DisplayListRenderer(rendererResources(width, height), rightLens = rightLens).render(511, + DisplayListRenderer.Target(screen, width, height), DisplayListRenderer.Target(output, width, height), SETTLED_MS) + return output + } + /** Layer surfaces, then retained resources, by index, and the root list at 511. */ private fun rendererResources(width: Int, height: Int): HashMap { val resources = HashMap() diff --git a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt index 18acc3bd..bee49d5a 100644 --- a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt +++ b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt @@ -86,6 +86,9 @@ class IosGlassesSession internal constructor( fun setRequiredFirmwareRevision(revision: Int) = core.setRequiredFirmwareRevision(revision) + /** Drive an Even G1 on g1v0 (see GlassesSessionG1.kt). Before [start]. */ + fun useG1() = core.useG1() + fun start(): Boolean = core.start() fun disconnect() = core.disconnect() diff --git a/tests/even-advertisement.test.cjs b/tests/even-advertisement.test.cjs index c2757d65..d87c12ac 100644 --- a/tests/even-advertisement.test.cjs +++ b/tests/even-advertisement.test.cjs @@ -180,3 +180,43 @@ test("RayNeo iO advertisements classify as one device with its MAC", () => { // G2 advertisements are untouched assert.equal(classifyAdvertisement(raw({})).role, "left"); }); + +// --------------------------------------------------------------------------- +// Even G1 +// --------------------------------------------------------------------------- + +const g1Ascii = (text) => Array.from(text).map((c) => c.charCodeAt(0).toString(16).padStart(2, "0")).join(""); +const g1Raw = (name, manufacturerData, address = "F4:27:E9:CA:E8:3F") => ({ + address, + name, + manufacturerData, + rssi: -50, + txPower: null, + connectable: true, + bonded: false, + source: "scan", + seenAtMs: 1000, +}); + +test("a G1 arm on Even's firmware: side from the name, serial after the side byte", () => { + const ad = classifyAdvertisement(g1Raw("Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139") + "0000000000")); + assert.equal(ad.role, "left"); + assert.equal(ad.g1Firmware, "stock"); + assert.equal(ad.serial, "S110LABC030139"); + assert.equal(ad.embeddedMac, null); +}); + +test("a G1 arm on g1v0: the name says all, the serial is in the 0xFFFF record", () => { + const ad = classifyAdvertisement(g1Raw("G1v0_R", "ffff" + "01" + "04" + g1Ascii("S110LABC030139"))); + assert.equal(ad.role, "right"); + assert.equal(ad.g1Firmware, "g1v0"); + assert.equal(ad.serial, "S110LABC030139"); + assert.equal(classifyAdvertisement(g1Raw("G1v0S_L", "")).g1Firmware, "g1v0-safe"); + assert.equal(classifyAdvertisement(g1Raw("G1v0S_L", "")).serial, null); +}); + +test("names that only look like a G1 are not admitted", () => { + for (const name of ["G1v0_X", "G1v0", "G1 Tracker", "Even G1", "Pixel G1v0_L"]) { + assert.equal(classifyAdvertisement(g1Raw(name, "")), null, name); + } +}); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt new file mode 100644 index 00000000..42032373 --- /dev/null +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt @@ -0,0 +1,777 @@ +package com.faceclaw.app + +import kotlin.concurrent.Volatile +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +private const val LEFT = "F4:27:E9:CA:E8:3F" +private const val RIGHT = "CD:EB:89:BF:E9:EC" +private const val W = 640 +private const val H = 480 +private const val STRIDE = W / 2 + +private fun awaitTrue(timeoutMs: Long, condition: () -> Boolean): Boolean { + val platform = testPlatform() + val deadline = platform.elapsedRealtimeMs() + timeoutMs + while (platform.elapsedRealtimeMs() < deadline) { + if (condition()) return true + sleepMs(10) + } + return condition() +} + +private fun nibble(frame: ByteArray, x: Int, y: Int): Int { + val v = frame[y * STRIDE + x / 2].toInt() and 255 + return if (x % 2 == 0) v ushr 4 else v and 15 +} + +private fun setNibble(frame: ByteArray, x: Int, y: Int, c: Int) { + val i = y * STRIDE + x / 2 + val v = frame[i].toInt() and 255 + frame[i] = (if (x % 2 == 0) (v and 0x0f) or (c shl 4) else (v and 0xf0) or c).toByte() +} + +/** What fc.c does with a draw message: bbox and clear calls into [frame]; returns the calls' rectangles. */ +private fun applyDraw(frame: ByteArray, m: ByteArray): List { + val rects = ArrayList() + fun u16(p: Int) = (m[p].toInt() and 255) or ((m[p + 1].toInt() and 255) shl 8) + val count = u16(1) + var p = 3 + repeat(count) { + val len = u16(p) + p += 2 + val end = p + len + assertEquals(0, m[p + 1].toInt(), "a G1 call carries no target, depth or clip") + assertEquals(DRAW_OP_BOUNDING_BOX, m[p].toInt(), "only pixels on a G1") + var q = p + 2 + val x: Int + val y: Int + val w: Int + val h: Int + if (m[q].toInt() == 0) { + x = (m[q + 1].toInt() and 255) * 4 + y = (m[q + 2].toInt() and 255) * 2 + w = (m[q + 3].toInt() and 255) * 4 + h = (m[q + 4].toInt() and 255) * 2 + q += 5 + } else { + x = u16(q + 1) + y = u16(q + 3) + w = u16(q + 5) + h = u16(q + 7) + q += 9 + } + assertTrue(x + w <= W && y + h <= H, "rect $x,$y ${w}x$h") + var left = w * h + var cx = x + var cy = y + while (q < end) { + val token = m[q++].toInt() and 255 + val color = token and 15 + var run = token ushr 4 + if (run == 0) { + run = m[q++].toInt() and 255 + if (run == 0) { + run = u16(q) + q += 2 + } + } + left -= run + assertTrue(left >= 0, "RLE overruns its rectangle") + repeat(run) { + setNibble(frame, cx, cy, color) + cx++ + if (cx == x + w) { + cx = x + cy++ + } + } + } + assertEquals(0, left, "RLE must cover the rectangle exactly") + rects.add(intArrayOf(x, y, w, h)) + p = end + } + assertEquals(m.size, p) + return rects +} + +/** One arm on g1v0, as the phone sees it over GATT. */ +private class FakeG1Arm(val left: Boolean) { + val frame = ByteArray(STRIDE * H) + /** What a look through the lens shows: the frame as of the last PRESENT while visible. */ + val panel = ByteArray(STRIDE * H) + var visible = true + var panelOn = false + val records = ArrayList() + var current = ByteArray(0) + val messageTypes = ArrayList() + val rects = ArrayList() + var nackNext = false + var brightness = -1 + var wireBytes = 0 + var pairedWrites = 0 + var eventsMask = 0 + var healthOk = 0 + var bonded = false + var inCase = 0 + var battery = 80 +} + +private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { + lateinit var core: GlassesSessionCore + val lock = platform.createLock() + val leftArm = FakeG1Arm(true) + val rightArm = FakeG1Arm(false) + @Volatile var hasDisplayPath = true + /** Out of the case, or the OS said no: no bond can be made. */ + @Volatile var pairingRefused = false + private val out = ArrayList>() + + private fun arm(address: String) = if (address == LEFT) leftArm else rightArm + + /** Delivered off the writer's stack, as the BLE callback thread does: the session writes outside its monitor. */ + private fun event(address: String, type: Int, body: ByteArray) { + val data = ByteArray(9) + body + data[0] = type.toByte() + core.onNotification(address, G1Ble.EVT_CHAR_UUID, data) + } + + fun input(address: String, trigger: Int, value: Int) { + val body = ByteArray(7) + body[2] = trigger.toByte() + for (i in 0..3) body[3 + i] = (value ushr (8 * i)).toByte() + event(address, G1Protocol.EV_INPUT, body) + } + + override fun connect(address: String, timeoutMs: Int): Boolean = true + + override fun isConnected(address: String): Boolean = true + + override fun requestHighPriority(address: String) {} + + override fun requestMtu(address: String, mtu: Int, timeoutMs: Int): Boolean = true + + override fun negotiatedMtu(address: String): Int = 185 + + override fun discoverServices(address: String, timeoutMs: Int): Boolean = true + + override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean = + characteristicUuid == G1Ble.EVT_CHAR_UUID + + override fun requestBond(address: String) { + if (!pairingRefused) lock.withLock { arm(address).bonded = true } + } + + override fun writeFrames(address: String, characteristicUuid: String, frames: List, mode: GattWriteMode, timeoutMs: Int): Boolean { + val a = arm(address) + when (characteristicUuid) { + G1Ble.PAIR_CHAR_UUID -> { + assertEquals(GattWriteMode.WITH_RESPONSE, mode, "only a write with response can make the OS pair") + if (pairingRefused) return false + lock.withLock { + a.pairedWrites++ + a.bonded = true + } + } + G1Ble.CTRL_CHAR_UUID -> for (f in frames) control(address, a, f) + G1Ble.FC_CHAR_UUID -> { + assertEquals(GattWriteMode.WITHOUT_RESPONSE, mode) + assertTrue(frames.all { it.size <= 182 }, "writes must fit the MTU") + for (f in frames) packet(address, a, f) + } + else -> throw AssertionError("write to $characteristicUuid") + } + return true + } + + private fun reply(address: String, op: Int, tag: Int, status: Int, body: ByteArray = ByteArray(0)) = + event(address, 0x80 or op, byteArrayOf(tag.toByte(), status.toByte()) + body) + + private fun control(address: String, a: FakeG1Arm, f: ByteArray) { + val op = f[0].toInt() and 255 + val tag = f[1].toInt() and 255 + when (op) { + G1Protocol.OP_HELLO -> { + val body = ByteArray(35) + body[0] = 5 + body[1] = 0 + body[2] = 5 + body[3] = 62 + body[4] = (if (a.left) 1 else 0).toByte() + body[5] = (2 or 64).toByte() + reply(address, op, tag, 0, body) + } + G1Protocol.OP_FC_INFO -> if (hasDisplayPath) { + val body = ByteArray(26) + body[0] = 1 + reply(address, op, tag, 0, body) + } else reply(address, op, tag, 2) + G1Protocol.OP_EVENTS -> { + lock.withLock { a.eventsMask = (f[2].toInt() and 255) or ((f[3].toInt() and 255) shl 8) } + reply(address, op, tag, 0, f.copyOfRange(2, 4)) + } + G1Protocol.OP_HEALTH_OK -> { + lock.withLock { a.healthOk++ } + reply(address, op, tag, 0, ByteArray(1)) + } + G1Protocol.OP_PROPS -> { + val values = lock.withLock { intArrayOf(a.battery, 0, a.inCase, 1) } + val body = ByteArray(4 * values.size) + for (i in values.indices) for (b in 0..3) body[4 * i + b] = (values[i] ushr (8 * b)).toByte() + reply(address, op, tag, 0, body) + } + else -> reply(address, op, tag, 2) + } + } + + private fun packet(address: String, a: FakeG1Arm, p: ByteArray) { + val opts = p[0].toInt() and 255 + val stream = p[1].toInt() and 255 + val complete = lock.withLock { + if (opts and 0x80 != 0) a.current = ByteArray(0) + a.current += p.copyOfRange(2, p.size) + if (opts and 0x40 != 0) a.current.also { a.current = ByteArray(0) } else null + } ?: return + var size = 0 + val crc = (complete[3].toInt() and 255) or ((complete[4].toInt() and 255) shl 8) + var ok = false + lock.withLock { + a.wireBytes += complete.size + val lens = complete[0].toInt() and CfwTransport.BOTH + assertEquals(if (a.left) 1 else 2, lens, "a record names the arm it goes to") + if (a.nackNext) { + a.nackNext = false + } else { + if (complete[0].toInt() and CfwTransport.RESET_CONTEXT != 0) a.records.clear() + a.records.add(complete) + val message = inflateRecords(a.records).last() + size = message.size + assertTrue(size <= 16384, "the firmware's limit on a decoded message: $size") + if (CfwTransport.crc(message) == crc) { + ok = true + apply(a, message) + } + } + } + val body = byteArrayOf((if (ok) 1 else 3).toByte(), stream.toByte(), 0, 0, (if (a.left) 1 else 2).toByte(), + size.toByte(), (size ushr 8).toByte(), crc.toByte(), (crc ushr 8).toByte()) + event(address, G1Protocol.EV_FC_ACK, body) + } + + private fun apply(a: FakeG1Arm, m: ByteArray) { + val type = m[0].toInt() and 255 + a.messageTypes.add(type) + when (type) { + CFW_MSG_DRAW_CALLS -> a.rects.addAll(applyDraw(a.frame, m)) + CFW_MSG_PRESENT -> if (a.visible) { + a.frame.copyInto(a.panel) + a.panelOn = true + } + CFW_MSG_BRIGHTNESS -> { + a.brightness = m[2].toInt() and 255 + if (a.visible && m[3].toInt() == 0) a.panelOn = false + a.visible = m[3].toInt() != 0 + } + else -> throw AssertionError("message type $type must not reach a G1") + } + } + + override fun disconnect(address: String) {} + + override fun close() {} + + override fun isBonded(address: String): Boolean = lock.withLock { arm(address).bonded } + + override fun prepareBenchmarkLink(address: String, mode: Int) {} + + override fun recordDisplayFrameSent() {} +} + +private class G1Listener(platform: ProtocolPlatform) : FaceclawBleCommunicatorListener { + private val lock = platform.createLock() + private val phaseList = ArrayList() + private val eventList = ArrayList() + private val batteryList = ArrayList() + private val firmwareList = ArrayList() + private val wearList = ArrayList() + @Volatile var lastStatus = "" + val phases get() = lock.withLock { phaseList.toList() } + val events get() = lock.withLock { eventList.toList() } + val batteries get() = lock.withLock { batteryList.toList() } + val firmware get() = lock.withLock { firmwareList.toList() } + val wear get() = lock.withLock { wearList.toList() } + + override fun onStateChange(phase: String?, status: String?) { + lock.withLock { phaseList.add(phase ?: "") } + lastStatus = status ?: "" + } + + override fun onRingEvent(kind: String?, containerName: String?, eventType: Int, eventSource: Int, systemExitReasonCode: Int, frameId: Int, ringTick: Long, ringType: Int, ringAux: Int, ringSpeed: Int) { + lock.withLock { eventList.add("$kind:$eventType:$eventSource") } + } + + override fun onBatteryState(headsetBattery: Int, headsetCharging: Int, ringBattery: Int, ringCharging: Int) { + lock.withLock { batteryList.add("$headsetBattery/$headsetCharging") } + } + + override fun onSilentMode(silent: Boolean) {} + + override fun onWearState(wearing: Boolean) { + lock.withLock { wearList.add(wearing) } + } + + override fun onPhoneLockState(locked: Boolean) {} + + override fun onCaseState(caseBattery: Int, caseCharging: Int, caseDocked: Boolean) {} + + override fun onEvenAppConflict(message: String?) {} + + override fun onFrameMetrics(paintMs: Int, transmitMs: Int, tileCount: Int) {} + + override fun onFrameFinished(frameId: Int, outcome: String?) {} + + override fun onFirmwareInfo(leftVersion: String?, rightVersion: String?, extension: String?) { + lock.withLock { firmwareList.add("$leftVersion|$rightVersion|$extension") } + } +} + +private class G1Session { + val platform = testPlatform() + val glasses = FakeG1Glasses(platform) + private val host = object : SessionHost { + private val lock = platform.createLock() + private val lines = ArrayList() + private var done: Latch? = null + + fun logs(): List = lock.withLock { lines.toList() } + + override fun postToMain(action: () -> Unit) = action() + + override fun currentThreadDispatcher(): SessionDispatcher = SessionDispatcher { it() } + + override fun isPhoneLocked(): Boolean = false + + override fun setScreenWakeLock(on: Boolean) {} + + override fun isEvenAppActive(): Boolean = false + + override fun startWorker(body: () -> Unit) { + val latch = Latch(1, platform) + done = latch + startThread("g1-test-session", true) { + try { + body() + } finally { + latch.countDown() + } + } + } + + override fun joinWorker(timeoutMs: Long) { + done?.await(timeoutMs) + } + + override fun log(level: SessionLogLevel, tag: String, message: String, error: Throwable?) { + lock.withLock { lines.add("$level $tag: $message") } + } + } + val listener = G1Listener(platform) + val core = GlassesSessionCore(glasses, host, FrameTimingsCore(platform), platform, RIGHT, LEFT, "") + + init { + glasses.core = core + core.setListener(listener) + core.setRequiredFirmwareRevision(38) + core.useG1() + core.configureCompositorScreen(W, H) + core.configureSurface("s", 0, 0, W, 64, 0, SurfaceCompositor.TRANSPARENCY_OPAQUE) + } + + fun ready(): Boolean = core.monitor.withLock { core.sessionReady && core.fixedLayoutCreated } + + fun displayedMatchesDesired(): Boolean = core.monitor.withLock { + core.desiredTilesLock.locked { core.desiredFingerprint.isNotEmpty() && core.desiredFingerprint == core.displayedFingerprint } + } + + fun pixels(seed: Int) = ByteArray(W * 64) { if ((it + seed) % 11 == 0) 0xF0.toByte() else if (it % 17 == 0) 0x70 else 0 } + + fun submit(seed: Int, frameId: Int) = + core.submitSurfaceFrame(ArrayByteReader(pixels(seed)), "s", 0, 0, W, 64, "content-$seed", 0, frameId, null) + + /** The packed picture the surface's gray pixels should give on both lenses. */ + fun expected(seed: Int): ByteArray { + val packed = ByteArray(STRIDE * H) + BmpUtil.pack4bppFromGray8(pixels(seed), W, 64).copyInto(packed) + return packed + } + + fun tail(): String = host.logs().takeLast(30).joinToString("\n") + + fun shownOnBoth(picture: ByteArray): Boolean = glasses.lock.withLock { + glasses.leftArm.panel.contentEquals(picture) && glasses.rightArm.panel.contentEquals(picture) + } +} + +class G1SessionTest { + @Test + fun pairsOnFirstConnectAndShowsEachLensItsFrame() { + val s = G1Session() + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, "never ready:\n" + s.tail()) + assertTrue(s.core.isEvenG1()) + assertEquals(1, s.glasses.leftArm.pairedWrites, "each arm's encryption is proved by a PAIR write") + assertEquals(1, s.glasses.rightArm.pairedWrites) + assertEquals(G1Protocol.EVENTS_MASK, s.glasses.leftArm.eventsMask) + assertEquals(G1Protocol.EVENTS_MASK, s.glasses.rightArm.eventsMask) + assertEquals(1, s.glasses.leftArm.healthOk, "the boot is confirmed healthy") + assertTrue(s.listener.firmware.single().startsWith("g1v0 0.5.62|g1v0 0.5.62|Faceclaw/"), s.listener.firmware.toString()) + + s.submit(1, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, "frame never displayed:\n" + s.tail()) + val picture = s.expected(1) + assertTrue(s.shownOnBoth(picture), "both lenses show the whole frame:\n" + s.tail()) + for (arm in listOf(s.glasses.leftArm, s.glasses.rightArm)) { + assertEquals(CFW_MSG_PRESENT, arm.messageTypes.last(), "an update ends in PRESENT") + assertTrue(arm.messageTypes.all { it == CFW_MSG_DRAW_CALLS || it == CFW_MSG_PRESENT || it == CFW_MSG_BRIGHTNESS }, + arm.messageTypes.toString()) + } + } finally { + s.core.disconnect() + } + } + + @Test + fun aSecondFrameIsADeltaThatCostsLittle() { + val s = G1Session() + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + s.submit(1, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + val first = s.glasses.lock.withLock { s.glasses.leftArm.wireBytes } + val rectsBefore = s.glasses.lock.withLock { s.glasses.leftArm.rects.size } + // One small area of the surface changes. + val pixels = s.pixels(1) + for (y in 10 until 14) for (x in 100 until 120) pixels[y * W + x] = 0x80.toByte() + s.core.submitSurfaceFrame(ArrayByteReader(pixels), "s", 0, 0, W, 64, "content-delta", 0, 2, null) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + val packed = ByteArray(STRIDE * H) + BmpUtil.pack4bppFromGray8(pixels, W, 64).copyInto(packed) + assertTrue(s.shownOnBoth(packed), s.tail()) + s.glasses.lock.withLock { + val rects = s.glasses.leftArm.rects.drop(rectsBefore) + assertTrue(rects.isNotEmpty() && rects.all { it[2] * it[3] < 64 * 16 }, "tight rects: " + rects.map { it.toList() }) + assertTrue(s.glasses.leftArm.wireBytes - first < first, "${s.glasses.leftArm.wireBytes - first} after $first") + } + } finally { + s.core.disconnect() + } + } + + @Test + fun anUnchangedFrameSendsNothing() { + val s = G1Session() + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + s.submit(1, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + val before = s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.size } + s.core.submitSurfaceFrame(ArrayByteReader(s.pixels(1)), "s", 0, 0, W, 64, "content-again", 0, 2, null) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + assertEquals(before, s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.size }) + } finally { + s.core.disconnect() + } + } + + @Test + fun aNackReplaysFromAResetStreamAndTheFrameStillArrives() { + val s = G1Session() + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + s.glasses.lock.withLock { s.glasses.rightArm.nackNext = true } + s.submit(2, 1) + assertTrue(awaitTrue(8_000) { s.displayedMatchesDesired() }, "never displayed:\n" + s.tail()) + assertTrue(s.shownOnBoth(s.expected(2)), s.tail()) + assertFalse(s.glasses.lock.withLock { s.glasses.rightArm.nackNext }) + } finally { + s.core.disconnect() + } + } + + @Test + fun gesturesWearAndBatteryReachTheListener() { + val s = G1Session() + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_TAP) + s.glasses.input(RIGHT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_TAP) + s.glasses.input(RIGHT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_DOUBLE_TAP) + s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_LONG_START) + s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_LONG_END) + assertEquals( + listOf( + "sys-event:${BleProtocol.EVENT_SCROLL_TOP}:${BleProtocol.EVENT_SOURCE_GLASSES_L}", + "sys-event:${BleProtocol.EVENT_SCROLL_BOTTOM}:${BleProtocol.EVENT_SOURCE_GLASSES_R}", + "sys-event:${BleProtocol.EVENT_CLICK}:${BleProtocol.EVENT_SOURCE_GLASSES_R}", + "sys-event:${BleProtocol.EVENT_DOUBLE_CLICK}:${BleProtocol.EVENT_SOURCE_GLASSES_L}", + ), + s.listener.events, + ) + // The first props poll tells battery and wear; the pair reads its lower arm. + assertTrue(awaitTrue(3_000) { s.listener.batteries.contains("80/0") }, s.listener.batteries.toString()) + assertTrue(awaitTrue(3_000) { s.listener.wear.contains(true) }, s.listener.wear.toString()) + s.glasses.input(LEFT, G1Protocol.TRIGGER_BATTERY, 55) + assertTrue(awaitTrue(3_000) { s.listener.batteries.contains("55/0") }, s.listener.batteries.toString()) + } finally { + s.core.disconnect() + } + } + + @Test + fun blankingHidesThePanelsAndWakingIsADelta() { + val s = G1Session() + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + s.submit(1, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + val wire = s.glasses.lock.withLock { s.glasses.leftArm.wireBytes } + val draws = s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.count { it == CFW_MSG_DRAW_CALLS } } + + s.core.setScreenBlanked(true) + assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { !s.glasses.leftArm.visible && !s.glasses.rightArm.visible } }, s.tail()) + assertTrue(s.shownOnBoth(s.expected(1)), "the arms keep the picture for the wake") + assertFalse(s.glasses.lock.withLock { s.glasses.leftArm.panelOn }) + + // In the dark a tap is for the Glanceboard and a double tap wakes, as on a G2. + s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_TAP) + s.glasses.input(RIGHT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_DOUBLE_TAP) + assertEquals( + listOf("sys-event:${BleProtocol.EVENT_CLICK}:${BleProtocol.EVENT_SOURCE_GLASSES_L}", + "display-wake:${BleProtocol.EVENT_DOUBLE_CLICK}:0"), + s.listener.events, + ) + + s.core.setScreenBlanked(false) + assertTrue(awaitTrue(5_000) { + s.glasses.lock.withLock { s.glasses.leftArm.visible && s.glasses.leftArm.panelOn && s.glasses.rightArm.panelOn } + }, "the panels must come back with a PRESENT:\n" + s.tail()) + assertEquals(draws, s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.count { it == CFW_MSG_DRAW_CALLS } }, + "the same picture needs no pixels") + assertTrue(s.glasses.lock.withLock { s.glasses.leftArm.wireBytes } - wire < 256) + } finally { + s.core.disconnect() + } + } + + @Test + fun bothArmsInTheCaseDarkenThePanelsAndStopFrames() { + val s = G1Session() + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + s.submit(1, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + s.glasses.input(LEFT, G1Protocol.TRIGGER_CASE, 1) + assertFalse(s.core.monitor.withLock { s.core.chargingMode }, "one arm isn't the pair") + s.glasses.input(RIGHT, G1Protocol.TRIGGER_CASE, 1) + assertTrue(awaitTrue(3_000) { s.listener.phases.contains("charging") }, s.listener.phases.toString()) + assertTrue(awaitTrue(3_000) { s.glasses.lock.withLock { !s.glasses.leftArm.visible && !s.glasses.rightArm.visible } }, s.tail()) + } finally { + s.core.disconnect() + } + } + + @Test + fun anArmThatCannotBondParksWithInstructions() { + val s = G1Session() + s.glasses.pairingRefused = true + try { + // A short window for the test: the session waits for the OS's pairing dialog. + assertTrue(s.core.start()) + assertTrue(awaitTrue(40_000) { s.listener.phases.contains("unpaired") }, s.listener.phases.toString() + "\n" + s.tail()) + assertTrue(s.listener.lastStatus.contains("case"), s.listener.lastStatus) + assertFalse(s.ready()) + } finally { + s.core.disconnect() + } + } + + @Test + fun firmwareWithoutTheDisplayPathIsIncompatible() { + val s = G1Session() + s.glasses.hasDisplayPath = false + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.listener.phases.contains("incompatible-firmware") }, s.listener.phases.toString() + "\n" + s.tail()) + assertTrue(s.listener.firmware.single().endsWith("|"), s.listener.firmware.toString()) + } finally { + s.core.disconnect() + } + } +} + +class G1ProtocolTest { + @Test + fun packetsCarryARecordWithinTheMtu() { + val record = ByteArray(1000) { it.toByte() } + val packets = G1Protocol.packets(record, 42, 185) + assertTrue(packets.all { it.size <= 182 }) + assertEquals(0x80, packets.first()[0].toInt() and 0xC0) + assertEquals(0x40, packets.last()[0].toInt() and 0xC0) + assertTrue(packets.drop(1).dropLast(1).all { it[0].toInt() == 0 }) + assertTrue(packets.all { it[1].toInt() == 42 }) + assertTrue(record.contentEquals(packets.flatMap { it.drop(2) }.toByteArray())) + val one = G1Protocol.packets(byteArrayOf(1, 2, 3, 4, 5), 7, 247) + assertEquals(1, one.size) + assertEquals(0xC0, one[0][0].toInt() and 0xC0) + } + + @Test + fun theFirmwaresPacketLimitHoldsAtAnyMtu() { + assertEquals(244, G1Protocol.packets(ByteArray(5000), 1, 512).maxOf { it.size }) + } + + @Test + fun eventsAreParsed() { + val ack = ByteArray(9) + byteArrayOf(1, 9, 0, 0, 2, 0x34, 0x12, 0x78, 0x56) + ack[0] = G1Protocol.EV_FC_ACK.toByte() + val parsed = assertNotNull(G1Protocol.parseFcAck(ack)) + assertFalse(parsed.nack) + assertEquals(9, parsed.streamId) + assertEquals(2, parsed.lens) + assertEquals(0x1234, parsed.size) + assertEquals(0x5678, parsed.checksum) + ack[9] = 3 + assertTrue(assertNotNull(G1Protocol.parseFcAck(ack)).nack) + ack[9] = 2 + assertNull(G1Protocol.parseFcAck(ack)) + assertNull(G1Protocol.parseFcAck(ByteArray(5))) + + val input = ByteArray(9) + byteArrayOf(1, 0, G1Protocol.TRIGGER_TOUCH.toByte(), 2, 0, 0, 0) + input[0] = G1Protocol.EV_INPUT.toByte() + val parsedInput = assertNotNull(G1Protocol.parseInput(input)) + assertEquals(G1Protocol.TRIGGER_TOUCH, parsedInput.trigger) + assertEquals(2, parsedInput.value) + + val reply = assertNotNull(G1Protocol.parseReply(ByteArray(9).also { it[0] = 0x81.toByte() } + byteArrayOf(7, 0, 42))) + assertEquals(1, reply.op) + assertEquals(7, reply.tag) + assertEquals(42, reply.body[0].toInt()) + } + + @Test + fun helloAndPropsAreParsed() { + val body = ByteArray(35) + body[0] = 5 + body[1] = 0 + body[2] = 5 + body[3] = 62 + body[4] = 1 + body[5] = (2 or 64 or 128).toByte() + val hello = assertNotNull(G1Protocol.parseHello(body)) + assertEquals("0.5.62", hello.version) + assertTrue(hello.leftArm && hello.panelOk && hello.encrypted && hello.inCase) + assertFalse(hello.safeMode) + body[0] = 4 + assertNull(G1Protocol.parseHello(body), "protocol 4 is not this firmware") + + val unknown = byteArrayOf(0, 0, 0, 0x80.toByte(), 7, 0, 0, 0) + val props = assertNotNull(G1Protocol.parseProps(unknown, 2)) + assertEquals(G1Protocol.UNKNOWN, props[0]) + assertEquals(7, props[1]) + assertNull(G1Protocol.parseProps(unknown, 3)) + } + + @Test + fun gesturesMapToWhatTheUiExpects() { + assertEquals(BleProtocol.EVENT_SCROLL_TOP, G1Protocol.gestureEventType(G1Protocol.GESTURE_TAP, true)) + assertEquals(BleProtocol.EVENT_SCROLL_BOTTOM, G1Protocol.gestureEventType(G1Protocol.GESTURE_TAP, false)) + assertEquals(BleProtocol.EVENT_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_DOUBLE_TAP, true)) + assertEquals(BleProtocol.EVENT_DOUBLE_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_TRIPLE_TAP, false)) + assertEquals(BleProtocol.EVENT_DOUBLE_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_LONG_START, true)) + assertNull(G1Protocol.gestureEventType(G1Protocol.GESTURE_LONG_END, true)) + assertEquals(BleProtocol.EVENT_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_TAP, false, dark = true)) + assertEquals(BleProtocol.EVENT_DOUBLE_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_DOUBLE_TAP, false, dark = true)) + } +} + +class G1FramePlannerTest { + private fun noise(seed: Int): ByteArray { + var state = seed + return ByteArray(STRIDE * H) { + state = state * 1103515245 + 12345 + (state ushr 16).toByte() + } + } + + private fun replay(start: ByteArray?, messages: List): ByteArray { + val frame = start?.copyOf() ?: ByteArray(STRIDE * H) + for (m in messages) applyDraw(frame, m) + return frame + } + + @Test + fun aFullFrameOfNoiseFitsTheMessageLimit() { + val next = noise(5) + val messages = G1FramePlanner.plan(null, next, W, H) + assertTrue(messages.size > 1) + assertTrue(messages.all { it.size <= G1FramePlanner.MAX_MESSAGE }, messages.maxOf { it.size }.toString()) + assertTrue(replay(null, messages).contentEquals(next)) + } + + @Test + fun nothingChangedIsEmpty() { + val next = noise(5) + assertTrue(G1FramePlanner.plan(next, next.copyOf(), W, H).isEmpty()) + } + + @Test + fun deltasReconstructTheFrameAtAnyPosition() { + val before = noise(5) + for ((x, y, w, h) in listOf(listOf(0, 0, 1, 1), listOf(639, 479, 1, 1), listOf(101, 51, 33, 17), listOf(0, 100, 640, 3), listOf(300, 0, 2, 480))) { + val next = before.copyOf() + for (yy in y until y + h) for (xx in x until x + w) setNibble(next, xx, yy, 15 - nibble(next, xx, yy)) + val messages = G1FramePlanner.plan(before, next, W, H) + assertTrue(messages.isNotEmpty()) + assertTrue(replay(before, messages).contentEquals(next), "rect $x,$y ${w}x$h") + } + // Two far-apart changes + val next = before.copyOf() + setNibble(next, 3, 3, 15 - nibble(next, 3, 3)) + setNibble(next, 600, 440, 15 - nibble(next, 600, 440)) + assertTrue(replay(before, G1FramePlanner.plan(before, next, W, H)).contentEquals(next)) + } +} + +class G1ShellSceneTest { + @Test + fun aSceneWithNoLayersIsTheScreen() { + val screen = ByteArray(STRIDE * H) + assertTrue(ShellScene.EMPTY.composed(screen, W, H, false) === screen) + assertFalse(ShellScene.EMPTY.hasStereoDepth) + } + + @Test + fun depthShiftsEachLensItsOwnWay() { + val screen = ByteArray(STRIDE * H) + setNibble(screen, 100, 50, 9) + val scene = ShellScene(emptyList(), screenDepth = 2) + assertTrue(scene.hasStereoDepth) + val left = scene.composed(screen, W, H, false) + val right = scene.composed(screen, W, H, true) + assertEquals(9, nibble(left, 101, 50), "depth +2 moves the left lens +1") + assertEquals(9, nibble(right, 99, 50), "and the right lens -1") + assertEquals(0, nibble(left, 100, 50)) + assertEquals(9, nibble(screen, 100, 50), "the screen itself is left alone") + } +} diff --git a/tests/pairing-candidates.test.cjs b/tests/pairing-candidates.test.cjs index 50d860fe..b0168817 100644 --- a/tests/pairing-candidates.test.cjs +++ b/tests/pairing-candidates.test.cjs @@ -306,3 +306,58 @@ test("a RayNeo iO is its own candidate, never half of a G2 pair", () => { assert.equal(row.canSelect, true); assert.equal(row.isPreviouslyPaired, true); }); + +// --------------------------------------------------------------------------- +// Even G1 +// --------------------------------------------------------------------------- + +const G1_SERIAL = "S110LABC030139"; +const g1Arm = (name, address, manufacturerData) => ({ + address, name, manufacturerData, rssi: -50, txPower: null, connectable: true, bonded: false, source: "scan", seenAtMs: 1000, +}); +const g1v0Arm = (side, address) => g1Arm(`G1v0_${side}`, address, "ffff0104" + ascii(G1_SERIAL)); + +test("G1 arms on g1v0 join on the frame serial and can be selected", () => { + const aggregator = new DiscoveryAggregator(); + aggregator.ingest(g1v0Arm("L", "F4:27:E9:CA:E8:3F")); + aggregator.ingest(g1v0Arm("R", "CD:EB:89:BF:E9:EC")); + const [pair, ...rest] = aggregator.pairs(); + assert.equal(rest.length, 0); + assert.equal(pair.completeness, "complete"); + assert.equal(pair.g1Firmware, "g1v0"); + assert.equal(pair.identity, null); + const row = glassesRow(pair); + assert.equal(row.modelTitle, "Even Realities G1"); + assert.equal(row.canSelect, true); + assert.match(row.armsSummary, /case/); +}); + +test("G1 arms on Even's firmware show up but can't be selected", () => { + const aggregator = new DiscoveryAggregator(); + aggregator.ingest(g1Arm("Even G1_70_L_EF50E5", "C0:66:16:EF:50:E5", "02" + ascii(G1_SERIAL))); + aggregator.ingest(g1Arm("Even G1_70_R_CBE689", "E4:46:BA:CB:E6:89", "01" + ascii(G1_SERIAL))); + const [pair] = aggregator.pairs(); + assert.equal(pair.g1Firmware, "stock"); + assert.equal(pair.completeness, "complete"); + const row = glassesRow(pair); + assert.equal(row.canSelect, false); + assert.match(row.armsSummary, /computer/); +}); + +test("a G1 pair with one arm in safe mode can't be selected", () => { + const aggregator = new DiscoveryAggregator(); + aggregator.ingest(g1v0Arm("L", "F4:27:E9:CA:E8:3F")); + aggregator.ingest(g1Arm("G1v0S_R", "CD:EB:89:BF:E9:EC", "ffff0104" + ascii(G1_SERIAL))); + const [pair] = aggregator.pairs(); + assert.equal(pair.g1Firmware, "g1v0-safe"); + assert.equal(glassesRow(pair).canSelect, false); +}); + +test("G2 pairs carry no G1 firmware", () => { + const aggregator = new DiscoveryAggregator(); + aggregator.ingest(arm("left", "S110LABC030139", "EC:D7:82:69:3C:CB", -50)); + aggregator.ingest(arm("right", "S110LABC030139", "D0:7A:47:82:09:67", -50)); + const pairs = aggregator.pairs(); + assert.equal(pairs.length, 1); + assert.equal(pairs[0].g1Firmware, undefined); +}); From 345ba36c33af45b3e3e6b9d4cdfed4459de9d4d6 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Fri, 6 Nov 2026 01:44:37 -0800 Subject: [PATCH 08/34] G1: Microphone, light sensor, accelerometer, bandwidth benchmark, wear detection --- app/apps/compass/compass-app.ts | 17 +- app/g2/brightness-curve.ts | 6 + app/ui/dashboard-settings.ts | 7 +- .../kotlin/com/faceclaw/app/g1/G1Protocol.kt | 110 +++++++- .../session/GlassesSessionControls.kt | 5 +- .../g2protocol/session/GlassesSessionCore.kt | 18 +- .../g2protocol/session/GlassesSessionG1.kt | 241 ++++++++++++++++- tests/brightness-curve.test.cjs | 5 +- tests/compass-readout.test.cjs | 14 +- tests/compass-texture-cache.test.cjs | 1 + .../kotlin/com/faceclaw/app/G1SessionTest.kt | 243 +++++++++++++++++- 11 files changed, 635 insertions(+), 32 deletions(-) diff --git a/app/apps/compass/compass-app.ts b/app/apps/compass/compass-app.ts index 27cb1303..9559ea42 100644 --- a/app/apps/compass/compass-app.ts +++ b/app/apps/compass/compass-app.ts @@ -10,6 +10,7 @@ import { type CompassDiagnostics, } from "../../native/compass"; import { wrapText } from "../../graphics/textwrap"; +import { glassesTypeSetting } from "../../ui/dashboard-settings"; import { type InputEvent } from "../../ui/gestures"; import { type Layer, type LayerContext } from "../../ui/layers"; import { lineStep } from "../../ui/metrics"; @@ -151,6 +152,7 @@ class CompassLayer implements Layer { } private statusText(): string { + if (noCompassSensor()) return "These glasses have no compass sensor"; if (this.firmwareStatus !== null) return this.firmwareStatus; if (!this.enabled) return "Compass paused"; if (this.rawHeading === null) return "Waiting for compass data…"; @@ -206,8 +208,10 @@ class CompassLayer implements Layer { image.drawText(small, Math.round(cx - small.measureText(line) / 2), y, line, 125); y += smallStep; } - const accuracyText = magneticAccuracyText(this.diagnostics); - image.drawText(small, width - ACCURACY_RIGHT_PAD - small.measureText(accuracyText), ACCURACY_TOP_PAD, accuracyText, 175); + if (!noCompassSensor()) { + const accuracyText = magneticAccuracyText(this.diagnostics); + image.drawText(small, width - ACCURACY_RIGHT_PAD - small.measureText(accuracyText), ACCURACY_TOP_PAD, accuracyText, 175); + } return image; } @@ -216,10 +220,15 @@ class CompassLayer implements Layer { // "Uncalibrated" prompt advertises, and re-calibrating is a normal thing to // want once the glasses have been taken off and put back on. handleInput(event: InputEvent, ctx: LayerContext): void { - if (event.type === "click") this.openCalibration(ctx); + if (event.type === "click" && !noCompassSensor()) this.openCalibration(ctx); } } +/** A G1 has an accelerometer and a gyroscope, but no magnetometer. */ +function noCompassSensor(): boolean { + return glassesTypeSetting.get() === "g1"; +} + export function createCompassAppWindow(options: InProcessAppOptions): InProcessWindow { let requestRender = () => {}; const layer = new CompassLayer(() => requestRender()); @@ -231,7 +240,7 @@ export function createCompassAppWindow(options: InProcessAppOptions): InProcessW icon: "compass", closeable: true, actions: options.actions, - menuItems: () => [ + menuItems: () => noCompassSensor() ? [] : [ { label: "Calibrate", onSelect: (ctx) => { diff --git a/app/g2/brightness-curve.ts b/app/g2/brightness-curve.ts index 357c76de..4f215640 100644 --- a/app/g2/brightness-curve.ts +++ b/app/g2/brightness-curve.ts @@ -8,6 +8,12 @@ const PREVIOUS_DEFAULT_CURVE = "0:0,1:10,10:30,100:65,1000:100"; */ export const RAYNEO_IO_BRIGHTNESS_CURVE = "0:0,3:11,10:26,200:26,300:41,600:56,1000:70,4000:93,5000:100"; +/** + * An Even G1's OPT3007 also reads lux (centilux on the wire). These knots are the stock firmware's table: levels 0, 10, 25, + * 41 and 42 of 42 at 0, 50, 200, 1000 and 2000 lux (g1_firmware/docs/VM.md §6.7). + */ +export const G1_BRIGHTNESS_CURVE = "0:0,50:24,200:60,1000:98,2000:100"; + /** Percent of the configured range; defaults (20–100) give 20/26/46/100. */ export function brightnessCurveError(value: string): string | null { const pairs = value.split(",").map(part => part.trim().split(":")); diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index ac40fdf4..212945e8 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -1,6 +1,6 @@ import { normalizeNightscoutThreshold, type NightscoutThresholds } from "../apps/nightscout/nightscout-alerts"; import { GESTURE_DOUBLE_CLICK, InputEvent } from "./gestures"; -import { DEFAULT_BRIGHTNESS_CURVE, RAYNEO_IO_BRIGHTNESS_CURVE, normalizeBrightnessCurve, brightnessCurveError } from "../g2/brightness-curve"; +import { DEFAULT_BRIGHTNESS_CURVE, G1_BRIGHTNESS_CURVE, RAYNEO_IO_BRIGHTNESS_CURVE, normalizeBrightnessCurve, brightnessCurveError } from "../g2/brightness-curve"; import { getBooleanSetting, getStringSetting, @@ -600,7 +600,10 @@ export const autoBrightnessMaxSetting = new ConfigSettingEnum({ export const autoBrightnessCurveSetting = new ConfigSettingString({ id: "autoBrightnessCurve", label: "Auto light curve", storageKey: "display.autoBrightnessCurve", defaultValue: DEFAULT_BRIGHTNESS_CURVE, normalize: normalizeBrightnessCurve, validate: brightnessCurveError, - dynamicDefault: () => (glassesTypeSetting.get() === "rayneo-io" ? RAYNEO_IO_BRIGHTNESS_CURVE : undefined), + dynamicDefault: () => { + const glasses = glassesTypeSetting.get(); + return glasses === "rayneo-io" ? RAYNEO_IO_BRIGHTNESS_CURVE : glasses === "g1" ? G1_BRIGHTNESS_CURVE : undefined; + }, description: "2–16 lux:percent pairs, separated by commas. Percent is within your minimum–maximum range. Start at 0:0, end at 100%, and increase lux without decreasing percent. Incomplete edits stay in the preview; brightness keeps using the last valid curve.", }); /** The screen on/off fade at Normal speed. */ diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt index 1df1a24a..93770653 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt @@ -22,9 +22,13 @@ object G1Protocol { const val OP_HELLO = 0x01 const val OP_HEALTH_OK = 0x07 const val OP_PROPS = 0x0A + const val OP_MIC = 0x13 const val OP_EVENTS = 0x14 const val OP_FC_INFO = 0x1D + const val OP_PROP_SET = 0x1E + const val EV_NOTICE = 0x05 + const val EV_MIC_DATA = 0x06 const val EV_INPUT = 0x07 const val EV_FC_ACK = 0x08 private const val EV_REPLY = 0x80 @@ -34,16 +38,33 @@ object G1Protocol { private const val MAX_PACKET = 244 private const val PACKET_HEADER = 2 + /** The light sensor converts only while something uses it, as this bit of `EVENTS` does; the left arm has none. */ + const val TRIGGER_LIGHT = 4 const val TRIGGER_BATTERY = 5 const val TRIGGER_CASE = 6 const val TRIGGER_WEAR = 7 const val TRIGGER_TOUCH = 8 - const val EVENTS_MASK = (1 shl TRIGGER_BATTERY) or (1 shl TRIGGER_CASE) or (1 shl TRIGGER_WEAR) or (1 shl TRIGGER_TOUCH) + const val EVENTS_MASK = (1 shl TRIGGER_LIGHT) or (1 shl TRIGGER_BATTERY) or (1 shl TRIGGER_CASE) or + (1 shl TRIGGER_WEAR) or (1 shl TRIGGER_TOUCH) + + const val NOTICE_MIC_STOPPED = 5 + const val MIC_STOPPED_LEASE = 3 + const val NOTICE_GUARD = 7 const val PROP_BATT_PCT = 0x11 const val PROP_CHARGE = 0x12 const val PROP_IN_CASE = 0x13 const val PROP_WORN = 0x14 + const val PROP_ACC_X = 0x18 + const val PROP_ACC_Y = 0x19 + const val PROP_ACC_Z = 0x1A + /** 0.01 lux, on the right arm, while the panel is on. */ + const val PROP_LIGHT = 0x1C + const val PROP_IMU_RATE = 0x28 + const val PROP_BRIGHTNESS_MAX = 0x29 + const val IMU_RATE_IDLE = 13 + const val IMU_RATE_STREAM = 26 + const val BRIGHTNESS_LEVEL_MAX = 42 /** A property without a value yet (VM_UNKNOWN). */ const val UNKNOWN = Int.MIN_VALUE @@ -78,6 +99,13 @@ object G1Protocol { fun eventsRequest(mask: Int): ByteArray = byteArrayOf(mask.toByte(), (mask ushr 8).toByte()) + /** `PROP_SET` (0.5.63+): what SYS_WRITE does, for a host that runs no instructions. */ + fun propSet(id: Int, value: Int): ByteArray = + byteArrayOf(id.toByte(), value.toByte(), (value ushr 8).toByte(), (value ushr 16).toByte(), (value ushr 24).toByte()) + + /** On, or a renewal of the lease; 32 kbps, the rate [Lc3PacketFramer] decodes. */ + fun micRequest(on: Boolean): ByteArray = byteArrayOf(if (on) 1 else 0, 0) + /** An event's type, or -1 for bytes too short to be one. */ fun eventType(data: ByteArray): Int = if (data.size >= EVENT_HEADER) data[0].toInt() and 255 else -1 @@ -106,6 +134,38 @@ object G1Protocol { return Input(data[EVENT_HEADER + 2].toInt() and 255, u32(data, EVENT_HEADER + 3)) } + class Notice(@JvmField val kind: Int, @JvmField val body: ByteArray) + + fun parseNotice(data: ByteArray): Notice? { + if (eventType(data) != EV_NOTICE || data.size < EVENT_HEADER + 1) return null + return Notice(data[EVENT_HEADER].toInt() and 255, data.copyOfRange(EVENT_HEADER + 1, data.size)) + } + + /** + * What the arm's light reading looks like to [BrightnessPolicy] and the Developer app: a live passive poll in the + * G2 custom firmware's report (settings field 105), whose value counts tenths of a lux. + */ + fun alsReport(centilux: Int, brightness: Int, tickMs: Long): ByteArray { + val report = ByteArray(24) + report[0] = 0x41 + report[1] = 0x4c + report[2] = 1 + report[3] = 2 // a poll + report[4] = 0x0b // opened, passive, read ok + report[5] = 3 // polling + val tenths = centilux / 10 + for (i in 0..3) { + report[6 + i] = (tenths ushr (8 * i)).toByte() + report[10 + i] = (tenths ushr (8 * i)).toByte() + report[20 + i] = (tickMs ushr (8 * i)).toByte() + } + report[14] = brightness.toByte() + report[16] = brightness.toByte() + report[18] = 0 + report[19] = 4 // scale 1.0 in Q10 + return report + } + class Hello( @JvmField val version: String, @JvmField val leftArm: Boolean, @@ -113,13 +173,15 @@ object G1Protocol { @JvmField val panelOk: Boolean, @JvmField val encrypted: Boolean, @JvmField val inCase: Boolean, + /** `MIC` captures here: the right arm. */ + @JvmField val mic: Boolean, ) fun parseHello(body: ByteArray): Hello? { if (body.size < 7 || body[0].toInt() != 5) return null val flags = body[5].toInt() and 255 return Hello("${body[1].toInt() and 255}.${body[2].toInt() and 255}.${body[3].toInt() and 255}", - body[4].toInt() == 1, flags and 1 != 0, flags and 2 != 0, flags and 64 != 0, flags and 128 != 0) + body[4].toInt() == 1, flags and 1 != 0, flags and 2 != 0, flags and 64 != 0, flags and 128 != 0, body[6].toInt() and 4 != 0) } /** The display path's version, or -1 for a body that isn't FC_INFO's. */ @@ -142,7 +204,51 @@ object G1Protocol { else -> null } + /** `MIC_DATA`'s frames: the counter of the first one, how many, and where they start in [data]. */ + fun micFrames(data: ByteArray): Triple? { + if (eventType(data) != EV_MIC_DATA || data.size < EVENT_HEADER + 3) return null + val count = data[EVENT_HEADER + 2].toInt() and 255 + val start = EVENT_HEADER + 3 + return if (data.size - start < count * Lc3PacketFramer.FRAME_BYTES) null else Triple(u16(data, EVENT_HEADER), count, start) + } + private fun u16(b: ByteArray, p: Int): Int = (b[p].toInt() and 255) or ((b[p + 1].toInt() and 255) shl 8) private fun u32(b: ByteArray, p: Int): Int = u16(b, p) or (u16(b, p + 2) shl 16) } + +/** + * A G1's microphone frames as the packets [Lc3PacketFramer] takes from a G2: five 10 ms LC3 frames, then the two values + * of the G2's stereo capture (a G1 has one mic: zero) and a packet counter. A gap loses the part-filled packet, and the + * counter tells the decoder to conceal it. + */ +class G1MicAssembler { + private val frames = ByteArray(Lc3PacketFramer.LC3_BYTES) + private var have = 0 + private var firstCounter = 0 + private var nextCounter = -1 + + fun reset() { + have = 0 + nextCounter = -1 + } + + fun ingest(first: Int, count: Int, data: ByteArray, start: Int, emit: (ByteArray) -> Unit) { + val size = Lc3PacketFramer.FRAME_BYTES + for (i in 0 until count) { + val counter = (first + i) and 0xffff + if (counter != nextCounter) have = 0 + if (have == 0) firstCounter = counter + data.copyInto(frames, have * size, start + i * size, start + (i + 1) * size) + have++ + nextCounter = (counter + 1) and 0xffff + if (have == Lc3PacketFramer.FRAMES_PER_PACKET) { + val packet = ByteArray(Lc3PacketFramer.PACKET_BYTES) + frames.copyInto(packet) + packet[Lc3PacketFramer.COUNTER_OFFSET] = (firstCounter / Lc3PacketFramer.FRAMES_PER_PACKET).toByte() + emit(packet) + have = 0 + } + } + } +} diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt index 99edbcee..c39d7aa3 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt @@ -86,13 +86,16 @@ internal fun GlassesSessionCore.enqueueBenchmarkMessageLocked() { kotlin.random.Random.nextBytes(payload) payload[0] = CFW_MSG_DIAGNOSTICS.toByte() // CFW diagnostic-control mode... payload[1] = 0x7f.toByte() // ...with an unused sub-op: acked, no effect + // A G1's arms are two links and every frame goes down both, so the run alternates between them. + val leftArm = if (isG1) benchmarkMessageCounter++ % 2 == 0 else connectionOptions.sendImagesToLeft val message = messageBuilder.imagePayload( "bandwidth", DASHBOARD_TILE, nextMapSessionId(), payload, "bandwidth no-op " + payload.size + "B", - connectionOptions.sendImagesToLeft) + leftArm) + if (isG1) message.cfwRequiredLenses = if (leftArm) G1Timings.LENS_LEFT else G1Timings.LENS_RIGHT val payloadBytes = payload.size // Logical custom-message bytes; excludes length tag and packet framing. val wireBytes = message.message.size diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index d7ee3663..8a39dacc 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -438,6 +438,7 @@ class GlassesSessionCore( internal var benchmarkLastAckAtMs = 0L internal var benchmarkEndAtMs = 0L // 0 while running; set when the run drains internal var benchmarkMessagesSent = 0 + internal var benchmarkMessageCounter = 0 internal var benchmarkMessagesAcked = 0 internal var benchmarkTimeouts = 0 internal var benchmarkPayloadBytesAcked = 0L @@ -693,10 +694,7 @@ class GlassesSessionCore( } // The iO's packets are Opus from its remote audio stream (see ioStartAudioCapture). if (isIo) return ioStartAudioCapture(listener) - if (isG1) { - logLine("skip G1 mic: not in this version") - return false - } + if (isG1) return g1StartAudioCapture(listener) var magic = 0 monitor.withLock { if (!running || !sessionReady || shutdownRequested || !fixedLayoutCreated) { @@ -715,7 +713,7 @@ class GlassesSessionCore( fun stopG2AudioCapture() { if (isIo) return ioStopAudioCapture() - if (isG1) return + if (isG1) return g1StopAudioCapture() var magic = 0 monitor.withLock { audioPacketListener = null @@ -918,6 +916,7 @@ class GlassesSessionCore( * (ignored on disable). */ fun setImuReportEnabled(enable: Boolean, reportFrq: Int) { + if (isG1) return g1SetImuReport(enable) monitor.withLock { if (!running || !sessionReady) { logLine("skip IMU " + (if (enable) "enable" else "disable") + "; session not ready") @@ -1275,6 +1274,11 @@ class GlassesSessionCore( /** Request one CFW ambient-light report (image-handler mode 16 op 0). */ fun queryAmbientLight() { monitor.withLock { + if (isG1) { + g1.lastLightAtMs = 0 + interruptibleSleep.interrupt() + return + } enqueueAmbientLightControlLocked(byteArrayOf(CFW_MSG_AMBIENT_LIGHT.toByte(), 0.toByte()), "als query", false) } interruptibleSleep.interrupt() @@ -1357,7 +1361,7 @@ class GlassesSessionCore( * queued (no session, or a malformed record). */ fun sendFaceclawMicControl(record: ByteArray?, label: String, rightTemple: Boolean, leftTemple: Boolean): Boolean { - if (record == null || record.size < 4) { + if (!isG2 || record == null || record.size < 4) { return false } monitor.withLock { @@ -1825,7 +1829,7 @@ class GlassesSessionCore( val sleepMs = driveSession() if (sleepMs > 0) { - interruptibleSleep.sleep(sleepMs) + interruptibleSleep.sleep(if (isG1) minOf(sleepMs, g1MaxSleepMs()) else sleepMs) } } catch (t: Throwable) { if (!running) { diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt index 3f692742..01f10c07 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt @@ -41,6 +41,20 @@ internal class G1SessionState { /** The panel may be blank: the next update ends in PRESENT even with no pixels to send. */ var presentPending = false + /** What a PROPS request asked for, by arm and tag: a reply doesn't repeat it. */ + val propRequests = HashMap() + /** `PROP_SET`s for the worker thread to write: arm to body. */ + val pendingPropSets = ArrayList>() + var lastLightAtMs = 0L + /** The last reading that made it to the log, in 0.01 lux. */ + var loggedLight = -1 + /** IMU samples are polled this often while someone wants them; 0: nobody does. */ + var imuPeriodMs = 0L + var lastImuAtMs = 0L + var micOn = false + var lastMicRenewAtMs = 0L + val mic = G1MicAssembler() + fun nextTag(): Int { tag = tag % 255 + 1 return tag @@ -51,6 +65,13 @@ internal class G1SessionState { replies.clear() lastPropsAtMs = 0 presentPending = true + propRequests.clear() + pendingPropSets.clear() + lastLightAtMs = 0 + lastImuAtMs = 0 + micOn = false + lastMicRenewAtMs = 0 + mic.reset() } } @@ -60,11 +81,22 @@ internal object G1Timings { /** The OS may be showing its pairing dialog. */ const val PAIRING_MS = 30_000 const val PROPS_MS = 60_000L + /** Well inside the arm's 2 s lease. */ + const val MIC_RENEW_MS = 1_000L + /** The sensor converts in 800 ms. */ + const val LIGHT_DEMO_MS = 800L + const val LIGHT_AUTO_MS = 1_000L + const val LIGHT_MANUAL_MS = 5_000L + /** The G2's IMU rate is a pace code with no meaning here, and a poll is one round trip. */ + const val IMU_POLL_MS = 50L + const val IDLE_WAKE_MS = 500L const val LENS_LEFT = 1 const val LENS_RIGHT = 2 } private val G1_PROPS = intArrayOf(G1Protocol.PROP_BATT_PCT, G1Protocol.PROP_CHARGE, G1Protocol.PROP_IN_CASE, G1Protocol.PROP_WORN) +private val G1_LIGHT = intArrayOf(G1Protocol.PROP_LIGHT) +private val G1_IMU = intArrayOf(G1Protocol.PROP_ACC_X, G1Protocol.PROP_ACC_Y, G1Protocol.PROP_ACC_Z) internal val GlassesSessionCore.isG1: Boolean get() = glassesType == GlassesType.G1 @@ -75,6 +107,8 @@ internal fun g1SupportsMessage(message: OutboundMessage): Boolean { if (message.sid != CfwTransport.SID || message.message.isEmpty()) return false return when (message.message[0].toInt() and CFW_MSG_TYPE_MASK) { CFW_MSG_DRAW_CALLS, CFW_MSG_PRESENT, CFW_MSG_BRIGHTNESS -> true + // The bandwidth benchmark's no-op: the firmware acknowledges what it doesn't know. + CFW_MSG_DIAGNOSTICS -> message.kind == "bandwidth" else -> false } } @@ -123,23 +157,121 @@ private fun GlassesSessionCore.g1Control(arm: Int, op: Int, body: ByteArray = By throw IllegalStateException("no reply to control $op from the " + (if (arm == 0) "left" else "right") + " arm") } -private fun GlassesSessionCore.g1RequestProps(arm: Int) { - val tag = monitor.withLock { g1.nextTag() } - g1WriteControl(g1ArmAddress(arm), G1Protocol.OP_PROPS, tag, ByteArray(G1_PROPS.size) { G1_PROPS[it].toByte() }) +private fun GlassesSessionCore.g1RequestProps(arm: Int, ids: IntArray) { + val tag = monitor.withLock { + val tag = g1.nextTag() + g1.propRequests[arm * 256 + tag] = ids + tag + } + g1WriteControl(g1ArmAddress(arm), G1Protocol.OP_PROPS, tag, ByteArray(ids.size) { ids[it].toByte() }) } -/** Nothing here keeps a lease; this only refreshes the battery. Worker thread, outside the monitor. */ +/** + * The firmware keeps no session of its own for most of this: the worker polls what it wants to know, keeps the + * microphone's lease and writes the properties that were asked for. Worker thread, outside the monitor. + */ internal fun GlassesSessionCore.g1Maintain() { - val due = monitor.withLock { + var status = false + var mic: Boolean? = null + var light = false + var imu = false + var sets: List> = emptyList() + monitor.withLock { + if (!sessionReady) return val now = now() - val due = sessionReady && now - g1.lastPropsAtMs >= G1Timings.PROPS_MS - if (due) g1.lastPropsAtMs = now - due + if (now - g1.lastPropsAtMs >= G1Timings.PROPS_MS) { + status = true + g1.lastPropsAtMs = now + } + if (audioCaptureActive) { + if (now - g1.lastMicRenewAtMs >= G1Timings.MIC_RENEW_MS) { + mic = true + g1.micOn = true + g1.lastMicRenewAtMs = now + } + } else if (g1.micOn) { + mic = false + g1.micOn = false + } + // The sensor only reads while the panel is on; a dark panel keeps the last filtered value. + val interval = if (brightnessDemoPolling) G1Timings.LIGHT_DEMO_MS + else if (brightnessPolicy.automatic) G1Timings.LIGHT_AUTO_MS else G1Timings.LIGHT_MANUAL_MS + if (brightnessSentVisible == true && !chargingMode && !shutdownRequested && now - g1.lastLightAtMs >= interval) { + light = true + g1.lastLightAtMs = now + } + if (g1.imuPeriodMs > 0 && now - g1.lastImuAtMs >= g1.imuPeriodMs) { + imu = true + g1.lastImuAtMs = now + } + if (g1.pendingPropSets.isNotEmpty()) { + sets = g1.pendingPropSets.toList() + g1.pendingPropSets.clear() + } } - if (due) { - g1RequestProps(0) - g1RequestProps(1) + if (status) { + g1RequestProps(0, G1_PROPS) + g1RequestProps(1, G1_PROPS) } + mic?.let { on -> + val tag = monitor.withLock { g1.nextTag() } + g1WriteControl(rightAddress, G1Protocol.OP_MIC, tag, G1Protocol.micRequest(on)) + } + if (light) g1RequestProps(1, G1_LIGHT) + if (imu) g1RequestProps(1, G1_IMU) + for ((arm, body) in sets) { + val tag = monitor.withLock { g1.nextTag() } + g1WriteControl(g1ArmAddress(arm), G1Protocol.OP_PROP_SET, tag, body) + } +} + +/** The longest the session worker may sleep and keep up with [g1Maintain]. */ +internal fun GlassesSessionCore.g1MaxSleepMs(): Long = + monitor.withLock { if (g1.imuPeriodMs > 0) g1.imuPeriodMs else G1Timings.IDLE_WAKE_MS } + +/** + * The right arm's microphone: 16 kHz mono LC3, in the packets the G2's decoder takes. The arm stops it 2 s after the last + * renewal and at a disconnection; meanwhile it shows its indicator in a corner of the panel (VM.md §6.5). + */ +internal fun GlassesSessionCore.g1StartAudioCapture(listener: FaceclawAudioPacketListener): Boolean { + monitor.withLock { + if (!running || !sessionReady || shutdownRequested) { + logLine("skip G1 mic: session not ready") + return false + } + if (g1.arms[1].hello?.mic != true) { + logLine("skip G1 mic: this arm has no capture") + return false + } + g1.mic.reset() + audioPacketListener = listener + audioCaptureActive = true + g1.lastMicRenewAtMs = 0 + } + interruptibleSleep.interrupt() + return true +} + +internal fun GlassesSessionCore.g1StopAudioCapture() { + monitor.withLock { + audioPacketListener = null + audioCaptureActive = false + } + interruptibleSleep.interrupt() +} + +/** + * There is no magnetometer on a G1, only the accelerometer and gyroscope: x, y, z in g, head frame, from the right arm. + * [enable] raises the sample rate and polls it; [g1MaxSleepMs] follows. + */ +internal fun GlassesSessionCore.g1SetImuReport(enable: Boolean) { + monitor.withLock { + g1.imuPeriodMs = if (enable) G1Timings.IMU_POLL_MS else 0 + g1.lastImuAtMs = 0 + g1.pendingPropSets.add(1 to G1Protocol.propSet(G1Protocol.PROP_IMU_RATE, + if (enable) G1Protocol.IMU_RATE_STREAM else G1Protocol.IMU_RATE_IDLE)) + } + interruptibleSleep.interrupt() } // --------------------------------------------------------------------------------------------- @@ -378,6 +510,8 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { if (events.status != 0) throw IllegalStateException("EVENTS refused: " + events.status) // The arm counts a boot healthy only after a host has said so (VM.md §6.4, safe mode). g1Control(arm, G1Protocol.OP_HEALTH_OK) + // A limit the last session left, when the other eye's panel guard had capped it. + g1Control(arm, G1Protocol.OP_PROP_SET, G1Protocol.propSet(G1Protocol.PROP_BRIGHTNESS_MAX, G1Protocol.BRIGHTNESS_LEVEL_MAX)) } monitor.withLock { sessionReady = true @@ -439,12 +573,23 @@ internal fun GlassesSessionCore.g1OnNotification(address: String, characteristic interruptibleSleep.interrupt() } G1Protocol.EV_INPUT -> g1HandleInput(arm, G1Protocol.parseInput(data) ?: return) + G1Protocol.EV_MIC_DATA -> g1HandleMicData(address, data) + G1Protocol.EV_NOTICE -> g1HandleNotice(arm, G1Protocol.parseNotice(data) ?: return) else -> if (type >= 0x80) { val reply = G1Protocol.parseReply(data) ?: return if (reply.op == G1Protocol.OP_PROPS) { - if (reply.status == 0) G1Protocol.parseProps(reply.body, G1_PROPS.size)?.let { g1HandleProps(arm, it) } + val ids = monitor.withLock { g1.propRequests.remove(arm * 256 + reply.tag) } ?: return + val values = if (reply.status == 0) G1Protocol.parseProps(reply.body, ids.size) else null + if (values != null) g1HandlePropsReply(arm, ids, values) return } + if (reply.op == G1Protocol.OP_MIC) { + if (reply.status != 0) g1MicRefused(reply.status) + return + } + if (reply.op == G1Protocol.OP_PROP_SET && reply.status != 0) { + logLine("G1 PROP_SET refused: " + reply.status + " (firmware before 0.5.63?)") + } monitor.withLock { lastIncomingAtMs = now() g1.replies[arm * 256 + reply.tag] = reply @@ -454,6 +599,73 @@ internal fun GlassesSessionCore.g1OnNotification(address: String, characteristic } } +private fun GlassesSessionCore.g1HandleMicData(address: String, data: ByteArray) { + val (first, count, start) = G1Protocol.micFrames(data) ?: return + val packets = ArrayList(1) + monitor.withLock { g1.mic.ingest(first, count, data, start) { packets.add(it) } } + for (packet in packets) handleRenderNotification(address, packet) +} + +private fun GlassesSessionCore.g1MicRefused(status: Int) { + logWarn("G1 mic refused: status $status (12: no capture, or the link isn't encrypted)") + monitor.withLock { + audioCaptureActive = false + audioPacketListener = null + g1.micOn = false + } +} + +private fun GlassesSessionCore.g1HandleNotice(arm: Int, notice: G1Protocol.Notice) { + when (notice.kind) { + G1Protocol.NOTICE_MIC_STOPPED -> { + val reason = if (notice.body.isNotEmpty()) notice.body[0].toInt() and 255 else 0 + logLine("G1 mic stopped by the arm: reason $reason") + if (reason == G1Protocol.MIC_STOPPED_LEASE) { + // A renewal came late: ask again, the capture still wants it. + monitor.withLock { g1.lastMicRenewAtMs = 0 } + interruptibleSleep.interrupt() + } else { + g1MicRefused(reason) + } + } + G1Protocol.NOTICE_GUARD -> { + if (notice.body.isEmpty()) return + // This arm's panel guard capped its level (a mostly white screen): keep the eyes matched. + val cap = notice.body[0].toInt() and 255 + logLine("G1 panel guard on the " + (if (arm == 0) "left" else "right") + " arm: cap $cap") + monitor.withLock { g1.pendingPropSets.add((1 - arm) to G1Protocol.propSet(G1Protocol.PROP_BRIGHTNESS_MAX, cap)) } + interruptibleSleep.interrupt() + } + } +} + +private fun GlassesSessionCore.g1HandlePropsReply(arm: Int, ids: IntArray, values: IntArray) { + when { + ids === G1_PROPS -> g1HandleProps(arm, values) + ids === G1_LIGHT -> if (values[0] != G1Protocol.UNKNOWN) g1HandleLight(values[0]) + ids === G1_IMU -> if (values.none { it == G1Protocol.UNKNOWN }) { + emitImuData(values[0] / 1000.0, values[1] / 1000.0, values[2] / 1000.0, BleProtocol.EVENT_SOURCE_GLASSES_R) + } + } +} + +/** A reading in the shape of the G2's report, so the brightness policy and the Developer app need nothing new. */ +private fun GlassesSessionCore.g1HandleLight(centilux: Int) { + val report = monitor.withLock { + val logged = g1.loggedLight + if (logged < 0 || kotlin.math.abs(centilux - logged) > maxOf(100, logged / 2)) { + g1.loggedLight = centilux + logLine("G1 light: " + centilux / 100 + " lux") + } + val report = G1Protocol.alsReport(centilux, brightnessPolicy.target, now()) + lastIncomingAtMs = now() + brightnessPolicy.sample(report, lastIncomingAtMs) + report + } + emitAmbientLight(report) + interruptibleSleep.interrupt() +} + private fun GlassesSessionCore.g1HandleInput(arm: Int, input: G1Protocol.Input) { when (input.trigger) { G1Protocol.TRIGGER_TOUCH -> g1HandleGesture(arm, input.value) @@ -498,7 +710,10 @@ private fun GlassesSessionCore.g1HandleProps(arm: Int, values: IntArray, battery if (values[0] != G1Protocol.UNKNOWN) state.battery = values[0] if (values[1] != G1Protocol.UNKNOWN) state.charge = values[1] if (values[2] != G1Protocol.UNKNOWN) state.inCase = values[2] - if (values[3] != G1Protocol.UNKNOWN) state.worn = values[3] + if (values[3] != G1Protocol.UNKNOWN) { + if (values[3] != state.worn) logLine("G1 " + (if (arm == 0) "left" else "right") + " arm: worn " + values[3]) + state.worn = values[3] + } val batteries = g1.arms.map { it.battery }.filter { it >= 0 } val battery = if (batteries.isEmpty()) -1 else batteries.min() diff --git a/tests/brightness-curve.test.cjs b/tests/brightness-curve.test.cjs index 1136e068..3427275a 100644 --- a/tests/brightness-curve.test.cjs +++ b/tests/brightness-curve.test.cjs @@ -1,6 +1,6 @@ const { test } = require('node:test'); const assert = require('node:assert/strict'); -const { normalizeBrightnessCurve, brightnessCurveError, DEFAULT_BRIGHTNESS_CURVE, RAYNEO_IO_BRIGHTNESS_CURVE } = require('../.test-build/app/g2/brightness-curve.js'); +const { normalizeBrightnessCurve, brightnessCurveError, DEFAULT_BRIGHTNESS_CURVE, G1_BRIGHTNESS_CURVE, RAYNEO_IO_BRIGHTNESS_CURVE } = require('../.test-build/app/g2/brightness-curve.js'); test('brightness curve accepts monotone knots and canonicalizes spacing', () => { assert.equal(normalizeBrightnessCurve(' 0:0, 2.5:20,1000:100 '), '0:0,2.5:20,1000:100'); }); @@ -50,6 +50,9 @@ test('an unset curve follows the paired glasses; a chosen one stays', () => { store.set('deviceType', 'rayneo-io'); assert.equal(api.getBrightnessPreferences().curve, RAYNEO_IO_BRIGHTNESS_CURVE); assert.equal(brightnessCurveError(RAYNEO_IO_BRIGHTNESS_CURVE), null); + store.set('deviceType', 'g1'); + assert.equal(api.getBrightnessPreferences().curve, G1_BRIGHTNESS_CURVE); + assert.equal(brightnessCurveError(G1_BRIGHTNESS_CURVE), null); api.autoBrightnessCurveSetting.set('0:0,2:50,8:100'); assert.equal(api.getBrightnessPreferences().curve, '0:0,2:50,8:100'); store.set('deviceType', 'g2'); diff --git a/tests/compass-readout.test.cjs b/tests/compass-readout.test.cjs index 7a801134..05acf06f 100644 --- a/tests/compass-readout.test.cjs +++ b/tests/compass-readout.test.cjs @@ -23,7 +23,7 @@ const font = (size) => BdfFont.parse(fs.readFileSync(path.join(__dirname, `../ap const small = font(18), large = font(32); const diagnostics = { magneticAccuracy: 3, magneticAnomalies: 2, orientationSource: 3, flags: 0x8c, sampleTimeMs: 1234 }; -function compass(width = 576, height = 260) { +function compass(width = 576, height = 260, glasses = 'g2') { let listener, window; class RecordingImage extends graphics.GrayImage { texts = []; @@ -55,6 +55,7 @@ function compass(width = 576, height = 260) { }, '../../ui/shell/shell': { shell: { isWindowVisible: () => true } }, '../../native/location-permissions': { hasLocationPermission: () => false }, + '../../ui/dashboard-settings': { glassesTypeSetting: { get: () => glasses } }, './calibration': calibration, './calibration-layer': {}, './declination': { onDeclinationChanged: () => () => {} }, './heading': { getNorthReference: () => 'magnetic', resolveHeading: (v) => ({ displayDegrees: v }) }, @@ -63,6 +64,7 @@ function compass(width = 576, height = 260) { app.createCompassAppWindow({ onClosed() {} }); return { menu: () => window.menuItems(), paint: () => window.baseLayer.paint(ctx), + tap: () => window.baseLayer.handleInput({ type: 'click' }, ctx), heading: (info) => listener({ command: 15, headingDegrees: 359, diagnostics: info }) }; } @@ -110,3 +112,13 @@ test('calibration readout fits the viewport without overlapping the heading or s } } }); + +test('glasses without a magnetometer say so and offer no calibration', () => { + const app = compass(576, 260, 'g1'); + const image = app.paint(); + assert.ok(image.texts.some((t) => t.text === 'These glasses have no compass sensor')); + assert.equal(calibrationText(image), undefined); + assert.equal(app.menu().length, 0); + // ctx.stack has no push or topMatches here, so opening calibration would throw. + app.tap(); +}); diff --git a/tests/compass-texture-cache.test.cjs b/tests/compass-texture-cache.test.cjs index 740a313e..4326f5ba 100644 --- a/tests/compass-texture-cache.test.cjs +++ b/tests/compass-texture-cache.test.cjs @@ -44,6 +44,7 @@ const compass = load('app/apps/compass/compass-app.ts', { '../../ui/shell/in-process-window': {}, '../../ui/shell/shell': {}, '../../native/location-permissions': {}, + '../../ui/dashboard-settings': { glassesTypeSetting: { get: () => 'g2' } }, './calibration': calibration, './calibration-layer': {}, './compass-rose': rose, diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt index 42032373..ee0af11f 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt @@ -119,6 +119,11 @@ private class FakeG1Arm(val left: Boolean) { var bonded = false var inCase = 0 var battery = 80 + val props = HashMap() + val propSets = ArrayList>() + val micRequests = ArrayList() + var micStatus = 0 + var benchmarkMessages = 0 } private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { @@ -140,6 +145,18 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { core.onNotification(address, G1Ble.EVT_CHAR_UUID, data) } + /** `MIC_DATA` from the right arm: [count] frames, each filled with its counter's low byte. */ + fun micData(first: Int, count: Int) { + val body = ByteArray(3 + count * 40) + body[0] = first.toByte() + body[1] = (first ushr 8).toByte() + body[2] = count.toByte() + for (i in 0 until count) body.fill((first + i).toByte(), 3 + i * 40, 3 + (i + 1) * 40) + event(RIGHT, G1Protocol.EV_MIC_DATA, body) + } + + fun notice(address: String, kind: Int, vararg body: Byte) = event(address, G1Protocol.EV_NOTICE, byteArrayOf(kind.toByte()) + body) + fun input(address: String, trigger: Int, value: Int) { val body = ByteArray(7) body[2] = trigger.toByte() @@ -203,6 +220,7 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { body[3] = 62 body[4] = (if (a.left) 1 else 0).toByte() body[5] = (2 or 64).toByte() + body[6] = (if (a.left) 0 else 4).toByte() reply(address, op, tag, 0, body) } G1Protocol.OP_FC_INFO -> if (hasDisplayPath) { @@ -219,11 +237,35 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { reply(address, op, tag, 0, ByteArray(1)) } G1Protocol.OP_PROPS -> { - val values = lock.withLock { intArrayOf(a.battery, 0, a.inCase, 1) } + val ids = f.drop(2).map { it.toInt() and 255 } + val values = lock.withLock { + ids.map { + when (it) { + G1Protocol.PROP_BATT_PCT -> a.battery + G1Protocol.PROP_CHARGE -> 0 + G1Protocol.PROP_IN_CASE -> a.inCase + G1Protocol.PROP_WORN -> 1 + else -> a.props[it] ?: G1Protocol.UNKNOWN + } + } + } val body = ByteArray(4 * values.size) for (i in values.indices) for (b in 0..3) body[4 * i + b] = (values[i] ushr (8 * b)).toByte() reply(address, op, tag, 0, body) } + G1Protocol.OP_PROP_SET -> { + val id = f[2].toInt() and 255 + val value = (f[3].toInt() and 255) or ((f[4].toInt() and 255) shl 8) + lock.withLock { + a.propSets.add(id to value) + a.props[id] = value + } + reply(address, op, tag, 0) + } + G1Protocol.OP_MIC -> { + lock.withLock { a.micRequests.add(f[2].toInt()) } + reply(address, op, tag, a.micStatus) + } else -> reply(address, op, tag, 2) } } @@ -276,6 +318,7 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { if (a.visible && m[3].toInt() == 0) a.panelOn = false a.visible = m[3].toInt() != 0 } + CFW_MSG_DIAGNOSTICS -> a.benchmarkMessages++ else -> throw AssertionError("message type $type must not reach a G1") } } @@ -620,7 +663,203 @@ class G1SessionTest { } } +private class G1AudioSink(platform: ProtocolPlatform) : FaceclawAudioPacketListener { + private val lock = platform.createLock() + private val list = ArrayList>() + val packets get() = lock.withLock { list.toList() } + + override fun onAudioPacket(data: ByteArray?, arm: String?, arrivalMs: Long) { + lock.withLock { list.add(data!! to arm!!) } + } +} + +class G1FeaturesTest { + private fun ready(): G1Session { + val s = G1Session() + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + return s + } + + private fun requests(s: G1Session) = s.glasses.lock.withLock { s.glasses.rightArm.micRequests.toList() } + + @Test + fun theMicIsRenewedAndItsFramesBecomeG2Packets() { + val s = ready() + try { + val sink = G1AudioSink(s.platform) + assertTrue(s.core.startG2AudioCapture(sink)) + assertTrue(s.core.isAudioCaptureActive()) + assertTrue(awaitTrue(2_000) { requests(s).contains(1) }, s.tail()) + assertTrue(awaitTrue(3_000) { requests(s).count { it == 1 } >= 2 }, "the lease must be renewed:\n" + s.tail()) + assertEquals(emptyList(), s.glasses.lock.withLock { s.glasses.leftArm.micRequests.toList() }, "the left arm has no mic") + + s.glasses.micData(100, 5) + s.glasses.micData(105, 5) + val packets = sink.packets + assertEquals(2, packets.size) + for ((packet, arm) in packets) { + assertEquals("R", arm) + assertEquals(Lc3PacketFramer.PACKET_BYTES, packet.size) + } + assertEquals(20, packets[0].first[Lc3PacketFramer.COUNTER_OFFSET].toInt()) + assertEquals(21, packets[1].first[Lc3PacketFramer.COUNTER_OFFSET].toInt()) + assertEquals(104.toByte(), packets[0].first[199], "the frames in order") + assertEquals(0.toByte(), packets[0].first[Lc3PacketFramer.SSR_OFFSET]) + + s.core.stopG2AudioCapture() + assertFalse(s.core.isAudioCaptureActive()) + assertTrue(awaitTrue(2_000) { requests(s).last() == 0 }, requests(s).toString()) + s.glasses.micData(110, 5) + assertEquals(2, sink.packets.size, "nothing reaches a stopped capture") + } finally { + s.core.disconnect() + } + } + + @Test + fun aRefusedOrFaultedMicEndsTheCaptureAndALateRenewalDoesNot() { + val s = ready() + try { + val sink = G1AudioSink(s.platform) + assertTrue(s.core.startG2AudioCapture(sink)) + assertTrue(awaitTrue(2_000) { requests(s).isNotEmpty() }, s.tail()) + val before = requests(s).size + s.glasses.notice(RIGHT, G1Protocol.NOTICE_MIC_STOPPED, G1Protocol.MIC_STOPPED_LEASE.toByte()) + assertTrue(s.core.isAudioCaptureActive()) + assertTrue(awaitTrue(900) { requests(s).size > before }, "asked again at once") + s.glasses.notice(RIGHT, G1Protocol.NOTICE_MIC_STOPPED, 2) + assertFalse(s.core.isAudioCaptureActive(), "a capture fault ends it") + + s.glasses.lock.withLock { s.glasses.rightArm.micStatus = 12 } + assertTrue(s.core.startG2AudioCapture(sink)) + assertTrue(awaitTrue(2_000) { !s.core.isAudioCaptureActive() }, s.tail()) + } finally { + s.core.disconnect() + } + } + + @Test + fun lightReadingsDriveTheBrightnessPolicy() { + val s = ready() + try { + s.core.configureBrightness(true, 50, 20, 100, "0:0,50:24,200:60,1000:98,2000:100", 280) + s.submit(1, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + // 1000 lux on the right arm's sensor, reported in 0.01 lux; the policy filters it towards the curve's top. + s.glasses.lock.withLock { s.glasses.rightArm.props[G1Protocol.PROP_LIGHT] = 100_000 } + assertTrue(awaitTrue(6_000) { s.glasses.lock.withLock { s.glasses.rightArm.brightness > 60 && s.glasses.leftArm.brightness > 60 } }, + "both eyes follow: " + s.glasses.lock.withLock { s.glasses.rightArm.brightness } + "\n" + s.tail()) + // In the dark, a lower level, again on both. + s.glasses.lock.withLock { s.glasses.rightArm.props[G1Protocol.PROP_LIGHT] = 500 } + assertTrue(awaitTrue(12_000) { s.glasses.lock.withLock { s.glasses.rightArm.brightness < 50 && s.glasses.leftArm.brightness < 50 } }, + "brightness " + s.glasses.lock.withLock { s.glasses.rightArm.brightness } + "\n" + s.tail()) + } finally { + s.core.disconnect() + } + } + + @Test + fun onePanelGuardsCapHoldsBothEyes() { + val s = ready() + try { + s.glasses.notice(RIGHT, G1Protocol.NOTICE_GUARD, 12, 12) + assertTrue(awaitTrue(2_000) { s.glasses.lock.withLock { s.glasses.leftArm.props[G1Protocol.PROP_BRIGHTNESS_MAX] == 12 } }, s.tail()) + assertEquals(G1Protocol.BRIGHTNESS_LEVEL_MAX, s.glasses.lock.withLock { s.glasses.rightArm.props[G1Protocol.PROP_BRIGHTNESS_MAX] }, + "only the other eye: the arm's own cap already holds it") + s.glasses.notice(RIGHT, G1Protocol.NOTICE_GUARD, 42, 21) + assertTrue(awaitTrue(2_000) { s.glasses.lock.withLock { s.glasses.leftArm.props[G1Protocol.PROP_BRIGHTNESS_MAX] == 42 } }, s.tail()) + } finally { + s.core.disconnect() + } + } + + @Test + fun imuSamplesArePolledWhileWanted() { + val s = ready() + try { + val lock = s.platform.createLock() + val readings = ArrayList>() + s.core.addImuListener(object : FaceclawImuListener { + override fun onImuData(x: Double, y: Double, z: Double, eventSource: Int) { + lock.withLock { readings.add(listOf(x, y, z, eventSource.toDouble())) } + } + }) + s.glasses.lock.withLock { + s.glasses.rightArm.props[G1Protocol.PROP_ACC_X] = 100 + s.glasses.rightArm.props[G1Protocol.PROP_ACC_Y] = -1000 + s.glasses.rightArm.props[G1Protocol.PROP_ACC_Z] = 250 + } + s.core.setImuReportEnabled(true, 200) + assertTrue(awaitTrue(3_000) { lock.withLock { readings.size >= 5 } }, "samples: " + lock.withLock { readings.size } + "\n" + s.tail()) + assertEquals(listOf(0.1, -1.0, 0.25, BleProtocol.EVENT_SOURCE_GLASSES_R.toDouble()), lock.withLock { readings.first() }) + assertTrue(awaitTrue(1_000) { s.glasses.lock.withLock { s.glasses.rightArm.props[G1Protocol.PROP_IMU_RATE] == G1Protocol.IMU_RATE_STREAM } }) + s.core.setImuReportEnabled(false, 0) + assertTrue(awaitTrue(1_000) { s.glasses.lock.withLock { s.glasses.rightArm.props[G1Protocol.PROP_IMU_RATE] == G1Protocol.IMU_RATE_IDLE } }) + sleepMs(200) + val count = lock.withLock { readings.size } + sleepMs(300) + assertEquals(count, lock.withLock { readings.size }, "the polling stops") + } finally { + s.core.disconnect() + } + } + + @Test + fun theBandwidthBenchmarkRunsOverBothArms() { + val s = ready() + try { + s.submit(1, 1) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail()) + assertTrue(s.core.startBandwidthBenchmarkWithLinkMode(1000, 3, 1_000, 0)) + assertTrue(awaitTrue(8_000) { !s.core.monitor.withLock { s.core.benchmarkActive } }, s.tail()) + assertTrue(s.core.monitor.withLock { !s.core.benchmarkAborted && s.core.benchmarkMessagesAcked > 2 && s.core.benchmarkTimeouts == 0 }, + s.core.getBandwidthBenchmarkStatus() + "\n" + s.tail()) + val left = s.glasses.lock.withLock { s.glasses.leftArm.benchmarkMessages } + val right = s.glasses.lock.withLock { s.glasses.rightArm.benchmarkMessages } + assertTrue(left > 0 && kotlin.math.abs(left - right) <= 1, "left $left right $right") + } finally { + s.core.disconnect() + } + } +} + class G1ProtocolTest { + @Test + fun micFramesFillPacketsAcrossEventsAndAGapDropsTheRemainder() { + fun frames(first: Int, count: Int) = ByteArray(count * 40) { (first + it / 40).toByte() } + val out = ArrayList() + val a = G1MicAssembler() + // MTU too small for five frames an event: two, two, then one completes a packet. + a.ingest(10, 2, frames(10, 2), 0) { out.add(it) } + a.ingest(12, 2, frames(12, 2), 0) { out.add(it) } + assertTrue(out.isEmpty()) + a.ingest(14, 3, frames(14, 3), 0) { out.add(it) } + assertEquals(1, out.size) + assertEquals(2, out[0][Lc3PacketFramer.COUNTER_OFFSET].toInt(), "frame 10's packet") + assertEquals(14.toByte(), out[0][160]) + // 15 and 16 are waiting; 20 comes next, so they are gone and a new packet starts there. + a.ingest(20, 5, frames(20, 5), 0) { out.add(it) } + assertEquals(2, out.size) + assertEquals(4, out[1][Lc3PacketFramer.COUNTER_OFFSET].toInt()) + assertEquals(20.toByte(), out[1][0]) + } + + @Test + fun aLightReadingBecomesAReportThePolicyTakes() { + val report = G1Protocol.alsReport(123_400, 40, 5000) + assertEquals(24, report.size) + val policy = BrightnessPolicy() + policy.configure(true, 50, 2, 100, "0:0,1000:100", 280) + policy.sample(report, 1000) + assertTrue(policy.target > 90, "1234 lux on this curve: ${policy.target}") + } + + @Test + fun aPropertySetIsIdAndLittleEndianValue() { + assertTrue(byteArrayOf(0x29, 42, 0, 0, 0).contentEquals(G1Protocol.propSet(G1Protocol.PROP_BRIGHTNESS_MAX, 42))) + } + @Test fun packetsCarryARecordWithinTheMtu() { val record = ByteArray(1000) { it.toByte() } @@ -678,8 +917,10 @@ class G1ProtocolTest { body[3] = 62 body[4] = 1 body[5] = (2 or 64 or 128).toByte() + body[6] = 4 val hello = assertNotNull(G1Protocol.parseHello(body)) assertEquals("0.5.62", hello.version) + assertTrue(hello.mic) assertTrue(hello.leftArm && hello.panelOk && hello.encrypted && hello.inCase) assertFalse(hello.safeMode) body[0] = 4 From 38c52ebc31235298d57f101e502b04eb7375574d Mon Sep 17 00:00:00 2001 From: James Babcock Date: Fri, 6 Nov 2026 12:55:24 -0800 Subject: [PATCH 09/34] G1 support: Flashing within the Android app --- ACKNOWLEDGEMENTS.md | 5 + .../java/com/faceclaw/app/AndroidStockLink.kt | 4 + .../com/faceclaw/app/FaceclawG1Flasher.kt | 87 +++ app/g1/addresses.ts | 37 ++ app/g1/arm-scanner.ts | 75 +++ app/g1/firmware-builder.ts | 52 ++ app/g1/firmware-image.ts | 81 +++ app/g1/firmware/g1v0-image.ts | 41 ++ app/g1/firmware/g1v0-own-bytes.ts | 4 + app/g1/flash-plan.ts | 88 +++ app/g1/pako.d.ts | 4 + app/g2/firmware-compat.ts | 5 + app/g2/pairing-candidates.ts | 12 +- app/native/g1-flasher.ios.ts | 75 +++ app/native/g1-flasher.ts | 73 +++ app/native/ios-bluetooth.ts | 9 + app/phone-ui/g1-flash-view-model.ts | 345 +++++++++++ app/phone-ui/main-page.xml | 1 + app/phone-ui/main-view-model.ts | 13 +- .../onboarding-firmware-check-view-model.ts | 81 ++- app/phone-ui/onboarding-flash-page.ts | 9 +- app/phone-ui/onboarding-view-model.ts | 4 +- app/phone-ui/pairing-view-model.ts | 9 +- .../com/faceclaw/app/g1/G1ArmFlashFlow.kt | 467 +++++++++++++++ .../kotlin/com/faceclaw/app/g1/G1Protocol.kt | 13 + .../kotlin/com/faceclaw/app/g1/G1Smp.kt | 291 +++++++++ .../com/faceclaw/app/g2protocol/StockLink.kt | 6 + .../g2protocol/session/GlassesSessionG1.kt | 17 +- .../com/faceclaw/app/ble/IosBleCentral.kt | 3 + .../com/faceclaw/app/ble/IosStockFlows.kt | 53 ++ tests/firmware-compat.test.cjs | 14 + tests/g1-firmware.test.cjs | 169 ++++++ .../kotlin/com/faceclaw/app/G1FlashTest.kt | 551 ++++++++++++++++++ .../kotlin/com/faceclaw/app/G1SessionTest.kt | 4 +- tests/pairing-candidates.test.cjs | 17 +- tests/tsconfig.json | 5 + tools/g1_firmware_bundle.py | 127 ++++ 37 files changed, 2819 insertions(+), 32 deletions(-) create mode 100644 App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt create mode 100644 app/g1/addresses.ts create mode 100644 app/g1/arm-scanner.ts create mode 100644 app/g1/firmware-builder.ts create mode 100644 app/g1/firmware-image.ts create mode 100644 app/g1/firmware/g1v0-image.ts create mode 100644 app/g1/firmware/g1v0-own-bytes.ts create mode 100644 app/g1/flash-plan.ts create mode 100644 app/g1/pako.d.ts create mode 100644 app/native/g1-flasher.ios.ts create mode 100644 app/native/g1-flasher.ts create mode 100644 app/phone-ui/g1-flash-view-model.ts create mode 100644 native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt create mode 100644 native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt create mode 100644 tests/g1-firmware.test.cjs create mode 100644 tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt create mode 100644 tools/g1_firmware_bundle.py diff --git a/ACKNOWLEDGEMENTS.md b/ACKNOWLEDGEMENTS.md index 95e41c3f..7e9ee19f 100644 --- a/ACKNOWLEDGEMENTS.md +++ b/ACKNOWLEDGEMENTS.md @@ -13,6 +13,11 @@ and others who contributed to documenting the G2's bluetooth protocol and firmwa G2 microphone LC3 decoding uses Google's liblc3: https://github.com/google/liblc3 +Even G1 support builds on ScouterKit (MIT License), by the ScouterKit authors: +https://github.com/mafik/scouter_kit. The firmware Faceclaw installs on a G1 is a +modified build of its g1v0, using the Zephyr RTOS and Nordic's nRF Connect SDK; the +parts of it that are Even Realities' own are downloaded from Even, not shipped here. + RayNeo iO support builds on the Glassly SDK and custom firmware by Tetramo, Inc. and Mentra Labs, Inc. (MIT License): https://github.com/tetramo-labs/glassly and https://github.com/tetramo-labs/glassly-rayneo-cfw. The iO wire codecs in diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt index 3e7d264e..700d12b9 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt @@ -48,6 +48,10 @@ class AndroidStockLink(context: Context) : StockLink, FaceclawBleListener { else -> BondState.UNKNOWN } + override fun negotiatedMtu(address: String): Int = bleManager.getNegotiatedMtu(address) + + override fun requestBond(address: String) = bleManager.requestBond(address) + override fun disconnect(address: String) = bleManager.disconnect(address) override fun close() = bleManager.close() diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt new file mode 100644 index 00000000..a7e9be7d --- /dev/null +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt @@ -0,0 +1,87 @@ +package com.faceclaw.app + +import android.content.Context +import android.os.Handler +import android.os.Looper + +/** + * Android host for the shared [G1ArmFlashFlow]: owns the GATT link and the worker thread for one G1 arm's install, or a + * question about what it runs, and delivers listener callbacks on the main thread. For app/native/g1-flasher.ts. + */ +class FaceclawG1Flasher(context: Context, address: String?, side: String?, firmwarePath: String?, mode: String?, connectWindowMs: Int) { + private val link = AndroidStockLink(context.applicationContext) + private val mainHandler = Handler(Looper.getMainLooper()) + private val lock = Any() + + @Volatile + private var listener: FaceclawFirmwareFlasherListener? = null + + @Volatile + private var worker: Thread? = null + + private val flow = + G1ArmFlashFlow( + link, + address ?: "", + side ?: "", + firmwarePath ?: "", + G1ArmFlashFlow.mode(mode ?: ""), + connectWindowMs, + object : FaceclawFirmwareFlasherListener { + override fun onLog(line: String?) { + android.util.Log.i(G1ArmFlashFlow.TAG, line ?: "") + post { it.onLog(line) } + } + + override fun onProgress( + lens: String?, + componentIndex: Int, + componentCount: Int, + blockIndex: Int, + blockCount: Int, + bytesSent: Long, + bytesTotal: Long, + ) = post { it.onProgress(lens, componentIndex, componentCount, blockIndex, blockCount, bytesSent, bytesTotal) } + + override fun onState(state: String?, detail: String?) = post { it.onState(state, detail ?: "") } + + override fun onComplete(success: Boolean, detail: String?) = post { it.onComplete(success, detail ?: "") } + }, + ) + + fun setListener(listener: FaceclawFirmwareFlasherListener?) { + this.listener = listener + } + + fun start() { + synchronized(lock) { + if (worker != null) { + return + } + val w = Thread({ flow.run() }, "faceclaw-g1-flash") + worker = w + w.start() + } + } + + fun cancel() { + flow.cancel() + } + + fun close() { + cancel() + try { + link.close() + } catch (ignored: Exception) { + } + } + + private fun post(action: (FaceclawFirmwareFlasherListener) -> Unit) { + mainHandler.post { + val current = listener + if (current != null) { + action(current) + } + } + } +} diff --git a/app/g1/addresses.ts b/app/g1/addresses.ts new file mode 100644 index 00000000..c966a453 --- /dev/null +++ b/app/g1/addresses.ts @@ -0,0 +1,37 @@ +/** Keeping what's saved about a G1 current as an install changes its arms' addresses. */ +import { + loadDeviceAddresses, + loadPairedGlassesIdentity, + saveDeviceAddresses, + savePairedGlassesIdentity, +} from "../g2/device-addresses"; +import type { EvenAdvertisement } from "../g2/even-advertisement"; +import type { GlassesPairCandidate } from "../g2/pairing-candidates"; +import type { G1Side } from "./flash-plan"; + +export function saveG1Pair(pair: GlassesPairCandidate): void { + const stored = loadDeviceAddresses(); + saveDeviceAddresses({ left: pair.left!.address, right: pair.right!.address, ring: stored.ring }); + const identity = loadPairedGlassesIdentity(); + savePairedGlassesIdentity({ + serial: pair.serial ?? identity?.serial ?? "", + leftName: pair.left!.name, + rightName: pair.right!.name, + leftAddress: pair.left!.address, + rightAddress: pair.right!.address, + ringName: identity?.ringName ?? "", + ringAddress: stored.ring, + pairedAtMs: identity?.pairedAtMs ?? Date.now(), + }); +} + +/** Saved as soon as it's known: if anything stops the install after this, the next try and the session still find this arm. */ +export function saveG1Arm(side: G1Side, arm: EvenAdvertisement): void { + saveDeviceAddresses({ ...loadDeviceAddresses(), [side]: arm.address }); + const identity = loadPairedGlassesIdentity(); + if (identity) { + savePairedGlassesIdentity(side === "left" + ? { ...identity, leftName: arm.name, leftAddress: arm.address } + : { ...identity, rightName: arm.name, rightAddress: arm.address }); + } +} diff --git a/app/g1/arm-scanner.ts b/app/g1/arm-scanner.ts new file mode 100644 index 00000000..02a9db53 --- /dev/null +++ b/app/g1/arm-scanner.ts @@ -0,0 +1,75 @@ +/** + * Finding a G1's arms by listening for them. That's how an install knows what each arm runs before connecting to it, + * and how it finds an arm again afterwards: an arm coming off Even's firmware has a new address. + */ +import { classifyAdvertisement, type EvenAdvertisement } from "../g2/even-advertisement"; +import { DiscoveryAggregator, type GlassesPairCandidate } from "../g2/pairing-candidates"; +import { DeviceDiscoveryBridge } from "../native/device-discovery"; +import { pickG1Pair, sameG1Serial, type G1Side, type G1Wanted } from "./flash-plan"; + +/** A serial should tell which arm is ours, but an arm that is the only one of its side around is good enough after this. */ +const ACCEPT_ANY_SERIAL_AFTER_MS = 45_000; + +export class G1ArmScanner { + private discovery: DeviceDiscoveryBridge | null = null; + private finish: (() => void) | null = null; + + /** Resolves with the wanted pair once both arms have been heard, or null after [timeoutMs]. */ + waitForPair(wanted: G1Wanted, timeoutMs: number): Promise { + const aggregator = new DiscoveryAggregator(); + return this.listen(timeoutMs, (raw, done) => { + if (aggregator.ingest(raw)) { + const pair = pickG1Pair(aggregator.pairs(), wanted); + if (pair) done(pair); + } + }); + } + + /** Resolves when an arm of this side on g1v0 is heard, or null after [timeoutMs]. */ + waitForG1v0Arm(side: G1Side, serial: string | null | undefined, timeoutMs: number): Promise { + const startedAt = Date.now(); + const others = new Map(); + return this.listen(timeoutMs, (raw, done) => { + const arm = classifyAdvertisement(raw); + if (!arm || arm.role !== side || !arm.g1Firmware || arm.g1Firmware === "stock") return; + if (!serial || sameG1Serial(arm.serial, serial)) { + done(arm); + return; + } + others.set(arm.address, arm); + if (others.size === 1 && Date.now() - startedAt >= ACCEPT_ANY_SERIAL_AFTER_MS) done(arm); + }); + } + + stop(): void { + this.finish?.(); + } + + private listen(timeoutMs: number, onRaw: (raw: Parameters[0], done: (value: T) => void) => void): Promise { + return new Promise((resolve, reject) => { + this.discovery ??= new DeviceDiscoveryBridge(); + const discovery = this.discovery; + if (!discovery.bluetoothEnabled) { + reject(new Error("Bluetooth is off. Turn it on, then try again.")); + return; + } + let settled = false; + const settle = (value: T | null, error?: Error) => { + if (settled) return; + settled = true; + clearTimeout(timer); + this.finish = null; + discovery.stopScan(); + if (error) reject(error); + else resolve(value); + }; + const timer = setTimeout(() => settle(null), timeoutMs); + this.finish = () => settle(null); + const started = discovery.startScan({ + onAdvertisement: (raw) => onRaw(raw, (value) => settle(value)), + onScanFailed: (_code, message) => settle(null, new Error(`The Bluetooth scan failed: ${message}`)), + }); + if (!started) settle(null, new Error("Could not start the Bluetooth scan. Check that Bluetooth is on.")); + }); + } +} diff --git a/app/g1/firmware-builder.ts b/app/g1/firmware-builder.ts new file mode 100644 index 00000000..b1242b60 --- /dev/null +++ b/app/g1/firmware-builder.ts @@ -0,0 +1,52 @@ +/** + * Prepares the g1v0 image on the phone, as app/g2/firmware-builder.ts does for a G2: downloads Even's public firmware, + * checks it, and puts the parts this firmware embeds back into what the app ships. The result is byte for byte the + * image that was built, tested and signed, and it is checked to be. It does not touch the glasses. + */ +import { knownFolders } from "@nativescript/core"; + +import { firmwareSha256, writeFirmwareFile } from "../native/firmware-files"; +import { decodeBase64 } from "../util/base64"; +import { fetchWithUserAgent } from "../util/http"; +import { G1V0_IMAGE } from "./firmware/g1v0-image"; +import { G1V0_OWN_BYTES_BASE64 } from "./firmware/g1v0-own-bytes"; +import { assembleG1Image, decodeG1OwnBytes, G1FirmwareError, readZipEntry } from "./firmware-image"; + +export type G1BuildProgress = "downloading" | "verifying" | "assembling" | "writing"; + +export type BuiltG1Firmware = { path: string; bytes: number; version: string }; + +function sha256(bytes: Uint8Array): string { + return firmwareSha256(bytes.slice().buffer); +} + +async function downloadStockZip(): Promise { + let response: Response; + try { + response = await fetchWithUserAgent(G1V0_IMAGE.stockZipUrl); + } catch (error) { + throw new G1FirmwareError(`Could not reach Even's firmware server: ${(error as Error)?.message ?? error}`); + } + if (!response.ok) throw new G1FirmwareError(`The firmware download failed (HTTP ${response.status}).`); + return new Uint8Array(await response.arrayBuffer()); +} + +export async function buildG1Firmware(onProgress?: (progress: G1BuildProgress) => void): Promise { + onProgress?.("downloading"); + const zip = await downloadStockZip(); + + onProgress?.("verifying"); + const zipHash = sha256(zip); + if (zipHash !== G1V0_IMAGE.stockZipSha256) { + throw new G1FirmwareError(`Even's firmware download failed verification.\nexpected ${G1V0_IMAGE.stockZipSha256}\ngot ${zipHash}`); + } + + onProgress?.("assembling"); + const own = decodeG1OwnBytes(G1V0_OWN_BYTES_BASE64, decodeBase64); + const image = assembleG1Image(G1V0_IMAGE, own, (name) => readZipEntry(zip, name), sha256); + + onProgress?.("writing"); + const path = `${knownFolders.documents().path}/g1v0_${G1V0_IMAGE.version}.bin`; + writeFirmwareFile(path, image.slice().buffer); + return { path, bytes: image.length, version: G1V0_IMAGE.version }; +} diff --git a/app/g1/firmware-image.ts b/app/g1/firmware-image.ts new file mode 100644 index 00000000..dfe45e78 --- /dev/null +++ b/app/g1/firmware-image.ts @@ -0,0 +1,81 @@ +/** + * Rebuilding the g1v0 image from what the app ships and Even's public firmware download. No I/O, so tests can run it + * on real or made-up files. tools/g1_firmware_bundle.py is the other half. + */ +import { inflate, inflateRaw } from "pako"; + +import type { G1FirmwareImage } from "./firmware/g1v0-image"; + +export class G1FirmwareError extends Error {} + +/** One file from a zip; throws when it's absent or in a form a firmware zip doesn't use. */ +export function readZipEntry(zip: Uint8Array, name: string): Uint8Array { + const view = new DataView(zip.buffer, zip.byteOffset, zip.byteLength); + const END_OF_DIRECTORY = 0x06054b50; + const DIRECTORY_ENTRY = 0x02014b50; + const LOCAL_HEADER = 0x04034b50; + let end = zip.length - 22; + while (end >= 0 && view.getUint32(end, true) !== END_OF_DIRECTORY) end--; + if (end < 0) throw new G1FirmwareError("The firmware download is not a zip file."); + const count = view.getUint16(end + 10, true); + let at = view.getUint32(end + 16, true); + for (let i = 0; i < count; i++) { + if (at + 46 > zip.length || view.getUint32(at, true) !== DIRECTORY_ENTRY) break; + const method = view.getUint16(at + 10, true); + const packedSize = view.getUint32(at + 20, true); + const nameLength = view.getUint16(at + 28, true); + const extraLength = view.getUint16(at + 30, true); + const commentLength = view.getUint16(at + 32, true); + const headerAt = view.getUint32(at + 42, true); + const entryName = String.fromCharCode(...zip.subarray(at + 46, at + 46 + nameLength)); + if (entryName === name || entryName.endsWith(`/${name}`)) { + if (view.getUint32(headerAt, true) !== LOCAL_HEADER) throw new G1FirmwareError(`Bad zip entry for ${name}.`); + const dataAt = headerAt + 30 + view.getUint16(headerAt + 26, true) + view.getUint16(headerAt + 28, true); + const packed = zip.subarray(dataAt, dataAt + packedSize); + if (method === 0) return packed.slice(); + if (method === 8) return inflateRaw(packed); + throw new G1FirmwareError(`${name} uses zip method ${method}.`); + } + at += 46 + nameLength + extraLength + commentLength; + } + throw new G1FirmwareError(`The firmware download has no ${name}.`); +} + +export function decodeG1OwnBytes(base64: string, decode: (text: string) => Uint8Array): Uint8Array { + return inflate(decode(base64)); +} + +/** + * The finished image. [fileBytes] gives one of Even's unpacked files by name, [sha256] a lowercase hex digest. Each part + * and the result are checked, so a success is byte for byte the image that was built and signed. + */ +export function assembleG1Image( + manifest: G1FirmwareImage, + own: Uint8Array, + fileBytes: (name: string) => Uint8Array, + sha256: (bytes: Uint8Array) => string, +): Uint8Array { + const image = new Uint8Array(manifest.size); + let position = 0; + let ownAt = 0; + for (const part of [...manifest.parts].sort((a, b) => a.offset - b.offset)) { + const before = part.offset - position; + image.set(own.subarray(ownAt, ownAt + before), position); + ownAt += before; + const bytes = fileBytes(part.file).subarray(part.fileOffset, part.fileOffset + part.length); + if (bytes.length !== part.length || sha256(bytes) !== part.sha256) { + throw new G1FirmwareError(`${part.file} in Even's download is not the one this firmware was built with.`); + } + image.set(bytes, part.offset); + position = part.offset + part.length; + } + image.set(own.subarray(ownAt), position); + if (ownAt + (manifest.size - position) !== own.length) { + throw new G1FirmwareError("The firmware bundled with this app is damaged."); + } + const digest = sha256(image); + if (digest !== manifest.sha256) { + throw new G1FirmwareError(`The assembled firmware failed verification.\nexpected ${manifest.sha256}\ngot ${digest}`); + } + return image; +} diff --git a/app/g1/firmware/g1v0-image.ts b/app/g1/firmware/g1v0-image.ts new file mode 100644 index 00000000..7a45c443 --- /dev/null +++ b/app/g1/firmware/g1v0-image.ts @@ -0,0 +1,41 @@ +// AUTO-GENERATED by tools/g1_firmware_bundle.py -- do not edit by hand. +// What the app installs on a G1, and the parts of it that come from Even's own download. + +export type G1FirmwarePart = { offset: number; length: number; file: string; fileOffset: number; sha256: string }; + +export type G1FirmwareImage = { + version: string; + sha256: string; + size: number; + source: string; + stockVersion: string; + stockZipUrl: string; + stockZipSha256: string; + parts: G1FirmwarePart[]; +}; + +export const G1V0_IMAGE: G1FirmwareImage = { + "version": "0.5.64", + "sha256": "25e759efbe17093390386ac286865515d1f3f47efa8e40b5f054685fc7b2d6b6", + "size": 574408, + "source": "51596992c1f1", + "stockVersion": "1.6.6", + "stockZipUrl": "https://cdn.evenreal.co/firmware/dcfa510c090e476c10a6f6c348a22415.zip", + "stockZipSha256": "748836f2d9d092b0783cbb7672fdccec4f730051cad27f095bbb156ac3e5d316", + "parts": [ + { + "offset": 263344, + "length": 226020, + "file": "net_core_app_update.bin", + "fileOffset": 0, + "sha256": "c277749be97a2763742db399afeb10ca6916059abd60d41bbc05c8892c002c77" + }, + { + "offset": 489392, + "length": 352, + "file": "app_update.bin", + "fileOffset": 531288, + "sha256": "92e73a6dd92da734bc21e8184d94d69e9a49e23056e378670b24334a305a953d" + } + ] +}; diff --git a/app/g1/firmware/g1v0-own-bytes.ts b/app/g1/firmware/g1v0-own-bytes.ts new file mode 100644 index 00000000..9ec33a30 --- /dev/null +++ b/app/g1/firmware/g1v0-own-bytes.ts @@ -0,0 +1,4 @@ +// AUTO-GENERATED by tools/g1_firmware_bundle.py -- do not edit by hand. +// The built g1v0 image without Even's parts (g1v0-image.ts), deflated. + +export const G1V0_OWN_BYTES_BASE64 = "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"; diff --git a/app/g1/flash-plan.ts b/app/g1/flash-plan.ts new file mode 100644 index 00000000..0582d1fa --- /dev/null +++ b/app/g1/flash-plan.ts @@ -0,0 +1,88 @@ +/** What installing firmware on a G1 has to decide. No I/O. */ +import type { GlassesPairCandidate } from "../g2/pairing-candidates"; + +export type G1Side = "left" | "right"; + +/** Left first: a right arm on g1v0 next to a left arm on Even's firmware would leave the left eye dark. */ +export const G1_SIDES: readonly G1Side[] = ["left", "right"]; + +export const G1_CASE_INSTRUCTIONS = + "Put the glasses in their charging case with the lid open, and plug the case in. Stay nearby, and leave Faceclaw open."; + +export const G1_INSTALL_NOTICE = + "This replaces the firmware on both arms, about two minutes each. Going back to Even's firmware later takes a computer, and " + + "may not be the version you have now. Installing custom firmware is not covered by warranty."; + +/** What the native flow says when it finishes (G1ArmFlashFlow). */ +export type G1FlashResult = { + flashed?: boolean; + firmware?: "g1v0" | "stock"; + version?: string; + safeMode?: boolean; + inCase?: boolean; + battery?: number | null; +}; + +export function parseG1FlashResult(detail: string): G1FlashResult { + try { + const parsed = JSON.parse(detail); + return parsed && typeof parsed === "object" ? (parsed as G1FlashResult) : {}; + } catch { + return {}; + } +} + +/** Dotted versions, component by component; a missing component counts as 0. */ +export function compareG1Versions(a: string, b: string): number { + const parts = (version: string) => version.split(".").map((part) => parseInt(part, 10) || 0); + const left = parts(a); + const right = parts(b); + for (let i = 0; i < Math.max(left.length, right.length); i++) { + const delta = (left[i] ?? 0) - (right[i] ?? 0); + if (delta !== 0) return delta; + } + return 0; +} + +export type G1Wanted = { serial?: string | null; left?: string; right?: string }; + +const serialOf = (serial: string | null | undefined) => (serial ?? "").trim().toUpperCase(); + +export function sameG1Serial(a: string | null | undefined, b: string | null | undefined): boolean { + return serialOf(a) !== "" && serialOf(a) === serialOf(b); +} + +/** + * The pair being installed on, among those heard, once both arms have been. Its serial decides, as a flash changes an arm's + * address; an address it was saved under also tells. Only with neither known does the only G1 around count: firmware + * must never go to someone else's glasses because the wanted ones weren't heard. + */ +export function pickG1Pair(pairs: readonly GlassesPairCandidate[], wanted: G1Wanted): GlassesPairCandidate | null { + const g1 = pairs.filter((pair) => pair.g1Firmware); + const complete = (pair: GlassesPairCandidate | undefined) => (pair?.left && pair.right ? pair : null); + const bySerial = g1.find((pair) => sameG1Serial(pair.serial, wanted.serial)); + if (bySerial) return complete(bySerial); + const byAddress = g1.find((pair) => + (!!wanted.left && pair.left?.address === wanted.left) || (!!wanted.right && pair.right?.address === wanted.right)); + if (byAddress) return complete(byAddress); + if (serialOf(wanted.serial) || wanted.left || wanted.right) return null; + return g1.length === 1 ? complete(g1[0]) : null; +} + +/** + * What a check of the two arms found: "stock", Even's firmware on an arm; "safe-mode", g1v0 restarted repeatedly and only + * updates work; "older", older than the app ships; "current", nothing to do. + */ +export type G1FirmwareState = "stock" | "safe-mode" | "older" | "current"; + +export function g1FirmwareState(arms: readonly G1FlashResult[], shipped: string): G1FirmwareState { + if (arms.some((arm) => arm.firmware === "stock")) return "stock"; + if (arms.some((arm) => arm.safeMode)) return "safe-mode"; + return arms.some((arm) => compareG1Versions(arm.version ?? "", shipped) < 0) ? "older" : "current"; +} + +/** Each arm counts for half of the bar. */ +export function g1FlashPercent(side: G1Side, bytesSent: number, bytesTotal: number): number { + const within = bytesTotal > 0 ? Math.min(1, bytesSent / bytesTotal) : 0; + return ((side === "right" ? 1 + within : within) / 2) * 100; +} diff --git a/app/g1/pako.d.ts b/app/g1/pako.d.ts new file mode 100644 index 00000000..8fe2e2a1 --- /dev/null +++ b/app/g1/pako.d.ts @@ -0,0 +1,4 @@ +declare module "pako" { + export function inflate(data: Uint8Array): Uint8Array; + export function inflateRaw(data: Uint8Array): Uint8Array; +} diff --git a/app/g2/firmware-compat.ts b/app/g2/firmware-compat.ts index 71ee5c91..3d8508e2 100644 --- a/app/g2/firmware-compat.ts +++ b/app/g2/firmware-compat.ts @@ -117,6 +117,11 @@ export function firmwareIncompatibilityMessage(info: FirmwareInfo): string | nul const versionsText = `L=${info.leftVersion || "unknown"} R=${info.rightVersion || "unknown"}`; const required = `Faceclaw firmware revision ${REQUIRED_FACECLAW_FIRMWARE_VERSION}`; + // A G1's session names what the arms run instead of a revision (GlassesSessionG1.kt). + if (extension.kind === "none" && reportedVersions.some((version) => /^(g1v0|Even's firmware)/.test(version))) { + return `These G1 glasses run ${versionsText}. This version of Faceclaw needs the firmware it comes with: install it to continue.`; + } + switch (extension.kind) { case "faceclaw": if (extension.version >= REQUIRED_FACECLAW_FIRMWARE_VERSION) return null; diff --git a/app/g2/pairing-candidates.ts b/app/g2/pairing-candidates.ts index e8c3256c..7c3de28f 100644 --- a/app/g2/pairing-candidates.ts +++ b/app/g2/pairing-candidates.ts @@ -386,14 +386,16 @@ export function g1Row(pair: GlassesPairCandidate, context: RowContext = {}): Pai if (pair.mismatchWarning) warnings.push(pair.mismatchWarning); let armsSummary: string; let canSelect = false; - if (pair.g1Firmware === "stock") { - armsSummary = "Needs the Faceclaw firmware for the G1, which is installed from a computer"; - } else if (pair.g1Firmware === "g1v0-safe") { - armsSummary = "In safe mode: the firmware restarted repeatedly. Reinstall it from a computer"; - } else if (pair.completeness !== "complete") { + if (pair.completeness !== "complete") { armsSummary = pair.completeness === "left-only" ? "Only the left arm has been seen — waiting for the right" : "Only the right arm has been seen — waiting for the left"; + } else if (pair.g1Firmware === "stock") { + armsSummary = "Runs Even's firmware. Faceclaw will install its own, with the glasses in the case"; + canSelect = true; + } else if (pair.g1Firmware === "g1v0-safe") { + armsSummary = "In safe mode: the firmware restarted repeatedly. Faceclaw can install it again, with the glasses in the case"; + canSelect = true; } else { armsSummary = "Left + right arms found. To pair, keep them in the case with the lid open"; canSelect = true; diff --git a/app/native/g1-flasher.ios.ts b/app/native/g1-flasher.ios.ts new file mode 100644 index 00000000..1ab77ece --- /dev/null +++ b/app/native/g1-flasher.ios.ts @@ -0,0 +1,75 @@ +import { Application } from '@nativescript/core' +import { parseG1FlashResult, type G1FlashResult } from '../g1/flash-plan' +import { iosBluetooth } from './ios-bluetooth' +import { kotlinListener } from './kotlin-listener.ios' +import type { G1FlasherOptions } from './g1-flasher' +export type { G1FlashMode, G1FlasherOptions } from './g1-flasher' + +declare const FaceclawKitIosG1Flasher: any, FaceclawKitFaceclawFirmwareFlasherListener: any + +/** + * iOS twin of the Android G1Flasher: the shared Kotlin G1ArmFlashFlow over a CoreBluetooth central. As with the G2's + * flasher, the phone must stay in the foreground with the screen awake, and addresses are mapped to peripheral + * identifiers first. + */ +export class G1Flasher { + private flasher: any = null + private listenerProxy: object | null = null + private logListener: ((line: string) => void) | null = null + private progressListener: ((bytesSent: number, bytesTotal: number) => void) | null = null + private stateListener: ((state: string) => void) | null = null + private previousIdle = false + private cancelled = false + private foregroundError = '' + + constructor(private readonly options: G1FlasherOptions) {} + + onLog(listener: (line: string) => void): void { this.logListener = listener } + onProgress(listener: (bytesSent: number, bytesTotal: number) => void): void { this.progressListener = listener } + onState(listener: (state: string) => void): void { this.stateListener = listener } + + private readonly backgrounded = () => { + this.foregroundError = 'The install stopped because Faceclaw left the foreground. Return to Faceclaw and try again.' + this.cancel() + } + + run(): Promise { + this.previousIdle = UIApplication.sharedApplication.idleTimerDisabled + UIApplication.sharedApplication.idleTimerDisabled = true + Application.on(Application.suspendEvent, this.backgrounded) + const restore = () => { + Application.off(Application.suspendEvent, this.backgrounded) + UIApplication.sharedApplication.idleTimerDisabled = this.previousIdle + } + return new Promise((resolve, reject) => { + const identifier = iosBluetooth().peripheralIdentifier(this.options.address, this.options.side) + if (!identifier) throw new Error(`Could not find the ${this.options.side} arm. Keep the glasses in the case with the lid open.`) + this.flasher = FaceclawKitIosG1Flasher.alloc().initWithAddressSideFirmwarePathModeConnectWindowMs( + identifier, this.options.side, this.options.firmwarePath, this.options.mode, this.options.connectWindowMs) + this.listenerProxy = kotlinListener(FaceclawKitFaceclawFirmwareFlasherListener, { + onLogLine: (line: string) => this.logListener?.(String(line ?? '')), + onProgressLensComponentIndexComponentCountBlockIndexBlockCountBytesSentBytesTotal: ( + _lens: string, _componentIndex: number, _componentCount: number, _blockIndex: number, _blockCount: number, sent: number, total: number, + ) => this.progressListener?.(Number(sent), Number(total)), + onStateStateDetail: (state: string) => this.stateListener?.(String(state)), + onCompleteSuccessDetail: (success: boolean, detail: string) => { + if (success) resolve(parseG1FlashResult(String(detail ?? ''))) + else reject(new Error(this.foregroundError || String(detail ?? '') || 'The install failed.')) + }, + }) + this.flasher.setListenerListener(this.listenerProxy) + if (this.cancelled) this.flasher.cancel() + this.flasher.start() + }).finally(restore) + } + + cancel(): void { + this.cancelled = true + try { this.flasher?.cancel() } catch { /* ignore */ } + } + + close(): void { + this.cancel() + try { this.flasher?.close() } catch { /* ignore */ } + } +} diff --git a/app/native/g1-flasher.ts b/app/native/g1-flasher.ts new file mode 100644 index 00000000..9f60423d --- /dev/null +++ b/app/native/g1-flasher.ts @@ -0,0 +1,73 @@ +import { Utils } from "@nativescript/core"; + +import { parseG1FlashResult, type G1FlashResult, type G1Side } from "../g1/flash-plan"; + +declare const com: any; + +export type G1FlashMode = "stock" | "update" | "probe"; + +export type G1FlasherOptions = { + address: string; + side: G1Side; + firmwarePath: string; + mode: G1FlashMode; + /** How long to keep trying to reach the arm and pair with it. */ + connectWindowMs: number; +}; + +/** TS wrapper around FaceclawG1Flasher: one arm's install, or a question about what it runs. */ +export class G1Flasher { + private readonly flasher: any; + private readonly listenerProxy: any; + private logListener: ((line: string) => void) | null = null; + private progressListener: ((bytesSent: number, bytesTotal: number) => void) | null = null; + private stateListener: ((state: string) => void) | null = null; + private completion: ((success: boolean, detail: string) => void) | null = null; + + constructor(options: G1FlasherOptions) { + const context = Utils.android.getApplicationContext(); + if (!context) throw new Error("Android application context unavailable"); + this.flasher = new com.faceclaw.app.FaceclawG1Flasher( + context, options.address, options.side, options.firmwarePath, options.mode, options.connectWindowMs, + ); + this.listenerProxy = new com.faceclaw.app.FaceclawFirmwareFlasherListener({ + onLog: (line: string) => this.logListener?.(String(line)), + onProgress: (_lens: string, _component: number, _components: number, _block: number, _blocks: number, sent: number, total: number) => + this.progressListener?.(Number(sent), Number(total)), + onState: (state: string) => this.stateListener?.(String(state)), + onComplete: (success: boolean, detail: string) => this.completion?.(Boolean(success), String(detail ?? "")), + }); + this.flasher.setListener(this.listenerProxy); + } + + onLog(listener: (line: string) => void): void { + this.logListener = listener; + } + + onProgress(listener: (bytesSent: number, bytesTotal: number) => void): void { + this.progressListener = listener; + } + + onState(listener: (state: string) => void): void { + this.stateListener = listener; + } + + run(): Promise { + return new Promise((resolve, reject) => { + this.completion = (success, detail) => { + this.completion = null; + if (success) resolve(parseG1FlashResult(detail)); + else reject(new Error(detail || "The install failed.")); + }; + this.flasher.start(); + }); + } + + cancel(): void { + this.flasher.cancel(); + } + + close(): void { + this.flasher.close(); + } +} diff --git a/app/native/ios-bluetooth.ts b/app/native/ios-bluetooth.ts index 5c523858..3de713f1 100644 --- a/app/native/ios-bluetooth.ts +++ b/app/native/ios-bluetooth.ts @@ -129,6 +129,15 @@ export class IosBluetooth { }) return result } + /** The peripheral last heard at this address, if it was on this side. */ + peripheralIdentifier(address: string, role: string): string | null { + try { + const saved = JSON.parse(ApplicationSettings.getString(`ios.ble.peripheral.${address}`, '{}')) + return saved.role === role && typeof saved.identifier === 'string' ? saved.identifier : null + } catch { + return null + } + } forget(address: string): void { ApplicationSettings.remove(`ios.ble.peripheral.${address}`); this.devices.delete(address) } } let instance: IosBluetooth | null = null diff --git a/app/phone-ui/g1-flash-view-model.ts b/app/phone-ui/g1-flash-view-model.ts new file mode 100644 index 00000000..4f901f27 --- /dev/null +++ b/app/phone-ui/g1-flash-view-model.ts @@ -0,0 +1,345 @@ +import { Frame, Observable } from "@nativescript/core"; + +import { G1ArmScanner } from "../g1/arm-scanner"; +import { G1V0_IMAGE } from "../g1/firmware/g1v0-image"; +import { buildG1Firmware, type BuiltG1Firmware, type G1BuildProgress } from "../g1/firmware-builder"; +import { saveG1Arm, saveG1Pair } from "../g1/addresses"; +import { G1_CASE_INSTRUCTIONS, G1_INSTALL_NOTICE, G1_SIDES, g1FlashPercent, type G1FlashResult, type G1Side } from "../g1/flash-plan"; +import { loadDeviceAddresses, loadPairedGlassesIdentity } from "../g2/device-addresses"; +import { downloadAndExtractEvenHubFonts, hasExtractedEvenHubFonts } from "../g2/firmware-builder"; +import { type GlassesPairCandidate } from "../g2/pairing-candidates"; +import { resumeAutoReconnect, suppressAutoReconnect } from "../g2/reconnect-policy"; +import { ensureBlePermissions } from "../native/ble-permissions"; +import { G1Flasher, type G1FlasherOptions } from "../native/g1-flasher"; +import { formatErrorMessage } from "../util/format-error"; +import { finishOnboardingNavigation } from "./onboarding-navigation"; +import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; + +type Phase = "intro" | "preparing" | "flashing" | "flashed" | "error" | "unavailable"; + +const LOCATE_MS = 45_000; +/** An arm takes about 20 s to copy the image, and a hung boot resets itself within two minutes. */ +const RETURN_MS = 240_000; +const CONNECT_MS = 60_000; +/** A new arm pairs only once it knows it's in the case, which a full case can take a while to tell it. */ +const FIRST_PAIRING_MS = 120_000; + +/** + * The install page on a G1, in place of OnboardingFlashViewModel. The two arms are separate devices that each take the + * image over MCUmgr (G1ArmFlashFlow), left first. There is nothing on the lens to confirm with before g1v0 is on the arm, + * so the confirmation is on the phone: the page before, or this one's intro. + * + * Every run starts by listening for what each arm runs now, so a retry picks up wherever the last one stopped. An arm's + * new address is saved as soon as it's known. + */ +export class G1FlashViewModel extends Observable { + private phase: Phase = "intro"; + private readonly fromOnboarding: boolean; + private readonly scanner = new G1ArmScanner(); + private image: BuiltG1Firmware | null = null; + private flasher: G1Flasher | null = null; + private generation = 0; + private disposed = false; + private unpairedArm = false; + + headline = "Install Faceclaw's Firmware"; + status = ""; + log = ""; + busy = false; + progress = 0; + + constructor(options?: { mode?: "install" | "uninstall"; fromOnboarding?: boolean; autoStart?: boolean }) { + super(); + this.fromOnboarding = options?.fromOnboarding ?? true; + if (options?.mode === "uninstall") { + // Restoring Even's firmware has never been run on a real arm, and an arm whose network core is older than the + // image may not come back, so the phone doesn't offer it yet. + this.phase = "unavailable"; + this.headline = "Back to Even's Firmware"; + this.status = "Faceclaw can't restore Even's firmware on a G1 yet. It takes a computer: see \"Restore Even's firmware\" in " + + "the ScouterKit firmware's README."; + return; + } + suppressAutoReconnect(); + this.status = `${G1_CASE_INSTRUCTIONS}\n\n${G1_INSTALL_NOTICE}`; + if (options?.autoStart) void this.run(); + } + + // --- what the page binds -------------------------------------------------- + + get logVisibility(): "visible" | "collapse" { + return this.log ? "visible" : "collapse"; + } + + get busyVisibility(): "visible" | "collapse" { + return this.busy ? "visible" : "collapse"; + } + + get progressVisibility(): "visible" | "collapse" { + return this.phase === "flashing" ? "visible" : "collapse"; + } + + get primaryLabel(): string { + switch (this.phase) { + case "intro": + return "Install"; + case "flashed": + return "Finish"; + case "error": + return "Retry"; + default: + return ""; + } + } + + get primaryVisibility(): "visible" | "collapse" { + return this.primaryLabel ? "visible" : "collapse"; + } + + get secondaryLabel(): string { + return "Back"; + } + + get secondaryVisibility(): "visible" | "collapse" { + // No way out mid-install, or after one. + return this.phase === "preparing" || this.phase === "flashing" || this.phase === "flashed" ? "collapse" : "visible"; + } + + onPrimaryTap(): void { + if (this.phase === "intro" || this.phase === "error") void this.run(); + else if (this.phase === "flashed") this.finish(); + } + + onSecondaryTap(): void { + if (this.phase === "intro" || this.phase === "error" || this.phase === "unavailable") this.leave(); + } + + // --- the install ---------------------------------------------------------- + + private async run(): Promise { + const generation = ++this.generation; + const live = () => !this.disposed && generation === this.generation; + this.setPhase("preparing"); + this.setBusy(true); + this.setText("Preparing Firmware", "Getting the firmware ready..."); + try { + await ensureBlePermissions(); + if (!live()) return; + if (!this.image) { + this.image = await buildG1Firmware((progress) => { + if (live()) this.setStatus(describeBuild(progress)); + }); + this.appendLog(`firmware ${this.image.version} prepared and verified (${this.image.bytes.toLocaleString()} bytes)`); + } + await this.prepareFonts(live); + if (!live()) return; + + this.setPhase("flashing"); + this.setText("Installing Firmware", "Listening for your glasses..."); + const identity = loadPairedGlassesIdentity(); + const stored = loadDeviceAddresses(); + const pair = await this.scanner.waitForPair({ serial: identity?.serial, left: stored.left, right: stored.right }, LOCATE_MS); + if (!live()) return; + if (!pair) { + throw new Error("Couldn't hear both arms of your glasses. Make sure they're in the case with the lid open, and that no other app " + + "or phone is connected to them, then retry."); + } + saveG1Pair(pair); + + this.unpairedArm = false; + for (const side of G1_SIDES) { + await this.installArm(side, pair, live); + if (!live()) return; + } + this.finished(); + } catch (error) { + if (live()) this.failed(formatErrorMessage(error)); + } + } + + private async installArm(side: G1Side, pair: GlassesPairCandidate, live: () => boolean): Promise { + const arm = pair[side]!; + const fromStock = arm.g1Firmware === "stock"; + this.setProgress(g1FlashPercent(side, 0, 1)); + this.setStatus(`Connecting to the ${side} arm...`); + const installed = await this.flash({ + address: arm.address, + side, + firmwarePath: this.image!.path, + mode: fromStock ? "stock" : "update", + connectWindowMs: CONNECT_MS, + }, (state) => { + if (state === "pairing") this.setStatus(`Pairing with the ${side} arm. If your phone asks, accept it.`); + else if (state === "checking") this.setStatus(`Checking the ${side} arm...`); + else if (state === "flashing") this.setStatus(`Sending the firmware to the ${side} arm. Nothing has changed yet.`); + else if (state === "committing") this.setStatus(`Installing on the ${side} arm. Keep the glasses in the case.`); + }, (sent, total) => this.setProgress(g1FlashPercent(side, sent, total))); + if (!live()) return; + this.setProgress(g1FlashPercent(side, 1, 1)); + if (!installed.flashed) { + this.appendLog(`${side} arm already runs ${installed.version}`); + return; + } + + this.setStatus(`The ${side} arm is restarting into the new firmware. This takes about 20 seconds; keep it in the case.`); + const identity = loadPairedGlassesIdentity(); + const back = await this.scanner.waitForG1v0Arm(side, identity?.serial ?? pair.serial, RETURN_MS); + if (!live()) return; + if (!back) { + throw new Error(`The ${side} arm hasn't come back yet. Leave the glasses in the plugged-in case for a few minutes, with the lid ` + + "open: an interrupted install finishes by itself. Then retry."); + } + saveG1Arm(side, back); + if (back.g1Firmware === "g1v0-safe") { + throw new Error(`The ${side} arm came back in safe mode: the new firmware restarted repeatedly. Retry to install it again.`); + } + + this.setStatus(`Pairing with the ${side} arm. If your phone asks, accept it.`); + let running: G1FlashResult; + try { + running = await this.flash({ + address: back.address, + side, + firmwarePath: "", + mode: "probe", + connectWindowMs: fromStock ? FIRST_PAIRING_MS : RETURN_MS, + }); + } catch (error) { + if (!fromStock || !live()) throw error; + // Installed, as its advertising shows; it just won't pair yet. The next connection pairs it. + this.appendLog(`${side} arm not paired yet: ${formatErrorMessage(error)}`); + this.unpairedArm = true; + return; + } + if (!live()) return; + if (running.version !== installed.version) { + throw new Error(`The ${side} arm runs ${running.version}, not ${installed.version}: it didn't take the new firmware. Retry to try again.`); + } + this.appendLog(`${side} arm runs ${running.version}`); + } + + private async flash( + options: G1FlasherOptions, + onState?: (state: string) => void, + onProgress?: (sent: number, total: number) => void, + ) { + const flasher = new G1Flasher(options); + this.flasher = flasher; + flasher.onLog((line) => this.appendLog(line)); + if (onState) flasher.onState(onState); + if (onProgress) flasher.onProgress(onProgress); + try { + return await flasher.run(); + } finally { + if (this.flasher === flasher) this.flasher = null; + flasher.close(); + } + } + + /** A G2's install gets these from the same download; Faceclaw's fonts are a phone-side matter, so a failure here is no reason to stop. */ + private async prepareFonts(live: () => boolean): Promise { + if (hasExtractedEvenHubFonts()) return; + if (live()) this.setStatus("Preparing fonts..."); + try { + await downloadAndExtractEvenHubFonts(); + } catch (error) { + this.appendLog(`fonts not prepared: ${formatErrorMessage(error)}`); + } + } + + private finished(): void { + // The glasses are ready for the main page to connect to. + resumeAutoReconnect(); + this.setBusy(false); + this.setProgress(100); + this.setPhase("flashed"); + this.setText("All Done", `Both arms run Faceclaw's firmware ${G1V0_IMAGE.version}.` + (this.unpairedArm + ? " Keep the glasses in the case with the lid open until Faceclaw has connected: they only pair in the case." + : "")); + } + + private failed(message: string): void { + this.setBusy(false); + this.setPhase("error"); + this.setText("Something Went Wrong", message); + } + + private finish(): void { + setPreviewOnlyMode(false); + setOnboardingCompleted(true); + this.teardown(); + finishOnboardingNavigation(); + } + + private leave(): void { + this.teardown(); + const frame = Frame.topmost(); + if (this.fromOnboarding && frame?.canGoBack()) { + frame.goBack(); + return; + } + if (!this.fromOnboarding) { + finishOnboardingNavigation(); + return; + } + frame?.navigate({ moduleName: "phone-ui/onboarding-page", clearHistory: true }); + } + + dispose(): void { + this.disposed = true; + this.teardown(); + } + + private teardown(): void { + ++this.generation; + this.scanner.stop(); + this.flasher?.close(); + this.flasher = null; + } + + // --- page state ----------------------------------------------------------- + + private setText(headline: string, status: string): void { + this.set("headline", headline); + this.set("status", status); + } + + private setStatus(status: string): void { + this.set("status", status); + } + + private setBusy(busy: boolean): void { + this.set("busy", busy); + this.notifyPropertyChange("busyVisibility", this.busyVisibility); + } + + private setProgress(percent: number): void { + this.set("progress", Math.max(0, Math.min(100, Math.round(percent)))); + } + + private setPhase(phase: Phase): void { + this.phase = phase; + for (const property of ["primaryLabel", "primaryVisibility", "secondaryVisibility", "progressVisibility"] as const) { + this.notifyPropertyChange(property, this[property]); + } + } + + private appendLog(line: string): void { + const stamp = new Date().toISOString().slice(11, 19); + this.set("log", this.log ? `${this.log}\n[${stamp}] ${line}` : `[${stamp}] ${line}`); + this.notifyPropertyChange("logVisibility", this.logVisibility); + } +} + +function describeBuild(progress: G1BuildProgress): string { + switch (progress) { + case "downloading": + return "Downloading the parts it needs from Even's firmware server..."; + case "verifying": + return "Verifying the download..."; + case "assembling": + return "Assembling the firmware..."; + default: + return "Saving the firmware..."; + } +} diff --git a/app/phone-ui/main-page.xml b/app/phone-ui/main-page.xml index 846fa253..7868d259 100644 --- a/app/phone-ui/main-page.xml +++ b/app/phone-ui/main-page.xml @@ -15,6 +15,7 @@ + diff --git a/app/phone-ui/main-view-model.ts b/app/phone-ui/main-view-model.ts index 7f236cc6..5018f5b3 100644 --- a/app/phone-ui/main-view-model.ts +++ b/app/phone-ui/main-view-model.ts @@ -662,6 +662,14 @@ export class MainViewModel extends RemoteControlsViewModel { * auto-reconnect suppression right away. */ async onPrepareFontsTap(): Promise { + await this.openFirmwareCheck(); + } + + async onCheckFirmwareTap(): Promise { + await this.openFirmwareCheck(); + } + + private async openFirmwareCheck(): Promise { this.setWarningsModalVisible(false); if (this.phase === "connected" || this.phase === "charging" || this.phase === "connecting") { try { @@ -909,8 +917,9 @@ export class MainViewModel extends RemoteControlsViewModel { } private async openFlashPage(mode: "install" | "uninstall"): Promise { - // The flasher needs the glasses to itself, so drop the main connection first. - if (this.phase === "connected" || this.phase === "charging") { + // The flasher needs the glasses to itself, so drop the main connection first. That includes a session + // still retrying: an install brings arms back at the addresses it is dialling. + if (this.phase === "connected" || this.phase === "charging" || this.phase === "connecting") { try { await dashboardController.disconnect(); } catch { diff --git a/app/phone-ui/onboarding-firmware-check-view-model.ts b/app/phone-ui/onboarding-firmware-check-view-model.ts index 2b4cda27..87b146ed 100644 --- a/app/phone-ui/onboarding-firmware-check-view-model.ts +++ b/app/phone-ui/onboarding-firmware-check-view-model.ts @@ -18,11 +18,21 @@ import { type OnboardingFirmwareKind, } from "../g2/firmware-compat"; import { DeviceInfoProbe, DeviceInfoState } from "../native/device-info-probe"; +import { G1Flasher } from "../native/g1-flasher"; +import { saveG1Pair } from "../g1/addresses"; +import { G1ArmScanner } from "../g1/arm-scanner"; +import { G1V0_IMAGE } from "../g1/firmware/g1v0-image"; +import { G1_CASE_INSTRUCTIONS, G1_INSTALL_NOTICE, g1FirmwareState, type G1FlashResult, type G1Side } from "../g1/flash-plan"; +import { loadPairedGlassesIdentity } from "../g2/device-addresses"; +import { glassesTypeSetting } from "../ui/dashboard-settings"; import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; import { formatErrorMessage } from "../util/format-error"; type CheckPhase = "checking" | "fonts" | "custom" | "flashable" | "newer-validated" | "newer" | "error"; +const G1_LOCATE_MS = 30_000; +const G1_CHECK_CONNECT_MS = 45_000; + export class OnboardingFirmwareCheckViewModel extends Observable { private _phase: CheckPhase = "checking"; private _headline = "Checking Firmware"; @@ -31,7 +41,7 @@ export class OnboardingFirmwareCheckViewModel extends Observable { private generation = 0; - private probeInstance: DeviceInfoProbe | null = null; + private probeInstance: { close(): void } | null = null; constructor() { super(); @@ -175,6 +185,10 @@ export class OnboardingFirmwareCheckViewModel extends Observable { try { await ensureBlePermissions(); if (generation !== this.generation) return; + if (glassesTypeSetting.get() === "g1") { + await this.checkG1(generation); + return; + } const stored = loadDeviceAddresses(); if (!isValidMacAddress(stored.right)) { this.toError("No glasses address is configured. Go back and set the device addresses."); @@ -194,11 +208,72 @@ export class OnboardingFirmwareCheckViewModel extends Observable { this.applyClassification(kind, version, extension); } catch (error) { if (generation !== this.generation) return; - this.probeInstance = null; this.toError(this.formatError(error)); } } + /** + * What each arm's name says first, as that needs no connection: Even's firmware can't be asked in the same way, and an + * arm that is about to be replaced shouldn't have to pair. Only arms on g1v0 are asked which version they run. + */ + private async checkG1(generation: number): Promise { + this.status = "Listening for your glasses..."; + const scanner = new G1ArmScanner(); + this.probeInstance = { close: () => scanner.stop() }; + const stored = loadDeviceAddresses(); + const pair = await scanner.waitForPair({ serial: loadPairedGlassesIdentity()?.serial, left: stored.left, right: stored.right }, G1_LOCATE_MS); + if (generation !== this.generation) return; + this.probeInstance = null; + if (!pair) { + this.toError(`Couldn't hear both arms of your glasses. ${G1_CASE_INSTRUCTIONS} Make sure no other app or phone is connected to them, then retry.`); + return; + } + saveG1Pair(pair); + const named = [pair.left!.g1Firmware, pair.right!.g1Firmware]; + if (named.includes("stock")) { + this.showG1Install({ firmware: "stock" }); + return; + } + if (named.includes("g1v0-safe")) { + this.showG1Install({ safeMode: true }); + return; + } + const arms: G1FlashResult[] = []; + for (const side of ["left", "right"] as G1Side[]) { + const flasher = new G1Flasher({ address: pair[side]!.address, side, firmwarePath: "", mode: "probe", connectWindowMs: G1_CHECK_CONNECT_MS }); + this.probeInstance = flasher; + flasher.onState((state) => { + if (generation !== this.generation) return; + if (state === "pairing") { + this.status = `Pairing with the ${side} arm. If your phone asks, accept it. A G1 pairs only in its case, with the lid open.`; + } else { + this.status = `Checking the ${side} arm...`; + } + }); + arms.push(await flasher.run()); + if (generation !== this.generation) return; + this.disposeProbe(); + } + const state = g1FirmwareState(arms, G1V0_IMAGE.version); + if (state === "current") this.applyClassification("custom", arms[0]!.version ?? "", { kind: "none" }); + else this.showG1Install(state === "stock" ? { firmware: "stock" } : state === "safe-mode" ? { safeMode: true } : arms.find((arm) => arm.version) ?? {}); + } + + private showG1Install(found: G1FlashResult): void { + this.busy = false; + this.setPhase("flashable"); + if (found.firmware === "stock") { + this.headline = "Ready to Install"; + this.status = `Your glasses run Even's firmware.\n\n${G1_CASE_INSTRUCTIONS}\n\n${G1_INSTALL_NOTICE}`; + } else if (found.safeMode) { + this.headline = "Firmware Needs Reinstalling"; + this.status = `An arm of your glasses is in safe mode: its firmware restarted repeatedly. Installing it again usually fixes this.\n\n${G1_CASE_INSTRUCTIONS}`; + } else { + this.headline = "Firmware Update Available"; + this.status = `Your glasses run Faceclaw's firmware ${found.version ?? ""}, and this version of Faceclaw comes with ${G1V0_IMAGE.version}.\n\n${G1_CASE_INSTRUCTIONS}`; + } + } + private reportProbeState(state: DeviceInfoState, detail: string): void { // The probe brings up the right lens, then the left, and pairs with each // in turn (they are separate Bluetooth devices with separate bonds). @@ -326,7 +401,7 @@ export class OnboardingFirmwareCheckViewModel extends Observable { this.busy = false; this.setPhase("custom"); this.headline = extractedFonts ? "Fonts Ready" : "Custom Firmware Detected"; - const details = [ + const details = glassesTypeSetting.get() === "g1" ? [version].filter(Boolean) : [ extension.kind === "faceclaw" ? `revision ${extension.version}` : "", version ? `based on stock ${version}` : "", ].filter(Boolean); diff --git a/app/phone-ui/onboarding-flash-page.ts b/app/phone-ui/onboarding-flash-page.ts index 225dde33..8fa28948 100644 --- a/app/phone-ui/onboarding-flash-page.ts +++ b/app/phone-ui/onboarding-flash-page.ts @@ -1,5 +1,7 @@ import { NavigatedData, Page } from "@nativescript/core"; +import { glassesTypeSetting } from "../ui/dashboard-settings"; +import { G1FlashViewModel } from "./g1-flash-view-model"; import { FlashMode, OnboardingFlashViewModel } from "./onboarding-flash-view-model"; export function navigatingTo(args: NavigatedData): void { @@ -7,16 +9,17 @@ export function navigatingTo(args: NavigatedData): void { if (!page.bindingContext) { const context = (args.context as { mode?: FlashMode; fromOnboarding?: boolean; autoStart?: boolean } | undefined) ?? undefined; - page.bindingContext = new OnboardingFlashViewModel({ + const options = { mode: context?.mode ?? "install", fromOnboarding: context?.fromOnboarding ?? true, autoStart: context?.autoStart ?? false, - }); + }; + page.bindingContext = glassesTypeSetting.get() === "g1" ? new G1FlashViewModel(options) : new OnboardingFlashViewModel(options); } } export function navigatingFrom(args: NavigatedData): void { const page = args.object as Page; - (page.bindingContext as OnboardingFlashViewModel | undefined)?.dispose(); + (page.bindingContext as OnboardingFlashViewModel | G1FlashViewModel | undefined)?.dispose(); page.bindingContext = null; } diff --git a/app/phone-ui/onboarding-view-model.ts b/app/phone-ui/onboarding-view-model.ts index 897c2ffc..10cb3a1d 100644 --- a/app/phone-ui/onboarding-view-model.ts +++ b/app/phone-ui/onboarding-view-model.ts @@ -30,7 +30,7 @@ const STEP_CONTENT: Record = { 2: { headline: "Before You Continue", tagline: "", - body: "This software provides a custom user interface and functionality for the Even Realities G2 smart glasses. It is not created or supported by Even Realities. If this software somehow breaks your headset, this is not Even's fault and is not covered by the hardware's warranty. If this software doesn't break you headset, using this software may void the hardware's warranty anyways, at the sole discretion of Even Realities. This software is beta; don't rely on it for anything critically important." + + body: "This software provides a custom user interface and functionality for the Even Realities G2 and G1 smart glasses. It is not created or supported by Even Realities. If this software somehow breaks your headset, this is not Even's fault and is not covered by the hardware's warranty. If this software doesn't break you headset, using this software may void the hardware's warranty anyways, at the sole discretion of Even Realities. This software is beta; don't rely on it for anything critically important." + (global.isIOS ? "\n\niOS / TestFlight privacy\n\n" + IOS_PRIVACY_NOTICE : ""), primaryLabel: "Agree", secondaryLabel: "Back", @@ -40,7 +40,7 @@ const STEP_CONTENT: Record = { 3: { headline: "Custom Firmware Required", tagline: "", - body: "Faceclaw only runs on Even Realities G2 glasses that have Faceclaw's custom firmware installed. You have two choices:\n\n• Preview Only — explore Faceclaw's interface on your phone's screen without pairing any glasses. Nothing is written to a headset.\n\n• Flash Firmware — install the custom firmware on your glasses now, then use Faceclaw for real.\n\nFlashing replaces the official firmware. You can uninstall and return to the official firmware later, by reconnecting the official Even Realities app. Installing custom firmware is not covered by warranty.", + body: "Faceclaw only runs on Even Realities G2 or G1 glasses that have Faceclaw's custom firmware installed. You have two choices:\n\n• Preview Only — explore Faceclaw's interface on your phone's screen without pairing any glasses. Nothing is written to a headset.\n\n• Flash Firmware — install the custom firmware on your glasses now, then use Faceclaw for real.\n\nFlashing replaces the official firmware. On a G2 you can uninstall and return to the official firmware later, by reconnecting the official Even Realities app; on a G1 that takes a computer. Installing custom firmware is not covered by warranty.", primaryLabel: "Flash Firmware", secondaryLabel: "Preview Only", splash: false, diff --git a/app/phone-ui/pairing-view-model.ts b/app/phone-ui/pairing-view-model.ts index 82309f18..6e96d225 100644 --- a/app/phone-ui/pairing-view-model.ts +++ b/app/phone-ui/pairing-view-model.ts @@ -358,8 +358,7 @@ export class PairingViewModel extends Observable { ring: ringAddress, }; saveDeviceAddresses(addresses); - const g1 = !!pair?.g1Firmware; - if (pair) glassesTypeSetting.set(g1 ? "g1" : "g2"); + if (pair) glassesTypeSetting.set(pair.g1Firmware ? "g1" : "g2"); if (pair) { savePairedGlassesIdentity({ serial: pair.serial ?? "", @@ -386,12 +385,6 @@ export class PairingViewModel extends Observable { this.dispose(); if (this.onboarding) { setPreviewOnlyMode(false); - if (g1) { - // The G2 firmware check and flash pages don't apply: a G1's firmware is installed from a - // computer, and the session reports incompatible firmware if it lacks the display path. - finishOnboardingNavigation(); - return; - } // Continue the onboarding chain: check the glasses' firmware next. Frame.topmost()?.navigate({ moduleName: "phone-ui/onboarding-firmware-check-page" }); return; diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt new file mode 100644 index 00000000..5238b689 --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt @@ -0,0 +1,467 @@ +package com.faceclaw.app + +import kotlin.concurrent.Volatile +import kotlin.jvm.JvmField + +class G1FlashTimings( + @JvmField val connectTimeoutMs: Int = ConnectionOptions.CONNECT_TIMEOUT_MS, + @JvmField val servicesTimeoutMs: Int = ConnectionOptions.SERVICES_TIMEOUT_MS, + @JvmField val descriptorTimeoutMs: Int = ConnectionOptions.DESCRIPTOR_TIMEOUT_MS, + @JvmField val writeTimeoutMs: Int = ConnectionOptions.WRITE_TIMEOUT_MS, + /** The OS may be showing its pairing dialog. */ + @JvmField val pairingMs: Int = 60_000, + @JvmField val retryDelayMs: Int = 2_000, + @JvmField val controlReplyMs: Int = 1_500, + @JvmField val controlTries: Int = 4, + /** The first chunk of an upload waits for the arm to erase its slot. */ + @JvmField val uploadReplyMs: Int = 30_000, + @JvmField val smpReplyMs: Int = 20_000, + /** The arm may go down before its reply leaves. */ + @JvmField val resetReplyMs: Int = 5_000, + @JvmField val heartbeatMs: Int = 8_000, + @JvmField val pollMs: Int = 200, + @JvmField val uploadRetries: Int = 40, +) + +/** + * Installs an MCUboot image on one G1 arm through MCUmgr SMP, or asks an arm what it runs; a port of scouter_kit's + * g1_firmware/flash.py. The caller handles one arm at a time, left first, and looks for the arm again afterwards: it + * restarts, and coming off Even's firmware it has a new address. + * + * Nothing changes on the arm until the confirm, which comes only after the arm's image list shows that its second slot + * holds exactly this image. MCUboot then overwrites the running firmware with no way back. [run] blocks; the worker thread + * is the host's. + */ +class G1ArmFlashFlow( + private val link: StockLink, + private val address: String, + private val side: String, + private val firmwarePath: String, + private val mode: Mode, + /** How long to keep trying to reach the arm and pair with it. */ + private val connectWindowMs: Int, + private val listener: FaceclawFirmwareFlasherListener, + private val timings: G1FlashTimings = G1FlashTimings(), + platform: ProtocolPlatform = protocolPlatform(), + private val readImage: (String) -> ByteArray = ::readFileData, +) : StockLinkListener { + enum class Mode { + /** The arm runs Even's firmware. */ + STOCK, + /** The arm runs g1v0: it answers what it runs, and an arm that already has this version is left alone. */ + UPDATE, + /** Only say what the arm runs, and pair with it. */ + PROBE, + } + + companion object { + const val TAG = "FaceclawG1Flash" + private const val MIN_BATTERY_PERCENT = 30 + + fun mode(name: String): Mode = when (name) { + "stock" -> Mode.STOCK + "update" -> Mode.UPDATE + "probe" -> Mode.PROBE + else -> throw IllegalArgumentException("unknown mode $name") + } + } + + private class LinkLostException(message: String) : Exception(message) + + /** The arm has no g1v0 service. */ + private class NotG1v0Exception : Exception("this arm doesn't run g1v0") + + private val platform = platform + private val lock = platform.createLock() + private val sleeper = InterruptibleSleep(platform) + private val assembler = G1Smp.Assembler() + + private var smpSeq = -1 + private var smpReply: Map<*, *>? = null + private var smpLatch: Latch? = null + private var nextSmpSeq = 0 + + private var controlTag = -1 + private var controlReply: G1Protocol.Reply? = null + private var controlLatch: Latch? = null + private var nextControlTag = 0 + + private var linkLost = false + private var heartbeats = 0 + private var nextHeartbeatAtMs = 0L + + @Volatile + private var cancelled = false + + fun cancel() { + cancelled = true + lock.withLock { + smpLatch?.countDown() + controlLatch?.countDown() + } + sleeper.interrupt() + } + + fun run() { + link.setListener(this) + try { + if (mode == Mode.PROBE) probe() else install() + } catch (e: Exception) { + val message = if (cancelled) "Cancelled." else StockLinkSession.messageOf(e) + log("failed: $message") + listener.onState("error", message) + listener.onComplete(false, message) + } finally { + quietly { link.disconnect(address) } + } + } + + private fun probe() { + listener.onState("connecting", side) + try { + bringUp() + } catch (e: NotG1v0Exception) { + listener.onComplete(true, """{"firmware":"stock"}""") + return + } + listener.onState("checking", side) + val hello = hello() + listener.onComplete(true, """{"firmware":"g1v0","version":"${hello.version}","safeMode":${hello.safeMode},"inCase":${hello.inCase},"battery":${batteryPercent()}}""") + } + + private fun install() { + listener.onState("validating", side) + val image = try { + readImage(firmwarePath) + } catch (e: Exception) { + throw IllegalStateException("could not read the firmware: " + StockLinkSession.messageOf(e), e) + } + val version = G1Smp.imageVersion(image) + val hash = G1Smp.imageHash(image) + log("image $version, ${image.size} bytes, hash ${BinaryEncoding.bytesToHex(hash.copyOf(8))}") + + listener.onState("connecting", side) + bringUp() + if (mode == Mode.UPDATE) { + listener.onState("checking", side) + val hello = hello() + log("runs g1v0 ${hello.version}, safe mode ${hello.safeMode}, in the case ${hello.inCase}, encrypted ${hello.encrypted}") + if (hello.version == version && !hello.safeMode) { + listener.onComplete(true, """{"flashed":false,"version":"$version"}""") + return + } + val battery = batteryPercent() + if (battery != null && battery < MIN_BATTERY_PERCENT) { + throw IllegalStateException("The $side arm's battery is at $battery%, too low to install safely. " + + "Charge both arms to at least $MIN_BATTERY_PERCENT% in the case, then try again.") + } + } + + val slots = retrying { images() } + for (slot in slots) log(slot.toString()) + listener.onState("flashing", side) + if (holdsImage(slots, hash)) { + log("the second slot already holds this image") + listener.onProgress(side, 1, 1, image.size, image.size, image.size.toLong(), image.size.toLong()) + } else { + val startedAt = now() + upload(image) + log("uploaded in ${(now() - startedAt) / 1000} s") + } + if (!holdsImage(retrying { images() }, hash)) { + throw IllegalStateException("The $side arm's second slot doesn't hold the image after the upload. Nothing was installed.") + } + throwIfCancelled() + + listener.onState("committing", side) + val confirm = smp(G1Smp.OP_WRITE, G1Smp.GROUP_IMAGE, G1Smp.CMD_IMAGE_STATE, G1Smp.confirmRequest(hash), timings.smpReplyMs) + val code = G1Smp.replyCode(confirm) + if (code != 0) throw IllegalStateException("The $side arm refused the image (error $code). Nothing was installed.") + log("confirmed: MCUboot installs it at the next boot") + try { + smp(G1Smp.OP_WRITE, G1Smp.GROUP_OS, G1Smp.CMD_OS_RESET, emptyMap(), timings.resetReplyMs) + } catch (e: StockTimeoutException) { + log("no answer to the reset") + } catch (e: LinkLostException) { + log("the link went down with the reset") + } + listener.onState("rebooting", side) + listener.onComplete(true, """{"flashed":true,"version":"$version"}""") + } + + private fun holdsImage(slots: List, hash: ByteArray): Boolean = + slots.any { it.image == 0 && it.slot == 1 && it.hash.contentEquals(hash) } + + private fun images(): List = + G1Smp.parseSlots(smp(G1Smp.OP_READ, G1Smp.GROUP_IMAGE, G1Smp.CMD_IMAGE_STATE, emptyMap(), timings.smpReplyMs)) + + /** MCUmgr answers each chunk with the offset it wants next, so an upload resumes after a lost link. */ + private fun upload(image: ByteArray) { + val fileSha = sha256(image) + var offset = 0 + var failures = 0 + while (offset < image.size) { + throwIfCancelled() + val reply = try { + smp(G1Smp.OP_WRITE, G1Smp.GROUP_IMAGE, G1Smp.CMD_IMAGE_UPLOAD, G1Smp.uploadRequest(image, offset, fileSha), timings.uploadReplyMs) + } catch (e: Exception) { + if (e !is StockTimeoutException && e !is LinkLostException) throw e + failures++ + if (failures > timings.uploadRetries) throw e + log("chunk at $offset failed (${e.message}), trying again") + reconnectIfNeeded() + continue + } + val code = G1Smp.replyCode(reply) + val next = G1Smp.replyOffset(reply) + if (code != 0 || next == null || next < 0 || next > image.size) { + throw IllegalStateException("The $side arm refused the upload at $offset (error $code). Nothing was installed.") + } + offset = next + listener.onProgress(side, 1, 1, offset, image.size, offset.toLong(), image.size.toLong()) + } + } + + private fun retrying(request: () -> T): T { + var attempt = 0 + while (true) { + try { + return request() + } catch (e: Exception) { + if (e !is StockTimeoutException && e !is LinkLostException) throw e + attempt++ + if (attempt >= 10) throw e + log("request failed (${e.message}), trying again") + reconnectIfNeeded() + } + } + } + + private fun reconnectIfNeeded() { + throwIfCancelled() + lock.withLock { assembler.reset() } + if (!link.isConnected(address)) bringUp() + } + + // ---- the link ------------------------------------------------------------ + + private fun bringUp() { + val deadline = now() + connectWindowMs + var attempt = 0 + while (true) { + throwIfCancelled() + attempt++ + val failure = try { + connectOnce() + log("connected (attempt $attempt)") + return + } catch (e: NotG1v0Exception) { + throw e + } catch (e: Exception) { + StockLinkSession.messageOf(e) + } + log("connect attempt $attempt failed: $failure") + quietly { link.disconnect(address) } + if (now() >= deadline) { + throw IllegalStateException("Couldn't reach the $side arm: $failure." + if (mode == Mode.STOCK) { + " If this phone was paired with these glasses before, remove them from its Bluetooth settings and try again." + } else { + "" + }) + } + sleeper.sleep(timings.retryDelayMs.toLong()) + } + } + + private fun connectOnce() { + if (!link.connect(address, timings.connectTimeoutMs)) throw IllegalStateException("connect failed") + lock.withLock { + linkLost = false + assembler.reset() + } + link.prepareLink(address, G1Ble.REQUESTED_MTU, timings.connectTimeoutMs) + if (!link.discoverServices(address, timings.servicesTimeoutMs)) throw IllegalStateException("service discovery failed") + if (mode == Mode.STOCK) { + // Even's firmware serves its own service only on an encrypted link, and the heartbeat goes there. + settleBond() + if (!link.enableNotifications(address, G1Smp.NUS_TX_UUID, timings.descriptorTimeoutMs)) { + throw IllegalStateException("no link to Even's service") + } + heartbeats = 0 + nextHeartbeatAtMs = 0 + } else { + if (!link.enableNotifications(address, G1Ble.EVT_CHAR_UUID, timings.descriptorTimeoutMs)) { + if (!link.isConnected(address)) throw LinkLostException("the link went down") + throw NotG1v0Exception() + } + // Out of the case the arm obeys only an encrypted link. + settleBond() + val paired = try { + link.writeFrames(address, G1Ble.PAIR_CHAR_UUID, listOf(byteArrayOf(1)), GattWriteMode.WITH_RESPONSE, timings.pairingMs) + } catch (e: IllegalStateException) { + false + } + if (!paired) throw IllegalStateException("no encrypted link: an arm pairs only in its case") + } + if (mode != Mode.PROBE && !link.enableNotifications(address, G1Smp.SMP_CHAR_UUID, timings.descriptorTimeoutMs)) { + throw IllegalStateException("no update service") + } + } + + /** Asks the OS to pair if it hasn't, and waits for that to end; a platform that doesn't say pairs by itself. */ + private fun settleBond() { + if (link.bondState(address) == BondState.NONE) { + listener.onState("pairing", side) + link.requestBond(address) + } + val deadline = now() + timings.pairingMs + var sawBonding = false + while (true) { + throwIfCancelled() + when (link.bondState(address)) { + BondState.BONDED, BondState.UNKNOWN -> return + BondState.BONDING -> sawBonding = true + BondState.NONE -> if (sawBonding) throw IllegalStateException("pairing was refused") + } + if (!link.isConnected(address)) throw LinkLostException("the link went down while pairing") + if (now() >= deadline) throw IllegalStateException("pairing took too long") + sleeper.sleep(timings.pollMs.toLong()) + } + } + + private fun heartbeatIfDue() { + if (mode != Mode.STOCK || now() < nextHeartbeatAtMs) return + val seq = heartbeats % 0xff + heartbeats++ + nextHeartbeatAtMs = now() + timings.heartbeatMs + try { + link.writeFrames(address, G1Smp.NUS_RX_UUID, listOf(G1Smp.stockHeartbeat(seq)), GattWriteMode.WITHOUT_RESPONSE, timings.writeTimeoutMs) + } catch (e: IllegalStateException) { + // The request waiting now finds out. + } + } + + private fun smp(op: Int, group: Int, cmd: Int, payload: Map, timeoutMs: Int): Map<*, *> { + val seq = nextSmpSeq + nextSmpSeq = (nextSmpSeq + 1) and 0xff + val latch = Latch(1, platform) + lock.withLock { + smpSeq = seq + smpReply = null + smpLatch = latch + } + try { + heartbeatIfDue() + val frames = G1Smp.split(G1Smp.frame(op, group, seq, cmd, payload), link.negotiatedMtu(address)) + val written = try { + link.writeFrames(address, G1Smp.SMP_CHAR_UUID, frames, GattWriteMode.WITHOUT_RESPONSE, timings.writeTimeoutMs) + } catch (e: IllegalStateException) { + false + } + if (!written) throw LinkLostException("write failed") + val deadline = now() + timeoutMs + while (true) { + throwIfCancelled() + heartbeatIfDue() + val remaining = deadline - now() + if (remaining <= 0) throw StockTimeoutException("no answer from the $side arm within $timeoutMs ms") + latch.await(minOf(remaining, timings.pollMs.toLong())) + val (reply, lost) = lock.withLock { smpReply to linkLost } + if (reply != null) return reply + if (lost) throw LinkLostException("the link went down") + } + } finally { + lock.withLock { + if (smpLatch === latch) smpLatch = null + } + } + } + + private fun control(op: Int, body: ByteArray = ByteArray(0)): G1Protocol.Reply { + repeat(timings.controlTries) { + val tag = nextControlTag % 255 + 1 + nextControlTag = tag + val latch = Latch(1, platform) + lock.withLock { + controlTag = tag + controlReply = null + controlLatch = latch + } + val written = try { + link.writeFrames(address, G1Ble.CTRL_CHAR_UUID, listOf(G1Protocol.control(op, tag, body)), GattWriteMode.WITHOUT_RESPONSE, timings.writeTimeoutMs) + } catch (e: IllegalStateException) { + false + } + if (!written) throw LinkLostException("write failed") + latch.await(timings.controlReplyMs.toLong()) + throwIfCancelled() + val (reply, lost) = lock.withLock { + controlLatch = null + controlReply to linkLost + } + if (reply != null) return reply + if (lost) throw LinkLostException("the link went down") + } + throw StockTimeoutException("no answer to request $op from the $side arm") + } + + private fun hello(): G1Protocol.Hello { + val reply = control(G1Protocol.OP_HELLO) + return G1Protocol.parseHello(reply.body) ?: throw IllegalStateException("The $side arm's firmware isn't one this app knows.") + } + + /** Null when the arm doesn't know yet, or a firmware doesn't say. */ + private fun batteryPercent(): Int? { + val reply = control(G1Protocol.OP_PROPS, byteArrayOf(G1Protocol.PROP_BATT_PCT.toByte())) + if (reply.status != 0) return null + val value = G1Protocol.parseProps(reply.body, 1)?.get(0) ?: return null + return if (value in 0..100) value else null + } + + private fun throwIfCancelled() { + if (cancelled) throw IllegalStateException("Cancelled.") + } + + private fun now(): Long = platform.elapsedRealtimeMs() + + private fun log(line: String) = listener.onLog("$side arm: $line") + + private inline fun quietly(action: () -> Unit) { + try { + action() + } catch (ignored: Exception) { + } + } + + // ---- inbound ------------------------------------------------------------- + + override fun onNotification(address: String, characteristicUuid: String, data: ByteArray) { + if (characteristicUuid.equals(G1Smp.SMP_CHAR_UUID, ignoreCase = true)) { + lock.withLock { + for ((seq, body) in assembler.feed(data)) { + if (seq == smpSeq) { + smpReply = body + smpLatch?.countDown() + } + } + } + } else if (characteristicUuid.equals(G1Ble.EVT_CHAR_UUID, ignoreCase = true)) { + val reply = G1Protocol.parseReply(data) ?: return + lock.withLock { + if (reply.tag == controlTag) { + controlReply = reply + controlLatch?.countDown() + } + } + } + } + + override fun onConnectionStateChange(address: String, connected: Boolean) { + if (connected) return + lock.withLock { + linkLost = true + smpLatch?.countDown() + controlLatch?.countDown() + } + } +} diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt index 93770653..f3b46acc 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt @@ -11,6 +11,19 @@ object G1Ble { /** Faceclaw's records (VM.md §6.11). */ const val FC_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4405" const val REQUESTED_MTU = 247 + /** The oldest firmware this app works with: `PROP_SET` came in here. */ + const val REQUIRED_FIRMWARE = "0.5.63" + + /** Dotted versions, component by component. */ + fun firmwareAtLeast(version: String, required: String = REQUIRED_FIRMWARE): Boolean { + val have = version.split(".").map { it.toIntOrNull() ?: 0 } + val want = required.split(".").map { it.toIntOrNull() ?: 0 } + for (i in 0 until maxOf(have.size, want.size)) { + val delta = have.getOrElse(i) { 0 } - want.getOrElse(i) { 0 } + if (delta != 0) return delta > 0 + } + return true + } } /** diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt new file mode 100644 index 00000000..581e4279 --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt @@ -0,0 +1,291 @@ +package com.faceclaw.app + +import kotlin.jvm.JvmField + +/** The part of CBOR that MCUmgr uses: integers, byte and text strings, arrays, maps, booleans and null. */ +object G1Cbor { + fun encode(value: Any?): ByteArray { + val out = Output() + write(out, value) + return out.toByteArray() + } + + fun decode(data: ByteArray, start: Int = 0): Any? = Reader(data, start).value() + + private class Output { + private var bytes = ByteArray(256) + private var size = 0 + + private fun reserve(extra: Int) { + if (size + extra > bytes.size) bytes = bytes.copyOf(maxOf(bytes.size * 2, size + extra)) + } + + fun add(byte: Int) { + reserve(1) + bytes[size++] = byte.toByte() + } + + fun add(data: ByteArray) { + reserve(data.size) + data.copyInto(bytes, size) + size += data.size + } + + fun toByteArray(): ByteArray = bytes.copyOf(size) + } + + private fun head(out: Output, major: Int, n: Long) { + val first = major shl 5 + val width = when { + n < 24 -> { + out.add(first or n.toInt()) + return + } + n < 0x100L -> 1 + n < 0x10000L -> 2 + n < 0x100000000L -> 4 + else -> 8 + } + out.add(first or (24 + width.countTrailingZeroBits())) + for (i in width - 1 downTo 0) out.add(((n ushr (8 * i)) and 0xff).toInt()) + } + + private fun write(out: Output, value: Any?) { + when (value) { + null -> out.add(0xf6) + is Boolean -> out.add(if (value) 0xf5 else 0xf4) + is Int -> write(out, value.toLong()) + is Long -> if (value >= 0) head(out, 0, value) else head(out, 1, -1 - value) + is ByteArray -> { + head(out, 2, value.size.toLong()) + out.add(value) + } + is String -> { + val text = value.encodeToByteArray() + head(out, 3, text.size.toLong()) + out.add(text) + } + is List<*> -> { + head(out, 4, value.size.toLong()) + for (item in value) write(out, item) + } + is Map<*, *> -> { + head(out, 5, value.size.toLong()) + for ((key, item) in value) { + write(out, key) + write(out, item) + } + } + else -> throw IllegalArgumentException("not CBOR: $value") + } + } + + private class Reader(private val data: ByteArray, private var at: Int) { + private fun u8(): Int { + if (at >= data.size) throw IllegalArgumentException("CBOR cut short") + return data[at++].toInt() and 0xff + } + + fun value(): Any? { + val first = u8() + val major = first ushr 5 + val info = first and 31 + val n: Long? = when { + info < 24 -> info.toLong() + info in 24..27 -> { + var v = 0L + repeat(1 shl (info - 24)) { v = (v shl 8) or u8().toLong() } + v + } + info == 31 -> null + else -> throw IllegalArgumentException("bad CBOR header $first") + } + return when (major) { + 0 -> n ?: throw IllegalArgumentException("bad CBOR integer") + 1 -> -1 - (n ?: throw IllegalArgumentException("bad CBOR integer")) + 2, 3 -> { + val size = (n ?: throw IllegalArgumentException("indefinite CBOR string")).toInt() + if (size < 0 || at + size > data.size) throw IllegalArgumentException("CBOR cut short") + val bytes = data.copyOfRange(at, at + size) + at += size + if (major == 2) bytes else bytes.decodeToString() + } + 4 -> { + val items = ArrayList() + while (more(n, items.size)) items.add(value()) + if (n == null) at++ + items + } + 5 -> { + val items = LinkedHashMap() + while (more(n, items.size)) { + val key = value() + items[key] = value() + } + if (n == null) at++ + items + } + 7 -> when (info) { + 20 -> false + 21 -> true + 22 -> null + else -> throw IllegalArgumentException("unsupported CBOR simple value $info") + } + else -> throw IllegalArgumentException("unsupported CBOR major type $major") + } + } + + /** An indefinite-length array or map (what Zephyr's image list uses) ends at a 0xFF. */ + private fun more(n: Long?, count: Int): Boolean { + if (n != null) return count < n + if (at >= data.size) throw IllegalArgumentException("CBOR cut short") + return (data[at].toInt() and 0xff) != 0xff + } + } +} + +/** + * MCUmgr SMP, the update service of both Even's firmware and g1v0: as much of it as installing an image takes, and what + * an MCUboot image says about itself. The same requests as scouter_kit's tools/g1host.py (class Smp), which was proven on + * real arms first. + */ +object G1Smp { + const val SMP_CHAR_UUID = "da2e7828-fbce-4e01-ae9e-261174997c48" + const val NUS_RX_UUID = "6e400002-b5a3-f393-e0a9-e50e24dcca9e" + const val NUS_TX_UUID = "6e400003-b5a3-f393-e0a9-e50e24dcca9e" + + const val OP_READ = 0 + const val OP_WRITE = 2 + const val GROUP_OS = 0 + const val GROUP_IMAGE = 1 + const val CMD_IMAGE_STATE = 0 + const val CMD_IMAGE_UPLOAD = 1 + const val CMD_OS_RESET = 5 + const val UPLOAD_CHUNK = 2048 + private const val HEADER = 8 + + /** Even's firmware drops a link it hears no heartbeat on. */ + fun stockHeartbeat(seq: Int): ByteArray = + byteArrayOf(0x25, 0x06, 0x00, seq.toByte(), 0x04, seq.toByte()) + + fun frame(op: Int, group: Int, seq: Int, cmd: Int, payload: Map): ByteArray { + val body = G1Cbor.encode(payload) + val out = ByteArray(HEADER + body.size) + out[0] = op.toByte() + out[2] = (body.size ushr 8).toByte() + out[3] = body.size.toByte() + out[4] = (group ushr 8).toByte() + out[5] = group.toByte() + out[6] = seq.toByte() + out[7] = cmd.toByte() + body.copyInto(out, HEADER) + return out + } + + /** One ATT write at most [mtu] - 3 bytes long; MCUmgr joins them again. */ + fun split(frame: ByteArray, mtu: Int): List { + val size = maxOf(mtu - 3, 20) + return (frame.indices step size).map { frame.copyOfRange(it, minOf(it + size, frame.size)) } + } + + /** The first chunk also says what is coming, which lets the arm resume an upload of the same file. */ + fun uploadRequest(image: ByteArray, offset: Int, fileSha256: ByteArray): Map { + val data = image.copyOfRange(offset, minOf(offset + UPLOAD_CHUNK, image.size)) + return if (offset == 0) { + mapOf("image" to 0, "len" to image.size, "off" to 0, "sha" to fileSha256, "data" to data, "upgrade" to false) + } else { + mapOf("off" to offset, "data" to data) + } + } + + fun confirmRequest(imageHash: ByteArray): Map = mapOf("hash" to imageHash, "confirm" to true) + + /** Joins notifications into replies; [feed] gives each complete one as sequence number and body. */ + class Assembler { + private var pending = ByteArray(0) + + fun reset() { + pending = ByteArray(0) + } + + fun feed(data: ByteArray): List>> { + pending += data + val replies = ArrayList>>() + while (pending.size >= HEADER) { + val size = ((pending[2].toInt() and 0xff) shl 8) or (pending[3].toInt() and 0xff) + if (pending.size < HEADER + size) break + val seq = pending[6].toInt() and 0xff + val body = try { + if (size == 0) emptyMap() else G1Cbor.decode(pending, HEADER) as? Map<*, *> + } catch (e: IllegalArgumentException) { + null + } + if (body == null) { + // A frame cut by a lost link: the request is sent again. + pending = ByteArray(0) + break + } + pending = pending.copyOfRange(HEADER + size, pending.size) + replies.add(seq to body) + } + return replies + } + } + + class Slot( + @JvmField val image: Int, + @JvmField val slot: Int, + @JvmField val version: String, + @JvmField val hash: ByteArray, + @JvmField val flags: List, + ) { + override fun toString(): String = + "image $image slot $slot: $version ${BinaryEncoding.bytesToHex(hash.copyOf(minOf(8, hash.size)))} ${flags.joinToString(" ")}".trim() + } + + fun parseSlots(reply: Map<*, *>): List { + val images = reply["images"] as? List<*> ?: return emptyList() + return images.mapNotNull { item -> + val entry = item as? Map<*, *> ?: return@mapNotNull null + val hash = entry["hash"] as? ByteArray ?: return@mapNotNull null + Slot((entry["image"] as? Long ?: 0L).toInt(), (entry["slot"] as? Long ?: -1L).toInt(), entry["version"] as? String ?: "?", hash, + listOf("bootable", "pending", "confirmed", "active", "permanent").filter { entry[it] == true }) + } + } + + fun replyCode(reply: Map<*, *>): Int = (reply["rc"] as? Long ?: 0L).toInt() + + fun replyOffset(reply: Map<*, *>): Int? = (reply["off"] as? Long)?.toInt() + + /** The dotted version in an MCUboot header. */ + fun imageVersion(image: ByteArray): String { + requireImage(image) + val revision = (image[22].toInt() and 0xff) or ((image[23].toInt() and 0xff) shl 8) + return "${image[20].toInt() and 0xff}.${image[21].toInt() and 0xff}.$revision" + } + + /** The SHA-256 TLV: how MCUmgr names an image. */ + fun imageHash(image: ByteArray): ByteArray { + requireImage(image) + var at = u16(image, 8) + u32(image, 12) + require(at + 4 <= image.size && u16(image, at) == 0x6907) { "the image has no TLV area" } + val end = at + u16(image, at + 2) + require(end <= image.size) { "the image's TLV area is cut short" } + at += 4 + while (at + 4 <= end) { + val type = u16(image, at) + val size = u16(image, at + 2) + if (type == 0x10 && size == 32 && at + 4 + size <= end) return image.copyOfRange(at + 4, at + 4 + size) + at += 4 + size + } + throw IllegalArgumentException("the image has no SHA-256 TLV") + } + + private fun requireImage(image: ByteArray) { + require(image.size > 32 && u32(image, 0) == 0x96f3b83d.toInt()) { "not an MCUboot image" } + } + + private fun u16(data: ByteArray, at: Int): Int = (data[at].toInt() and 0xff) or ((data[at + 1].toInt() and 0xff) shl 8) + + private fun u32(data: ByteArray, at: Int): Int = u16(data, at) or (u16(data, at + 2) shl 16) +} diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt index b7a200f2..0e2cc4ec 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt @@ -48,6 +48,12 @@ interface StockLink { fun bondState(address: String): BondState + /** The ATT MTU agreed on this link. */ + fun negotiatedMtu(address: String): Int = 23 + + /** Ask the OS to pair with a connected device; a platform that pairs by itself on demand does nothing. */ + fun requestBond(address: String) {} + fun disconnect(address: String) fun close() diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt index 01f10c07..4edd75e6 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt @@ -94,6 +94,8 @@ internal object G1Timings { const val LENS_RIGHT = 2 } +/** What the Install prompt says an arm runs when it isn't g1v0. */ +private const val G1_OTHER_FIRMWARE = "Even's firmware" private val G1_PROPS = intArrayOf(G1Protocol.PROP_BATT_PCT, G1Protocol.PROP_CHARGE, G1Protocol.PROP_IN_CASE, G1Protocol.PROP_WORN) private val G1_LIGHT = intArrayOf(G1Protocol.PROP_LIGHT) private val G1_IMU = intArrayOf(G1Protocol.PROP_ACC_X, G1Protocol.PROP_ACC_Y, G1Protocol.PROP_ACC_Z) @@ -421,6 +423,9 @@ internal fun GlassesSessionCore.g1HideBeforeDisconnect() { // --------------------------------------------------------------------------------------------- // Connect (worker thread) +/** The arm has no g1v0 service: it runs Even's firmware. */ +private class G1OtherFirmwareException : Exception("not g1v0 firmware") + private fun GlassesSessionCore.g1ConnectArm(arm: Int, deadlineMs: Long) { val address = g1ArmAddress(arm) val timeoutMs = maxOf(deadlineMs - now(), ConnectionOptions.CONNECT_TIMEOUT_MS.toLong()) @@ -433,7 +438,8 @@ private fun GlassesSessionCore.g1ConnectArm(arm: Int, deadlineMs: Long) { throw IllegalStateException("discoverServices failed: $address") } if (!link.enableNotifications(address, G1Ble.EVT_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS)) { - throw IllegalStateException("no event characteristic on $address: not g1v0 firmware?") + if (!link.isConnected(address)) throw IllegalStateException("link lost: $address") + throw G1OtherFirmwareException() } link.requestLe2mPhy(address) monitor.withLock { @@ -495,9 +501,9 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { logLine("G1 " + (if (arm == 0) "left" else "right") + " arm: " + versions[arm] + " display path " + fcVersion + " encrypted=" + hello.encrypted + " inCase=" + hello.inCase + " panelOk=" + hello.panelOk + " phy=" + link.describePhy(g1ArmAddress(arm))) - compatible = compatible && fcVersion >= 1 + compatible = compatible && fcVersion >= 1 && G1Ble.firmwareAtLeast(hello.version) } - // The firmware's own number, not the G2 custom firmware's: the path has one version so far, and TS compares this. + // Not the G2 custom firmware's revision: this firmware has its own version, compared here, and TS compares this. val firmware = BleProtocol.FirmwareInfo(versions[0], versions[1], if (compatible) BleProtocol.FirmwareInfo.FACECLAW_EXTENSION_PREFIX + requiredFirmwareRevision else "") emitFirmwareInfo(firmware) @@ -533,6 +539,11 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { } setStateDisplay("connected", "Connected.") interruptibleSleep.interrupt() + } catch (t: G1OtherFirmwareException) { + logLine("G1: an arm runs Even's firmware") + val firmware = BleProtocol.FirmwareInfo(G1_OTHER_FIRMWARE, G1_OTHER_FIRMWARE, "") + emitFirmwareInfo(firmware) + monitor.withLock { incompatibleFirmware = firmware } } catch (t: Throwable) { logLine("G1 connect failed: " + safeMessage(t)) val unpaired = firstUnpairedArm() diff --git a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt index 2cc2ddb8..625ca4b8 100644 --- a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt +++ b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt @@ -461,6 +461,9 @@ class IosBleCentral(private val platform: ProtocolPlatform = IosProtocolPlatform override fun isBonded(address: String): Boolean = true + /** CoreBluetooth pairs by itself when an attribute needs it. */ + override fun requestBond(address: String) {} + override fun prepareBenchmarkLink(address: String, mode: Int) {} override fun recordDisplayFrameSent() { diff --git a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosStockFlows.kt b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosStockFlows.kt index a8146eba..a4c9a028 100644 --- a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosStockFlows.kt +++ b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosStockFlows.kt @@ -171,3 +171,56 @@ class IosFirmwareFlasher(rightAddress: String, leftAddress: String, firmwarePath lock.withLock { listener }?.let(action) } } + +/** iOS host for the shared [G1ArmFlashFlow]: one G1 arm's install, or a question about what it runs. */ +class IosG1Flasher(address: String, side: String, firmwarePath: String, mode: String, connectWindowMs: Int) { + private val link = IosBleCentral() + private val lock = IosProtocolPlatform.createLock() + private var started = false + private var listener: FaceclawFirmwareFlasherListener? = null + + private val flow = G1ArmFlashFlow( + link, + address, + side, + firmwarePath, + G1ArmFlashFlow.mode(mode), + connectWindowMs, + object : FaceclawFirmwareFlasherListener { + override fun onLog(line: String?) { + PlatformLog.i(G1ArmFlashFlow.TAG, line ?: "") + post { it.onLog(line) } + } + + override fun onProgress(lens: String?, componentIndex: Int, componentCount: Int, blockIndex: Int, blockCount: Int, bytesSent: Long, bytesTotal: Long) = + post { it.onProgress(lens, componentIndex, componentCount, blockIndex, blockCount, bytesSent, bytesTotal) } + + override fun onState(state: String?, detail: String?) = post { it.onState(state, detail ?: "") } + + override fun onComplete(success: Boolean, detail: String?) = post { it.onComplete(success, detail ?: "") } + }, + ) + + fun setListener(listener: FaceclawFirmwareFlasherListener?) { + lock.withLock { this.listener = listener } + } + + fun start() { + lock.withLock { + if (started) return + started = true + } + runOnThread("faceclaw-g1-flash") { flow.run() } + } + + fun cancel() = flow.cancel() + + fun close() { + cancel() + runCatching { link.close() } + } + + private fun post(action: (FaceclawFirmwareFlasherListener) -> Unit) = main { + lock.withLock { listener }?.let(action) + } +} diff --git a/tests/firmware-compat.test.cjs b/tests/firmware-compat.test.cjs index ada86113..0d3e50c1 100644 --- a/tests/firmware-compat.test.cjs +++ b/tests/firmware-compat.test.cjs @@ -74,3 +74,17 @@ test("reportedFirmwareVersion picks the higher arm", () => { assert.equal(compat.reportedFirmwareVersion(info("", "", "2.2.9.22")), "2.2.9.22"); assert.equal(compat.reportedFirmwareVersion(info("", "", "")), ""); }); + +test("a G1's report names what the arms run and offers the install, stock or too old", () => { + const stock = compat.firmwareIncompatibilityMessage(info("", "Even's firmware", "Even's firmware")); + assert.match(stock, /G1/); + assert.match(stock, /Even's firmware/); + assert.match(stock, /install/); + assert.doesNotMatch(stock, /revision/); + const older = compat.firmwareIncompatibilityMessage(info("", "g1v0 0.5.62", "g1v0 0.5.63")); + assert.match(older, /L=g1v0 0\.5\.62 R=g1v0 0\.5\.63/); + assert.match(older, /install/); + // A compatible G1 reports the extension, and a G2's stock report is unchanged. + assert.equal(compat.firmwareIncompatibilityMessage(info(`Faceclaw/${REQUIRED}`, "g1v0 0.5.63", "g1v0 0.5.63")), null); + assert.match(compat.firmwareIncompatibilityMessage(info("")), /stock firmware/); +}); diff --git a/tests/g1-firmware.test.cjs b/tests/g1-firmware.test.cjs new file mode 100644 index 00000000..4f71e2f6 --- /dev/null +++ b/tests/g1-firmware.test.cjs @@ -0,0 +1,169 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const crypto = require('node:crypto'); +const zlib = require('node:zlib'); + +const { readZipEntry, assembleG1Image, decodeG1OwnBytes, G1FirmwareError } = require('../.test-build/app/g1/firmware-image.js'); +const plan = require('../.test-build/app/g1/flash-plan.js'); +const { G1V0_IMAGE } = require('../.test-build/app/g1/firmware/g1v0-image.js'); +const { G1V0_OWN_BYTES_BASE64 } = require('../.test-build/app/g1/firmware/g1v0-own-bytes.js'); + +const sha = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex'); +const noise = (length, seed) => Uint8Array.from({ length }, (_, i) => (i * 31 + seed * 17 + (i >> 3)) & 0xff); +const fromBase64 = (text) => new Uint8Array(Buffer.from(text, 'base64')); + +/** A zip the way Even's are made: one entry stored, the others deflated, under a folder. */ +function zipOf(entries) { + const locals = []; + const directory = []; + let offset = 0; + for (const { name, data, deflate } of entries) { + const packed = deflate ? zlib.deflateRawSync(data) : Buffer.from(data); + const nameBytes = Buffer.from(name); + const local = Buffer.alloc(30); + local.writeUInt32LE(0x04034b50, 0); + local.writeUInt16LE(deflate ? 8 : 0, 8); + local.writeUInt32LE(packed.length, 18); + local.writeUInt32LE(data.length, 22); + local.writeUInt16LE(nameBytes.length, 26); + const central = Buffer.alloc(46); + central.writeUInt32LE(0x02014b50, 0); + central.writeUInt16LE(deflate ? 8 : 0, 10); + central.writeUInt32LE(packed.length, 20); + central.writeUInt32LE(data.length, 24); + central.writeUInt16LE(nameBytes.length, 28); + central.writeUInt32LE(offset, 42); + locals.push(local, nameBytes, packed); + directory.push(central, nameBytes); + offset += local.length + nameBytes.length + packed.length; + } + const centralBytes = Buffer.concat(directory); + const end = Buffer.alloc(22); + end.writeUInt32LE(0x06054b50, 0); + end.writeUInt16LE(entries.length, 8); + end.writeUInt16LE(entries.length, 10); + end.writeUInt32LE(centralBytes.length, 12); + end.writeUInt32LE(offset, 16); + return new Uint8Array(Buffer.concat([...locals, centralBytes, end])); +} + +function fixture() { + const net = noise(5000, 1); + const app = noise(9000, 2); + const image = noise(20000, 3); + const table = app.subarray(4000, 4352); + image.set(net, 3000); + image.set(table, 12000); + const parts = [ + { offset: 3000, length: net.length, file: 'net.bin', fileOffset: 0, sha256: sha(net) }, + { offset: 12000, length: table.length, file: 'app.bin', fileOffset: 4000, sha256: sha(table) }, + ]; + const own = Buffer.concat([image.subarray(0, 3000), image.subarray(8000, 12000), image.subarray(12352)]); + const manifest = { version: '0.0.1', sha256: sha(image), size: image.length, source: 't', stockVersion: 's', stockZipUrl: 'u', stockZipSha256: 'z', parts }; + return { net, app, image, own: new Uint8Array(own), manifest }; +} + +test('a zip entry is found, deflated or stored, also under a folder', () => { + const stored = noise(300, 4); + const packed = noise(70000, 5); + const zip = zipOf([{ name: 'manifest.json', data: stored }, { name: 'firmware/app.bin', data: packed, deflate: true }]); + assert.deepEqual(readZipEntry(zip, 'manifest.json'), stored); + assert.deepEqual(Buffer.from(readZipEntry(zip, 'app.bin')), Buffer.from(packed)); + assert.throws(() => readZipEntry(zip, 'missing.bin'), /no missing\.bin/); + assert.throws(() => readZipEntry(noise(100, 6), 'x'), /not a zip/); +}); + +test('the parts go back where they were, byte for byte', () => { + const { net, app, image, own, manifest } = fixture(); + const files = { 'net.bin': net, 'app.bin': app }; + const out = assembleG1Image(manifest, own, (name) => files[name], sha); + assert.deepEqual(Buffer.from(out), Buffer.from(image)); +}); + +test('a part that is not the one it was built with is refused', () => { + const { net, app, own, manifest } = fixture(); + const bad = net.slice(); + bad[100] ^= 1; + const files = { 'net.bin': bad, 'app.bin': app }; + assert.throws(() => assembleG1Image(manifest, own, (name) => files[name], sha), G1FirmwareError); + const short = { 'net.bin': net.subarray(0, 100), 'app.bin': app }; + assert.throws(() => assembleG1Image(manifest, own, (name) => short[name], sha), /not the one/); +}); + +test('damaged bundled bytes never pass as an image', () => { + const { net, app, own, manifest } = fixture(); + const files = { 'net.bin': net, 'app.bin': app }; + const flipped = own.slice(); + flipped[10] ^= 1; + assert.throws(() => assembleG1Image(manifest, flipped, (name) => files[name], sha), /failed verification/); + assert.throws(() => assembleG1Image(manifest, own.subarray(0, own.length - 1), (name) => files[name], sha), G1FirmwareError); +}); + +test('the bundled firmware is whole and carries none of Even\'s bytes in its manifest ranges', () => { + const own = decodeG1OwnBytes(G1V0_OWN_BYTES_BASE64, fromBase64); + const taken = G1V0_IMAGE.parts.reduce((sum, part) => sum + part.length, 0); + assert.equal(own.length + taken, G1V0_IMAGE.size); + // MCUboot's magic and the version in its header, ahead of the first part. + assert.equal(Buffer.from(own.subarray(0, 4)).toString('hex'), '3db8f396'); + assert.equal(`${own[20]}.${own[21]}.${own[22] | (own[23] << 8)}`, G1V0_IMAGE.version); + assert.match(G1V0_IMAGE.stockZipUrl, /^https:\/\/cdn\.evenreal\.co\//); + assert.match(G1V0_IMAGE.sha256, /^[0-9a-f]{64}$/); + const sorted = [...G1V0_IMAGE.parts].sort((a, b) => a.offset - b.offset); + assert.ok(sorted[0].offset > 512 && sorted.at(-1).offset + sorted.at(-1).length < G1V0_IMAGE.size); + assert.doesNotMatch(G1V0_IMAGE.source, /uncommitted/, 'ship only a firmware that was committed'); +}); + +test('versions compare by number, not by text', () => { + assert.ok(plan.compareG1Versions('0.5.100', '0.5.63') > 0); + assert.ok(plan.compareG1Versions('0.5.9', '0.5.63') < 0); + assert.equal(plan.compareG1Versions('0.5.63', '0.5.63'), 0); + assert.equal(plan.compareG1Versions('0.5', '0.5.0'), 0); + assert.ok(plan.compareG1Versions('', '0.5.63') < 0); +}); + +test('a pair is chosen by serial, then address, and never guessed between two', () => { + const g1 = (serial, left, right) => ({ g1Firmware: 'g1v0', serial, left: left && { address: left }, right: right && { address: right } }); + const ours = g1('S1', 'L1', 'R1'); + const theirs = g1('S2', 'L2', 'R2'); + assert.equal(plan.pickG1Pair([theirs, ours], { serial: 's1' }), ours); + assert.equal(plan.pickG1Pair([theirs, ours], { left: 'L1' }), ours); + assert.equal(plan.pickG1Pair([theirs, ours], { right: 'R2' }), theirs); + assert.equal(plan.pickG1Pair([theirs, ours], {}), null); + assert.equal(plan.pickG1Pair([ours], {}), ours); + // A flash changed the addresses: the serial still finds it. + assert.equal(plan.pickG1Pair([g1('S1', 'NEW', 'NEW2'), theirs], { serial: 'S1', left: 'OLD', right: 'OLD2' }).left.address, 'NEW'); + // Our serial with one arm heard so far: wait, even if another pair is complete. + assert.equal(plan.pickG1Pair([g1('S1', 'L1', null), theirs], { serial: 'S1' }), null); + // The wanted glasses weren't heard: another pair is never a stand-in, even the only one around. + assert.equal(plan.pickG1Pair([theirs], { serial: 'S1' }), null); + assert.equal(plan.pickG1Pair([theirs], { left: 'L1', right: 'R1' }), null); + // A wanted address on one side doesn't match a pair for lacking the other. + assert.equal(plan.pickG1Pair([g1('S2', 'L2', null)], { left: 'L1' }), null); + // G2 pairs don't count. + assert.equal(plan.pickG1Pair([{ serial: 'S9', left: { address: 'a' }, right: { address: 'b' } }], {}), null); +}); + +test('the state of the two arms is that of the arm that needs the most', () => { + const on = (version, extra = {}) => ({ firmware: 'g1v0', version, safeMode: false, ...extra }); + const state = (...arms) => plan.g1FirmwareState(arms, '0.5.63'); + assert.equal(state(on('0.5.63'), on('0.5.63')), 'current'); + assert.equal(state(on('0.5.64'), on('0.5.63')), 'current'); + assert.equal(state(on('0.5.62'), on('0.5.63')), 'older'); + assert.equal(state(on('0.5.63', { safeMode: true }), on('0.5.62')), 'safe-mode'); + assert.equal(state({ firmware: 'stock' }, on('0.5.63', { safeMode: true })), 'stock'); +}); + +test('the native flow\'s answer is read, and nonsense is no answer', () => { + assert.deepEqual(plan.parseG1FlashResult('{"flashed":true,"version":"0.5.64"}'), { flashed: true, version: '0.5.64' }); + assert.deepEqual(plan.parseG1FlashResult('nonsense'), {}); + assert.deepEqual(plan.parseG1FlashResult(''), {}); + assert.deepEqual(plan.parseG1FlashResult('null'), {}); +}); + +test('each arm counts for half of the bar', () => { + assert.equal(plan.g1FlashPercent('left', 0, 100), 0); + assert.equal(plan.g1FlashPercent('left', 100, 100), 50); + assert.equal(plan.g1FlashPercent('right', 0, 100), 50); + assert.equal(plan.g1FlashPercent('right', 100, 100), 100); + assert.equal(plan.g1FlashPercent('right', 5, 0), 50); +}); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt new file mode 100644 index 00000000..b07df483 --- /dev/null +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt @@ -0,0 +1,551 @@ +package com.faceclaw.app + +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +private const val ARM = "F4:27:E9:CA:E8:3F" + +private fun hex(text: String): ByteArray = ByteArray(text.length / 2) { text.substring(it * 2, it * 2 + 2).toInt(16).toByte() } + +/** An image the way MCUboot lays one out: header, payload, then a TLV area with its SHA-256. */ +private fun testImage(version: Triple = Triple(0, 5, 64), payloadSize: Int = 5000): ByteArray { + val headerSize = 512 + val hash = ByteArray(32) { (it * 3 + version.third).toByte() } + val image = ByteArray(headerSize + payloadSize + 4 + 4 + 32) + fun put16(at: Int, value: Int) { + image[at] = value.toByte() + image[at + 1] = (value ushr 8).toByte() + } + fun put32(at: Int, value: Int) { + put16(at, value and 0xffff) + put16(at + 2, value ushr 16) + } + put32(0, 0x96f3b83d.toInt()) + put16(8, headerSize) + put32(12, payloadSize) + image[20] = version.first.toByte() + image[21] = version.second.toByte() + put16(22, version.third) + for (i in 0 until payloadSize) image[headerSize + i] = (i * 7).toByte() + val tlv = headerSize + payloadSize + put16(tlv, 0x6907) + put16(tlv + 2, 4 + 4 + 32) + put16(tlv + 4, 0x10) + put16(tlv + 6, 32) + hash.copyInto(image, tlv + 8) + return image +} + +/** + * One arm behind the StockLink port: MCUmgr's image and OS groups as flash.py meets them on real arms, and g1v0's HELLO + * and PROPS. Requests are answered synchronously, from the write. + */ +private class FakeArm(private val image: ByteArray, var stock: Boolean = false) : StockLink { + var inbound: StockLinkListener? = null + var connected = false + var bond = BondState.BONDED + var bondRequests = 0 + var bondResult = BondState.BONDED + val subscribed = ArrayList() + val heartbeats = ArrayList() + val calls = ArrayList() + + var runningVersion = "0.5.63" + var safeMode = false + var battery = 80 + + var slot1Hash: ByteArray? = null + var uploaded = ByteArray(0) + var uploadOffset = 0 + var uploadRefusal = 0 + /** After the upload the list shows this instead of the image's hash. */ + var corruptAfterUpload = false + var confirmRefusal = 0 + var dropAtOffset = -1 + var silentRequests = 0 + /** The chunk at this offset gets no answer, once. */ + var silentAtOffset = -1 + var onChunk: (() -> Unit)? = null + var connects = 0 + + val wantHash = G1Smp.imageHash(image) + + override fun setListener(listener: StockLinkListener?) { inbound = listener } + override fun connect(address: String, timeoutMs: Int): Boolean { + connects++ + connected = true + return true + } + override fun prepareLink(address: String, desiredMtu: Int, timeoutMs: Int) {} + override fun discoverServices(address: String, timeoutMs: Int): Boolean = connected + override fun enableNotifications(address: String, characteristicUuid: String, timeoutMs: Int): Boolean { + if (!connected) return false + if (stock && characteristicUuid == G1Ble.EVT_CHAR_UUID) return false + if (!stock && characteristicUuid == G1Smp.NUS_TX_UUID) return false + subscribed.add(characteristicUuid) + return true + } + override fun isConnected(address: String): Boolean = connected + override fun bondState(address: String): BondState = bond + override fun requestBond(address: String) { + bondRequests++ + bond = bondResult + } + override fun negotiatedMtu(address: String): Int = 100 + override fun disconnect(address: String) { connected = false } + override fun close() { connected = false } + + fun drop() { + connected = false + inbound?.onConnectionStateChange(ARM, false) + } + + override fun writeFrames(address: String, characteristicUuid: String, frames: List, mode: GattWriteMode, timeoutMs: Int): Boolean { + if (!connected) throw IllegalStateException("Not connected") + when (characteristicUuid) { + G1Smp.NUS_RX_UUID -> heartbeats.add(frames.single()) + G1Ble.PAIR_CHAR_UUID -> return bond == BondState.BONDED + G1Ble.CTRL_CHAR_UUID -> control(frames.single()) + G1Smp.SMP_CHAR_UUID -> { + for (frame in frames) assertTrue(frame.size <= 97, "a write longer than the MTU allows") + smp(frames.reduce { a, b -> a + b }) + } + else -> throw IllegalStateException("write to $characteristicUuid") + } + return true + } + + private fun control(request: ByteArray) { + val op = request[0].toInt() and 0xff + val tag = request[1] + val body = when (op) { + G1Protocol.OP_HELLO -> { + val parts = runningVersion.split(".").map { it.toInt().toByte() } + val flags = (if (safeMode) 1 else 0) or 2 or 64 + byteArrayOf(5, parts[0], parts[1], parts[2], 1, flags.toByte(), 0) + } + G1Protocol.OP_PROPS -> byteArrayOf(battery.toByte(), 0, 0, 0) + else -> ByteArray(0) + } + val event = ByteArray(9) + byteArrayOf(tag, 0) + body + event[0] = (0x80 or op).toByte() + inbound?.onNotification(ARM, G1Ble.EVT_CHAR_UUID, event) + } + + private fun smp(frame: ByteArray) { + val op = frame[0].toInt() + val group = frame[5].toInt() + val seq = frame[6].toInt() and 0xff + val cmd = frame[7].toInt() + val body = G1Cbor.decode(frame, 8) as Map<*, *> + if (silentRequests > 0) { + silentRequests-- + return + } + when { + group == 1 && cmd == 1 -> { + calls.add("upload") + val off = (body["off"] as Long).toInt() + onChunk?.invoke() + if (off == silentAtOffset) { + silentAtOffset = -1 + return + } + if (uploadRefusal != 0) return reply(op, group, seq, cmd, mapOf("rc" to uploadRefusal)) + if (off == uploadOffset) { + val data = body["data"] as ByteArray + if (off == 0) { + assertEquals(image.size.toLong(), body["len"]) + assertContentEquals(sha256(image), body["sha"] as ByteArray) + assertEquals(0L, body["image"]) + uploaded = ByteArray(0) + } + uploaded += data + uploadOffset += data.size + if (uploadOffset == image.size) slot1Hash = if (corruptAfterUpload) ByteArray(32) else G1Smp.imageHash(uploaded) + } + if (uploadOffset >= dropAtOffset && dropAtOffset >= 0) { + dropAtOffset = -1 + drop() + return + } + reply(op, group, seq, cmd, mapOf("rc" to 0, "off" to uploadOffset)) + } + group == 1 && cmd == 0 && op == G1Smp.OP_READ -> { + calls.add("list") + val images = ArrayList>() + images.add(mapOf("image" to 0, "slot" to 0, "version" to runningVersion, "hash" to ByteArray(32), "active" to true, "confirmed" to true, "bootable" to true)) + slot1Hash?.let { images.add(mapOf("image" to 0, "slot" to 1, "version" to "0.5.64", "hash" to it, "bootable" to true)) } + reply(op, group, seq, cmd, mapOf("images" to images)) + } + group == 1 && cmd == 0 -> { + calls.add("confirm") + assertEquals(true, body["confirm"]) + assertContentEquals(wantHash, body["hash"] as ByteArray) + reply(op, group, seq, cmd, mapOf("rc" to confirmRefusal)) + } + group == 0 && cmd == 5 -> { + calls.add("reset") + reply(op, group, seq, cmd, emptyMap()) + drop() + } + else -> throw IllegalStateException("SMP $group/$cmd") + } + } + + /** The reply comes in pieces, as notifications do. */ + private fun reply(op: Int, group: Int, seq: Int, cmd: Int, body: Map) { + val frame = G1Smp.frame(op or 1, group, seq, cmd, body) + for (piece in G1Smp.split(frame, 23)) inbound?.onNotification(ARM, G1Smp.SMP_CHAR_UUID, piece) + } +} + +private class Recorder : FaceclawFirmwareFlasherListener { + val states = ArrayList() + val logs = ArrayList() + var progress = 0L + var total = 0L + var success: Boolean? = null + var detail = "" + + override fun onLog(line: String?) { logs.add(line ?: "") } + override fun onProgress(lens: String?, componentIndex: Int, componentCount: Int, blockIndex: Int, blockCount: Int, bytesSent: Long, bytesTotal: Long) { + progress = bytesSent + total = bytesTotal + } + override fun onState(state: String?, detail: String?) { states.add(state ?: "") } + override fun onComplete(success: Boolean, detail: String?) { + this.success = success + this.detail = detail ?: "" + } +} + +private val FAST = G1FlashTimings( + connectTimeoutMs = 50, servicesTimeoutMs = 50, descriptorTimeoutMs = 50, writeTimeoutMs = 50, pairingMs = 200, retryDelayMs = 1, + controlReplyMs = 20, controlTries = 2, uploadReplyMs = 150, smpReplyMs = 150, resetReplyMs = 50, heartbeatMs = 30, pollMs = 5, uploadRetries = 5, +) + +class G1SmpTest { + private val sha = ByteArray(32) { it.toByte() } + + /** The expected bytes come from scouter_kit's tools/g1host.py, whose requests were proven on real arms. */ + @Test + fun requestsMatchTheProvenPythonTool() { + val image = ByteArray(574408) + image[0] = 1 + image[1] = 2 + image[2] = 3 + val first = G1Smp.uploadRequest(image, 0, sha).toMutableMap() + first["data"] = byteArrayOf(1, 2, 3) + assertEquals( + "0200004e00010001a665696d61676500636c656e1a0008c3c8636f666600637368615820000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f6464617461430102036775706772616465f4", + BinaryEncoding.bytesToHex(G1Smp.frame(G1Smp.OP_WRITE, G1Smp.GROUP_IMAGE, 0, G1Smp.CMD_IMAGE_UPLOAD, first)), + ) + assertEquals( + "0200001100010101a2636f6666190800646461746143010203", + BinaryEncoding.bytesToHex(G1Smp.frame(G1Smp.OP_WRITE, G1Smp.GROUP_IMAGE, 1, G1Smp.CMD_IMAGE_UPLOAD, mapOf("off" to 2048, "data" to byteArrayOf(1, 2, 3)))), + ) + assertEquals( + "0200003100010500a264686173685820000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f67636f6e6669726df5", + BinaryEncoding.bytesToHex(G1Smp.frame(G1Smp.OP_WRITE, G1Smp.GROUP_IMAGE, 5, G1Smp.CMD_IMAGE_STATE, G1Smp.confirmRequest(sha))), + ) + assertEquals("0000000100010700a0", BinaryEncoding.bytesToHex(G1Smp.frame(G1Smp.OP_READ, G1Smp.GROUP_IMAGE, 7, G1Smp.CMD_IMAGE_STATE, emptyMap()))) + assertEquals("020000010000ff05a0", BinaryEncoding.bytesToHex(G1Smp.frame(G1Smp.OP_WRITE, G1Smp.GROUP_OS, 255, G1Smp.CMD_OS_RESET, emptyMap()))) + } + + @Test + fun cborMatchesPythonAndRoundTrips() { + val value = mapOf("n" to -5, "big" to 70000, "huge" to 5000000000L, "t" to true, "s" to "ab") + val encoded = G1Cbor.encode(value) + assertEquals("a5616e24636269671a0001117064687567651b000000012a05f2006174f56173626162", BinaryEncoding.bytesToHex(encoded)) + val decoded = G1Cbor.decode(encoded) as Map<*, *> + assertEquals(-5L, decoded["n"]) + assertEquals(70000L, decoded["big"]) + assertEquals(5000000000L, decoded["huge"]) + assertEquals(true, decoded["t"]) + assertEquals("ab", decoded["s"]) + } + + @Test + fun cborReadsTheIndefiniteLengthsOfAnImageList() { + // {"images": [{"slot": 1, "active": true}]}, each container of indefinite length. + val data = hex("bf66696d616765739fbf64736c6f74016661637469766" + "5f5ffffff") + val slots = (G1Cbor.decode(data) as Map<*, *>)["images"] as List<*> + val slot = slots.single() as Map<*, *> + assertEquals(1L, slot["slot"]) + assertEquals(true, slot["active"]) + } + + @Test + fun malformedCborIsAnErrorNotAWrongValue() { + assertFailsWith { G1Cbor.decode(hex("5820")) } + assertFailsWith { G1Cbor.decode(hex("bf")) } + assertFailsWith { G1Cbor.decode(ByteArray(0)) } + } + + @Test + fun repliesAreJoinedAcrossNotifications() { + val assembler = G1Smp.Assembler() + val one = G1Smp.frame(3, 1, 7, 1, mapOf("off" to 2048, "rc" to 0)) + val two = G1Smp.frame(3, 1, 8, 0, emptyMap()) + val all = one + two + val replies = ArrayList>>() + for (start in all.indices step 5) replies += assembler.feed(all.copyOfRange(start, minOf(start + 5, all.size))) + assertEquals(listOf(7, 8), replies.map { it.first }) + assertEquals(2048, G1Smp.replyOffset(replies[0].second)) + assertEquals(0, G1Smp.replyCode(replies[1].second)) + } + + @Test + fun anImageSaysWhatItIs() { + val image = testImage(Triple(0, 5, 300)) + assertEquals("0.5.300", G1Smp.imageVersion(image)) + assertContentEquals(ByteArray(32) { (it * 3 + 300).toByte() }, G1Smp.imageHash(image)) + assertFailsWith { G1Smp.imageVersion(ByteArray(100)) } + val cut = image.copyOf(image.size - 20) + assertFailsWith { G1Smp.imageHash(cut) } + } + + @Test + fun writesFitTheMtu() { + val pieces = G1Smp.split(ByteArray(1000), 247) + assertTrue(pieces.all { it.size <= 244 }) + assertEquals(1000, pieces.sumOf { it.size }) + } +} + +class G1ArmFlashFlowTest { + private val image = testImage() + + private fun flow(arm: FakeArm, listener: Recorder, mode: G1ArmFlashFlow.Mode, window: Int = 100) = + G1ArmFlashFlow(arm, ARM, "left", "image.bin", mode, window, listener, FAST, testPlatform(), { image }) + + private fun run(arm: FakeArm, mode: G1ArmFlashFlow.Mode, window: Int = 100): Recorder { + val listener = Recorder() + flow(arm, listener, mode, window).run() + assertNotNull(listener.success, "the flow must always finish") + return listener + } + + private fun confirmIsLast(arm: FakeArm) { + assertEquals(listOf("confirm", "reset"), arm.calls.takeLast(2)) + assertEquals(1, arm.calls.count { it == "confirm" }) + } + + @Test + fun anUpdateUploadsChecksThenConfirmsAndResets() { + val arm = FakeArm(image) + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(true, result.success, result.detail) + assertEquals("""{"flashed":true,"version":"0.5.64"}""", result.detail) + assertContentEquals(image, arm.uploaded) + assertEquals(image.size.toLong(), result.progress) + assertEquals(image.size.toLong(), result.total) + confirmIsLast(arm) + // The list before the confirm is what proves the slot holds this image. + assertEquals("list", arm.calls[arm.calls.indexOf("confirm") - 1]) + assertTrue(arm.heartbeats.isEmpty(), "g1v0 has no heartbeat") + assertTrue("rebooting" in result.states) + } + + @Test + fun anArmAlreadyOnThisVersionIsLeftAlone() { + val arm = FakeArm(image) + arm.runningVersion = "0.5.64" + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(true, result.success) + assertEquals("""{"flashed":false,"version":"0.5.64"}""", result.detail) + assertTrue(arm.calls.isEmpty(), "nothing goes to the update service") + } + + @Test + fun anArmInSafeModeOnThisVersionIsInstalledAgain() { + val arm = FakeArm(image) + arm.runningVersion = "0.5.64" + arm.safeMode = true + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals("""{"flashed":true,"version":"0.5.64"}""", result.detail) + confirmIsLast(arm) + } + + @Test + fun aSlotThatDoesNotHoldTheImageIsNeverConfirmed() { + val arm = FakeArm(image) + arm.corruptAfterUpload = true + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(false, result.success) + assertFalse("confirm" in arm.calls) + assertFalse("reset" in arm.calls) + assertTrue("Nothing was installed" in result.detail, result.detail) + } + + @Test + fun aRefusedUploadIsNeverConfirmed() { + val arm = FakeArm(image) + arm.uploadRefusal = 9 + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(false, result.success) + assertFalse("confirm" in arm.calls) + assertTrue("error 9" in result.detail, result.detail) + } + + @Test + fun aRefusedConfirmIsNotAReset() { + val arm = FakeArm(image) + arm.confirmRefusal = 2 + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(false, result.success) + assertFalse("reset" in arm.calls) + } + + @Test + fun aLowBatteryStopsAnUpdateBeforeAnyUpload() { + val arm = FakeArm(image) + arm.battery = 12 + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(false, result.success) + assertTrue("12%" in result.detail, result.detail) + assertTrue(arm.calls.isEmpty()) + } + + @Test + fun aDamagedImageFailsBeforeTheLinkIsTouched() { + val listener = Recorder() + val arm = FakeArm(image) + G1ArmFlashFlow(arm, ARM, "left", "image.bin", G1ArmFlashFlow.Mode.UPDATE, 100, listener, FAST, testPlatform(), { ByteArray(100) }).run() + assertEquals(false, listener.success) + assertEquals(0, arm.connects) + } + + @Test + fun anUnreadableImageIsAClearFailure() { + val listener = Recorder() + val arm = FakeArm(image) + G1ArmFlashFlow(arm, ARM, "left", "image.bin", G1ArmFlashFlow.Mode.STOCK, 100, listener, FAST, testPlatform(), { throw IllegalStateException("gone") }).run() + assertEquals(false, listener.success) + assertTrue("could not read the firmware" in listener.detail, listener.detail) + } + + @Test + fun aLostLinkResumesTheUpload() { + val arm = FakeArm(image) + arm.dropAtOffset = 2048 + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(true, result.success, result.detail) + assertContentEquals(image, arm.uploaded) + assertTrue(arm.connects >= 2, "it connected again") + confirmIsLast(arm) + } + + @Test + fun aChunkThatGetsNoAnswerIsSentAgain() { + val arm = FakeArm(image) + arm.silentAtOffset = 2048 + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(true, result.success, result.detail) + assertContentEquals(image, arm.uploaded) + confirmIsLast(arm) + } + + @Test + fun anUploadThatNeverGetsAnswersGivesUpWithoutConfirming() { + val arm = FakeArm(image) + arm.silentRequests = 1000 + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(false, result.success) + assertFalse("confirm" in arm.calls) + } + + @Test + fun aSlotAlreadyHoldingTheImageSkipsTheUpload() { + val arm = FakeArm(image) + arm.slot1Hash = arm.wantHash + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(true, result.success, result.detail) + assertFalse("upload" in arm.calls) + confirmIsLast(arm) + } + + @Test + fun stockGetsAHeartbeatEvenWhileAChunkWaits() { + val arm = FakeArm(image, stock = true) + // A chunk can wait a long time, as the first does while the arm erases its slot: the heartbeat has to keep going. + arm.silentAtOffset = 2048 + val result = run(arm, G1ArmFlashFlow.Mode.STOCK) + assertEquals(true, result.success, result.detail) + assertTrue(arm.heartbeats.size >= 3, "heartbeats: ${arm.heartbeats.size}") + assertTrue(G1Smp.NUS_TX_UUID in arm.subscribed) + assertEquals(0x25, arm.heartbeats[0][0].toInt()) + assertEquals(arm.heartbeats[1][3], 1.toByte()) + assertEquals(arm.heartbeats[1][5], 1.toByte()) + confirmIsLast(arm) + } + + @Test + fun stockIsPairedWithFirst() { + val arm = FakeArm(image, stock = true) + arm.bond = BondState.NONE + val result = run(arm, G1ArmFlashFlow.Mode.STOCK) + assertEquals(true, result.success, result.detail) + assertEquals(1, arm.bondRequests) + assertTrue("pairing" in result.states) + } + + @Test + fun aRefusedBondIsRetriedThenReported() { + val arm = FakeArm(image) + arm.bond = BondState.NONE + arm.bondResult = BondState.NONE + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE, window = 1) + assertEquals(false, result.success) + assertTrue(arm.calls.isEmpty()) + assertTrue("Couldn't reach the left arm" in result.detail, result.detail) + } + + @Test + fun aPlatformThatCannotSeeBondsReliesOnTheEncryptedWrite() { + val arm = FakeArm(image) + arm.bond = BondState.UNKNOWN + val listener = Recorder() + // The write to PAIR fails on an unknown bond in this fake, as on an arm out of the case: no encrypted link. + flow(arm, listener, G1ArmFlashFlow.Mode.PROBE, 1).run() + assertEquals(false, listener.success) + assertEquals(0, arm.bondRequests) + assertTrue("an arm pairs only in its case" in listener.detail, listener.detail) + } + + @Test + fun aProbeSaysWhatAnArmRuns() { + val arm = FakeArm(image) + val result = run(arm, G1ArmFlashFlow.Mode.PROBE) + assertEquals(true, result.success, result.detail) + assertEquals("""{"firmware":"g1v0","version":"0.5.63","safeMode":false,"inCase":false,"battery":80}""", result.detail) + assertTrue(arm.calls.isEmpty()) + } + + @Test + fun aProbeOfEvensFirmwareNeedsNoPairing() { + val arm = FakeArm(image, stock = true) + arm.bond = BondState.NONE + val result = run(arm, G1ArmFlashFlow.Mode.PROBE) + assertEquals("""{"firmware":"stock"}""", result.detail) + assertEquals(0, arm.bondRequests) + } + + @Test + fun cancellingDuringTheUploadStopsBeforeTheConfirm() { + val arm = FakeArm(image) + val listener = Recorder() + val flow = flow(arm, listener, G1ArmFlashFlow.Mode.UPDATE) + arm.onChunk = { flow.cancel() } + flow.run() + assertEquals(false, listener.success) + assertEquals("Cancelled.", listener.detail) + assertFalse("confirm" in arm.calls) + } +} diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt index ee0af11f..8670b651 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt @@ -217,7 +217,7 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { body[0] = 5 body[1] = 0 body[2] = 5 - body[3] = 62 + body[3] = 63 body[4] = (if (a.left) 1 else 0).toByte() body[5] = (2 or 64).toByte() body[6] = (if (a.left) 0 else 4).toByte() @@ -472,7 +472,7 @@ class G1SessionTest { assertEquals(G1Protocol.EVENTS_MASK, s.glasses.leftArm.eventsMask) assertEquals(G1Protocol.EVENTS_MASK, s.glasses.rightArm.eventsMask) assertEquals(1, s.glasses.leftArm.healthOk, "the boot is confirmed healthy") - assertTrue(s.listener.firmware.single().startsWith("g1v0 0.5.62|g1v0 0.5.62|Faceclaw/"), s.listener.firmware.toString()) + assertTrue(s.listener.firmware.single().startsWith("g1v0 0.5.63|g1v0 0.5.63|Faceclaw/"), s.listener.firmware.toString()) s.submit(1, 1) assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, "frame never displayed:\n" + s.tail()) diff --git a/tests/pairing-candidates.test.cjs b/tests/pairing-candidates.test.cjs index b0168817..54cdcea7 100644 --- a/tests/pairing-candidates.test.cjs +++ b/tests/pairing-candidates.test.cjs @@ -332,7 +332,7 @@ test("G1 arms on g1v0 join on the frame serial and can be selected", () => { assert.match(row.armsSummary, /case/); }); -test("G1 arms on Even's firmware show up but can't be selected", () => { +test("G1 arms on Even's firmware can be selected, to install on", () => { const aggregator = new DiscoveryAggregator(); aggregator.ingest(g1Arm("Even G1_70_L_EF50E5", "C0:66:16:EF:50:E5", "02" + ascii(G1_SERIAL))); aggregator.ingest(g1Arm("Even G1_70_R_CBE689", "E4:46:BA:CB:E6:89", "01" + ascii(G1_SERIAL))); @@ -340,16 +340,25 @@ test("G1 arms on Even's firmware show up but can't be selected", () => { assert.equal(pair.g1Firmware, "stock"); assert.equal(pair.completeness, "complete"); const row = glassesRow(pair); - assert.equal(row.canSelect, false); - assert.match(row.armsSummary, /computer/); + assert.equal(row.canSelect, true); + assert.match(row.armsSummary, /install/); }); -test("a G1 pair with one arm in safe mode can't be selected", () => { +test("a G1 pair with one arm in safe mode can be selected, to install again", () => { const aggregator = new DiscoveryAggregator(); aggregator.ingest(g1v0Arm("L", "F4:27:E9:CA:E8:3F")); aggregator.ingest(g1Arm("G1v0S_R", "CD:EB:89:BF:E9:EC", "ffff0104" + ascii(G1_SERIAL))); const [pair] = aggregator.pairs(); assert.equal(pair.g1Firmware, "g1v0-safe"); + assert.equal(glassesRow(pair).canSelect, true); +}); + +test("a G1 pair needs both arms heard, whatever it runs", () => { + const aggregator = new DiscoveryAggregator(); + aggregator.ingest(g1Arm("Even G1_70_L_EF50E5", "C0:66:16:EF:50:E5", "02" + ascii(G1_SERIAL))); + const [pair] = aggregator.pairs(); + assert.equal(pair.g1Firmware, "stock"); + assert.equal(pair.completeness, "left-only"); assert.equal(glassesRow(pair).canSelect, false); }); diff --git a/tests/tsconfig.json b/tests/tsconfig.json index 5c5fd912..7f5af242 100644 --- a/tests/tsconfig.json +++ b/tests/tsconfig.json @@ -41,6 +41,11 @@ "../app/apps/glanceboard/layout.ts", "../app/apps/files/video-layout.ts", "../app/g2/pairing-candidates.ts", + "../app/g1/pako.d.ts", + "../app/g1/firmware-image.ts", + "../app/g1/flash-plan.ts", + "../app/g1/firmware/g1v0-image.ts", + "../app/g1/firmware/g1v0-own-bytes.ts", "../app/apps/calculator/math/*.ts", "../app/apps/microphones/mic-protocol.ts", "../app/apps/calculator/calculator-commands.ts", diff --git a/tools/g1_firmware_bundle.py b/tools/g1_firmware_bundle.py new file mode 100644 index 00000000..5ff93341 --- /dev/null +++ b/tools/g1_firmware_bundle.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +"""Turns a built g1v0 image into what the app ships: app/g1/firmware/g1v0-image.ts and g1v0-own-bytes.ts. + +A built image embeds two of Even's files (scouter_kit g1_firmware/README.md, "Build the image"), which must not be +published: its network-core image and its TouchBar table. Those bytes are cut out here, and the phone puts them back +from Even's own download (app/g1/firmware-builder.ts). The result has the same SHA-256 as the build, so the MCUboot +signature made at build time stays valid. + + tools/g1_firmware_bundle.py WORK/build/g1v0-v0563/zephyr/app_update.bin --firmware-dir ~/src/scouter_kit/g1_firmware + +--firmware-dir holds stock_images.txt and, under work/firmware/1.6.6/, Even's unpacked files (scripts/fetch_stock.sh). +""" +import argparse +import base64 +import hashlib +import json +import struct +import subprocess +import zlib +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +OUT = ROOT / "app" / "g1" / "firmware" +STOCK_VERSION = "1.6.6" +TABLE = "aw9320x_table" + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def stock_pins(firmware_dir): + rows = [line.split() for line in (firmware_dir / "stock_images.txt").read_text().splitlines() + if line.strip() and not line.startswith("#")] + return {row[1]: row[2:] for row in rows if row[0] == STOCK_VERSION} + + +def only_place(image, part, label): + at = image.find(part) + if at < 0: + raise SystemExit(f"{label} is not in the image: was it built with Even's {STOCK_VERSION}?") + if image.find(part, at + 1) >= 0: + raise SystemExit(f"{label} is in the image twice") + return at + + +def image_version(image): + if image[:4] != bytes.fromhex("3db8f396"): + raise SystemExit("not an MCUboot image") + major, minor, revision = struct.unpack_from(" Date: Fri, 6 Nov 2026 15:13:46 -0800 Subject: [PATCH 10/34] Don't show the Compass app on hardware (ie G1s) that can't support it --- app/apps/app-definition.ts | 7 ++ app/apps/compass/compass-app.ts | 15 ++--- app/apps/compass/index.ts | 2 + app/apps/glanceboard/glanceboard-settings.ts | 39 +++++++---- app/apps/launcher/index.ts | 2 +- app/assistant/window-tools.ts | 22 +++--- app/g2/dashboard-controller.ts | 8 +-- app/g2/ios-preview-controller.ts | 4 +- app/g2/wear-remote.ts | 6 +- app/ui/dashboard-settings.ts | 9 +++ tests/compass-readout.test.cjs | 2 +- tests/compass-texture-cache.test.cjs | 2 +- tests/display-layout-setting.test.cjs | 11 +++ tests/glanceboard-settings.test.cjs | 49 +++++++++++++- tests/ios-watch-remote.test.cjs | 2 +- tests/unsupported-apps.test.cjs | 71 ++++++++++++++++++++ 16 files changed, 202 insertions(+), 49 deletions(-) create mode 100644 tests/unsupported-apps.test.cjs diff --git a/app/apps/app-definition.ts b/app/apps/app-definition.ts index b46c809d..a51adf4f 100644 --- a/app/apps/app-definition.ts +++ b/app/apps/app-definition.ts @@ -30,6 +30,13 @@ export type AppDefinition = { boot?: (ctx: AppContext) => void; /** False for apps that must not appear in the launcher grid (the launcher itself). */ showInLauncher?: boolean; + /** + * False while the paired glasses can't run the app (absent means they can). + * It then leaves the launcher grid and what mirrors it: the watch remote and + * the apps.launch tool. A window restored from before a re-pair still opens, + * so the app needs to say what's wrong rather than assume it never runs. + */ + isSupported?: () => boolean; /** Present on the app that handles text shared via the Android share intent. */ openSharedText?: (ctx: AppContext, title: string, text: string) => void; /** diff --git a/app/apps/compass/compass-app.ts b/app/apps/compass/compass-app.ts index 9559ea42..8c01ff0f 100644 --- a/app/apps/compass/compass-app.ts +++ b/app/apps/compass/compass-app.ts @@ -10,7 +10,7 @@ import { type CompassDiagnostics, } from "../../native/compass"; import { wrapText } from "../../graphics/textwrap"; -import { glassesTypeSetting } from "../../ui/dashboard-settings"; +import { glassesHaveCompass } from "../../ui/dashboard-settings"; import { type InputEvent } from "../../ui/gestures"; import { type Layer, type LayerContext } from "../../ui/layers"; import { lineStep } from "../../ui/metrics"; @@ -152,7 +152,7 @@ class CompassLayer implements Layer { } private statusText(): string { - if (noCompassSensor()) return "These glasses have no compass sensor"; + if (!glassesHaveCompass()) return "These glasses have no compass sensor"; if (this.firmwareStatus !== null) return this.firmwareStatus; if (!this.enabled) return "Compass paused"; if (this.rawHeading === null) return "Waiting for compass data…"; @@ -208,7 +208,7 @@ class CompassLayer implements Layer { image.drawText(small, Math.round(cx - small.measureText(line) / 2), y, line, 125); y += smallStep; } - if (!noCompassSensor()) { + if (glassesHaveCompass()) { const accuracyText = magneticAccuracyText(this.diagnostics); image.drawText(small, width - ACCURACY_RIGHT_PAD - small.measureText(accuracyText), ACCURACY_TOP_PAD, accuracyText, 175); } @@ -220,15 +220,10 @@ class CompassLayer implements Layer { // "Uncalibrated" prompt advertises, and re-calibrating is a normal thing to // want once the glasses have been taken off and put back on. handleInput(event: InputEvent, ctx: LayerContext): void { - if (event.type === "click" && !noCompassSensor()) this.openCalibration(ctx); + if (event.type === "click" && glassesHaveCompass()) this.openCalibration(ctx); } } -/** A G1 has an accelerometer and a gyroscope, but no magnetometer. */ -function noCompassSensor(): boolean { - return glassesTypeSetting.get() === "g1"; -} - export function createCompassAppWindow(options: InProcessAppOptions): InProcessWindow { let requestRender = () => {}; const layer = new CompassLayer(() => requestRender()); @@ -240,7 +235,7 @@ export function createCompassAppWindow(options: InProcessAppOptions): InProcessW icon: "compass", closeable: true, actions: options.actions, - menuItems: () => noCompassSensor() ? [] : [ + menuItems: () => !glassesHaveCompass() ? [] : [ { label: "Calibrate", onSelect: (ctx) => { diff --git a/app/apps/compass/index.ts b/app/apps/compass/index.ts index 4b8442a8..6741a735 100644 --- a/app/apps/compass/index.ts +++ b/app/apps/compass/index.ts @@ -1,3 +1,4 @@ +import { glassesHaveCompass } from "../../ui/dashboard-settings"; import { type AppDefinition } from "../app-definition"; import { COMPASS_SURFACE_ID, COMPASS_WINDOW_ID, createCompassAppWindow } from "./compass-app"; @@ -5,6 +6,7 @@ const compassApp: AppDefinition = { appId: "compass", title: "Compass", icon: "compass", + isSupported: glassesHaveCompass, launch: (ctx) => ctx.launchInProcessApp(COMPASS_WINDOW_ID, COMPASS_SURFACE_ID, createCompassAppWindow), }; diff --git a/app/apps/glanceboard/glanceboard-settings.ts b/app/apps/glanceboard/glanceboard-settings.ts index 4d729490..eebc91f8 100644 --- a/app/apps/glanceboard/glanceboard-settings.ts +++ b/app/apps/glanceboard/glanceboard-settings.ts @@ -1,4 +1,4 @@ -import { ConfigSettingBoolean, ConfigSettingEnum } from "../../ui/dashboard-settings"; +import { ConfigSettingBoolean, ConfigSettingEnum, glassesHaveCompass } from "../../ui/dashboard-settings"; import { QUADRANT_LAYOUT, SIX_SLOT_LAYOUT, slotsVerticallyAdjacent, type GlanceLayout } from "./layout"; import { type GlanceWidgetId } from "./widget"; import { glanceWidgetSpans } from "./widgets"; @@ -23,6 +23,11 @@ export function glanceSlotChoiceLabel(choice: GlanceSlotChoice): string { return SLOT_CHOICE_LABELS[choice] ?? choice; } +/** Whether the paired glasses can drive this widget; if not, it is left out of the slot picker. */ +function slotChoiceAvailable(choice: GlanceSlotChoice): boolean { + return choice !== "compass" || glassesHaveCompass(); +} + /** * Slot order follows QUADRANT_LAYOUT: top left, top right, bottom left, bottom * right. Calendar in both right slots merges into one double-height region. @@ -146,18 +151,26 @@ export const glanceShowLinesSetting = new ConfigSettingBoolean({ export function glanceSlotSettings(layout: GlanceLayout = glanceLayout()): ConfigSettingEnum[] { const grid = layout === QUADRANT_LAYOUT || layout === SIX_SLOT_LAYOUT; const storageId = grid ? QUADRANT_LAYOUT.id : layout.id; - return layout.slots.map( - (slot, index) => - new ConfigSettingEnum({ - id: `glanceboard-${layout.id}-slot-${index}`, - label: slot.label, - storageKey: `glanceboard.${storageId}.slot.${index}`, - defaultValue: (grid ? DEFAULT_QUADRANT_CHOICES[index] : undefined) ?? "none", - values: SLOT_CHOICES, - formatValue: glanceSlotChoiceLabel, - description: `Which widget fills the ${slot.label.toLowerCase()} slot of the Glanceboard.`, - }), - ); + return layout.slots.map((slot, index) => { + const defaultValue: GlanceSlotChoice = (grid ? DEFAULT_QUADRANT_CHOICES[index] : undefined) ?? "none"; + return new ConfigSettingEnum({ + id: `glanceboard-${layout.id}-slot-${index}`, + label: slot.label, + storageKey: `glanceboard.${storageId}.slot.${index}`, + defaultValue, + values: SLOT_CHOICES.filter(slotChoiceAvailable), + // A stored choice the glasses can't drive reads as Empty, not the slot's + // default (which could put a widget on the board twice). The stored value + // stays, so pairing glasses that can drive it brings it back. + normalize: (value) => { + const choice = value as GlanceSlotChoice; + if (!SLOT_CHOICES.includes(choice)) return defaultValue; + return slotChoiceAvailable(choice) ? choice : "none"; + }, + formatValue: glanceSlotChoiceLabel, + description: `Which widget fills the ${slot.label.toLowerCase()} slot of the Glanceboard.`, + }); + }); } /** diff --git a/app/apps/launcher/index.ts b/app/apps/launcher/index.ts index 1c16f4b9..40448347 100644 --- a/app/apps/launcher/index.ts +++ b/app/apps/launcher/index.ts @@ -11,7 +11,7 @@ import { export function launcherEntries(apps: readonly AppDefinition[]) { return [ ...apps - .filter((app) => app.showInLauncher !== false) + .filter((app) => app.showInLauncher !== false && app.isSupported?.() !== false) .map((app) => ({ appId: app.appId, label: app.title, diff --git a/app/assistant/window-tools.ts b/app/assistant/window-tools.ts index 44350606..9724550a 100644 --- a/app/assistant/window-tools.ts +++ b/app/assistant/window-tools.ts @@ -5,11 +5,11 @@ * mirrors what the user can do from the launcher grid and the sidebar. * * The launchable set is the built-in launcher apps plus whatever EvenHub - * packages are installed right now, matching the launcher grid. Installs and - * uninstalls change that set at runtime, so the tools re-register (replacing - * themselves by name) whenever it changes to keep the id enums and - * descriptions current; register() fires the tools-changed broadcast that - * propagates the new specs to the assistant backends. + * packages are installed right now, matching the launcher grid. Installs, + * uninstalls and pairing different glasses change that set at runtime, so the + * tools re-register (replacing themselves by name) whenever it changes to keep + * the id enums and descriptions current; register() fires the tools-changed + * broadcast that propagates the new specs to the assistant backends. */ import { shell, type ShellWindow } from "../ui/shell/shell"; import type { AppDefinition } from "../apps/app-definition"; @@ -30,8 +30,8 @@ import { onAnySettingChanged } from "../ui/dashboard-settings"; import { toolRegistry, type ToolRegistry, type ToolResult } from "./tool-registry"; export type WindowToolsOptions = { - /** The built-in launcher apps; installed EvenHub apps are added dynamically. */ - apps: readonly AppDefinition[]; + /** The built-in launcher apps for the paired glasses; installed EvenHub apps are added dynamically. */ + apps: () => readonly AppDefinition[]; /** Launch (or focus) an app exactly as the launcher grid would. */ launchApp: (appId: string) => Promise | void; /** Repaint the shell surface so the sidebar reflects a focus change. */ @@ -47,9 +47,11 @@ export function registerWindowTools( if (registered) return; registered = true; registerTools(options, registry); - let fingerprint = getInstalledEvenHubFingerprint(); + const launchableFingerprint = () => + `${getInstalledEvenHubFingerprint()}\n${options.apps().map((app) => app.appId).join()}`; + let fingerprint = launchableFingerprint(); onAnySettingChanged(() => { - const current = getInstalledEvenHubFingerprint(); + const current = launchableFingerprint(); if (current === fingerprint) return; fingerprint = current; registerTools(options, registry); @@ -58,7 +60,7 @@ export function registerWindowTools( function registerTools(options: WindowToolsOptions, registry: ToolRegistry): void { const installedApps = getInstalledEvenHubApps(); - const apps = new Map(options.apps.map((app) => [app.appId, app.title])); + const apps = new Map(options.apps().map((app) => [app.appId, app.title])); for (const app of installedApps) { apps.set(installedEvenHubAppId(app.packageId), app.name); } diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index 2d798e68..b52caef1 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -195,8 +195,8 @@ const LOW_BATTERY_PERCENT = 5; const EVEN_APP_DETECTED_MESSAGE = "The Even Realities app appears to be running. If Faceclaw has trouble connecting, open its app settings and force stop it."; -// The launcher grid's app list; also fixes the app ids apps.launch accepts. -const LAUNCHABLE_APPS = ALL_APPS.filter((app) => app.showInLauncher !== false); +// The launcher grid's app list for the paired glasses; also fixes the app ids apps.launch accepts. +const launchableApps = () => ALL_APPS.filter((app) => app.showInLauncher !== false && app.isSupported?.() !== false); /** * The global settings window viewport sizes depend on: the paired glasses' @@ -422,7 +422,7 @@ class DashboardController { registerRoamTools((appId) => this.launchApp(appId)); // apps.* tools mirror the launcher grid and sidebar (launch, focus, close). registerWindowTools({ - apps: LAUNCHABLE_APPS, + apps: launchableApps, launchApp: (appId) => this.launchApp(appId), requestShellRender: () => this.requestShellRender(), }); @@ -506,7 +506,7 @@ class DashboardController { assistant: text => shell.sendToAssistant(text), }); this.wearRemote = new WearRemote({ - apps: LAUNCHABLE_APPS, + apps: launchableApps, injectInput: (kind) => this.injectSyntheticRingInput(kind, "watch"), launchApp: (appId) => this.launchApp(appId), connect: () => this.connect(), diff --git a/app/g2/ios-preview-controller.ts b/app/g2/ios-preview-controller.ts index 247d8f1d..61d219be 100644 --- a/app/g2/ios-preview-controller.ts +++ b/app/g2/ios-preview-controller.ts @@ -272,7 +272,7 @@ export class IosPreviewController { // The header's EvenHub phone-UI button hides while that UI is showing. onPhoneShownChanged(() => this.syncEvenHubPhoneUi()) registerSystemTools() - registerWindowTools({ apps: ALL_APPS.filter(app => !iosAppUnavailableReason(app.appId)), + registerWindowTools({ apps: () => ALL_APPS.filter(app => app.isSupported?.() !== false && !iosAppUnavailableReason(app.appId)), launchApp: id => this.launchApp(id), requestShellRender: () => this.requestShellRender() }) registerNavigateTools(id => this.launchApp(id)) registerRoamTools(id => this.launchApp(id)) @@ -280,7 +280,7 @@ export class IosPreviewController { iosVoiceInput.onSpeechEnd(() => this.syncContinuousCapture()) for (const app of ALL_APPS) if (app.appId !== 'launcher' && !iosAppUnavailableReason(app.appId)) app.boot?.(this.buildAppContext(app)) this.wearRemote = new WearRemote({ - apps: ALL_APPS.filter(app => app.showInLauncher !== false && !iosAppUnavailableReason(app.appId)), + apps: () => ALL_APPS.filter(app => app.showInLauncher !== false && app.isSupported?.() !== false && !iosAppUnavailableReason(app.appId)), injectInput: kind => this.injectWatchInput(kind), launchApp: id => this.launchApp(id), // The watch's Connect/Disconnect are explicit user choices, like the phone's own buttons. diff --git a/app/g2/wear-remote.ts b/app/g2/wear-remote.ts index c2e2b597..e865b32a 100644 --- a/app/g2/wear-remote.ts +++ b/app/g2/wear-remote.ts @@ -115,8 +115,8 @@ const WATCH_BATTERY_MAX_AGE_MS = 4 * 60 * 60_000; /** What the dashboard controller lends the watch remote. */ export type WearRemoteHost = { - /** The launcher-grid apps; installed EvenHub packages are added dynamically. */ - apps: readonly AppDefinition[]; + /** The launcher-grid apps for the paired glasses; installed EvenHub packages are added dynamically. */ + apps: () => readonly AppDefinition[]; injectInput: (kind: WearRemoteInputKind) => Promise; launchApp: (appId: string) => Promise; connect: () => Promise; @@ -320,7 +320,7 @@ export class WearRemote { /** Launchable apps, matching the launcher grid and the apps.launch tool. */ private listApps(): Array<{ appId: string; title: string }> { - const apps = this.host.apps.map((app) => ({ appId: app.appId, title: app.title })); + const apps = this.host.apps().map((app) => ({ appId: app.appId, title: app.title })); for (const installed of getInstalledEvenHubApps()) { apps.push({ appId: installedEvenHubAppId(installed.packageId), title: installed.name }); } diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 212945e8..e8d6a5c1 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -396,6 +396,15 @@ export const glassesTypeSetting = new ConfigSettingEnum({ reportInAnalytics: false, }); +/** + * Whether the paired glasses can report a heading. A G1 has an accelerometer + * and a gyroscope but no magnetometer; the RayNeo iO's firmware has no compass + * messages. + */ +export function glassesHaveCompass(): boolean { + return glassesTypeSetting.get() === "g2"; +} + const APP_SWITCHER_POSITION_LABELS: Record = { left: "Left", right: "Right", diff --git a/tests/compass-readout.test.cjs b/tests/compass-readout.test.cjs index 05acf06f..fd772a58 100644 --- a/tests/compass-readout.test.cjs +++ b/tests/compass-readout.test.cjs @@ -55,7 +55,7 @@ function compass(width = 576, height = 260, glasses = 'g2') { }, '../../ui/shell/shell': { shell: { isWindowVisible: () => true } }, '../../native/location-permissions': { hasLocationPermission: () => false }, - '../../ui/dashboard-settings': { glassesTypeSetting: { get: () => glasses } }, + '../../ui/dashboard-settings': { glassesHaveCompass: () => glasses === 'g2' }, './calibration': calibration, './calibration-layer': {}, './declination': { onDeclinationChanged: () => () => {} }, './heading': { getNorthReference: () => 'magnetic', resolveHeading: (v) => ({ displayDegrees: v }) }, diff --git a/tests/compass-texture-cache.test.cjs b/tests/compass-texture-cache.test.cjs index 4326f5ba..702daebe 100644 --- a/tests/compass-texture-cache.test.cjs +++ b/tests/compass-texture-cache.test.cjs @@ -44,7 +44,7 @@ const compass = load('app/apps/compass/compass-app.ts', { '../../ui/shell/in-process-window': {}, '../../ui/shell/shell': {}, '../../native/location-permissions': {}, - '../../ui/dashboard-settings': { glassesTypeSetting: { get: () => 'g2' } }, + '../../ui/dashboard-settings': { glassesHaveCompass: () => true }, './calibration': calibration, './calibration-layer': {}, './compass-rose': rose, diff --git a/tests/display-layout-setting.test.cjs b/tests/display-layout-setting.test.cjs index d17d5666..8c583682 100644 --- a/tests/display-layout-setting.test.cjs +++ b/tests/display-layout-setting.test.cjs @@ -98,3 +98,14 @@ test('a RayNeo iO always takes the R1 directly, leaving the G2\'s ring connectio api.glassesTypeSetting.set('g2'); assert.equal(api.effectiveRingConnectionMode(), 'health'); }); + +test('only a G2 has a compass', () => { + const api = settingsFixture(); + assert.equal(api.glassesHaveCompass(), true); + api.glassesTypeSetting.set('g1'); + assert.equal(api.glassesHaveCompass(), false); + api.glassesTypeSetting.set('rayneo-io'); + assert.equal(api.glassesHaveCompass(), false); + api.glassesTypeSetting.set('g2'); + assert.equal(api.glassesHaveCompass(), true); +}); diff --git a/tests/glanceboard-settings.test.cjs b/tests/glanceboard-settings.test.cjs index ebb171f9..47dc8358 100644 --- a/tests/glanceboard-settings.test.cjs +++ b/tests/glanceboard-settings.test.cjs @@ -20,18 +20,26 @@ function load(file, dependencies) { function harness() { const values = new Map(); const listeners = new Set(); + const live = new Set(); + const glasses = { haveCompass: true }; class Setting { constructor(options) { Object.assign(this, options); } - get() { return values.get(this.storageKey) ?? this.defaultValue; } + get() { + const value = values.get(this.storageKey) ?? this.defaultValue; + return this.normalize ? this.normalize(value) : value; + } set(value) { values.set(this.storageKey, value); } } const config = { ConfigSettingBoolean: Setting, ConfigSettingEnum: Setting, + glassesHaveCompass: () => glasses.haveCompass, onAnySettingChanged: (listener) => { listeners.add(listener); return () => listeners.delete(listener); }, }; const widgets = { glanceWidgetSpans: (choice) => choice === 'calendar' || choice === 'terminal', - findGlanceWidget: () => ({ create: () => ({ start() {}, stop() {}, paint() {} }) }), + findGlanceWidget: (choice) => ({ create: () => ({ + start() { live.add(choice); }, stop() { live.delete(choice); }, paint() {}, + }) }), }; const settings = load('app/apps/glanceboard/glanceboard-settings.ts', { '../../ui/dashboard-settings': config, './layout': layout, './widgets': widgets, @@ -45,7 +53,7 @@ function harness() { '../../graphics/image': { GrayImage }, '../../ui/dashboard-settings': config, './glanceboard-settings': settings, './layout': layout, './widgets': widgets, }); - return { settings, GlanceBoard, values, listeners, notify: () => [...listeners].forEach((listener) => listener()) }; + return { settings, GlanceBoard, values, listeners, live, glasses, notify: () => [...listeners].forEach((listener) => listener()) }; } test('layout defaults to 2x2; expanding preserves stored slots and remembers the extra row', () => { @@ -97,3 +105,38 @@ test('an active empty board resizes and requests a frame when the layout changes board.stop(); assert.equal(h.listeners.size, 0); }); + +test('glasses without a compass: no compass in the picker, and a stored one reads as Empty until a G2 returns', () => { + const h = harness(); + h.values.set('glanceboard.quadrants.slot.0', 'compass'); + assert.ok(h.settings.glanceSlotSettings()[0].values.includes('compass')); + assert.equal(h.settings.glanceSlotSettings()[0].get(), 'compass'); + + h.glasses.haveCompass = false; + const [slot] = h.settings.glanceSlotSettings(); + assert.ok(!slot.values.includes('compass')); + // Empty, not the slot's default: System card may already be elsewhere on the board. + assert.equal(slot.get(), 'none'); + assert.equal(h.values.get('glanceboard.quadrants.slot.0'), 'compass'); + + h.glasses.haveCompass = true; + assert.equal(h.settings.glanceSlotSettings()[0].get(), 'compass'); +}); + +test('an unknown stored slot value still falls back to the slot default', () => { + const { settings: s, values } = harness(); + values.set('glanceboard.quadrants.slot.0', 'removed-widget'); + assert.equal(s.glanceSlotSettings()[0].get(), 'system-card'); +}); + +test('a live board drops the compass widget when the paired glasses have no compass', () => { + const h = harness(); + h.values.set('glanceboard.quadrants.slot.0', 'compass'); + const board = new h.GlanceBoard(() => {}); + board.start(); + assert.ok(h.live.has('compass')); + h.glasses.haveCompass = false; + h.notify(); + assert.ok(!h.live.has('compass')); + board.stop(); +}); diff --git a/tests/ios-watch-remote.test.cjs b/tests/ios-watch-remote.test.cjs index 316b854b..57047b60 100644 --- a/tests/ios-watch-remote.test.cjs +++ b/tests/ios-watch-remote.test.cjs @@ -135,7 +135,7 @@ function loadRemote({ phase = 'disconnected', preview = false, now = 1_800_000_0 })[id] ?? {}, }); const remote = new WearRemote({ - apps: [{ appId: 'timer', title: 'Timer' }], + apps: () => [{ appId: 'timer', title: 'Timer' }], injectInput: async kind => { inputs.push(kind); }, launchApp: async () => {}, connect: async () => {}, disconnect: async () => {}, setGlassesLocked() {}, requestShellRender() {}, diff --git a/tests/unsupported-apps.test.cjs b/tests/unsupported-apps.test.cjs new file mode 100644 index 00000000..8a283494 --- /dev/null +++ b/tests/unsupported-apps.test.cjs @@ -0,0 +1,71 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const vm = require('node:vm'); +const ts = require('typescript'); + +function load(file, dependencies) { + const context = { exports: {}, console, require: (name) => { + assert.ok(name in dependencies, name); + return dependencies[name]; + } }; + vm.runInNewContext(ts.transpileModule(fs.readFileSync(path.join(__dirname, '..', file), 'utf8'), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText, context); + return context.exports; +} + +const installedApps = { + getInstalledEvenHubApps: () => [], + getInstalledEvenHubFingerprint: () => '', + installedEvenHubAppId: (packageId) => packageId, + renderInstalledEvenHubIcon: () => null, +}; + +test('the launcher grid leaves out an app the paired glasses cannot run', () => { + const { launcherEntries } = load('app/apps/launcher/index.ts', { + '../../ui/shell/shell': { shell: {} }, + './launcher-app': {}, + '../evenhub/installed-apps': installedApps, + }); + let supported = true; + const apps = [ + { appId: 'launcher', title: 'Apps', showInLauncher: false }, + { appId: 'timer', title: 'Timer' }, + { appId: 'compass', title: 'Compass', isSupported: () => supported }, + ]; + const ids = () => Array.from(launcherEntries(apps), (entry) => entry.appId); + assert.deepEqual(ids(), ['timer', 'compass']); + supported = false; + assert.deepEqual(ids(), ['timer']); +}); + +test('apps.launch follows the paired glasses', async () => { + const listeners = []; + const { registerWindowTools } = load('app/assistant/window-tools.ts', { + '../ui/shell/shell': { shell: { wake() {} } }, + '../apps/launcher/launcher-folders': {}, + '../apps/evenhub/installed-apps': installedApps, + '../ui/dashboard-settings': { onAnySettingChanged: (listener) => listeners.push(listener) }, + './tool-registry': { toolRegistry: null }, + }); + const tools = new Map(); + const registry = { registerSystemTool: (spec, handler) => tools.set(spec.name, { spec, handler }) }; + const launched = []; + const timer = { appId: 'timer', title: 'Timer' }; + const compass = { appId: 'compass', title: 'Compass' }; + let apps = [timer, compass]; + registerWindowTools({ apps: () => apps, launchApp: (appId) => launched.push(appId), requestShellRender() {} }, registry); + const launch = () => tools.get('apps.launch'); + const launchIds = () => Array.from(launch().spec.inputSchema.properties.app_id.enum); + assert.deepEqual(launchIds(), ['compass', 'timer']); + + apps = [timer]; + listeners.forEach((listener) => listener()); + assert.deepEqual(launchIds(), ['timer']); + await launch().handler({ app_id: 'compass' }); + assert.deepEqual(launched, []); + await launch().handler({ app_id: 'timer' }); + assert.deepEqual(launched, ['timer']); +}); From 6e4515afa59c2010720ce1c985cf4267c8e73a5e Mon Sep 17 00:00:00 2001 From: James Babcock Date: Fri, 6 Nov 2026 21:47:23 -0800 Subject: [PATCH 11/34] Add ANCS support to G1 --- app/g1/firmware/g1v0-image.ts | 12 +-- app/g1/firmware/g1v0-own-bytes.ts | 2 +- app/g2/ancs-client.ts | 4 +- app/g2/ios-preview-controller.ts | 8 ++ app/native/faceclaw-communicator.ios.ts | 5 + .../kotlin/com/faceclaw/app/g1/G1Protocol.kt | 7 +- .../g2protocol/session/GlassesSessionCore.kt | 13 ++- .../g2protocol/session/GlassesSessionG1.kt | 25 +++++ .../com/faceclaw/app/ble/IosGlassesSession.kt | 2 + tests/ancs-client.test.cjs | 11 +++ tests/ios-glanceboard.test.cjs | 32 +++++- .../kotlin/com/faceclaw/app/G1SessionTest.kt | 97 ++++++++++++++++++- 12 files changed, 199 insertions(+), 19 deletions(-) diff --git a/app/g1/firmware/g1v0-image.ts b/app/g1/firmware/g1v0-image.ts index 7a45c443..ee09df55 100644 --- a/app/g1/firmware/g1v0-image.ts +++ b/app/g1/firmware/g1v0-image.ts @@ -15,23 +15,23 @@ export type G1FirmwareImage = { }; export const G1V0_IMAGE: G1FirmwareImage = { - "version": "0.5.64", - "sha256": "25e759efbe17093390386ac286865515d1f3f47efa8e40b5f054685fc7b2d6b6", - "size": 574408, - "source": "51596992c1f1", + "version": "0.5.65", + "sha256": "b8707c80c3fbde1458e92eb39602125df8f03d809c768dab4f33b15c0e7dff9f", + "size": 582820, + "source": "51596992c1f1+uncommitted", "stockVersion": "1.6.6", "stockZipUrl": "https://cdn.evenreal.co/firmware/dcfa510c090e476c10a6f6c348a22415.zip", "stockZipSha256": "748836f2d9d092b0783cbb7672fdccec4f730051cad27f095bbb156ac3e5d316", "parts": [ { - "offset": 263344, + "offset": 271104, "length": 226020, "file": "net_core_app_update.bin", "fileOffset": 0, "sha256": "c277749be97a2763742db399afeb10ca6916059abd60d41bbc05c8892c002c77" }, { - "offset": 489392, + "offset": 497152, "length": 352, "file": "app_update.bin", "fileOffset": 531288, diff --git a/app/g1/firmware/g1v0-own-bytes.ts b/app/g1/firmware/g1v0-own-bytes.ts index 9ec33a30..7b499a2d 100644 --- a/app/g1/firmware/g1v0-own-bytes.ts +++ b/app/g1/firmware/g1v0-own-bytes.ts @@ -1,4 +1,4 @@ // AUTO-GENERATED by tools/g1_firmware_bundle.py -- do not edit by hand. // The built g1v0 image without Even's parts (g1v0-image.ts), deflated. -export const G1V0_OWN_BYTES_BASE64 = "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"; +export const G1V0_OWN_BYTES_BASE64 = "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"; diff --git a/app/g2/ancs-client.ts b/app/g2/ancs-client.ts index 0f11eedf..dc81813d 100644 --- a/app/g2/ancs-client.ts +++ b/app/g2/ancs-client.ts @@ -152,8 +152,10 @@ export class AncsClient { if (flags & 2) { const data = new Uint8Array(this.fragments); this.fragments = []; this.packetKind = -1 if (kind === 0) { - if (data.length !== 1 || data[0] > 2) { this.recover(); return true } + if (data.length !== 1 || data[0] > 3) { this.recover(); return true } if (data[0] === 2) { this.recover('Glasses reported a notification relay error. Retrying…'); return true } + // Only a G1's firmware looks for ANCS itself, so only it can say the phone isn't offering it. + if (data[0] === 3) { this.recover('iPhone is not sharing notifications with the glasses. Enable Share System Notifications in Settings → Bluetooth → right arm. Retrying…'); return true } if (data[0] === 0) { this.resetReceived = true; this.log('Glasses accepted notification relay START; awaiting subscription') } if (data[0] === 1) { if (this.timer !== null) clearTimeout(this.timer) diff --git a/app/g2/ios-preview-controller.ts b/app/g2/ios-preview-controller.ts index 61d219be..134019df 100644 --- a/app/g2/ios-preview-controller.ts +++ b/app/g2/ios-preview-controller.ts @@ -23,6 +23,7 @@ import { weatherBridge } from '../native/weather' import { FaceclawCommunicatorBridge, resolveIosPeripherals, type CommunicatorState, type RawInputEvent } from '../native/faceclaw-communicator.ios' import { PreviewDisplayTarget, type DisplayTarget } from '../native/preview-display.ios' import { AncsClient, ANCS_FIRMWARE_VERSION } from './ancs-client' +import { G1V0_IMAGE } from '../g1/firmware/g1v0-image' import { GlanceHost, type GlanceDisplay } from './glance-host' import { createLockScreenImage, LOCK_SCREEN_SURFACE_ID } from './lock-screen' import { OsEventTypeList } from './events' @@ -984,6 +985,8 @@ export class IosPreviewController { // (or re-pairs / installs the custom firmware, which lift the suppression). if (isHaltedSessionPhase(state.phase)) suppressAutoReconnect() const phase: SessionPhase = state.phase === 'charging' ? 'connected' : isHaltedSessionPhase(state.phase) ? 'error' : state.phase + // The relay ends with the link, so a reconnected session has to ask for it again (syncNotifications). + if (phase !== 'connected' && this.notifications && this.notifications.state !== 'disconnected') this.notifications.stop() // Wear state is a per-transport snapshot: ask again on every new session. if (phase !== 'connected') this.wearDetectionRequested = false this.update(phase, state.status) @@ -1027,6 +1030,11 @@ export class IosPreviewController { if (this.state.capabilities) notifications.stop(`Update glasses to Faceclaw firmware ${ANCS_FIRMWARE_VERSION} or newer for iPhone notifications.`) return } + // A G1 reports no revision that says so: its session knows from what the right arm answered. + if (!communicator.ancsRelayAvailable()) { + notifications.stop(`Update the glasses to Faceclaw's firmware ${G1V0_IMAGE.version} for iPhone notifications, then reconnect.`) + return + } if (notifications.state !== 'disconnected') return notifications.start((Date.now() ^ Math.floor(Math.random() * 0xffffffff)) >>> 0, communicator.rightWriteLimit()) } diff --git a/app/native/faceclaw-communicator.ios.ts b/app/native/faceclaw-communicator.ios.ts index 971e2c7a..563c6eb0 100644 --- a/app/native/faceclaw-communicator.ios.ts +++ b/app/native/faceclaw-communicator.ios.ts @@ -857,6 +857,11 @@ export class FaceclawCommunicatorBridge { return Boolean(this.communicator.isAncsAuthorized()); } + /** False on a G1 whose firmware has no relay; a G2's depends on its firmware revision. */ + ancsRelayAvailable(): boolean { + return Boolean(this.communicator.ancsRelayAvailable()); + } + onAncsAuthorization(listener: (authorized: boolean) => void): () => void { this.ancsAuthorizationListeners.add(listener); return () => this.ancsAuthorizationListeners.delete(listener); diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt index f3b46acc..c2105422 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Protocol.kt @@ -10,6 +10,8 @@ object G1Ble { const val PAIR_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4404" /** Faceclaw's records (VM.md §6.11). */ const val FC_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4405" + /** The iPhone notification relay (VM.md §6.12): the G2's `AN` commands and frames, with this characteristic to itself. */ + const val ANCS_CHAR_UUID = "f3da4d59-277a-4fc9-a1ed-41c9c22d4406" const val REQUESTED_MTU = 247 /** The oldest firmware this app works with: `PROP_SET` came in here. */ const val REQUIRED_FIRMWARE = "0.5.63" @@ -188,13 +190,16 @@ object G1Protocol { @JvmField val inCase: Boolean, /** `MIC` captures here: the right arm. */ @JvmField val mic: Boolean, + /** The iPhone notification relay answers here (0.5.65+). */ + @JvmField val ancs: Boolean, ) fun parseHello(body: ByteArray): Hello? { if (body.size < 7 || body[0].toInt() != 5) return null val flags = body[5].toInt() and 255 return Hello("${body[1].toInt() and 255}.${body[2].toInt() and 255}.${body[3].toInt() and 255}", - body[4].toInt() == 1, flags and 1 != 0, flags and 2 != 0, flags and 64 != 0, flags and 128 != 0, body[6].toInt() and 4 != 0) + body[4].toInt() == 1, flags and 1 != 0, flags and 2 != 0, flags and 64 != 0, flags and 128 != 0, body[6].toInt() and 4 != 0, + body[6].toInt() and 8 != 0) } /** The display path's version, or -1 for a body that isn't FC_INFO's. */ diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index 8a39dacc..6d700719 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -526,7 +526,8 @@ class GlassesSessionCore( /** * Write one already-framed packet to an arm outside the message scheduler (the ANCS * relay client builds its own packets). Blocks like any link write; false when the - * arm is unknown, the link rejects the write, or the session is not running. + * arm is unknown, the link rejects the write, or the session is not running. A G1 has a + * characteristic for them, whose ATT errors say why a command was refused. */ fun writeRawPacket(arm: String, packet: ByteArray): Boolean { val address = when (arm.uppercase()) { @@ -537,8 +538,11 @@ class GlassesSessionCore( val active = monitor.withLock { running } if (!active) return false return try { - val result = link.writeFrames(address, BleProtocol.WRITE_CHAR_UUID, listOf(packet), ConnectionOptions.WRITE_MODE, - ConnectionOptions.WRITE_TIMEOUT_MS) + val result = if (isG1) { + link.writeFrames(address, G1Ble.ANCS_CHAR_UUID, listOf(packet), GattWriteMode.WITH_RESPONSE, ConnectionOptions.WRITE_TIMEOUT_MS) + } else { + link.writeFrames(address, BleProtocol.WRITE_CHAR_UUID, listOf(packet), ConnectionOptions.WRITE_MODE, ConnectionOptions.WRITE_TIMEOUT_MS) + } if (result) monitor.withLock { noteWriteCompletedLocked(address, now()) } result } catch (t: Throwable) { @@ -589,6 +593,9 @@ class GlassesSessionCore( /** True when this session drives an Even G1. */ fun isEvenG1(): Boolean = isG1 + /** Whether the glasses can relay iPhone notifications, as far as the session knows: a G2's depends on its firmware revision, which TS checks. */ + fun ancsRelayAvailable(): Boolean = !isG1 || monitor.withLock { g1.ancsRelay } + /** True when this session drives a RayNeo iO. */ fun isRayNeoIo(): Boolean = isIo diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt index 4edd75e6..5af48c8f 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt @@ -54,6 +54,8 @@ internal class G1SessionState { var micOn = false var lastMicRenewAtMs = 0L val mic = G1MicAssembler() + /** The right arm's relay is there and this host listens to it. */ + var ancsRelay = false fun nextTag(): Int { tag = tag % 255 + 1 @@ -72,6 +74,7 @@ internal class G1SessionState { micOn = false lastMicRenewAtMs = 0 mic.reset() + ancsRelay = false } } @@ -519,6 +522,7 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { // A limit the last session left, when the other eye's panel guard had capped it. g1Control(arm, G1Protocol.OP_PROP_SET, G1Protocol.propSet(G1Protocol.PROP_BRIGHTNESS_MAX, G1Protocol.BRIGHTNESS_LEVEL_MAX)) } + g1ListenToAncsRelay() monitor.withLock { sessionReady = true shutdownRequested = false @@ -570,10 +574,31 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { } } +/** + * Only a host with a relay client listens, and the arm does nothing until that client says START. An arm updated just now + * may still look old to the OS, which keeps the GATT layout it last saw until it hears otherwise: not worth failing the + * session, and the next connection sees it. + */ +private fun GlassesSessionCore.g1ListenToAncsRelay() { + val wanted = rawFrameTap != null && monitor.withLock { g1.arms[1].hello?.ancs == true } + val listening = wanted && link.enableNotifications(rightAddress, G1Ble.ANCS_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS) + if (wanted && !listening) logWarn("G1: the right arm has a notification relay, but subscribing to it failed") + monitor.withLock { g1.ancsRelay = listening } +} + // --------------------------------------------------------------------------------------------- // Inbound (BLE callback thread) internal fun GlassesSessionCore.g1OnNotification(address: String, characteristicUuid: String, data: ByteArray) { + if (G1Ble.ANCS_CHAR_UUID == characteristicUuid) { + val tap = rawFrameTap + if (tap != null && data.size >= 2 && data[0] == GlassesSessionCore.RELAY_TAG_A && data[1] == GlassesSessionCore.RELAY_TAG_N + && address.equals(rightAddress, ignoreCase = true)) { + monitor.withLock { lastIncomingAtMs = now() } + tap(data.copyOf()) + } + return + } if (G1Ble.EVT_CHAR_UUID != characteristicUuid) return val arm = armIndex(address) if (arm < 0) return diff --git a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt index bee49d5a..4ad21dda 100644 --- a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt +++ b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt @@ -108,6 +108,8 @@ class IosGlassesSession internal constructor( fun isAncsAuthorized(): Boolean = central?.isAncsAuthorized(rightIdentifier) ?: false + fun ancsRelayAvailable(): Boolean = core.ancsRelayAvailable() + fun setAncsListener(listener: IosAncsListener?) { if (listener == null) { core.setRawFrameTap(null) diff --git a/tests/ancs-client.test.cjs b/tests/ancs-client.test.cjs index 392abe78..85bfe633 100644 --- a/tests/ancs-client.test.cjs +++ b/tests/ancs-client.test.cjs @@ -32,6 +32,17 @@ test('receives fragmented UTF-8 notifications; pre-existing and modified items d x.source(8,0,4);x.feed(3,[]);x.details(8);x.feed(3,[]);x.metadata(8);assert.equal(x.changed.at(-1)[1],false) assert.ok(x.sent.every(p=>p.length<=20)) }) +test('a phone that is not sharing ANCS says so and is asked again, and an unknown status restarts',t=>{ + const x=setup(t);x.client.stop() + const sent=[],c=new AncsClient(async b=>sent.push([...b]),()=>{}) + t.after(()=>c.stop());c.start(5,20) + c.receive(new Uint8Array([65,78,1,0,...le(5),0,0,3,0])) + c.receive(new Uint8Array([65,78,1,0,...le(5),1,0,3,3])) + assert.equal(c.state,'unavailable');assert.match(c.statusMessage,/Share System Notifications/) + const d=new AncsClient(async()=>{},()=>{});t.after(()=>d.stop());d.start(6,20) + d.receive(new Uint8Array([65,78,1,0,...le(6),0,0,3,4])) + assert.equal(d.state,'unavailable');assert.doesNotMatch(d.statusMessage,/Share System Notifications/) +}) test('removal during retrieval cannot resurrect notification',t=>{ const x=setup(t);x.source(7);x.source(7,2);x.details(7);x.feed(3,[]) assert.deepEqual(x.client.read(),[]) diff --git a/tests/ios-glanceboard.test.cjs b/tests/ios-glanceboard.test.cjs index 073ebf05..4aa88cd7 100644 --- a/tests/ios-glanceboard.test.cjs +++ b/tests/ios-glanceboard.test.cjs @@ -22,6 +22,7 @@ const timings = load('app/native/frame-timings.ts', {}); const LAUNCHER_GRAY = 75; function fixture() { + const relay = { available: true, starts: 0, client: null, message: undefined }; const observers = new Map(), phoneState = { protectedDataAvailable: true }; let settingsChanged, remoteHost, controller, bridge = null; let now = 1000, nextTask = 0, screenOn = true, shellOptions; @@ -107,9 +108,9 @@ function fixture() { constructor() { super(); bridge = this; } on(kind, fn) { this.listeners[kind] = fn; return () => { if (this.listeners[kind] === fn) delete this.listeners[kind]; }; } onStateChange(fn) { return this.on('state', fn); } onRingEvent(fn) { return this.on('ring', fn); } - onWearState(fn) { return this.on('wear', fn); } onBatteryState(fn) { return this.on('battery', fn); } onCaseState(fn) { return this.on('case', fn); } onFirmwareInfo() { return noop(); } + onWearState(fn) { return this.on('wear', fn); } onBatteryState(fn) { return this.on('battery', fn); } onCaseState(fn) { return this.on('case', fn); } onFirmwareInfo(fn) { return this.on('firmware', fn); } onFrameMetrics() { return noop(); } onPreviewAnimationFrame() { return noop(); } addCompassListener() { return noop(); } onAncsRelayFrame() { return noop(); } - onAncsAuthorization() { return noop(); } setRequiresAncs() {} rightWriteLimit() { return 20; } onPhoneLockSignal() {} + onAncsAuthorization() { return noop(); } setRequiresAncs() {} ancsRelayAvailable() { return relay.available; } rightWriteLimit() { return 20; } onPhoneLockSignal() {} async writeRawToRight() {} async configureBrightness() {} async setBrightness() {} async enableWearDetectionAndRequestState() {} async playBuzzerSequence() {} async close() {} emitState(phase, status = phase) { if (phase === 'connected' || phase === 'disconnected') this.phase = phase; this.listeners.state?.({ phase, status }); } emitRing(input) { this.listeners.ring?.(input); } @@ -148,7 +149,10 @@ function fixture() { '../ui/shell/voice-activity': { voiceActivity: { setActive() {}, isActive: () => false, subscribe: () => () => {} } }, '../native/faceclaw-communicator.ios': { FaceclawCommunicatorBridge, resolveIosPeripherals: async addresses => addresses }, '../native/preview-display.ios': { PreviewDisplayTarget }, - './ancs-client': { ANCS_FIRMWARE_VERSION: 16, AncsClient: class { state = 'disconnected'; start() {} stop() {} stopCommand() { return new Uint8Array(); } receive() { return false; } } }, + '../g1/firmware/g1v0-image': { G1V0_IMAGE: { version: '0.5.65' } }, + './ancs-client': { ANCS_FIRMWARE_VERSION: 16, AncsClient: class { state = 'disconnected'; constructor() { relay.client = this; } + start() { this.state = 'starting'; relay.starts++; } stop(message) { this.state = 'disconnected'; relay.message = message; } + stopCommand() { return new Uint8Array(); } receive() { return false; } } }, '../native/nightscout-bridge': { nightscoutBridge: { async start() {}, async stop() {} } }, '../native/weather': { weatherBridge: { setSessionActive() {} } }, './glance-host': { GlanceHost }, './events': events, @@ -214,10 +218,30 @@ function fixture() { } async function phone(type, origin = 'ring') { controller.gesture(type, origin); await render(); } async function connect() { await controller.connect(); await render(); } - return { controller, shell, battery, remoteHost, keyboardChanged: session => shellOptions.onKeyboardInputChanged(session), settings, phoneState, observers, + return { relay, controller, shell, battery, remoteHost, keyboardChanged: session => shellOptions.onKeyboardInputChanged(session), settings, phoneState, observers, get shellOptions() { return shellOptions; }, registered, inProcessApps, get bridge() { return bridge; }, connect, wear: wearing => bridge.emitWear(wearing), settingsChanged: () => settingsChanged(), sent, previews, received, boardStats, hardware, phone, advance, render }; } +test('a link that comes back asks for the notification relay again; a G1 without one is told to update', async () => { + const f = fixture(); + await f.connect(); + const firmware = { leftVersion: 'g1v0 0.5.65', rightVersion: 'g1v0 0.5.65', extension: 'Faceclaw/38' }; + f.bridge.listeners.firmware(firmware); + assert.equal(f.relay.starts, 1); + // Connected and running: nothing to do. + f.bridge.emitState('connected'); + assert.equal(f.relay.starts, 1); + // The firmware's relay ended with the link, so the client must not go on thinking it's ready. + f.bridge.emitState('retrying', 'Reconnecting'); + assert.equal(f.relay.client.state, 'disconnected'); + f.bridge.emitState('connected'); + assert.equal(f.relay.starts, 2); + f.bridge.emitState('retrying', 'Reconnecting'); + f.relay.available = false; + f.bridge.emitState('connected'); + assert.equal(f.relay.starts, 2); + assert.match(f.relay.message, /firmware 0\.5\.65/); +}); const assertBlank = pixels => assert.ok(pixels.every(p => p === 0)); const assertBoard = pixels => { assert.equal(pixels[48 * 640 + 270], 200); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt index 8670b651..907dc898 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt @@ -132,6 +132,11 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { val leftArm = FakeG1Arm(true) val rightArm = FakeG1Arm(false) @Volatile var hasDisplayPath = true + /** HELLO's bit for the notification relay, the characteristic behind it, and what reaches it. */ + @Volatile var hasAncsRelay = false + @Volatile var ancsCharacteristicMissing = false + val ancsSubscribed = ArrayList() + val ancsWrites = ArrayList>() /** Out of the case, or the OS said no: no bond can be made. */ @Volatile var pairingRefused = false private val out = ArrayList>() @@ -176,8 +181,13 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { override fun discoverServices(address: String, timeoutMs: Int): Boolean = true - override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean = - characteristicUuid == G1Ble.EVT_CHAR_UUID + override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean { + if (characteristicUuid == G1Ble.ANCS_CHAR_UUID && !ancsCharacteristicMissing) { + lock.withLock { ancsSubscribed.add(address) } + return true + } + return characteristicUuid == G1Ble.EVT_CHAR_UUID + } override fun requestBond(address: String) { if (!pairingRefused) lock.withLock { arm(address).bonded = true } @@ -200,6 +210,10 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { assertTrue(frames.all { it.size <= 182 }, "writes must fit the MTU") for (f in frames) packet(address, a, f) } + G1Ble.ANCS_CHAR_UUID -> { + assertEquals(GattWriteMode.WITH_RESPONSE, mode, "the arm's refusals come back as ATT errors") + lock.withLock { for (f in frames) ancsWrites.add(address to f) } + } else -> throw AssertionError("write to $characteristicUuid") } return true @@ -220,7 +234,7 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { body[3] = 63 body[4] = (if (a.left) 1 else 0).toByte() body[5] = (2 or 64).toByte() - body[6] = (if (a.left) 0 else 4).toByte() + body[6] = ((if (a.left) 0 else 4) or (if (hasAncsRelay) 8 else 0)).toByte() reply(address, op, tag, 0, body) } G1Protocol.OP_FC_INFO -> if (hasDisplayPath) { @@ -488,6 +502,79 @@ class G1SessionTest { } } + @Test + fun aRelayFirmwareIsListenedToOnTheRightArmOnly() { + val s = G1Session() + val frames = ArrayList() + val lock = testPlatform().createLock() + s.glasses.hasAncsRelay = true + s.core.setRawFrameTap { frame -> lock.withLock { frames.add(frame) } } + try { + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, s.tail()) + assertTrue(s.core.ancsRelayAvailable()) + assertEquals(listOf(RIGHT), s.glasses.lock.withLock { s.glasses.ancsSubscribed.toList() }) + + // A command goes to the relay's characteristic; a G2's would go to its command characteristic. + val start = byteArrayOf(0x41, 0x4e, 1, 0, 9, 0, 0, 0) + assertTrue(s.core.writeRawPacket("R", start)) + val written = s.glasses.lock.withLock { s.glasses.ancsWrites.single() } + assertEquals(RIGHT, written.first) + assertTrue(written.second.contentEquals(start)) + + // A frame reaches the client untouched, and isn't taken for an event; a stray one doesn't reach it. + val frame = byteArrayOf(0x41, 0x4e, 1, 0, 9, 0, 0, 0, 0, 0, 3, 1) + s.core.onNotification(RIGHT, G1Ble.ANCS_CHAR_UUID, frame) + s.core.onNotification(LEFT, G1Ble.ANCS_CHAR_UUID, frame) + s.core.onNotification(RIGHT, G1Ble.ANCS_CHAR_UUID, byteArrayOf(1, 2, 3)) + s.core.onNotification(RIGHT, G1Ble.EVT_CHAR_UUID.uppercase(), byteArrayOf(0x41, 0x4e, 1, 0, 9, 0, 0, 0, 0, 0, 3)) + lock.withLock { + assertEquals(1, frames.size, "only the right arm's relay frames") + assertTrue(frames[0].contentEquals(frame)) + } + } finally { + s.core.disconnect() + } + } + + @Test + fun theRelayIsAvailableOnlyWithFirmwareAHostThatListensAndTheCharacteristic() { + // Android: no client, so nothing to subscribe for, whatever the firmware has. + val android = G1Session() + android.glasses.hasAncsRelay = true + try { + assertTrue(android.core.start()) + assertTrue(awaitTrue(5_000) { android.ready() }, android.tail()) + assertFalse(android.core.ancsRelayAvailable()) + assertEquals(emptyList(), android.glasses.lock.withLock { android.glasses.ancsSubscribed.toList() }) + } finally { + android.core.disconnect() + } + // Firmware before the relay still runs Faceclaw, and doesn't get a subscription it can't answer. + val old = G1Session() + old.core.setRawFrameTap { } + try { + assertTrue(old.core.start()) + assertTrue(awaitTrue(5_000) { old.ready() }, old.tail()) + assertFalse(old.core.ancsRelayAvailable()) + assertEquals(emptyList(), old.glasses.lock.withLock { old.glasses.ancsSubscribed.toList() }) + } finally { + old.core.disconnect() + } + // The OS still has the layout from before the update: the session goes on without it. + val stale = G1Session() + stale.glasses.hasAncsRelay = true + stale.glasses.ancsCharacteristicMissing = true + stale.core.setRawFrameTap { } + try { + assertTrue(stale.core.start()) + assertTrue(awaitTrue(5_000) { stale.ready() }, stale.tail()) + assertFalse(stale.core.ancsRelayAvailable()) + } finally { + stale.core.disconnect() + } + } + @Test fun aSecondFrameIsADeltaThatCostsLittle() { val s = G1Session() @@ -921,7 +1008,11 @@ class G1ProtocolTest { val hello = assertNotNull(G1Protocol.parseHello(body)) assertEquals("0.5.62", hello.version) assertTrue(hello.mic) + assertFalse(hello.ancs, "firmware before the relay") assertTrue(hello.leftArm && hello.panelOk && hello.encrypted && hello.inCase) + body[6] = 8 + assertTrue(assertNotNull(G1Protocol.parseHello(body)).ancs) + assertFalse(assertNotNull(G1Protocol.parseHello(body)).mic) assertFalse(hello.safeMode) body[0] = 4 assertNull(G1Protocol.parseHello(body), "protocol 4 is not this firmware") From 32fa5c0e6e514ffbd5f656f8ee921b6259c0355b Mon Sep 17 00:00:00 2001 From: James Babcock Date: Fri, 6 Nov 2026 23:03:09 -0800 Subject: [PATCH 12/34] Fix issue that caused broken Nightscout widget on the status bar on iOS --- app/apps/nightscout/nightscout-app.ts | 3 ++- app/graphics/image.ts | 15 ++++++++++++--- tests/gray-image.test.cjs | 23 +++++++++++++++++++++++ tests/nightscout.test.cjs | 22 +++++++++++++++++++--- 4 files changed, 56 insertions(+), 7 deletions(-) create mode 100644 tests/gray-image.test.cjs diff --git a/app/apps/nightscout/nightscout-app.ts b/app/apps/nightscout/nightscout-app.ts index 6458541a..01032319 100644 --- a/app/apps/nightscout/nightscout-app.ts +++ b/app/apps/nightscout/nightscout-app.ts @@ -84,7 +84,8 @@ function buildNightscoutTrayIcon(state: NightscoutState): GrayImage { const font = getDefaultSmallFont(); const nowMs = Date.now(); const label = state.latest ? `${state.latest.sgv}` : "--"; - const labelWidth = font.measureText(label); + // A TTF face measures fractionally; the icon's size and layout need whole pixels. + const labelWidth = Math.ceil(font.measureText(label)); const warning = evaluateNightscoutAlerts(state, loadNightscoutThresholds(), nowMs).any; const graphEnd = labelWidth + 4 + TRAY_GRAPH_WIDTH; const image = new GrayImage(graphEnd + (warning ? 24 : 0), TRAY_HEIGHT, 0); diff --git a/app/graphics/image.ts b/app/graphics/image.ts index f36a0dd7..00445b64 100644 --- a/app/graphics/image.ts +++ b/app/graphics/image.ts @@ -4,6 +4,9 @@ import type { MenuHighlightAnimation } from "../ui/menu-highlight-motion"; import { Glyph } from "./bdffont"; import { wrapText } from "./textwrap"; +// This file is also built by tests/tsconfig.json, which has no DOM or Node types. +declare const console: { warn(message: string): void }; + export const G2_LENS_WIDTH = 640; export const G2_LENS_HEIGHT = 480; const DEFAULT_CORNER_RADIUS = 8; @@ -156,9 +159,15 @@ export class GrayImage { private memoizedSourceHash: number | null = null; constructor(width: number, height: number, fill = 0) { - this.width = width; - this.height = height; - this.pixels = new Uint8Array(width * height); + // A fractional width would put most rows' `y * width + x` between pixels, + // silently losing them. TTF text measures fractionally, so this is easy to + // hit; the stack is there because the size alone doesn't identify the caller. + if (!Number.isInteger(width) || !Number.isInteger(height)) { + console.warn(`GrayImage: rounding up non-integer size ${width}x${height}\n${new Error().stack}`); + } + this.width = Math.ceil(width); + this.height = Math.ceil(height); + this.pixels = new Uint8Array(this.width * this.height); if (fill !== 0) { this.clear(fill); } diff --git a/tests/gray-image.test.cjs b/tests/gray-image.test.cjs new file mode 100644 index 00000000..bce7b1b9 --- /dev/null +++ b/tests/gray-image.test.cjs @@ -0,0 +1,23 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const { GrayImage } = require('../.test-build/app/graphics/image.js'); + +test('a non-integer size rounds up, warns, and leaves every pixel addressable', t => { + const warn = t.mock.method(console, 'warn', () => {}); + const image = new GrayImage(78.625, 23.5, 7); + assert.deepEqual([image.width, image.height, image.pixels.length], [79, 24, 79 * 24]); + assert.ok(image.pixels.every(value => value === 7)); + for (let y = 0; y < image.height; y++) { + image.setPixel(78, y, 200); + assert.equal(image.getPixel(78, y), 200, `row ${y}`); + } + assert.equal(warn.mock.callCount(), 1); + assert.match(warn.mock.calls[0].arguments[0], /78\.625x23\.5/); +}); + +test('a whole-number size is kept as given, without a warning', t => { + const warn = t.mock.method(console, 'warn', () => {}); + const image = new GrayImage(79, 24); + assert.deepEqual([image.width, image.height], [79, 24]); + assert.equal(warn.mock.callCount(), 0); +}); diff --git a/tests/nightscout.test.cjs b/tests/nightscout.test.cjs index 8dcbb916..34340701 100644 --- a/tests/nightscout.test.cjs +++ b/tests/nightscout.test.cjs @@ -125,14 +125,14 @@ test('overflow warning backgrounds cover graph pixels and deferred graph labels' assert.equal(baked.getPixel(200, 8), 56, 'uncovered graph remains visible'); }); -function fixture(always = false) { +function fixture(always = false, GrayImage = Image, uiFont = font) { let time = now, icon, tick, changed, notify, renders = 0; const state = { ...healthy, available: true, latest: { sgv: 100, timestampMs: now }, history: [], units: 'mg/dL', delta: 0, direction: '', iob: 1, cob: 0, pumpStatus: '0m ago', configurationMissing: false }; const bridge = { snapshot: () => state, onStateChange(fn) { notify = fn; fn(state); } }; const settings = { loadNightscoutThresholds: () => limits, nightscoutAlwaysShowInTopBarSetting: { get: () => always }, onAnySettingChanged(fn) { changed = fn; }, isNightscoutSettingsConfigured: () => true }; const deps = { - '../../graphics/image': { GrayImage: Image }, - '../../graphics/ui-fonts': { getDefaultSmallFont: () => font, getDefaultLargeFont: () => font }, + '../../graphics/image': { GrayImage }, + '../../graphics/ui-fonts': { getDefaultSmallFont: () => uiFont, getDefaultLargeFont: () => uiFont }, '../../native/nightscout-bridge': { nightscoutBridge: bridge }, '../../ui/dashboard-settings': settings, './nightscout-alerts': alerts, @@ -181,6 +181,22 @@ test('tray is hidden by default and clears recovered measurement warnings immedi second.close(); assert.equal(f.icon(), null); }); +test('tray keeps every pixel row when a TTF font measures the reading fractionally', () => { + const { GrayImage } = require('../.test-build/app/graphics/image.js'); + // 8.875 is Roboto-Light 16's digit advance under iOS Core Text. + const f = fixture(true, GrayImage, { ...font, measureText: text => text.length * 8.875, drawText() {} }); + f.state.latest = { sgv: 142, timestampMs: now }; + // Spans the graph's full 60..200 range, so its line crosses every row. + f.state.history = [{ timestampMs: now - 10 * 60_000, sgv: 200 }, { timestampMs: now, sgv: 60 }]; + f.app.startNightscoutTrayIcon(); + const icon = f.icon(); + assert.ok(Number.isInteger(icon.width), `width ${icon.width}`); + for (let y = 0; y < icon.height; y++) { + const row = Array.from({ length: icon.width }, (_, x) => icon.getPixel(x, y)); + assert.ok(row.some(value => value !== 0), `row ${y} of the graph is drawn`); + } +}); + test('main page highlights only the breached field and removes highlights on recovery', () => { const f = fixture(); const page = load('app/apps/nightscout/nightscout.ts', { From e1a3e80b3dd2b2ba26943a5d9e16c79675c08ad1 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Fri, 6 Nov 2026 23:24:39 -0800 Subject: [PATCH 13/34] Terminal: Terminals now default to opening in the same rather than a new window --- app/apps/terminal/terminal-app.worker.ts | 197 +++++++-- app/g2/ios-preview-controller.ts | 2 +- app/ui/shell/worker-window.ts | 41 +- tests/app-layout.test.cjs | 2 +- tests/terminal-activity.test.cjs | 4 +- tests/terminal-in-place-view.test.cjs | 483 +++++++++++++++++++++++ 6 files changed, 696 insertions(+), 33 deletions(-) create mode 100644 tests/terminal-in-place-view.test.cjs diff --git a/app/apps/terminal/terminal-app.worker.ts b/app/apps/terminal/terminal-app.worker.ts index 87bf9fdc..0f32c5d3 100644 --- a/app/apps/terminal/terminal-app.worker.ts +++ b/app/apps/terminal/terminal-app.worker.ts @@ -6,9 +6,15 @@ * connected host's heading launches a shell there), and hosts the Manage * Connections section * where g2mirror:// connections are added, removed, and toggled. - * - "terminal:view:N": opened by selecting a session in the hub; each has - * its own websocket connection (the protocol allows one attached session - * per connection) and its own xterm emulator. + * - Selecting a session in the hub shows it in the hub's own window: a view + * takes the hub's place in `windows` under the same window id, and + * double-click puts the hub back. The window grows to the view's height + * meanwhile. Sessions already open in a window of their own focus it instead. + * - "terminal:view:N": a session in a window of its own, opened with "Open in + * new window" from the window menu (or by launching a session). + * + * Each view has its own websocket connection (the protocol allows one attached + * session per connection) and its own xterm emulator. * * Connections are g2mirror://@[:port] strings (g2mirrors:// for * TLS), stored as JSON in the settings store (see connections.ts). Each @@ -69,7 +75,7 @@ import { drawSubmenuIndicator, submenuItem, type MenuItem } from "../../ui/menu" import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { centeredTextY, lineStep, listRowHeight, textInkHeight } from "../../ui/metrics"; import { WindowMenu, WindowMenuLayer } from "../../ui/window-menu"; -import { appViewportSize } from "../../ui/shell/geometry"; +import { appViewportSize, type WindowHeightMode } from "../../ui/shell/geometry"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; import type { ToolResult, ToolSpec } from "../../assistant/tool-registry"; @@ -109,7 +115,10 @@ const LAUNCH_PRESETS_KEY = "terminal.launchPresets"; type BaseWindow = { windowId: string; surfaceId: string; - /** Shell-side window title, echoed back in the open-window message. */ + /** + * Window menu title: the shell-side window title, echoed back in the + * open-window message, or the session's label for a view in the hub's window. + */ title: string; /** Content viewport from the shell's open-window message; grid = viewport / cell. */ viewportWidth: number; @@ -155,6 +164,11 @@ type HubWindow = BaseWindow & { type ViewWindow = BaseWindow & { kind: "view"; + /** + * Set when this view is showing in the hub's window rather than one of its + * own: the hub it replaced, which double-click restores. + */ + hub: HubWindow | null; /** Grid font and integer cell pitch, captured at window creation. */ font: UiFont; cellWidth: number; @@ -202,8 +216,13 @@ type PendingView = { options: G2MirrorClientOptions; }; +type Viewport = { width: number; height: number }; + const windows = new Map(); const pendingViews = new Map(); +// Windows waiting on the shell's answer to a set-height-mode, by window id: +// what to do with the viewport it comes back with (see changeWindowHeight). +const pendingHeightChanges = new Map void>(); // The view an assistant tool acts on when the terminal isn't foregrounded: // the last view to be foregrounded or receive input. let activeViewId: string | null = null; @@ -338,6 +357,12 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { openWindow(message.windowId, message.surfaceId, message.title, message.viewport); break; case "resize-window": { + const heightChange = pendingHeightChanges.get(message.windowId); + if (heightChange) { + pendingHeightChanges.delete(message.windowId); + heightChange(message.viewport); + break; + } const window = windows.get(message.windowId); if (!window || (window.viewportWidth === message.viewport.width && window.viewportHeight === message.viewport.height)) break; window.viewportWidth = message.viewport.width; @@ -543,18 +568,24 @@ function openWindow(windowId: string, surfaceId: string, title: string, viewport updateHubAnimation(); } +/** Drop a view's connection for good: its window closed or the hub took its place. */ +function stopViewConnection(window: ViewWindow): void { + for (const unsubscribe of window.unsubscribers.splice(0)) { + unsubscribe(); + } + if (window.reconnectTimer) { + clearTimeout(window.reconnectTimer); + window.reconnectTimer = null; + } + window.client.stop(); +} + function closeWindow(windowId: string): void { const window = windows.get(windowId); if (!window) return; + pendingHeightChanges.delete(windowId); if (window.kind === "view") { - for (const unsubscribe of window.unsubscribers.splice(0)) { - unsubscribe(); - } - if (window.reconnectTimer) { - clearTimeout(window.reconnectTimer); - window.reconnectTimer = null; - } - window.client.stop(); + stopViewConnection(window); } if (window.kind === "hub" && window.mode === "add") { // Window closed mid-add: shut the phone editor down. @@ -759,10 +790,11 @@ function routeBell(connectionId: string, socket: string, lastBellAtMs: number): } } if (terminalWakeOnBellSetting.get()) { - // Wake to the belling session's view window, or the hub if it has none. - // The shell drops the message unless the glasses are actually asleep. + // Wake to the belling session's view window, or the hub's window (whatever + // it is showing) if it has none. The shell drops the message unless the + // glasses are actually asleep. const viewId = viewWindowIdForSocket(connectionId, socket); - const hubId = [...windows.values()].find((window) => window.kind === "hub")?.windowId ?? null; + const hubId = [...windows.values()].find((window) => window.kind === "hub" || window.hub)?.windowId ?? null; const target = viewId ?? hubId; if (target) post({ type: "wake-window", windowId: target }); } @@ -895,6 +927,7 @@ function createViewWindow( const client = new G2MirrorClient({ ...view.options, cols: gridCols, rows: gridRows }); const window: ViewWindow = { kind: "view", + hub: null, windowId, surfaceId, title, @@ -1053,12 +1086,41 @@ function connectedControls(): ControlConnection[] { return [...controls.values()].filter(isControlConnected); } +/** + * What the window menu's "Open in new window" does here, if it applies: to the + * session selected in the hub's list, or the session showing in the hub's + * window (which gives way to the list, as a session has one window at a time). + */ +function openInNewWindowAction(window: TerminalWindow): (() => void) | null { + if (window.kind === "hub") { + const row = hubMenu(window).selectedItem?.sessionRow; + if (!row) return null; + return () => { + if (!focusSessionWindow(row.control, row.session)) openViewWindowFor(row.control, row.session); + }; + } + const control = window.hub && controls.get(window.connectionId); + if (!control) return null; + return () => returnToHub(window, () => openViewWindow(control, window.socket, window.label)); +} + function windowMenuItems(window: TerminalWindow): MenuItem[] { - const items: MenuItem[] = [ + const items: MenuItem[] = []; + const openInNewWindow = openInNewWindowAction(window); + if (openInNewWindow) { + items.push({ + label: "Open in new window", + onSelect: (ctx) => { + ctx.stack.pop(); + openInNewWindow(); + }, + }); + } + items.push( submenuItem("Settings", (ctx) => { ctx.stack.push(new WindowMenuLayer("Terminal settings", settingsMenuItems())); }), - ]; + ); if (window.kind === "hub") { const connected = connectedControls(); const multiHost = connected.length > 1; @@ -1142,8 +1204,14 @@ function handleInput(window: TerminalWindow, event: InputEvent, frameId: number) return; } if (event.type === "double-click") { - // Inside the hub's sub-sections, double-click backs out one level; at the - // top level (and in views) it yields focus to the sidebar as everywhere. + // Inside the hub's sub-sections and a session shown in its window, + // double-click backs out one level; at the top level (and in views with + // windows of their own) it yields focus to the sidebar as everywhere. + if (window.kind === "view" && window.hub) { + frameTimings.finishFrame(frameId, "discarded: terminal returning to the session list"); + returnToHub(window); + return; + } if (window.kind === "hub" && window.mode === "add") { cancelAddConnection(window); renderAndSubmit(window, frameId); @@ -1233,6 +1301,8 @@ type HubItem = { active?: boolean; /** Glyph of the view window showing this session (the number column). */ openGlyph?: string | null; + /** The live session this row lists, for the window menu's "Open in new window". */ + sessionRow?: { control: ControlConnection; session: G2MirrorSession }; onSelect?: () => void; }; @@ -1371,13 +1441,9 @@ function hubSessionItems(window: HubWindow): HubItem[] { label: sessionLabel(session), active: isSessionActive(control.config.id, session.socket), openGlyph: viewGlyphForSocket(control.config.id, session.socket), + sessionRow: { control, session }, onSelect: () => { - const windowId = viewWindowIdForSocket(control.config.id, session.socket); - if (windowId) { - post({ type: "focus-window", windowId }); - } else { - openViewWindowFor(control, session); - } + if (!focusSessionWindow(control, session)) showSessionInHub(window, control, session); }, }); } @@ -1587,10 +1653,89 @@ function viewWindowIdForSocket(connectionId: string, socket: string): string | n return null; } +/** Focus the window already showing a session; false if it has none. */ +function focusSessionWindow(control: ControlConnection, session: G2MirrorSession): boolean { + const windowId = viewWindowIdForSocket(control.config.id, session.socket); + if (!windowId) return false; + post({ type: "focus-window", windowId }); + return true; +} + function openViewWindowFor(control: ControlConnection, session: G2MirrorSession): void { openViewWindow(control, session.socket, sessionLabel(session)); } +/** + * Ask the shell to move a window to another height band, then run `apply` with + * the viewport it answers with: only the shell knows what a band comes to (the + * bottom switcher's height lives on the main thread), and a view's grid goes + * into its websocket handshake, so the size has to be right before it starts. + * Ignored if the window is already waiting on an answer (a repeated gesture). + */ +function changeWindowHeight(windowId: string, heightMode: WindowHeightMode, apply: (viewport: Viewport) => void): void { + if (pendingHeightChanges.has(windowId)) return; + pendingHeightChanges.set(windowId, apply); + post({ type: "set-height-mode", windowId, heightMode }); +} + +/** Make `incoming` what its window id shows, in place of `outgoing`. */ +function replaceWindowContent(outgoing: TerminalWindow, incoming: TerminalWindow): void { + incoming.foreground = outgoing.foreground; + incoming.focused = outgoing.focused; + incoming.lastSubmittedFingerprint = ""; + // Its pending timers and emulator callbacks must not paint over the surface. + outgoing.foreground = false; + windows.set(incoming.windowId, incoming); + updateHubAnimation(); + renderAndSubmit(incoming, 0); +} + +/** A session was selected in the list: show it in the hub's own window. */ +function showSessionInHub(hub: HubWindow, control: ControlConnection, session: G2MirrorSession): void { + const options = clientOptionsFor(control.config); + if (!options) return; + const label = sessionLabel(session); + // Tall like a session in its own window (see openViewWindow). + changeWindowHeight(hub.windowId, "max", (viewport) => { + const view = createViewWindow(hub.windowId, hub.surfaceId, label, viewport, { + connectionId: control.config.id, + socket: session.socket, + label, + glyph: "", + options, + }); + view.hub = hub; + if (hub.foreground) activeViewId = view.windowId; + replaceWindowContent(hub, view); + }); +} + +/** + * Back from a session in the hub's window to the list. The list keeps the order + * it had, with this session's row selected: viewing a session bumps its + * recency, and re-sorting on every return would shuffle the list while the user + * steps through it. `then` runs once the session's connection is gone. + */ +function returnToHub(view: ViewWindow, then?: () => void): void { + const hub = view.hub; + if (!hub) return; + changeWindowHeight(view.windowId, "min", (viewport) => { + stopViewConnection(view); + view.emulator.dispose(); + if (activeViewId === view.windowId) activeViewId = null; + hub.viewportWidth = viewport.width; + hub.viewportHeight = viewport.height; + hub.menu?.resize(viewport); + const items = hubItems(hub); + const row = items.findIndex( + (item) => item.sessionRow?.control.config.id === view.connectionId && item.sessionRow.session.socket === view.socket, + ); + hubMenu(hub).setItems(items, row >= 0 ? row : undefined); + replaceWindowContent(view, hub); + then?.(); + }); +} + /** * Lowest unused sidebar-icon character for a new view window (its terminal * icon shows ">N"). Glyphs free up when their window closes, since usage is diff --git a/app/g2/ios-preview-controller.ts b/app/g2/ios-preview-controller.ts index 247d8f1d..bc56ba90 100644 --- a/app/g2/ios-preview-controller.ts +++ b/app/g2/ios-preview-controller.ts @@ -801,7 +801,7 @@ export class IosPreviewController { const display = this.display if (!display) return await display.configureSurface(id, { ...appViewportRect(heightMode, appId), zOrder: 0, transparency: 'opaque' }) - await display.setSurfaceVisible(id, visible) + await display.setSurfaceVisible(id, typeof visible === 'function' ? visible() : visible) }, setSurfaceVisible: (id, visible) => this.setWindowSurfaceVisible(id, visible), removeSurface: id => this.removeWindowSurface(id), diff --git a/app/ui/shell/worker-window.ts b/app/ui/shell/worker-window.ts index 79cb3799..16278ae4 100644 --- a/app/ui/shell/worker-window.ts +++ b/app/ui/shell/worker-window.ts @@ -79,6 +79,16 @@ export type WorkerAppReply = /** Window height: the standard 288px band ("min", default) or full screen ("max"). */ heightMode?: WindowHeightMode; } + | { + /** + * Move a window to another height band at runtime. The host resizes its + * surface and then always answers with resize-window, even if the size + * came out the same, so the worker can wait for the new viewport. + */ + type: "set-height-mode"; + windowId: string; + heightMode: WindowHeightMode; + } | { type: "set-title"; windowId: string; title: string } | { type: "set-attention"; windowId: string; attention: boolean } /** App-driven animation phase for sidebar icons that support an activity cursor. */ @@ -193,8 +203,12 @@ export type WorkerAppHostOptions = { navigationSensors?: { handle(request: NavigationSensorRequest): void; stop(): void }; openUrl?: (url: string) => void; playBuzzerSequence?: (payload: Uint8Array) => Promise | void; - /** Create/refresh a window surface on the compositor (no-op when disconnected). */ - configureSurface: (surfaceId: string, visible: boolean, heightMode: WindowHeightMode) => Promise; + /** + * Create/refresh a window surface on the compositor (no-op when disconnected). + * `visible` may be a function, read once the surface is configured, for a + * window that can lose the foreground in the meantime. + */ + configureSurface: (surfaceId: string, visible: boolean | (() => boolean), heightMode: WindowHeightMode) => Promise; setSurfaceVisible: (surfaceId: string, visible: boolean) => void; removeSurface: (surfaceId: string) => void; requestShellRender: () => void; @@ -320,6 +334,9 @@ export class WorkerAppHost { heightMode: message.heightMode, }); break; + case "set-height-mode": + this.setWindowHeightMode(message.windowId, message.heightMode); + break; case "set-attention": shell.setWindowAttention(message.windowId, message.attention); break; @@ -463,7 +480,7 @@ export class WorkerAppHost { // Every app worker resizes its live content in place, keeping its state // (a game in progress, a route): the bottom switcher's height changes // with what it holds, and full-height windows give way to it. - relayout: () => this.post({ type: "resize-window", windowId: spec.windowId, viewport: appViewportSize(heightMode, this.options.appId) }), + relayout: () => this.post({ type: "resize-window", windowId: spec.windowId, viewport: appViewportSize(window.heightMode, this.options.appId) }), hasAppMenu: () => this.windowGestures.get(spec.windowId)?.hasAppMenu ?? false, claimsLongPress: () => this.windowGestures.get(spec.windowId)?.claimsLongPress ?? false, close: () => { @@ -536,6 +553,24 @@ export class WorkerAppHost { return window; } + /** The worker asked for another height band (see set-height-mode). */ + private setWindowHeightMode(windowId: string, heightMode: WindowHeightMode): void { + const window = this.openWindows.has(windowId) ? shell.getWindows().find((w) => w.windowId === windowId) : undefined; + if (!window) return; + window.heightMode = heightMode; + // Resize the surface first, so the frame answering resize-window fits it. + void this.options + .configureSurface(window.surfaceId, () => shell.foregroundWindow()?.windowId === windowId, heightMode) + .catch((error) => { + console.error(`surface resize for ${windowId} failed: ${error}`); + }) + .then(() => { + window.relayout?.(); + // The chrome (top bar, bottom switcher) follows the foreground's band. + this.options.requestShellRender(); + }); + } + /** * Post a tool-call to the worker and resolve when its tool-result comes back. * Resolves with a tool error on timeout so a hung worker yields a tool error diff --git a/tests/app-layout.test.cjs b/tests/app-layout.test.cjs index 533ae0e8..f90b669c 100644 --- a/tests/app-layout.test.cjs +++ b/tests/app-layout.test.cjs @@ -911,7 +911,7 @@ test('Terminal resize keeps the view identity, negotiates its grid and skips pos client: { stop: () => calls.push('stop'), setViewport: (...size) => calls.push(size) }, }; const resize = resizeHandler('app/apps/terminal/terminal-app.worker.ts', { - windows: new Map([['test', window]]), clearTimeout: (timer) => calls.push(timer), + windows: new Map([['test', window]]), pendingHeightChanges: new Map(), clearTimeout: (timer) => calls.push(timer), TerminalEmulator: class { constructor(cols, rows) { this.cols = cols; this.rows = rows; } }, reconnectView: (view) => { assert.equal(view, window); calls.push('reconnect'); }, scheduleRender: () => calls.push('paint'), diff --git a/tests/terminal-activity.test.cjs b/tests/terminal-activity.test.cjs index 78a5be77..af8678c3 100644 --- a/tests/terminal-activity.test.cjs +++ b/tests/terminal-activity.test.cjs @@ -15,8 +15,8 @@ function worker() { const messages = []; const file = 'app/apps/terminal/terminal-app.worker.ts'; const source = ts.createSourceFile(file, read(file), ts.ScriptTarget.Latest, true); - const functions = new Set(['recencyKey', 'post', 'renderHubWindows', 'isSessionActive', 'isWindowSessionActive', 'hubAnimationShouldRun', 'syncWindowIconActivity', 'updateHubAnimation', 'noteSessionActivity', 'openWindow', 'closeWindow']); - const variables = new Set(['windows', 'pendingViews', 'activeViewId', 'sessionRecency', 'sessionActivity', 'ACTIVITY_ACTIVE_MS', 'HUB_ANIMATION_STEP_MS', 'hubAnimationPhase', 'hubAnimationTimer', 'windowIconActivity', 'screenOn']); + const functions = new Set(['recencyKey', 'post', 'stopViewConnection', 'renderHubWindows', 'isSessionActive', 'isWindowSessionActive', 'hubAnimationShouldRun', 'syncWindowIconActivity', 'updateHubAnimation', 'noteSessionActivity', 'openWindow', 'closeWindow']); + const variables = new Set(['windows', 'pendingViews', 'pendingHeightChanges', 'activeViewId', 'sessionRecency', 'sessionActivity', 'ACTIVITY_ACTIVE_MS', 'HUB_ANIMATION_STEP_MS', 'hubAnimationPhase', 'hubAnimationTimer', 'windowIconActivity', 'screenOn']); const selected = source.statements.filter(s => ts.isFunctionDeclaration(s) && functions.has(s.name?.text) || ts.isVariableStatement(s) && s.declarationList.declarations.some(d => variables.has(d.name.getText(source))) || diff --git a/tests/terminal-in-place-view.test.cjs b/tests/terminal-in-place-view.test.cjs new file mode 100644 index 00000000..fb5abe1a --- /dev/null +++ b/tests/terminal-in-place-view.test.cjs @@ -0,0 +1,483 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const { loader } = require('./helpers/load-typescript.cjs'); + +const HUB = 'terminal:hub'; +const MIN = { width: 552, height: 260 }; +const MAX = { width: 552, height: 452 }; +const font = { lineHeight: 12, measureText: (text) => text.length * 6, getGlyph: () => null }; +const tick = () => new Promise((resolve) => setTimeout(resolve, 0)); + +// A recording stand-in for the worker's images: enough to see what a frame shows. +function fakeImageModule() { + class GrayImage { + constructor(width, height) { + this.width = width; + this.height = height; + this.texts = []; + return new Proxy(this, { get: (target, key) => (key in target ? target[key] : () => {}) }); + } + drawText(_font, _x, _y, text) { this.texts.push(text); } + drawMenuSelection(row) { this.texts.push(...row.texts.map((text) => `[${text}]`)); } + } + return { GrayImage }; +} + +// Runs the real worker against the shell's message protocol, stubbing only what +// sits behind it: the websocket client, the emulator, the display and the menu host. +function terminal({ sessions = ['vim', 'top'], presets = '', bellWake = true } = {}) { + const replies = [], clients = [], frames = [], menus = []; + const global = { postMessage: (message) => replies.push(message) }; + + class FakeClient { + constructor(options) { + this.options = options; + this.stopped = false; + this.attached = null; + this.sent = []; + this.listeners = { state: [], bell: [], activity: [] }; + this.statusText = 'Connected.'; + clients.push(this); + } + state() { return { phase: this.stopped ? 'idle' : 'connected', status: this.statusText, serverName: 'host', sessions: sessions.map((title) => ({ socket: title, title, cwdHint: '' })) }; } + start() { this.stopped = false; this.listeners.state.forEach((listener) => listener(this.state())); } + stop() { this.stopped = true; } + setViewport(cols, rows) { this.viewport = [cols, rows]; } + connectSession(socket) { this.attached = socket; } + sendInput(text) { this.sent.push(text); } + submitInput(text) { this.sent.push(text); } + listSessions() {} + view() {} + requestHistory() {} + onStateChange(listener) { this.listeners.state.push(listener); return () => {}; } + onBell(listener) { this.listeners.bell.push(listener); return () => {}; } + onTitle() { return () => {}; } + onActivity(listener) { this.listeners.activity.push(listener); return () => {}; } + onSnapshot() { return () => {}; } + onHistoryLines() { return () => {}; } + onSessionAttached() { return () => {}; } + onTerminalData() { return () => {}; } + onSessionDetached() { return () => {}; } + } + + class FakeEmulator { + dispose() { this.disposed = true; } + write() {} + reset() {} + bufferLength() { return 0; } + lineAt() { return ''; } + cursorRow() { return 0; } + cursorCol() { return 0; } + } + + // Click runs the first item, the way the real menu does at its initial selection. + class FakeWindowMenu { + constructor(options) { this.options = options; this.opened = null; menus.push(this); } + isOpen() { return this.opened !== null; } + open(items = this.options.items()) { this.opened = items; } + close() { this.opened = null; } + resize(size) { this.options.size = size; } + paint() { this.options.items(); return [this.options.paintBase()]; } + async handleInput(event) { + if (event.type === 'click') { + await this.opened[0].onSelect({ stack: { pop: () => { this.opened = null; }, push() {} } }); + } + } + } + + const setting = (value) => ({ id: 'setting', get: () => value, set() {} }); + const image = fakeImageModule(); + const load = loader({ global, setTimeout, clearTimeout, setInterval, clearInterval }, { + '@nativescript/core/globals': {}, + './background': { hasTerminalBackgroundWork: () => false }, + '../../ui/shell/worker-lifecycle': { finishWorkerShutdown() {} }, + '../../graphics/image': image, + '../graphics/image': image, + '../../graphics/plane': { + planesFingerprint: (planes) => JSON.stringify([planes[0].width, planes[0].height, planes[0].texts]), + flattenPlanesWithDraws: (planes) => ({ image: { ...planes[0], width: planes[0].width, height: planes[0].height, texts: planes[0].texts, to8bppBuffer: () => ({ buffer: planes[0].texts }) }, draws: [] }), + }, + '../../graphics/glyph-wire': { prepareFrameDraws: () => null }, + '../../graphics/ui-fonts': { + getDefaultSmallFont: () => font, + getTerminalFontConfig: () => ({ font, cellWidth: 6, cellHeight: 12 }), + }, + '../../graphics/icons': { TERMINAL_ICON_GLYPHS: ['1', '2', '3'] }, + '../../native/frame-timings': { + startFrame: () => 1, finishFrame() {}, logFrame() {}, + span: (_frame, _name, run) => run(), runWithFrame: (_frame, run) => run(), + }, + '../../native/active-display': { + getActiveDisplay: () => ({ + submitSurfaceFrame: (texts, surfaceId, _x, _y, width, height) => frames.push({ surfaceId, width, height, texts }), + }), + }, + '../../ui/gestures': { GESTURE_DOUBLE_CLICK: 'double-tap' }, + '../../native/g2mirror-client': { G2MirrorClient: FakeClient }, + '../../native/settings-store': { onSettingsStoreChanged() {} }, + '../../ui/dashboard-settings': { + enumSettingMenuItem() {}, textSettingMenuItem() {}, toggleSettingMenuItem() {}, + terminalAutoReconnectSetting: setting(false), + terminalDisplayLayoutSetting: setting('default'), + terminalLaunchPresetsSetting: setting(presets), + terminalNewConnectionSetting: setting(''), + terminalWakeOnBellSetting: setting(bellWake), + }, + '../../ui/font-picker': { terminalFontPickerMenuItem() {} }, + './connections': { + TERMINAL_CONNECTIONS_KEY: 'terminal.connections', + connectionDisplayName: (config) => config.id, + loadConnections: () => [{ id: 'c1', url: 'ok', serverName: 'host', enabled: true }], + parseConnectionString: () => ({ host: 'host' }), + saveConnections() {}, updateConnection() {}, + }, + './terminal-emulator': { TerminalEmulator: FakeEmulator }, + '../../ui/menu': { drawSubmenuIndicator() {}, submenuItem: (label, onSelect) => ({ label, onSelect }) }, + '../../ui/window-menu': { WindowMenu: FakeWindowMenu, WindowMenuLayer: class {} }, + '../../ui/shell/geometry': { appViewportSize: () => MAX }, + }); + load('app/apps/terminal/terminal-app.worker.ts'); + + const send = (message) => global.onmessage({ data: message }); + const input = (type, windowId = HUB) => send({ type: 'input', windowId, event: { type }, frameId: 0, focused: true }); + const openWindow = (windowId, viewport) => { + send({ type: 'open-window', windowId, surfaceId: `window:${windowId}`, title: 'Terminal', viewport }); + send({ type: 'foreground', windowId, foreground: true, focused: true }); + }; + const repliesOf = (type) => replies.filter((reply) => reply.type === type); + return { + clients, frames, replies, menus, send, input, openWindow, repliesOf, + lastFrame: () => frames[frames.length - 1], + clearReplies: () => { replies.length = 0; }, + openMenu: (windowId = HUB) => input('short-then-long-press', windowId), + menuLabels: () => Array.from(menus.find((menu) => menu.isOpen()).opened, (item) => item.label), + closeMenu: () => menus.forEach((menu) => menu.close()), + // Past Manage Connections and Settings to the first session row. + selectFirstSession: () => { input('scroll-down'); input('scroll-down'); }, + answerHeight: (viewport, windowId = HUB) => send({ type: 'resize-window', windowId, viewport }), + }; +} + +function hubShowingList() { + const t = terminal(); + t.openWindow(HUB, MIN); + t.selectFirstSession(); + return t; +} + +function hubShowingSession() { + const t = hubShowingList(); + t.input('click'); + t.answerHeight(MAX); + t.clearReplies(); + return t; +} + +test('selecting a session shows it in the same window, at the height the shell answers with', () => { + const t = hubShowingList(); + assert.equal(t.clients.length, 1, 'just the control connection so far'); + assert.ok(t.lastFrame().texts.includes('[vim]') || t.lastFrame().texts.some((text) => text.includes('vim'))); + + t.input('click'); + assert.deepEqual(t.repliesOf('open-window-request'), [], 'no new window'); + assert.deepEqual(t.repliesOf('set-height-mode').map((reply) => reply.heightMode), ['max']); + assert.equal(t.clients.length, 1, 'no connection before the size is known'); + + t.answerHeight(MAX); + const view = t.clients[1]; + assert.deepEqual([view.options.cols, view.options.rows], [92, 37], 'grid from the answered viewport'); + assert.equal(view.attached, 'vim'); + assert.deepEqual([t.lastFrame().surfaceId, t.lastFrame().width, t.lastFrame().height], [`window:${HUB}`, MAX.width, MAX.height]); + assert.ok(!t.lastFrame().texts.includes('Terminal'), 'the list is gone'); +}); + +test('a repeated tap before the shell answers starts one view', () => { + const t = hubShowingList(); + t.input('click'); + t.input('click'); + assert.equal(t.repliesOf('set-height-mode').length, 1); + t.answerHeight(MAX); + assert.equal(t.clients.length, 2); +}); + +test('text input reaches the session shown in place', () => { + const t = hubShowingSession(); + t.send({ type: 'text-input', windowId: HUB, text: 'ls' }); + assert.deepEqual(t.clients[1].sent, ['ls']); +}); + +test('double-tap in a session shown in place goes back to the list, not the sidebar', () => { + const t = hubShowingSession(); + t.input('double-click'); + assert.deepEqual(t.repliesOf('yield-focus'), []); + assert.deepEqual(t.repliesOf('set-height-mode').map((reply) => reply.heightMode), ['min']); + assert.equal(t.clients[1].stopped, false, 'the session stays up until the window has resized'); + + t.answerHeight(MIN); + assert.equal(t.clients[1].stopped, true); + assert.deepEqual([t.lastFrame().width, t.lastFrame().height], [MIN.width, MIN.height]); + assert.ok(t.lastFrame().texts.includes('Terminal'), 'the list is back'); + assert.ok(t.lastFrame().texts.includes('[vim]'), 'with the session just viewed still selected'); + + t.input('double-click'); + assert.deepEqual(t.repliesOf('yield-focus').map((reply) => reply.windowId), [HUB], 'then double-tap yields as usual'); +}); + +test('coming back from a session keeps the list order despite its bumped recency, until the list next becomes visible', () => { + const t = hubShowingList(); + const sessionRows = () => t.lastFrame().texts.filter((text) => /vim|top/.test(text)); + t.input('scroll-down'); + assert.deepEqual(sessionRows(), ['vim', '[top]']); + t.input('click'); + t.answerHeight(MAX); + t.clients[0].listeners.activity.forEach((listener) => listener('top')); + + t.input('double-click'); + t.answerHeight(MIN); + assert.deepEqual(sessionRows(), ['vim', '[top]']); + + t.send({ type: 'foreground', windowId: HUB, foreground: false, focused: false }); + t.send({ type: 'foreground', windowId: HUB, foreground: true, focused: true }); + assert.deepEqual(sessionRows().map((text) => text.replace(/[[\]]/g, '')), ['top', 'vim'], 're-sorted as usual'); +}); + +test('the session just viewed stays selected when rows above it have shifted', () => { + const sessions = ['vim', 'top', 'htop']; + const t = terminal({ sessions }); + t.openWindow(HUB, MIN); + t.selectFirstSession(); + t.input('scroll-down'); + t.input('click'); + t.answerHeight(MAX); + // vim exits while top is on show, moving top's row up one (and htop into its place). + sessions.shift(); + t.clients[0].listeners.state.forEach((listener) => listener(t.clients[0].state())); + + t.input('double-click'); + t.answerHeight(MIN); + assert.ok(t.lastFrame().texts.includes('[top]')); +}); + +test('the window menu leads with Open in new window only while a session is selected', () => { + const t = terminal(); + t.openWindow(HUB, MIN); + t.openMenu(); + assert.equal(t.menuLabels()[0], 'Settings', 'Manage Connections is selected'); + t.closeMenu(); + t.input('scroll-down'); + t.openMenu(); + assert.equal(t.menuLabels()[0], 'Settings', 'Settings is selected'); + t.closeMenu(); + t.input('scroll-down'); + t.openMenu(); + assert.deepEqual(t.menuLabels().slice(0, 2), ['Open in new window', 'Settings']); +}); + +test('Open in new window on a selected session opens a window and leaves the list up', async () => { + const t = hubShowingList(); + t.openMenu(); + t.input('click'); + await tick(); + assert.deepEqual(t.repliesOf('set-height-mode'), []); + const [request] = t.repliesOf('open-window-request'); + assert.equal(request.title, 'vim'); + assert.equal(request.heightMode, 'max'); + assert.equal(request.focus, true); + assert.equal(t.repliesOf('open-window-request').length, 1); +}); + +test('selecting a session already in its own window focuses that window', async () => { + const t = hubShowingList(); + t.openMenu(); + t.input('click'); + await tick(); + const { windowId } = t.repliesOf('open-window-request')[0]; + t.send({ type: 'foreground', windowId: HUB, foreground: false, focused: false }); + t.openWindow(windowId, MAX); + t.send({ type: 'foreground', windowId: HUB, foreground: true, focused: true }); + t.clearReplies(); + + t.input('click'); + assert.deepEqual(t.repliesOf('focus-window').map((reply) => reply.windowId), [windowId]); + assert.deepEqual(t.repliesOf('set-height-mode'), []); +}); + +test('a session in place can move to a new window: the list comes back first, then the window opens', async () => { + const t = hubShowingSession(); + t.openMenu(); + assert.deepEqual(t.menuLabels().slice(0, 2), ['Open in new window', 'Settings']); + t.input('click'); + await tick(); + assert.deepEqual(t.repliesOf('set-height-mode').map((reply) => reply.heightMode), ['min']); + assert.deepEqual(t.repliesOf('open-window-request'), [], 'not while the old connection is up'); + + t.answerHeight(MIN); + assert.equal(t.clients[1].stopped, true); + const [request] = t.repliesOf('open-window-request'); + assert.equal(request.title, 'vim'); + assert.equal(request.iconGlyph, '1'); + assert.ok(t.lastFrame().texts.includes('Terminal')); +}); + +test('a session in its own window keeps its plain menu and double-tap yields focus', async () => { + const t = hubShowingList(); + t.openMenu(); + t.input('click'); + await tick(); + const { windowId } = t.repliesOf('open-window-request')[0]; + t.openWindow(windowId, MAX); + t.openMenu(windowId); + assert.equal(t.menuLabels()[0], 'Settings'); + t.closeMenu(); + t.input('double-click', windowId); + assert.deepEqual(t.repliesOf('yield-focus').map((reply) => reply.windowId), [windowId]); +}); + +test('a bell still finds the window while the hub is showing a session', () => { + const t = hubShowingSession(); + // A session with no view of its own wakes to the hub's window. + t.clients[0].listeners.bell.forEach((listener) => listener('top', Date.now() + 1000)); + assert.deepEqual(t.repliesOf('wake-window').map((reply) => reply.windowId), [HUB]); + t.clearReplies(); + + // The session on show: flagged only while the window is in the background. + t.send({ type: 'foreground', windowId: HUB, foreground: false, focused: false }); + t.clients[0].listeners.bell.forEach((listener) => listener('vim', Date.now() + 2000)); + assert.deepEqual(t.repliesOf('set-attention').map((reply) => reply.windowId), [HUB]); +}); + +test('a window backgrounded while waiting for the shell picks up the session without painting', () => { + const t = hubShowingList(); + t.input('click'); + t.send({ type: 'foreground', windowId: HUB, foreground: false, focused: false }); + const painted = t.frames.length; + t.answerHeight(MAX); + assert.equal(t.frames.length, painted); + t.send({ type: 'foreground', windowId: HUB, foreground: true, focused: true }); + assert.equal(t.lastFrame().height, MAX.height); +}); + +test('a list repaint scheduled before the swap does not paint over the session', async () => { + const sessions = ['vim', 'top']; + const t = terminal({ sessions }); + t.openWindow(HUB, MIN); + t.selectFirstSession(); + t.input('click'); + // A new session makes the list's next paint differ, so it would be submitted. + sessions.push('htop'); + t.clients[0].listeners.state.forEach((listener) => listener(t.clients[0].state())); + t.answerHeight(MAX); + await new Promise((resolve) => setTimeout(resolve, 80)); + assert.equal(t.lastFrame().height, MAX.height); + assert.ok(!t.lastFrame().texts.includes('Terminal')); +}); + +test('a session repaint scheduled before the swap does not paint over the list', async () => { + const t = hubShowingSession(); + t.input('double-click'); + t.clients[1].statusText = 'Reconnecting...'; + t.clients[1].listeners.state.forEach((listener) => listener(t.clients[1].state())); + t.answerHeight(MIN); + await new Promise((resolve) => setTimeout(resolve, 80)); + assert.equal(t.lastFrame().height, MIN.height); + assert.ok(t.lastFrame().texts.includes('Terminal')); +}); + +test('closing the window while the shell has not answered drops the change', () => { + const t = hubShowingList(); + t.input('click'); + t.send({ type: 'close-window', windowId: HUB }); + t.answerHeight(MAX); + assert.equal(t.clients.length, 1, 'no view connection started'); +}); + +test('closing the window while it shows a session stops that session', () => { + const t = hubShowingSession(); + t.send({ type: 'close-window', windowId: HUB }); + assert.equal(t.clients[1].stopped, true); +}); + +test('a later resize of a session in place reconnects at the new grid, and the list then gets its own size', () => { + const t = hubShowingSession(); + t.answerHeight({ width: 552, height: 400 }); + assert.equal(t.clients[1].stopped, false); + assert.deepEqual(t.clients[1].viewport, [92, 33]); + t.input('double-click'); + t.answerHeight({ width: 552, height: 240 }); + assert.equal(t.lastFrame().height, 240); +}); + +test('the shell host resizes the surface before answering with the new viewport', async () => { + const worker = { posted: [], postMessage(message) { this.posted.push(message); } }; + const surfaces = []; + const windows = []; + let renders = 0; + let foreground; + const load = loader({ global: { isIOS: false }, setTimeout, clearTimeout, Promise }, { + '../../graphics/image': {}, + './chrome-layer': { windowIcon() {} }, + '../../assistant/tool-registry': { toolRegistry: { removeAppTools() {} } }, + './geometry': { appViewportSize: (mode) => (mode === 'max' ? MAX : MIN) }, + '../../native/frame-timings': {}, + './worker-state': {}, + './shell': { shell: { + registerWindow: (window) => windows.push(window), + getWindows: () => windows, + foregroundWindow: () => foreground, + isWindowFocused: () => true, + } }, + }); + const { WorkerAppHost } = load('app/ui/shell/worker-window.ts'); + let finishConfigure = () => {}; + const host = new WorkerAppHost({ + appId: 'terminal', worker, + configureSurface: (surfaceId, visible, heightMode) => { + surfaces.push({ surfaceId, visible, heightMode }); + return heightMode === 'min' ? Promise.resolve() : new Promise((resolve) => { finishConfigure = resolve; }); + }, + requestShellRender: () => { renders++; }, + removeSurface() {}, + }); + worker.onmessage({ data: { type: 'worker-ready' } }); + const window = host.openWindow({ windowId: HUB, title: 'Terminal', iconLetter: 'T' }); + foreground = window; + await tick(); + worker.posted.length = 0; + renders = 0; + + worker.onmessage({ data: { type: 'set-height-mode', windowId: HUB, heightMode: 'max' } }); + assert.equal(window.heightMode, 'max', 'the chrome reads the band from here'); + const configured = surfaces[surfaces.length - 1]; + assert.equal(configured.heightMode, 'max'); + assert.equal(configured.visible(), true, 'asked late: the window may have lost the foreground'); + foreground = undefined; + assert.equal(configured.visible(), false); + foreground = window; + await tick(); + assert.deepEqual(worker.posted, [], 'no answer before the surface is ready'); + + finishConfigure(); + await tick(); + assert.deepEqual(worker.posted.map((message) => [message.type, message.viewport]), [['resize-window', MAX]]); + assert.equal(renders, 1); + + // Any later relayout (a switcher height change) keeps the new band. + worker.posted.length = 0; + window.relayout(); + assert.deepEqual(worker.posted.map((message) => message.viewport), [MAX]); + + // Unchanged band: still answered, so the worker can always wait on it. + worker.posted.length = 0; + worker.onmessage({ data: { type: 'set-height-mode', windowId: HUB, heightMode: 'min' } }); + await tick(); + worker.onmessage({ data: { type: 'set-height-mode', windowId: HUB, heightMode: 'min' } }); + await tick(); + assert.deepEqual(worker.posted.map((message) => message.viewport), [MIN, MIN]); + + // A closed window is not touched again. + window.close(); + const count = surfaces.length; + worker.onmessage({ data: { type: 'set-height-mode', windowId: HUB, heightMode: 'max' } }); + await tick(); + assert.equal(surfaces.length, count); +}); From b353483ac2a7f4b0f1cc69613bbebd48cd3163d7 Mon Sep 17 00:00:00 2001 From: James Babcock Date: Sat, 7 Nov 2026 04:16:15 -0800 Subject: [PATCH 14/34] G1 support: Preserve connections after flashing, debug --- .../com/faceclaw/app/AndroidSessionLink.kt | 7 + .../java/com/faceclaw/app/AndroidStockLink.kt | 7 + .../com/faceclaw/app/FaceclawBleManager.kt | 45 +++ .../faceclaw/app/FaceclawDeviceDiscovery.kt | 4 +- .../com/faceclaw/app/FaceclawG1Flasher.kt | 10 + app/g1/firmware/g1v0-image.ts | 12 +- app/g1/firmware/g1v0-own-bytes.ts | 2 +- app/g1/flash-plan.ts | 21 ++ app/g2/even-advertisement.ts | 25 +- app/g2/ios-peripheral-identity.ts | 16 +- app/g2/ios-preview-controller.ts | 4 +- app/native/g1-flasher.ios.ts | 3 + app/native/g1-flasher.ts | 6 + app/phone-ui/g1-flash-view-model.ts | 23 +- .../onboarding-firmware-check-view-model.ts | 29 +- app/phone-ui/pairing-view-model.ts | 7 +- build_paths.sh.template | 2 + .../com/faceclaw/app/g1/G1ArmFlashFlow.kt | 111 ++++++- .../kotlin/com/faceclaw/app/g1/G1Smp.kt | 9 + .../com/faceclaw/app/g2protocol/StockLink.kt | 9 + .../session/GlassesSessionControls.kt | 2 +- .../g2protocol/session/GlassesSessionCore.kt | 4 +- .../g2protocol/session/GlassesSessionG1.kt | 303 +++++++++++++++--- .../g2protocol/session/GlassesSessionSend.kt | 4 + .../app/g2protocol/session/SessionPorts.kt | 9 + .../com/faceclaw/app/ble/IosBleCentral.kt | 11 + scripts/config-transfer.md | 6 + scripts/ios_config.py | 189 +++++++---- scripts/resetOnboarding.sh | 26 +- scripts/resetOnboardingIos.sh | 35 ++ tests/config-transfer-scripts.test.cjs | 7 + tests/even-advertisement.test.cjs | 57 +++- tests/g1-firmware.test.cjs | 18 ++ tests/ios-glanceboard.test.cjs | 17 +- tests/ios-sensors.test.cjs | 10 + .../kotlin/com/faceclaw/app/G1FlashTest.kt | 128 +++++++- .../kotlin/com/faceclaw/app/G1SessionTest.kt | 269 +++++++++++++++- tests/pairing-candidates.test.cjs | 22 ++ 38 files changed, 1291 insertions(+), 178 deletions(-) create mode 100755 scripts/resetOnboardingIos.sh diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt index d303880b..f5ffece3 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt @@ -48,6 +48,13 @@ class AndroidSessionLink(private val bleManager: FaceclawBleManager) : SessionLi override fun requestBond(address: String) = bleManager.requestBond(address) + override fun removeBond(address: String): Boolean = bleManager.removeBond(address) + + override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = + bleManager.hasCharacteristic(address, characteristicUuid) + + override fun refreshServices(address: String, timeoutMs: Int): Boolean = bleManager.refreshServices(address, timeoutMs) + override fun prepareBenchmarkLink(address: String, mode: Int) = bleManager.prepareBenchmarkLink(address, mode) override fun recordDisplayFrameSent() = FaceclawBleManager.recordDisplayFrameSent() diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt index 700d12b9..c4ef4a5b 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt @@ -52,6 +52,13 @@ class AndroidStockLink(context: Context) : StockLink, FaceclawBleListener { override fun requestBond(address: String) = bleManager.requestBond(address) + override fun removeBond(address: String): Boolean = bleManager.removeBond(address) + + override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = + bleManager.hasCharacteristic(address, characteristicUuid) + + override fun refreshServices(address: String, timeoutMs: Int): Boolean = bleManager.refreshServices(address, timeoutMs) + override fun disconnect(address: String) = bleManager.disconnect(address) override fun close() = bleManager.close() diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt index 46c47993..3782e821 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt @@ -27,6 +27,11 @@ import java.util.concurrent.atomic.AtomicLong class FaceclawBleManager(context: Context) { companion object { private const val TAG = "FaceclawBle" + + /** Not public API, but long stable, and the only way short of sending the user to Settings. */ + fun removeBond(device: BluetoothDevice): Boolean = + device.bondState == BluetoothDevice.BOND_NONE || device.javaClass.getMethod("removeBond").invoke(device) == true + private val WRITE_RETRY_DELAYS_MS = intArrayOf(1, 1, 1, 2, 4, 8, 12, 20, 35, 100, 200) // Gap after each LE 2M PHY request before checking whether it landed and asking @@ -160,6 +165,21 @@ class FaceclawBleManager(context: Context) { } } + /** + * Remove this phone's half of a pairing the other side no longer has. False when the platform refused. + */ + fun removeBond(address: String?): Boolean { + if (address == null || address.trim().isEmpty()) { + return false + } + return try { + removeBond(bluetoothAdapter.getRemoteDevice(address)) + } catch (t: Throwable) { + Log.w(TAG, "removeBond failed: $address", t) + false + } + } + /** Start bonding, without waiting: the OS may ask the user, and [isBonded] tells when it is done. */ fun requestBond(address: String?) { if (address == null || address.trim().isEmpty()) { @@ -379,6 +399,31 @@ class FaceclawBleManager(context: Context) { return status == BluetoothGatt.GATT_SUCCESS } + /** After discovery: whether the service table has this characteristic. */ + fun hasCharacteristic(address: String, characteristicUuid: String): Boolean { + synchronized(bluetoothApiLock) { + val gatt = links[address]?.gatt ?: return false + val target = UUID.fromString(characteristicUuid) + return gatt.services.any { it.getCharacteristic(target) != null } + } + } + + /** + * Forget the service table Android remembers for a bonded device and read it again. A G1 arm keeps its address across an + * install that changes its services, and a cached table would make new firmware look like the old one. + */ + fun refreshServices(address: String, timeoutMs: Int): Boolean { + synchronized(bluetoothApiLock) { + val gatt = links[address]?.gatt ?: return false + try { + gatt.javaClass.getMethod("refresh").invoke(gatt) + } catch (t: Throwable) { + Log.w(TAG, "refresh failed: $address", t) + } + } + return discoverServices(address, timeoutMs) + } + fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean { synchronized(bluetoothApiLock) { val gatt = requireGatt(address) diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt index 5440806d..13074560 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt @@ -141,9 +141,9 @@ class FaceclawDeviceDiscovery(context: Context) { val upper = name.uppercase() // A bare "R1" substring also matches unrelated hardware ("Oppo Enco // R1"), and TS only classifies rings from the stock name prefix. - // Even G1: its stock name, or g1v0's G1v0_L / G1v0S_R (safe mode). + // Even G1: its stock name, or g1v0's G1CFW_L_XXXXXX (before 0.5.66: G1v0_L, G1v0S_R). return upper.contains("G2") || upper.startsWith("EVEN R1") || upper.startsWith("RAYNEO") || - upper.startsWith("EVEN G1") || upper.startsWith("G1V0") + upper.startsWith("EVEN G1") || upper.startsWith("G1CFW_") || upper.startsWith("G1V0") } private fun buildJson( diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt index a7e9be7d..f8383e7c 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt @@ -76,6 +76,16 @@ class FaceclawG1Flasher(context: Context, address: String?, side: String?, firmw } } + companion object { + /** The phone's pairing with an address these glasses no longer use. */ + @JvmStatic + fun forgetPairing(context: Context, address: String?) { + if (address == null) return + val manager = context.applicationContext.getSystemService(Context.BLUETOOTH_SERVICE) as android.bluetooth.BluetoothManager + FaceclawBleManager.removeBond(manager.adapter.getRemoteDevice(address)) + } + } + private fun post(action: (FaceclawFirmwareFlasherListener) -> Unit) { mainHandler.post { val current = listener diff --git a/app/g1/firmware/g1v0-image.ts b/app/g1/firmware/g1v0-image.ts index ee09df55..07b3a1fd 100644 --- a/app/g1/firmware/g1v0-image.ts +++ b/app/g1/firmware/g1v0-image.ts @@ -15,23 +15,23 @@ export type G1FirmwareImage = { }; export const G1V0_IMAGE: G1FirmwareImage = { - "version": "0.5.65", - "sha256": "b8707c80c3fbde1458e92eb39602125df8f03d809c768dab4f33b15c0e7dff9f", - "size": 582820, - "source": "51596992c1f1+uncommitted", + "version": "0.5.66", + "sha256": "9861a5671ed2fab6a678feae1f22e57d0b41bbb5934d83b898c5108db3a474fd", + "size": 582992, + "source": "ceb74cce6945", "stockVersion": "1.6.6", "stockZipUrl": "https://cdn.evenreal.co/firmware/dcfa510c090e476c10a6f6c348a22415.zip", "stockZipSha256": "748836f2d9d092b0783cbb7672fdccec4f730051cad27f095bbb156ac3e5d316", "parts": [ { - "offset": 271104, + "offset": 271264, "length": 226020, "file": "net_core_app_update.bin", "fileOffset": 0, "sha256": "c277749be97a2763742db399afeb10ca6916059abd60d41bbc05c8892c002c77" }, { - "offset": 497152, + "offset": 497312, "length": 352, "file": "app_update.bin", "fileOffset": 531288, diff --git a/app/g1/firmware/g1v0-own-bytes.ts b/app/g1/firmware/g1v0-own-bytes.ts index 7b499a2d..66afc7e8 100644 --- a/app/g1/firmware/g1v0-own-bytes.ts +++ b/app/g1/firmware/g1v0-own-bytes.ts @@ -1,4 +1,4 @@ // AUTO-GENERATED by tools/g1_firmware_bundle.py -- do not edit by hand. // The built g1v0 image without Even's parts (g1v0-image.ts), deflated. -export const G1V0_OWN_BYTES_BASE64 = "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"; +export const G1V0_OWN_BYTES_BASE64 = "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"; diff --git a/app/g1/flash-plan.ts b/app/g1/flash-plan.ts index 0582d1fa..e8337cf0 100644 --- a/app/g1/flash-plan.ts +++ b/app/g1/flash-plan.ts @@ -9,6 +9,10 @@ export const G1_SIDES: readonly G1Side[] = ["left", "right"]; export const G1_CASE_INSTRUCTIONS = "Put the glasses in their charging case with the lid open, and plug the case in. Stay nearby, and leave Faceclaw open."; +/** An arm bonds only once it knows it's in the case, and a full case only says so about every 5 minutes. */ +export const G1_CASE_DELAY_HINT = + "A fully charged arm can take up to 5 minutes to notice it's in the case, so this may take a while."; + export const G1_INSTALL_NOTICE = "This replaces the firmware on both arms, about two minutes each. Going back to Even's firmware later takes a computer, and " + "may not be the version you have now. Installing custom firmware is not covered by warranty."; @@ -81,6 +85,23 @@ export function g1FirmwareState(arms: readonly G1FlashResult[], shipped: string) return arms.some((arm) => compareG1Versions(arm.version ?? "", shipped) < 0) ? "older" : "current"; } +/** + * What the arms' advertising alone says about their firmware, or null when an arm has to be asked: firmware before 0.5.66 + * doesn't advertise its version. + */ +export function g1StateFromAdvertising( + pair: Pick, + shipped: string, +): { state: G1FirmwareState; version: string } | null { + const arms = [pair.left, pair.right]; + if (arms.some((arm) => arm?.g1Firmware === "stock")) return { state: "stock", version: "" }; + if (arms.some((arm) => arm?.g1Firmware === "g1v0-safe")) return { state: "safe-mode", version: "" }; + const versions = arms.map((arm) => arm?.g1Version); + if (!versions[0] || !versions[1]) return null; + const lowest = compareG1Versions(versions[0], versions[1]) <= 0 ? versions[0] : versions[1]; + return { state: compareG1Versions(lowest, shipped) < 0 ? "older" : "current", version: lowest }; +} + /** Each arm counts for half of the bar. */ export function g1FlashPercent(side: G1Side, bytesSent: number, bytesTotal: number): number { const within = bytesTotal > 0 ? Math.min(1, bytesSent / bytesTotal) : 0; diff --git a/app/g2/even-advertisement.ts b/app/g2/even-advertisement.ts index d20912fb..341cd286 100644 --- a/app/g2/even-advertisement.ts +++ b/app/g2/even-advertisement.ts @@ -32,7 +32,7 @@ export const EVEN_COMPANY_IDENTIFIER = 0x5245; export type EvenDeviceRole = "left" | "right" | "ring" | "rayneo-io"; -/** The firmware an Even G1 arm's name shows: Even's, or g1v0 (in safe mode: only updates work). */ +/** The firmware an Even G1 arm advertises: Even's, or Faceclaw's g1v0 (in safe mode: only updates work). */ export type G1Firmware = "stock" | "g1v0" | "g1v0-safe"; /** True when the manufacturer data opens with Even's `"ER"` marker. */ @@ -79,11 +79,15 @@ export function extractG2AdvertisementFlag(mfg: Uint8Array): number | null { * * On Even's firmware the name is `Even G1___` and the manufacturer data `[01 right | 02 left]` + * the ASCII serial, zero-padded (the first two bytes read as a "company id" that differs per arm). On g1v0 the name - * is `G1v0_L` or `G1v0_R` (`G1v0S_…` in safe mode) and the scan response holds company 0xFFFF, a format byte (1), a - * flags byte, and the pair ID in ASCII: the frame serial, the same on both arms. + * is `G1CFW__` with the same digits and address as stock's, and the scan response holds company 0xFFFF, a + * format byte (2), a flags byte (bit 3: safe mode), the firmware's version in three bytes, and the pair ID in ASCII: + * the frame serial, the same on both arms. Before 0.5.66: `G1v0_L` or `G1v0_R` (`G1v0S_…` in safe mode), format 1, no + * version. */ export function g1FromName(name: string | null | undefined): { side: "left" | "right"; firmware: G1Firmware } | null { if (!name) return null; + const custom = /^G1CFW_([LR])_[0-9A-F]{6}$/i.exec(name.trim()); + if (custom) return { side: custom[1]!.toUpperCase() === "L" ? "left" : "right", firmware: "g1v0" }; const g1v0 = /^G1V0(S?)_([LR])$/i.exec(name.trim()); if (g1v0) { return { @@ -96,9 +100,16 @@ export function g1FromName(name: string | null | undefined): { side: "left" | "r return side ? { side, firmware: "stock" } : null; } +/** What g1v0's pair record says beyond the serial; null when there is no record of a format that says it. */ +export function parseG1Record(mfg: Uint8Array): { version: string; safeMode: boolean } | null { + if (mfg.length < 7 || mfg[0] !== 0xff || mfg[1] !== 0xff || mfg[2] !== 2) return null; + return { version: `${mfg[4]}.${mfg[5]}.${mfg[6]}`, safeMode: (mfg[3]! & 8) !== 0 }; +} + /** The pair's serial from an arm's manufacturer data, on either firmware; null when absent. */ export function extractG1Serial(mfg: Uint8Array, firmware: G1Firmware): string | null { - const start = firmware === "stock" ? 1 : mfg.length >= 4 && mfg[0] === 0xff && mfg[1] === 0xff && mfg[2] === 1 ? 4 : -1; + const record = mfg.length >= 4 && mfg[0] === 0xff && mfg[1] === 0xff; + const start = firmware === "stock" ? 1 : record && mfg[2] === 2 ? 7 : record && mfg[2] === 1 ? 4 : -1; if (start < 0 || mfg.length <= start) return null; let serial = ""; for (let i = start; i < mfg.length; i++) { @@ -259,6 +270,8 @@ export type EvenAdvertisement = { note: string | null; /** Set on an Even G1 arm (role left or right): its firmware. */ g1Firmware?: G1Firmware; + /** The version g1v0 advertises (0.5.66+); absent when it doesn't say. */ + g1Version?: string; }; /** @@ -285,6 +298,7 @@ export function classifyAdvertisement(raw: RawAdvertisement): EvenAdvertisement const g1 = g1FromName(name); if (g1) { const serial = extractG1Serial(mfg, g1.firmware); + const record = g1.firmware === "stock" ? null : parseG1Record(mfg); return { address: normalizeMacAddress(raw.address), name, @@ -302,7 +316,8 @@ export function classifyAdvertisement(raw: RawAdvertisement): EvenAdvertisement seenAtMs: raw.seenAtMs, manufacturerData: raw.manufacturerData ?? "", note: serial ? null : "no serial in the advertisement (it may still be arriving)", - g1Firmware: g1.firmware, + g1Firmware: record?.safeMode ? "g1v0-safe" : g1.firmware, + ...(record ? { g1Version: record.version } : {}), }; } diff --git a/app/g2/ios-peripheral-identity.ts b/app/g2/ios-peripheral-identity.ts index 4dd32f12..41a31151 100644 --- a/app/g2/ios-peripheral-identity.ts +++ b/app/g2/ios-peripheral-identity.ts @@ -1,12 +1,26 @@ -import { classifyAdvertisement, hasEvenManufacturerSignature, type EvenAdvertisement } from './even-advertisement' +import { classifyAdvertisement, g1FromName, hasEvenManufacturerSignature, type EvenAdvertisement } from './even-advertisement' import { hexToBytes } from '../util/hex-util' export type IosAdvertisement = { identifier: string; name: string; manufacturerData: string; rssi: number; connectable: boolean } export type IosDevice = EvenAdvertisement & { identifier: string } +/** + * A G1 arm advertises no full MAC, and CoreBluetooth hides the real one. Faceclaw's addresses are MAC-shaped everywhere, so its + * address on this phone is made from the peripheral identifier. It's stable as long as the identifier is, which on firmware + * 0.5.66 and later is across installs too, and it only has to mean something on this phone: nobody types it in. + */ +export function g1IosAddress(identifier: string): string { + return identifier.replace(/-/g, '').slice(0, 12).toUpperCase().replace(/(..)(?=.)/g, '$1:') +} + /** Only a full vendor-advertised MAC may bind a manually entered address. */ export function identifyIosPeripheral(raw: IosAdvertisement): IosDevice | null { if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(raw.identifier)) return null + if (g1FromName(raw.name)) { + const arm = classifyAdvertisement({ ...raw, address: g1IosAddress(raw.identifier), source: 'scan', bonded: false, + txPower: null, seenAtMs: Date.now() }) + return arm && { ...arm, identifier: raw.identifier.toUpperCase() } + } if (!hasEvenManufacturerSignature(hexToBytes(raw.manufacturerData))) return null const candidate = classifyAdvertisement({ ...raw, address: '', source: 'scan', bonded: false, txPower: null, seenAtMs: Date.now() }) diff --git a/app/g2/ios-preview-controller.ts b/app/g2/ios-preview-controller.ts index 728714e5..3ccf020f 100644 --- a/app/g2/ios-preview-controller.ts +++ b/app/g2/ios-preview-controller.ts @@ -54,7 +54,7 @@ import { onAnySettingChanged, previewColorSetting, lockScreenEnabledSetting, getBrightnessPreferences, getStringSettingById, nightscoutSiteUrlSetting, nightscoutApiTokenSetting, voiceProviderSetting, elevenLabsApiKeySetting, openAiApiKeySetting, sonioxApiKeySetting, whisperServerApiKeySetting, whisperServerLanguageSetting, - whisperServerModelSetting, whisperServerUrlSetting, ringConnectionModeSetting, saveTranscribeAudioSetting } from '../ui/dashboard-settings' + whisperServerModelSetting, whisperServerUrlSetting, ringConnectionModeSetting, saveTranscribeAudioSetting, glassesTypeSetting } from '../ui/dashboard-settings' import { transcriptionKey, type VoiceProviderSelection } from '../native/cloud-stt-provider' import type { PhoneGesture } from '../phone-ui/phone-gestures' import { claimGlassesOnboardingAutoLaunch, ONBOARDING_APP_ID } from '../apps/onboarding/onboarding-progress' @@ -881,7 +881,7 @@ export class IosPreviewController { return } if (this.communicator) await this.closeCommunicator() - const communicator = new FaceclawCommunicatorBridge(identifiers) + const communicator = new FaceclawCommunicatorBridge({ ...identifiers, glassesType: glassesTypeSetting.get() }) this.teardownPreviewDisplay() this.communicator = communicator this.wearDetectionRequested = false diff --git a/app/native/g1-flasher.ios.ts b/app/native/g1-flasher.ios.ts index 1ab77ece..0f3df3fa 100644 --- a/app/native/g1-flasher.ios.ts +++ b/app/native/g1-flasher.ios.ts @@ -7,6 +7,9 @@ export type { G1FlashMode, G1FlasherOptions } from './g1-flasher' declare const FaceclawKitIosG1Flasher: any, FaceclawKitFaceclawFirmwareFlasherListener: any +/** CoreBluetooth has no way to remove a pairing; iOS Settings does it, and a stale one does no harm. */ +export function forgetG1Pairing(_address: string): void {} + /** * iOS twin of the Android G1Flasher: the shared Kotlin G1ArmFlashFlow over a CoreBluetooth central. As with the G2's * flasher, the phone must stay in the foreground with the screen awake, and addresses are mapped to peripheral diff --git a/app/native/g1-flasher.ts b/app/native/g1-flasher.ts index 9f60423d..49f04931 100644 --- a/app/native/g1-flasher.ts +++ b/app/native/g1-flasher.ts @@ -15,6 +15,12 @@ export type G1FlasherOptions = { connectWindowMs: number; }; +/** Removes the phone's pairing with an address the glasses no longer use. */ +export function forgetG1Pairing(address: string): void { + const context = Utils.android.getApplicationContext(); + if (context) com.faceclaw.app.FaceclawG1Flasher.forgetPairing(context, address); +} + /** TS wrapper around FaceclawG1Flasher: one arm's install, or a question about what it runs. */ export class G1Flasher { private readonly flasher: any; diff --git a/app/phone-ui/g1-flash-view-model.ts b/app/phone-ui/g1-flash-view-model.ts index 4f901f27..271037e2 100644 --- a/app/phone-ui/g1-flash-view-model.ts +++ b/app/phone-ui/g1-flash-view-model.ts @@ -4,13 +4,21 @@ import { G1ArmScanner } from "../g1/arm-scanner"; import { G1V0_IMAGE } from "../g1/firmware/g1v0-image"; import { buildG1Firmware, type BuiltG1Firmware, type G1BuildProgress } from "../g1/firmware-builder"; import { saveG1Arm, saveG1Pair } from "../g1/addresses"; -import { G1_CASE_INSTRUCTIONS, G1_INSTALL_NOTICE, G1_SIDES, g1FlashPercent, type G1FlashResult, type G1Side } from "../g1/flash-plan"; +import { + G1_CASE_DELAY_HINT, + G1_CASE_INSTRUCTIONS, + G1_INSTALL_NOTICE, + G1_SIDES, + g1FlashPercent, + type G1FlashResult, + type G1Side, +} from "../g1/flash-plan"; import { loadDeviceAddresses, loadPairedGlassesIdentity } from "../g2/device-addresses"; import { downloadAndExtractEvenHubFonts, hasExtractedEvenHubFonts } from "../g2/firmware-builder"; import { type GlassesPairCandidate } from "../g2/pairing-candidates"; import { resumeAutoReconnect, suppressAutoReconnect } from "../g2/reconnect-policy"; import { ensureBlePermissions } from "../native/ble-permissions"; -import { G1Flasher, type G1FlasherOptions } from "../native/g1-flasher"; +import { forgetG1Pairing, G1Flasher, type G1FlasherOptions } from "../native/g1-flasher"; import { formatErrorMessage } from "../util/format-error"; import { finishOnboardingNavigation } from "./onboarding-navigation"; import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; @@ -190,11 +198,16 @@ export class G1FlashViewModel extends Observable { "open: an interrupted install finishes by itself. Then retry."); } saveG1Arm(side, back); + // Coming from firmware before 0.5.66, which had an address of its own: the phone needn't remember that one. + if (back.address !== arm.address) forgetG1Pairing(arm.address); if (back.g1Firmware === "g1v0-safe") { throw new Error(`The ${side} arm came back in safe mode: the new firmware restarted repeatedly. Retry to install it again.`); } - this.setStatus(`Pairing with the ${side} arm. If your phone asks, accept it.`); + this.setStatus(`Checking the ${side} arm. If your phone asks to pair, accept it. ${G1_CASE_DELAY_HINT}`); + // An arm at a new address has no bond yet (coming from Even's firmware the address is kept from 0.5.66 on, and so is the + // bond). It may refuse one for a while: it's installed either way, and the session pairs it later. + const newAddress = back.address !== arm.address; let running: G1FlashResult; try { running = await this.flash({ @@ -202,10 +215,10 @@ export class G1FlashViewModel extends Observable { side, firmwarePath: "", mode: "probe", - connectWindowMs: fromStock ? FIRST_PAIRING_MS : RETURN_MS, + connectWindowMs: newAddress ? FIRST_PAIRING_MS : RETURN_MS, }); } catch (error) { - if (!fromStock || !live()) throw error; + if (!newAddress || !live()) throw error; // Installed, as its advertising shows; it just won't pair yet. The next connection pairs it. this.appendLog(`${side} arm not paired yet: ${formatErrorMessage(error)}`); this.unpairedArm = true; diff --git a/app/phone-ui/onboarding-firmware-check-view-model.ts b/app/phone-ui/onboarding-firmware-check-view-model.ts index 87b146ed..bba7cd8a 100644 --- a/app/phone-ui/onboarding-firmware-check-view-model.ts +++ b/app/phone-ui/onboarding-firmware-check-view-model.ts @@ -22,7 +22,15 @@ import { G1Flasher } from "../native/g1-flasher"; import { saveG1Pair } from "../g1/addresses"; import { G1ArmScanner } from "../g1/arm-scanner"; import { G1V0_IMAGE } from "../g1/firmware/g1v0-image"; -import { G1_CASE_INSTRUCTIONS, G1_INSTALL_NOTICE, g1FirmwareState, type G1FlashResult, type G1Side } from "../g1/flash-plan"; +import { + G1_CASE_DELAY_HINT, + G1_CASE_INSTRUCTIONS, + G1_INSTALL_NOTICE, + g1FirmwareState, + g1StateFromAdvertising, + type G1FlashResult, + type G1Side, +} from "../g1/flash-plan"; import { loadPairedGlassesIdentity } from "../g2/device-addresses"; import { glassesTypeSetting } from "../ui/dashboard-settings"; import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; @@ -213,8 +221,8 @@ export class OnboardingFirmwareCheckViewModel extends Observable { } /** - * What each arm's name says first, as that needs no connection: Even's firmware can't be asked in the same way, and an - * arm that is about to be replaced shouldn't have to pair. Only arms on g1v0 are asked which version they run. + * What the arms advertise first, as that needs no connection or pairing. Only firmware from before it advertised its + * version (0.5.66) has to be asked. */ private async checkG1(generation: number): Promise { this.status = "Listening for your glasses..."; @@ -229,13 +237,12 @@ export class OnboardingFirmwareCheckViewModel extends Observable { return; } saveG1Pair(pair); - const named = [pair.left!.g1Firmware, pair.right!.g1Firmware]; - if (named.includes("stock")) { - this.showG1Install({ firmware: "stock" }); - return; - } - if (named.includes("g1v0-safe")) { - this.showG1Install({ safeMode: true }); + const advertised = g1StateFromAdvertising(pair, G1V0_IMAGE.version); + if (advertised) { + if (advertised.state === "current") this.applyClassification("custom", advertised.version, { kind: "none" }); + else if (advertised.state === "stock") this.showG1Install({ firmware: "stock" }); + else if (advertised.state === "safe-mode") this.showG1Install({ safeMode: true }); + else this.showG1Install({ version: advertised.version }); return; } const arms: G1FlashResult[] = []; @@ -245,7 +252,7 @@ export class OnboardingFirmwareCheckViewModel extends Observable { flasher.onState((state) => { if (generation !== this.generation) return; if (state === "pairing") { - this.status = `Pairing with the ${side} arm. If your phone asks, accept it. A G1 pairs only in its case, with the lid open.`; + this.status = `Pairing with the ${side} arm. If your phone asks, accept it. A G1 pairs only in its case, with the lid open. ${G1_CASE_DELAY_HINT}`; } else { this.status = `Checking the ${side} arm...`; } diff --git a/app/phone-ui/pairing-view-model.ts b/app/phone-ui/pairing-view-model.ts index 6e96d225..8fbb4bdc 100644 --- a/app/phone-ui/pairing-view-model.ts +++ b/app/phone-ui/pairing-view-model.ts @@ -383,9 +383,10 @@ export class PairingViewModel extends Observable { } } this.dispose(); - if (this.onboarding) { - setPreviewOnlyMode(false); - // Continue the onboarding chain: check the glasses' firmware next. + if (this.onboarding) setPreviewOnlyMode(false); + // Onboarding checks the glasses' firmware next. So does choosing a G1 from anywhere: it may run Even's firmware, + // and whether it does is known without connecting. + if (this.onboarding || pair?.g1Firmware) { Frame.topmost()?.navigate({ moduleName: "phone-ui/onboarding-firmware-check-page" }); return; } diff --git a/build_paths.sh.template b/build_paths.sh.template index 5cc81e1c..ac9baf4c 100644 --- a/build_paths.sh.template +++ b/build_paths.sh.template @@ -11,6 +11,8 @@ # iOS bundle ID; set one your signing team owns to sideload alongside the # official build (default com.faceclaw.app). Also used by the iOS config scripts. #export IOS_BUNDLE_ID= +# Which iPhone scripts target (default: the only one connected) +#export IOS_DEVICE= # Embed the Apple Watch app in the iOS app. Its link to the phone needs this, and # signing it needs a watch registered to your team, so it's off by default. #export FACECLAW_EMBED_WATCH=1 diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt index 5238b689..3ce8da17 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1ArmFlashFlow.kt @@ -86,6 +86,12 @@ class G1ArmFlashFlow( private var controlLatch: Latch? = null private var nextControlTag = 0 + private var stockBattery: Int? = null + private var stockBatteryLatch: Latch? = null + + /** The OS's half of a stale pairing goes once per run: a second failure isn't that. */ + private var bondRemoved = false + private var linkLost = false private var heartbeats = 0 private var nextHeartbeatAtMs = 0L @@ -150,11 +156,11 @@ class G1ArmFlashFlow( listener.onComplete(true, """{"flashed":false,"version":"$version"}""") return } - val battery = batteryPercent() - if (battery != null && battery < MIN_BATTERY_PERCENT) { - throw IllegalStateException("The $side arm's battery is at $battery%, too low to install safely. " + - "Charge both arms to at least $MIN_BATTERY_PERCENT% in the case, then try again.") - } + requireBattery(batteryPercent()) + } else { + val battery = stockBatteryPercent() + log(if (battery == null) "battery unknown; going on, as the arm is in the case" else "battery $battery%") + requireBattery(battery) } val slots = retrying { images() } @@ -189,6 +195,13 @@ class G1ArmFlashFlow( listener.onComplete(true, """{"flashed":true,"version":"$version"}""") } + private fun requireBattery(percent: Int?) { + if (percent != null && percent < MIN_BATTERY_PERCENT) { + throw IllegalStateException("The $side arm's battery is at $percent%, too low to install safely. " + + "Charge both arms to at least $MIN_BATTERY_PERCENT% in the case, then try again.") + } + } + private fun holdsImage(slots: List, hash: ByteArray): Boolean = slots.any { it.image == 0 && it.slot == 1 && it.hash.contentEquals(hash) } @@ -263,11 +276,9 @@ class G1ArmFlashFlow( log("connect attempt $attempt failed: $failure") quietly { link.disconnect(address) } if (now() >= deadline) { - throw IllegalStateException("Couldn't reach the $side arm: $failure." + if (mode == Mode.STOCK) { - " If this phone was paired with these glasses before, remove them from its Bluetooth settings and try again." - } else { - "" - }) + throw IllegalStateException("Couldn't reach the $side arm: $failure. Keep the glasses in the case with the lid open; a fully " + + "charged arm can take up to 5 minutes to notice it's in the case. If this phone was paired with these glasses before and " + + "this keeps happening, remove them from its Bluetooth settings and try again.") } sleeper.sleep(timings.retryDelayMs.toLong()) } @@ -284,16 +295,20 @@ class G1ArmFlashFlow( if (mode == Mode.STOCK) { // Even's firmware serves its own service only on an encrypted link, and the heartbeat goes there. settleBond() - if (!link.enableNotifications(address, G1Smp.NUS_TX_UUID, timings.descriptorTimeoutMs)) { + if (!haveCharacteristic(G1Smp.NUS_TX_UUID)) throw IllegalStateException("no link to Even's service") + if (!subscribe(G1Smp.NUS_TX_UUID)) { + // Bonded and refused: Even's firmware keeps one bond and has lost this one. This run started in the case. + removeStaleBond() throw IllegalStateException("no link to Even's service") } heartbeats = 0 nextHeartbeatAtMs = 0 } else { - if (!link.enableNotifications(address, G1Ble.EVT_CHAR_UUID, timings.descriptorTimeoutMs)) { + if (!haveCharacteristic(G1Ble.EVT_CHAR_UUID)) { if (!link.isConnected(address)) throw LinkLostException("the link went down") throw NotG1v0Exception() } + if (!subscribe(G1Ble.EVT_CHAR_UUID)) throw IllegalStateException("no events from the arm") // Out of the case the arm obeys only an encrypted link. settleBond() val paired = try { @@ -301,13 +316,71 @@ class G1ArmFlashFlow( } catch (e: IllegalStateException) { false } - if (!paired) throw IllegalStateException("no encrypted link: an arm pairs only in its case") + if (!paired) { + // The OS says bonded and the arm disagrees. Giving that up is safe only where a new bond can be made. + if (link.isConnected(address) && inCaseWithoutEncryption()) removeStaleBond() + throw IllegalStateException("no encrypted link: an arm pairs only in its case") + } } - if (mode != Mode.PROBE && !link.enableNotifications(address, G1Smp.SMP_CHAR_UUID, timings.descriptorTimeoutMs)) { + if (mode != Mode.PROBE && (!haveCharacteristic(G1Smp.SMP_CHAR_UUID) || !subscribe(G1Smp.SMP_CHAR_UUID))) { throw IllegalStateException("no update service") } } + /** An arm keeps its address across an install, and the OS may remember the services it had before: look again before believing that. */ + private fun haveCharacteristic(uuid: String): Boolean { + if (link.hasCharacteristic(address, uuid)) return true + log("no $uuid in the service table: reading it again") + link.refreshServices(address, timings.servicesTimeoutMs) + return link.hasCharacteristic(address, uuid) + } + + private fun subscribe(uuid: String): Boolean = try { + link.enableNotifications(address, uuid, timings.descriptorTimeoutMs) + } catch (e: IllegalStateException) { + false + } + + private fun removeStaleBond() { + if (bondRemoved || link.bondState(address) != BondState.BONDED) return + if (link.removeBond(address)) { + bondRemoved = true + log("the arm no longer has this phone's pairing: removed it, pairing again") + } + } + + /** An unencrypted link gets an answer only from an arm in the case. */ + private fun inCaseWithoutEncryption(): Boolean = try { + val hello = G1Protocol.parseHello(control(G1Protocol.OP_HELLO, tries = 1).body) + hello != null && hello.inCase && !hello.encrypted + } catch (e: Exception) { + false + } + + /** Null when no answer came, which firmware that doesn't have the query also gives. */ + private fun stockBatteryPercent(): Int? { + repeat(timings.controlTries) { + val latch = Latch(1, platform) + lock.withLock { + stockBattery = null + stockBatteryLatch = latch + } + try { + link.writeFrames(address, G1Smp.NUS_RX_UUID, listOf(G1Smp.STOCK_BATTERY_QUERY), GattWriteMode.WITHOUT_RESPONSE, timings.writeTimeoutMs) + } catch (e: IllegalStateException) { + return null + } + latch.await(timings.controlReplyMs.toLong()) + throwIfCancelled() + val answer = lock.withLock { + stockBatteryLatch = null + stockBattery + } + if (answer != null) return answer + } + return null + } + /** Asks the OS to pair if it hasn't, and waits for that to end; a platform that doesn't say pairs by itself. */ private fun settleBond() { if (link.bondState(address) == BondState.NONE) { @@ -377,8 +450,8 @@ class G1ArmFlashFlow( } } - private fun control(op: Int, body: ByteArray = ByteArray(0)): G1Protocol.Reply { - repeat(timings.controlTries) { + private fun control(op: Int, body: ByteArray = ByteArray(0), tries: Int = timings.controlTries): G1Protocol.Reply { + repeat(tries) { val tag = nextControlTag % 255 + 1 nextControlTag = tag val latch = Latch(1, platform) @@ -445,6 +518,12 @@ class G1ArmFlashFlow( } } } + } else if (characteristicUuid.equals(G1Smp.NUS_TX_UUID, ignoreCase = true)) { + val percent = G1Smp.parseStockBattery(data) ?: return + lock.withLock { + stockBattery = percent + stockBatteryLatch?.countDown() + } } else if (characteristicUuid.equals(G1Ble.EVT_CHAR_UUID, ignoreCase = true)) { val reply = G1Protocol.parseReply(data) ?: return lock.withLock { diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt index 581e4279..dd9bbb47 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g1/G1Smp.kt @@ -168,6 +168,15 @@ object G1Smp { fun stockHeartbeat(seq: Int): ByteArray = byteArrayOf(0x25, 0x06, 0x00, seq.toByte(), 0x04, seq.toByte()) + /** Even's firmware's battery query; its reply is `2C 66`, then the percentage. The bytes its real firmware answered in emulation. */ + val STOCK_BATTERY_QUERY = byteArrayOf(0x2c, 0x04, 0x00, 0x00) + + /** The percentage in a reply to [STOCK_BATTERY_QUERY]; null for anything else, or a value that can't be one. */ + fun parseStockBattery(data: ByteArray): Int? { + if (data.size < 3 || data[0].toInt() != 0x2c || (data[1].toInt() and 0xff) != 0x66) return null + return (data[2].toInt() and 0xff).takeIf { it in 1..100 } + } + fun frame(op: Int, group: Int, seq: Int, cmd: Int, payload: Map): ByteArray { val body = G1Cbor.encode(payload) val out = ByteArray(HEADER + body.size) diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt index 0e2cc4ec..c291a6a4 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/StockLink.kt @@ -54,6 +54,15 @@ interface StockLink { /** Ask the OS to pair with a connected device; a platform that pairs by itself on demand does nothing. */ fun requestBond(address: String) {} + /** Remove this phone's half of a pairing; false where the platform can't or refused. */ + fun removeBond(address: String): Boolean = false + + /** After discovery: whether the service table has this characteristic. Enabling notifications on one it lacks may throw. */ + fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = true + + /** Read the service table again, past whatever the OS cached for this address. */ + fun refreshServices(address: String, timeoutMs: Int): Boolean = discoverServices(address, timeoutMs) + fun disconnect(address: String) fun close() diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt index c39d7aa3..badd9509 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionControls.kt @@ -496,7 +496,7 @@ internal fun GlassesSessionCore.scheduleReconnectLocked(sessionWasReady: Boolean if (sessionWasReady && now - lastSessionReadyAtMs >= ConnectionOptions.STABLE_SESSION_MS) { consecutiveReconnects = 0 } - val schedule = ConnectionOptions.RECONNECT_BACKOFF_MS + val schedule = if (isG1) G1Timings.RECONNECT_BACKOFF_MS else ConnectionOptions.RECONNECT_BACKOFF_MS val delayMs = schedule[minOf(consecutiveReconnects, schedule.size - 1)].toLong() consecutiveReconnects++ reconnectAfterMs = now + delayMs diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index 6d700719..f64886f8 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -2275,7 +2275,9 @@ class GlassesSessionCore( return } if (!connected && isIo) io.reassembler.reset() - if (!connected) { + if (!connected && isG1 && g1CarryOnWithoutArmLocked(address)) { + // The session goes on; the worker brings this arm back. + } else if (!connected) { // Before the session is ready, this is an attempt failing (or an arm // dropping mid-setup): the connect sequence notices on its own and // schedules the retry, so leave the backoff alone. diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt index 5af48c8f..856ca6e2 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionG1.kt @@ -57,6 +57,13 @@ internal class G1SessionState { /** The right arm's relay is there and this host listens to it. */ var ancsRelay = false + /** When an arm dropped while the session carried on with the other; 0: its link is up. */ + val armDownSinceMs = LongArray(2) + /** When to ask for a lost arm's link again. */ + val armRetryAtMs = LongArray(2) + /** How long the session carries on with one arm before it starts over. */ + var armRecoveryMs = G1Timings.ARM_RECOVERY_MS + fun nextTag(): Int { tag = tag % 255 + 1 return tag @@ -75,6 +82,8 @@ internal class G1SessionState { lastMicRenewAtMs = 0 mic.reset() ancsRelay = false + armDownSinceMs.fill(0) + armRetryAtMs.fill(0) } } @@ -95,8 +104,18 @@ internal object G1Timings { const val IDLE_WAKE_MS = 500L const val LENS_LEFT = 1 const val LENS_RIGHT = 2 + const val ARM_RECOVERY_MS = 15_000L + const val ARM_RETRY_MS = 1_000L + /** With the other arm's traffic waiting behind it. */ + const val ARM_RECOVERY_WRITE_MS = 5_000 + + /** An arm advertises fast for a minute after a disconnection, so most links are back at once. */ + val RECONNECT_BACKOFF_MS = intArrayOf(500, 1_000, 2_000, 4_000, 8_000) } +/** An arm bonds only once it knows it's in the case, and a full case only says so about every 5 minutes. */ +private const val G1_CASE_DELAY_HINT = "A fully charged arm can take up to 5 minutes to notice it's in the case." + /** What the Install prompt says an arm runs when it isn't g1v0. */ private const val G1_OTHER_FIRMWARE = "Even's firmware" private val G1_PROPS = intArrayOf(G1Protocol.PROP_BATT_PCT, G1Protocol.PROP_CHARGE, G1Protocol.PROP_IN_CASE, G1Protocol.PROP_WORN) @@ -120,6 +139,8 @@ internal fun g1SupportsMessage(message: OutboundMessage): Boolean { private fun GlassesSessionCore.g1ArmAddress(arm: Int): String = if (arm == 0) leftAddress else rightAddress +private fun g1Side(arm: Int): String = if (arm == 0) "left" else "right" + private fun g1Lens(arm: Int): Int = if (arm == 0) G1Timings.LENS_LEFT else G1Timings.LENS_RIGHT // --------------------------------------------------------------------------------------------- @@ -141,25 +162,32 @@ private fun GlassesSessionCore.g1WriteControl(address: String, op: Int, tag: Int * A control request and its reply; worker thread, outside the monitor. Writes on a link the arm doesn't yet obey * (out of the case, before encryption) are ignored and control requests can be lost, so it asks again. */ -private fun GlassesSessionCore.g1Control(arm: Int, op: Int, body: ByteArray = ByteArray(0)): G1Protocol.Reply { +private fun GlassesSessionCore.g1Control(arm: Int, op: Int, body: ByteArray = ByteArray(0), tries: Int = G1Timings.CONTROL_TRIES): G1Protocol.Reply { val address = g1ArmAddress(arm) - repeat(G1Timings.CONTROL_TRIES) { + repeat(tries) { val tag = monitor.withLock { g1.nextTag() } val key = arm * 256 + tag - if (!g1WriteControl(address, op, tag, body)) throw IllegalStateException("control $op write failed") + val written = try { + g1WriteControl(address, op, tag, body) + } catch (e: IllegalStateException) { + false + } + if (!written) throw G1ConnectException(g1Side(arm) + " arm dropped", "The " + g1Side(arm) + " arm dropped the connection.") val deadline = now() + G1Timings.CONTROL_REPLY_MS monitor.withLock { while (true) { g1.replies.remove(key)?.let { return it } if (!running || userDisconnectRequested) throw IllegalStateException("stopped while waiting for control $op") - if (!(if (arm == 0) leftConnected else rightConnected)) throw IllegalStateException("link lost waiting for control $op") + if (!(if (arm == 0) leftConnected else rightConnected)) { + throw G1ConnectException(g1Side(arm) + " arm dropped", "The " + g1Side(arm) + " arm dropped the connection.") + } val remaining = deadline - now() if (remaining <= 0) break monitor.awaitMs(minOf(remaining, 100L)) } } } - throw IllegalStateException("no reply to control $op from the " + (if (arm == 0) "left" else "right") + " arm") + throw G1ConnectException(g1Side(arm) + " arm silent", "The " + g1Side(arm) + " arm isn't answering.") } private fun GlassesSessionCore.g1RequestProps(arm: Int, ids: IntArray) { @@ -176,19 +204,25 @@ private fun GlassesSessionCore.g1RequestProps(arm: Int, ids: IntArray) { * microphone's lease and writes the properties that were asked for. Worker thread, outside the monitor. */ internal fun GlassesSessionCore.g1Maintain() { + g1RecoverArms() var status = false var mic: Boolean? = null var light = false var imu = false var sets: List> = emptyList() + val up = BooleanArray(2) monitor.withLock { if (!sessionReady) return val now = now() + for (arm in 0..1) up[arm] = g1.armDownSinceMs[arm] == 0L if (now - g1.lastPropsAtMs >= G1Timings.PROPS_MS) { status = true g1.lastPropsAtMs = now } - if (audioCaptureActive) { + // What only the right arm has waits for it to come back, which starts all of it again. + if (!up[1]) { + // Nothing to do here. + } else if (audioCaptureActive) { if (now - g1.lastMicRenewAtMs >= G1Timings.MIC_RENEW_MS) { mic = true g1.micOn = true @@ -201,22 +235,21 @@ internal fun GlassesSessionCore.g1Maintain() { // The sensor only reads while the panel is on; a dark panel keeps the last filtered value. val interval = if (brightnessDemoPolling) G1Timings.LIGHT_DEMO_MS else if (brightnessPolicy.automatic) G1Timings.LIGHT_AUTO_MS else G1Timings.LIGHT_MANUAL_MS - if (brightnessSentVisible == true && !chargingMode && !shutdownRequested && now - g1.lastLightAtMs >= interval) { + if (up[1] && brightnessSentVisible == true && !chargingMode && !shutdownRequested && now - g1.lastLightAtMs >= interval) { light = true g1.lastLightAtMs = now } - if (g1.imuPeriodMs > 0 && now - g1.lastImuAtMs >= g1.imuPeriodMs) { + if (up[1] && g1.imuPeriodMs > 0 && now - g1.lastImuAtMs >= g1.imuPeriodMs) { imu = true g1.lastImuAtMs = now } if (g1.pendingPropSets.isNotEmpty()) { - sets = g1.pendingPropSets.toList() + sets = g1.pendingPropSets.filter { up[it.first] } g1.pendingPropSets.clear() } } if (status) { - g1RequestProps(0, G1_PROPS) - g1RequestProps(1, G1_PROPS) + for (arm in 0..1) if (up[arm]) g1RequestProps(arm, G1_PROPS) } mic?.let { on -> val tag = monitor.withLock { g1.nextTag() } @@ -312,7 +345,10 @@ internal fun GlassesSessionCore.g1EnqueueFrameLocked( val left = scene.composed(packed, width, height, false) val right = if (scene.hasStereoDepth) scene.composed(packed, width, height, true) else left composed = arrayOf(left, right) - updates = List(2) { arm -> G1FramePlanner.plan(g1.arms[arm].frame, composed[arm], width, height) } + // An arm that's away gets all of this when it's back: its frame stays unknown until then. + updates = List(2) { arm -> + if (g1.armDownSinceMs[arm] != 0L) emptyList() else G1FramePlanner.plan(g1.arms[arm].frame, composed[arm], width, height) + } } catch (e: Exception) { // As in the G2's path: this frame would fail the same way after a reconnect (#42), so drop it. lastEnqueuedFingerprint = fingerprint @@ -323,10 +359,12 @@ internal fun GlassesSessionCore.g1EnqueueFrameLocked( frameTimings.spanEnd(frameId, "compose-lenses") val force = g1.presentPending val queues = List(2) { arm -> - ArrayDeque(updates[arm]).also { if (it.isNotEmpty() || force) it.addLast(byteArrayOf(CFW_MSG_PRESENT.toByte())) } + ArrayDeque(updates[arm]).also { + if (g1.armDownSinceMs[arm] == 0L && (it.isNotEmpty() || force)) it.addLast(byteArrayOf(CFW_MSG_PRESENT.toByte())) + } } g1.presentPending = false - for (arm in 0..1) g1.arms[arm].frame = composed[arm] + for (arm in 0..1) if (g1.armDownSinceMs[arm] == 0L) g1.arms[arm].frame = composed[arm] lastEnqueuedFingerprint = fingerprint val messageCount = queues.sumOf { it.size } if (messageCount == 0) { @@ -361,6 +399,7 @@ internal fun GlassesSessionCore.g1EnqueueFrameLocked( /** Message 30 for both arms, its visibility ordered with the frames around it. */ internal fun GlassesSessionCore.g1EnqueueBrightnessLocked(payload: ByteArray, label: String, visibleChanged: Boolean, onTimeout: MessageCallback) { for (arm in 0..1) { + if (g1.armDownSinceMs[arm] != 0L) continue val message = messageBuilder.customMessage("brightness-output", payload, label, -1, arm == 0) message.cfwRequiredLenses = g1Lens(arm) message.onTimeout = onTimeout @@ -429,6 +468,42 @@ internal fun GlassesSessionCore.g1HideBeforeDisconnect() { /** The arm has no g1v0 service: it runs Even's firmware. */ private class G1OtherFirmwareException : Exception("not g1v0 firmware") +/** + * A connection that failed in a way the wearer can be told: [reason] for the log and counters, [display] for the screen. + * [repairing]: a stale pairing was just removed, and the next attempt makes a new one. + */ +private class G1ConnectException(reason: String, val display: String, val repairing: Boolean = false) : Exception(reason) + +/** + * Subscribes to the arm's events, which is also where its firmware shows. An arm keeps its address across an install, and the + * OS may remember the services it had before: read them again before believing the table either way. + */ +private fun GlassesSessionCore.g1SubscribeEvents(arm: Int) { + val address = g1ArmAddress(arm) + val timeoutMs = ConnectionOptions.SERVICES_TIMEOUT_MS + if (!link.hasCharacteristic(address, G1Ble.EVT_CHAR_UUID)) { + logLine("G1 " + g1Side(arm) + " arm: no event characteristic, reading its services again") + link.refreshServices(address, timeoutMs) + } + if (!link.hasCharacteristic(address, G1Ble.EVT_CHAR_UUID)) { + if (!link.isConnected(address)) throw G1ConnectException(g1Side(arm) + " arm dropped", "The " + g1Side(arm) + " arm dropped the connection.") + throw G1OtherFirmwareException() + } + fun subscribe(): Boolean = try { + link.enableNotifications(address, G1Ble.EVT_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS) + } catch (e: IllegalStateException) { + false + } + if (subscribe()) return + if (link.isConnected(address)) { + // A table that lists it and an arm that refuses: the table may be old in the other direction. + link.refreshServices(address, timeoutMs) + if (!link.hasCharacteristic(address, G1Ble.EVT_CHAR_UUID)) throw G1OtherFirmwareException() + if (subscribe()) return + } + throw G1ConnectException(g1Side(arm) + " arm dropped", "The " + g1Side(arm) + " arm dropped the connection.") +} + private fun GlassesSessionCore.g1ConnectArm(arm: Int, deadlineMs: Long) { val address = g1ArmAddress(arm) val timeoutMs = maxOf(deadlineMs - now(), ConnectionOptions.CONNECT_TIMEOUT_MS.toLong()) @@ -438,12 +513,9 @@ private fun GlassesSessionCore.g1ConnectArm(arm: Int, deadlineMs: Long) { link.requestHighPriority(address) link.requestMtu(address, G1Ble.REQUESTED_MTU, ConnectionOptions.CONNECT_TIMEOUT_MS) if (!link.discoverServices(address, ConnectionOptions.SERVICES_TIMEOUT_MS)) { - throw IllegalStateException("discoverServices failed: $address") - } - if (!link.enableNotifications(address, G1Ble.EVT_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS)) { - if (!link.isConnected(address)) throw IllegalStateException("link lost: $address") - throw G1OtherFirmwareException() + throw G1ConnectException(g1Side(arm) + " arm dropped", "The " + g1Side(arm) + " arm dropped the connection.") } + g1SubscribeEvents(arm) link.requestLe2mPhy(address) monitor.withLock { if (arm == 0) leftConnected = true else rightConnected = true @@ -455,10 +527,10 @@ private fun GlassesSessionCore.g1ConnectArm(arm: Int, deadlineMs: Long) { * through whatever the OS does (Android's dialog, iOS's); out of the case the arm refuses a new bond and the write fails. * Either way this is where the link is known to be encrypted, so the arm obeys everything that follows. */ -private fun GlassesSessionCore.g1Pair(arm: Int) { +private fun GlassesSessionCore.g1Pair(arm: Int, writeTimeoutMs: Int = G1Timings.PAIRING_MS) { val address = g1ArmAddress(arm) if (!link.isBonded(address)) { - logLine("G1 " + (if (arm == 0) "left" else "right") + " arm: asking the OS to pair") + logLine("G1 " + g1Side(arm) + " arm: asking the OS to pair") setStateDisplay("connecting", "Pairing with the glasses...") link.requestBond(address) val deadline = now() + G1Timings.PAIRING_MS @@ -467,8 +539,167 @@ private fun GlassesSessionCore.g1Pair(arm: Int) { if (!monitor.withLock { running && !userDisconnectRequested }) throw IllegalStateException("stopped while pairing") } } - if (!link.writeFrames(address, G1Ble.PAIR_CHAR_UUID, listOf(byteArrayOf(1)), GattWriteMode.WITH_RESPONSE, G1Timings.PAIRING_MS)) { - throw IllegalStateException("no encrypted link to the " + (if (arm == 0) "left" else "right") + " arm") + val encrypted = try { + link.writeFrames(address, G1Ble.PAIR_CHAR_UUID, listOf(byteArrayOf(1)), GattWriteMode.WITH_RESPONSE, writeTimeoutMs) + } catch (e: IllegalStateException) { + false + } + if (encrypted) return + if (!link.isConnected(address)) { + throw G1ConnectException(g1Side(arm) + " arm dropped", "The " + g1Side(arm) + " arm dropped the connection.") + } + // The link is up and the arm won't encrypt it. If the OS says this phone is bonded, the arm has lost its half: it has + // since paired on Even's firmware or with other hosts. Only an arm in the case can pair again, so that's the only time a + // bond is safe to give up. An unencrypted link gets an answer from nothing else, and this is the only way to ask. + if (link.isBonded(address) && g1InCaseWithoutEncryption(arm) && link.removeBond(address)) { + logLine("G1 " + g1Side(arm) + " arm: it lost this phone's pairing; removed it, pairing again") + throw G1ConnectException(g1Side(arm) + " arm pairing removed", "Pairing with the glasses again.", repairing = true) + } + throw G1ConnectException(g1Side(arm) + " arm stale pairing", "The glasses don't recognize this phone's pairing. Put them in their " + + "charging case with the lid open to pair again; if that doesn't help, remove them from this phone's Bluetooth settings. " + + G1_CASE_DELAY_HINT) +} + +private fun GlassesSessionCore.g1InCaseWithoutEncryption(arm: Int): Boolean = try { + val hello = G1Protocol.parseHello(g1Control(arm, G1Protocol.OP_HELLO, tries = 1).body) + hello != null && hello.inCase && !hello.encrypted +} catch (e: G1ConnectException) { + false +} + +/** What an arm needs to hear each time its link comes up. */ +private fun GlassesSessionCore.g1StartArm(arm: Int) { + val events = g1Control(arm, G1Protocol.OP_EVENTS, G1Protocol.eventsRequest(G1Protocol.EVENTS_MASK)) + if (events.status != 0) throw G1ConnectException(g1Side(arm) + " arm refused events", "The " + g1Side(arm) + " arm isn't answering.") + // The arm counts a boot healthy only after a host has said so (VM.md §6.4, safe mode). + g1Control(arm, G1Protocol.OP_HEALTH_OK) + // A limit the last session left, when the other eye's panel guard had capped it. + g1Control(arm, G1Protocol.OP_PROP_SET, G1Protocol.propSet(G1Protocol.PROP_BRIGHTNESS_MAX, G1Protocol.BRIGHTNESS_LEVEL_MAX)) +} + +// --------------------------------------------------------------------------------------------- +// One arm lost + +/** + * The arms are independent links, and in crowded 2.4 GHz one often drops alone. Carry on with the other, and bring this one + * back by itself, instead of dropping both and showing the wearer a reconnect for a blip. Whatever was on its way to this + * arm is gone, and so is what the phone knew about its frame. False: the session can't go on without it. Under the monitor, + * on the BLE callback thread. + */ +internal fun GlassesSessionCore.g1CarryOnWithoutArmLocked(address: String): Boolean { + val arm = armIndex(address) + if (arm < 0 || !running || !sessionReady || userDisconnectRequested) return false + val otherUp = g1.armDownSinceMs[1 - arm] == 0L && (if (arm == 0) rightConnected else leftConnected) + if (!otherUp) return false + // The relay's client has to be told to start again, and only a new session tells it. + if (arm == 1 && g1.ancsRelay) return false + if (benchmarkActive) finishBenchmarkLocked(true, "an arm dropped") + g1.armDownSinceMs[arm] = now() + g1.armRetryAtMs[arm] = 0 + g1DropArmMessagesLocked(arm) + logLine("G1 " + g1Side(arm) + " arm dropped: carrying on with the other while it comes back") + ConnectionCounters.increment("g1.arm-drop.carried-on") + return true +} + +private fun GlassesSessionCore.g1DropArmMessagesLocked(arm: Int) { + val left = arm == 0 + val reason = "the " + g1Side(arm) + " arm dropped" + val pending = pendingMessages.iterator() + while (pending.hasNext()) { + val message = pending.next() + if (message.sid != CfwTransport.SID || message.isLeftArmMessage != left) continue + pending.remove() + discardPrewriteIfMatchesLocked(message) + discardImageUpdateStatsLocked(message.imageUpdateId, reason) + magicPool.release(message.sid, message.magic, message.label, reason) + } + val inFlight = inFlightMessages.iterator() + while (inFlight.hasNext()) { + val message = inFlight.next() + if (message.sid != CfwTransport.SID || message.isLeftArmMessage != left) continue + inFlight.remove() + discardImageUpdateStatsLocked(message.imageUpdateId, reason) + magicPool.release(message.sid, message.magic, message.label, reason) + } + cfwTransports[arm].reset() + g1.arms[arm].frame = null + g1.presentPending = true + // What's displayed is no longer what the drive loop thinks; it gets another look. + lastEnqueuedFingerprint = "" + displayedFingerprint = "" +} + +/** A message for an arm that's away would only fail the write or wait for an ACK that can't come. */ +internal fun GlassesSessionCore.g1ArmIsAway(message: OutboundMessage): Boolean = + monitor.withLock { g1.armDownSinceMs[if (message.isLeftArmMessage) 0 else 1] != 0L } + +/** Worker thread, outside the monitor. Blocks the other arm's traffic only for the setup, not while waiting for a link. */ +private fun GlassesSessionCore.g1RecoverArms() { + for (arm in 0..1) { + val address = g1ArmAddress(arm) + var downSince = 0L + var retryAt = 0L + var limit = 0L + monitor.withLock { + downSince = if (sessionReady) g1.armDownSinceMs[arm] else 0L + retryAt = g1.armRetryAtMs[arm] + limit = g1.armRecoveryMs + } + if (downSince == 0L) continue + val now = now() + if (now - downSince >= limit) { + handleTransportFailure(g1Side(arm) + " arm lost", "Can't reach the " + g1Side(arm) + " arm of the glasses.") + return + } + if (!link.isConnected(address)) { + if (now >= retryAt) { + monitor.withLock { g1.armRetryAtMs[arm] = now + G1Timings.ARM_RETRY_MS } + link.beginConnect(address, false) + } + continue + } + try { + // A missing bond isn't a blip: that goes to the full connect, which knows what to say and can wait for the OS. + if (!link.isBonded(address)) throw G1ConnectException(g1Side(arm) + " arm not bonded", "The glasses aren't paired.") + g1ConnectArm(arm, now + ConnectionOptions.CONNECT_TIMEOUT_MS) + g1Pair(arm, G1Timings.ARM_RECOVERY_WRITE_MS) + val hello = G1Protocol.parseHello(g1Control(arm, G1Protocol.OP_HELLO).body) + ?: throw G1ConnectException(g1Side(arm) + " arm bad hello", "The " + g1Side(arm) + " arm isn't answering.") + g1StartArm(arm) + monitor.withLock { + g1.arms[arm].hello = hello + logLine("G1 " + g1Side(arm) + " arm back after " + (now() - downSince) + " ms") + ConnectionCounters.increment("g1.arm-recovered") + g1.armDownSinceMs[arm] = 0 + g1.armRetryAtMs[arm] = 0 + cfwTransports[arm].reset() + g1.presentPending = true + // It's had no frames: all of it again, the brightness too. The drive loop sends the desired frame. + brightnessSentLevel = -1 + brightnessSentVisible = null + displayedFingerprint = "" + lastEnqueuedFingerprint = "" + imageRetryAfterMs = 0 + g1.lastPropsAtMs = 0 + if (arm == 1) { + g1.lastLightAtMs = 0 + g1.lastMicRenewAtMs = 0 + g1.mic.reset() + g1.lastImuAtMs = 0 + if (g1.imuPeriodMs > 0) g1.pendingPropSets.add(1 to G1Protocol.propSet(G1Protocol.PROP_IMU_RATE, G1Protocol.IMU_RATE_STREAM)) + } + monitor.signalAll() + } + interruptibleSleep.interrupt() + } catch (t: Exception) { + logLine("G1 " + g1Side(arm) + " arm not back yet: " + (t.message ?: t.toString())) + monitor.withLock { g1.armRetryAtMs[arm] = now() + G1Timings.ARM_RETRY_MS } + try { + link.disconnect(address) + } catch (ignored: Exception) { + } + } } } @@ -493,7 +724,8 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { var compatible = true for (arm in 0..1) { val reply = g1Control(arm, G1Protocol.OP_HELLO) - val hello = G1Protocol.parseHello(reply.body) ?: throw IllegalStateException("bad HELLO from arm $arm") + val hello = G1Protocol.parseHello(reply.body) + ?: throw G1ConnectException(g1Side(arm) + " arm bad hello", "The " + g1Side(arm) + " arm isn't answering.") monitor.withLock { g1.arms[arm].hello = hello } versions[arm] = "g1v0 " + hello.version + (if (hello.safeMode) " (safe mode)" else "") if (hello.leftArm != (arm == 0)) { @@ -514,14 +746,7 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { monitor.withLock { incompatibleFirmware = firmware } return } - for (arm in 0..1) { - val events = g1Control(arm, G1Protocol.OP_EVENTS, G1Protocol.eventsRequest(G1Protocol.EVENTS_MASK)) - if (events.status != 0) throw IllegalStateException("EVENTS refused: " + events.status) - // The arm counts a boot healthy only after a host has said so (VM.md §6.4, safe mode). - g1Control(arm, G1Protocol.OP_HEALTH_OK) - // A limit the last session left, when the other eye's panel guard had capped it. - g1Control(arm, G1Protocol.OP_PROP_SET, G1Protocol.propSet(G1Protocol.PROP_BRIGHTNESS_MAX, G1Protocol.BRIGHTNESS_LEVEL_MAX)) - } + for (arm in 0..1) g1StartArm(arm) g1ListenToAncsRelay() monitor.withLock { sessionReady = true @@ -549,15 +774,16 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { emitFirmwareInfo(firmware) monitor.withLock { incompatibleFirmware = firmware } } catch (t: Throwable) { - logLine("G1 connect failed: " + safeMessage(t)) - val unpaired = firstUnpairedArm() + // The ways this is expected to fail have a reason of their own; the stack is for what isn't expected. + logLine("G1 connect failed: " + (if (t is G1ConnectException) t.message else safeMessage(t))) + val unpaired = if (t is G1ConnectException && t.repairing) null else firstUnpairedArm() if (unpaired != null) { logError("G1 connect failed and $unpaired is not paired; suspending reconnect") ConnectionCounters.increment("g1.unpaired") monitor.withLock { haltReconnectLocked("arm not paired: $unpaired") } if (!userDisconnectRequested) { setStateDisplay("unpaired", "The glasses are not paired with this phone. Put them in their charging case" - + " with the lid open, then connect: they only pair in the case.") + + " with the lid open, then connect: they only pair in the case. " + G1_CASE_DELAY_HINT) } interruptibleSleep.interrupt() } else if (t is ArmUnreachableException) { @@ -568,8 +794,10 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { } else { handleTransportFailure("glasses not found", "Can't find the glasses. They may be off or out of range.") } + } else if (t is G1ConnectException) { + handleTransportFailure(t.message, t.display) } else { - handleTransportFailure("connect failed") + handleTransportFailure("connect failed", "Couldn't connect to the glasses.") } } } @@ -581,7 +809,8 @@ internal fun GlassesSessionCore.g1ConnectLoopOnce() { */ private fun GlassesSessionCore.g1ListenToAncsRelay() { val wanted = rawFrameTap != null && monitor.withLock { g1.arms[1].hello?.ancs == true } - val listening = wanted && link.enableNotifications(rightAddress, G1Ble.ANCS_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS) + val listening = wanted && link.hasCharacteristic(rightAddress, G1Ble.ANCS_CHAR_UUID) + && link.enableNotifications(rightAddress, G1Ble.ANCS_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS) if (wanted && !listening) logWarn("G1: the right arm has a notification relay, but subscribing to it failed") monitor.withLock { g1.ancsRelay = listening } } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt index e1da052e..01580acb 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt @@ -398,6 +398,10 @@ internal fun GlassesSessionCore.writeMessage(message: OutboundMessage): Boolean ioDropUnsupported(message) return true } + if (isG1 && g1ArmIsAway(message)) { + ioDropUnsupported(message) + return true + } if (isIo && !ioSupportsMessage(message)) { // G2-only traffic (EvenHub/settings frames, the G2 hardware CFW modes) that a feature // queued anyway: the iO would NACK it into the replay limit, so it never goes out. diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt index aaa4b57a..aaa076b6 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/SessionPorts.kt @@ -71,6 +71,15 @@ interface SessionLink { /** Ask the OS to bond with a connected device, without waiting. A no-op where it pairs on demand only (CoreBluetooth). */ fun requestBond(address: String) {} + /** Remove this phone's half of a pairing; false where the platform can't or refused. */ + fun removeBond(address: String): Boolean = false + + /** After discovery: whether the service table has this characteristic. Enabling notifications on one it lacks may throw. */ + fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = true + + /** Read the service table again, past whatever the OS cached for this address. */ + fun refreshServices(address: String, timeoutMs: Int): Boolean = discoverServices(address, timeoutMs) + /** Bandwidth-benchmark link tuning; 0: current link, 1: HIGH priority, 2: 2M PHY, 3: both. */ fun prepareBenchmarkLink(address: String, mode: Int) diff --git a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt index 625ca4b8..68c31f7e 100644 --- a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt +++ b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosBleCentral.kt @@ -464,6 +464,17 @@ class IosBleCentral(private val platform: ProtocolPlatform = IosProtocolPlatform /** CoreBluetooth pairs by itself when an attribute needs it. */ override fun requestBond(address: String) {} + /** Only iOS Settings can remove a pairing. */ + override fun removeBond(address: String): Boolean = false + + override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean { + val peer = connectedPeer(address) ?: return false + return cond.withLock { peer.characteristics.containsKey(characteristicUuid.lowercase()) } + } + + /** CoreBluetooth follows Service Changed itself; discovering again is all there is. */ + override fun refreshServices(address: String, timeoutMs: Int): Boolean = discoverServices(address, timeoutMs) + override fun prepareBenchmarkLink(address: String, mode: Int) {} override fun recordDisplayFrameSent() { diff --git a/scripts/config-transfer.md b/scripts/config-transfer.md index 1c105633..dde3045c 100644 --- a/scripts/config-transfer.md +++ b/scripts/config-transfer.md @@ -102,6 +102,12 @@ Use `--device` / `-d` or set `IOS_DEVICE` when more than one device is connected Without either, the script selects the only device with an active Xcode tunnel. For the simulator, add `--simulator` (defaults to `booted`; `--device` selects one). +`scripts/resetOnboardingIos.sh` is the iOS counterpart of `scripts/resetOnboarding.sh`. +It pulls the config, then pushes every `onboarding.*` key that is set back to its empty +value, which the app reads the same as a missing key. Pushes can't remove keys, and the +plist can't be edited directly (see below). Its `--all` uninstalls the app, since iOS has +no equivalent of `pm clear`. + Transfers use `devicectl` app-container access. The app consumes a uniquely identified request at bootstrap, before loading settings getters and workers; it applies imports through NSUserDefaults rather than overwriting a plist that diff --git a/scripts/ios_config.py b/scripts/ios_config.py index a9f8020c..62f79d5b 100644 --- a/scripts/ios_config.py +++ b/scripts/ios_config.py @@ -18,6 +18,7 @@ BUNDLE = os.environ.get('IOS_BUNDLE_ID') or 'com.faceclaw.app' REMOTE = 'Library/FaceclawConfigPort' # The app reads requests of up to 8 MiB: a 2 MiB document embedded as an escaped JSON string. REQUEST_LIMIT = 8 * 1024 * 1024 +ONBOARDING_PREFIX = 'onboarding.' def run(args, tolerate=False): @@ -46,96 +47,160 @@ def atomic_write(path, data): temporary.unlink(missing_ok=True) +def resolve_device(args, work): + device = args.device or os.environ.get('IOS_DEVICE') + if args.simulator: + return device or 'booted' + if device: + return device + listing = work / 'devices.json' + run(['devicectl', 'list', 'devices', '--json-output', str(listing)]) + devices = json.loads(listing.read_text())['result']['devices'] + available = [d for d in devices if d.get('connectionProperties', {}).get('tunnelState') == 'connected'] + if len(available) != 1: + raise ValueError('Specify the iPhone with --device UDID (or IOS_DEVICE)') + return available[0]['identifier'] + + +def exchange(args, work, device, operation, document=None): + """Restart the app with one request for it to consume at launch; returns its successful reply.""" + if args.simulator: + container = Path(run(['simctl', 'get_app_container', device, BUNDLE, 'data']).stdout.strip()) + identifier = str(uuid.uuid4()) + payload = {'id': identifier, 'operation': operation} + if document is not None: + payload['document'] = document + encoded = json.dumps(payload, ensure_ascii=False, allow_nan=False).encode() + if len(encoded) > REQUEST_LIMIT: + raise ValueError('Config request exceeds 8 MiB') + stage = work / 'FaceclawConfigPort' + stage.mkdir(mode=0o700, exist_ok=True) + atomic_write(stage / 'request.json', encoded) + if args.simulator: + remote = container / REMOTE + remote.mkdir(parents=True, exist_ok=True) + atomic_write(remote / 'request.json', encoded) + run(['simctl', 'terminate', device, BUNDLE], tolerate=True) + run(['simctl', 'launch', device, BUNDLE]) + else: + run(['devicectl', 'device', 'copy', 'to', '--device', device, '--domain-type', 'appDataContainer', + '--domain-identifier', BUNDLE, '--source', str(stage), '--destination', REMOTE]) + run(['devicectl', 'device', 'process', 'launch', '--device', device, '--terminate-existing', BUNDLE]) + deadline = time.monotonic() + 25 + response = None + while time.monotonic() < deadline: + if args.simulator: + response_path = remote / 'response.json' + else: + response_path = work / 'response.json' + run(['devicectl', 'device', 'copy', 'from', '--device', device, '--domain-type', 'appDataContainer', + '--domain-identifier', BUNDLE, '--source', REMOTE + '/response.json', '--destination', str(response_path)], tolerate=True) + try: + candidate = json.loads(response_path.read_text()) + if candidate.get('id') == identifier: + response = candidate + break + except (OSError, ValueError): + pass + time.sleep(0.5) + if response is None: + raise RuntimeError('No matching config response. Unlock the phone and install a build with config-port support, then retry.') + if not response.get('ok'): + message = response.get('message', 'Config transfer failed') + if message == 'Invalid config request': + message += ' (does the installed build predate JSON config documents?)' + raise RuntimeError(message) + return response + + +def pull_document(args, work, device): + response = exchange(args, work, device, 'pull') + if not isinstance(response.get('document'), str): + raise RuntimeError('The installed build predates JSON config documents; update it and retry.') + return response + + def transfer(args): # Parse and validate before touching the device or restarting its app. document = read_document(args.file) if args.operation == 'push' else None with tempfile.TemporaryDirectory(prefix='faceclaw-config-') as work: work = Path(work) - device = args.device or os.environ.get('IOS_DEVICE') - if args.simulator: - device = device or 'booted' - container = Path(run(['simctl', 'get_app_container', device, BUNDLE, 'data']).stdout.strip()) - else: - if not device: - listing = work / 'devices.json' - run(['devicectl', 'list', 'devices', '--json-output', str(listing)]) - devices = json.loads(listing.read_text())['result']['devices'] - available = [d for d in devices if d.get('connectionProperties', {}).get('tunnelState') == 'connected'] - if len(available) != 1: - raise ValueError('Specify the iPhone with --device UDID (or IOS_DEVICE)') - device = available[0]['identifier'] - identifier = str(uuid.uuid4()) - payload = {'id': identifier, 'operation': args.operation} - if document is not None: - payload['document'] = document - encoded = json.dumps(payload, ensure_ascii=False, allow_nan=False).encode() - if len(encoded) > REQUEST_LIMIT: - raise ValueError('Config request exceeds 8 MiB') - stage = work / 'FaceclawConfigPort' - stage.mkdir(mode=0o700) - atomic_write(stage / 'request.json', encoded) - if args.simulator: - remote = container / REMOTE - remote.mkdir(parents=True, exist_ok=True) - atomic_write(remote / 'request.json', encoded) - run(['simctl', 'terminate', device, BUNDLE], tolerate=True) - run(['simctl', 'launch', device, BUNDLE]) - else: - run(['devicectl', 'device', 'copy', 'to', '--device', device, '--domain-type', 'appDataContainer', - '--domain-identifier', BUNDLE, '--source', str(stage), '--destination', REMOTE]) - run(['devicectl', 'device', 'process', 'launch', '--device', device, '--terminate-existing', BUNDLE]) - deadline = time.monotonic() + 25 - response = None - while time.monotonic() < deadline: - if args.simulator: - response_path = remote / 'response.json' - else: - response_path = work / 'response.json' - run(['devicectl', 'device', 'copy', 'from', '--device', device, '--domain-type', 'appDataContainer', - '--domain-identifier', BUNDLE, '--source', REMOTE + '/response.json', '--destination', str(response_path)], tolerate=True) - try: - candidate = json.loads(response_path.read_text()) - if candidate.get('id') == identifier: - response = candidate - break - except (OSError, ValueError): - pass - time.sleep(0.5) - if response is None: - raise RuntimeError('No matching config response. Unlock the phone and install a build with config-port support, then retry.') - if not response.get('ok'): - message = response.get('message', 'Config transfer failed') - if message == 'Invalid config request': - message += ' (does the installed build predate JSON config documents?)' - raise RuntimeError(message) + device = resolve_device(args, work) if args.operation == 'pull': - if not isinstance(response.get('document'), str): - raise RuntimeError('The installed build predates JSON config documents; update it and retry.') + response = pull_document(args, work, device) atomic_write(args.file, response['document'].encode()) print(f'Pulled {response.get("count", "?")} settings to {args.file} (mode 600). App restarted.') else: + response = exchange(args, work, device, 'push', document) skipped = response.get('skipped') or [] note = f' Left out {len(skipped)} {response.get("sourcePlatform") or "other-platform"}-only settings.' if skipped else '' print(f'Pushed {response["count"]} settings; app restarted.{note} Unspecified settings preserved; ' f'previous preferences backed up in {REMOTE}/previous.plist.') +def onboarding_reset_document(pulled): + """A document clearing the onboarding keys set in a pulled config, or None if none are. + + Pushes merge, so a key can be overwritten but not removed. Every onboarding key reads the + value written here the same as a missing key: false for flags, "" for the finished version. + """ + cleared = {} + for key, value in json.loads(pulled).get('platformSettings', {}).items(): + if not key.startswith(ONBOARDING_PREFIX): + continue + blank = False if isinstance(value, bool) else 0 if isinstance(value, (int, float)) else '' + if value != blank: + cleared[key] = blank + if not cleared: + return None + return json.dumps({'schema': 2, 'platform': 'ios', 'settings': {}, 'platformSettings': cleared}) + + +def reset_onboarding(args): + with tempfile.TemporaryDirectory(prefix='faceclaw-config-') as work: + work = Path(work) + device = resolve_device(args, work) + if args.all: + print(f'Uninstalling {BUNDLE}, which removes ALL of its data...') + if args.simulator: + run(['simctl', 'uninstall', device, BUNDLE]) + else: + run(['devicectl', 'device', 'uninstall', 'app', '--device', device, BUNDLE]) + print('Done. Reinstall (npm run run:ios) to start from a clean onboarding.') + return + print(f'Clearing onboarding preference keys ({ONBOARDING_PREFIX}*) for {BUNDLE}...') + document = onboarding_reset_document(pull_document(args, work, device)['document']) + if document is None: + print('No onboarding keys were set. App is already in pre-onboarding state.') + return + keys = json.loads(document)['platformSettings'] + exchange(args, work, device, 'push', document) + for key in keys: + print(f' cleared {key}') + print(f'Done. Faceclaw has restarted into onboarding; previous preferences backed up in {REMOTE}/previous.plist.') + + def main(): os.umask(0o077) - parser = argparse.ArgumentParser(description='Pull/push iOS Faceclaw config; restarts the app. Requires Xcode and an unlocked development device. Push merges supplied keys; accepts Faceclaw JSON from either platform, or legacy Android XML.') - parser.add_argument('operation', choices=['pull', 'push']) + parser = argparse.ArgumentParser(description='Pull/push iOS Faceclaw config, or reset its onboarding state; restarts the app. Requires Xcode and an unlocked development device. Push merges supplied keys; accepts Faceclaw JSON from either platform, or legacy Android XML.') + parser.add_argument('operation', choices=['pull', 'push', 'reset-onboarding']) parser.add_argument('path', nargs='?') parser.add_argument('-f', '--file') parser.add_argument('-d', '--device', help='iPhone UDID/name, or simulator ID with --simulator; defaults to IOS_DEVICE or the only connected device') parser.add_argument('--simulator', action='store_true', help='Use simctl (default device: booted)') + parser.add_argument('--all', action='store_true', help='With reset-onboarding: uninstall the app, wiping ALL of its data') args = parser.parse_args() + if args.operation == 'reset-onboarding' and (args.path or args.file): + parser.error('reset-onboarding does not take a file') + if args.all and args.operation != 'reset-onboarding': + parser.error('--all only applies to reset-onboarding') if args.path and args.file: parser.error('Specify one file, either positional or with -f') args.file = args.file or args.path or 'faceclaw_settings.ios.json' if args.operation == 'pull' and Path(args.file).suffix.lower() == '.xml': parser.error('Configs are pulled as JSON; choose a .json filename') try: - transfer(args) + (reset_onboarding if args.operation == 'reset-onboarding' else transfer)(args) except (OSError, ValueError, RuntimeError, ET.ParseError) as error: print(f'Error: {error}', file=sys.stderr) return 1 diff --git a/scripts/resetOnboarding.sh b/scripts/resetOnboarding.sh index 9daed669..55c0162a 100755 --- a/scripts/resetOnboarding.sh +++ b/scripts/resetOnboarding.sh @@ -15,20 +15,21 @@ # scripts/resetOnboarding.sh --all # full `pm clear` (wipes everything) # scripts/resetOnboarding.sh -s # target a specific adb device # -# The device id defaults to $FACECLAW_DEVICE_ID, then to the id used by -# build_and_run.sh. adb is located the same way build.sh finds its tools. +# The device id defaults to DEVICE_ID from build_paths.sh, the same device +# build_and_run.sh targets. adb must be on PATH, or added to it in build_paths.sh. + +# Sourced ahead of strict mode, since the build scripts source it without one. +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +if [ -f "$ROOT/build_paths.sh" ]; then + source "$ROOT/build_paths.sh" +fi set -euo pipefail PACKAGE="com.faceclaw.app" PREF_KEY_PREFIX="onboarding." -DEVICE_ID="${FACECLAW_DEVICE_ID:-3A101JEHN12330}" WIPE_ALL=0 -# Match build.sh's tool locations so adb is on PATH even from a bare shell. -export ANDROID_HOME="${ANDROID_HOME:-/Users/jbabcock/Library/Android/sdk}" -export PATH="$ANDROID_HOME/platform-tools:$PATH" - while [ $# -gt 0 ]; do case "$1" in --all) WIPE_ALL=1; shift ;; @@ -44,8 +45,19 @@ done command -v adb >/dev/null 2>&1 || { echo "error: adb not found on PATH" >&2; exit 1; } +if [ -z "${DEVICE_ID:-}" ]; then + echo "error: no adb device; set DEVICE_ID in build_paths.sh or pass -s ." >&2 + exit 2 +fi + ADB="adb -s $DEVICE_ID" +# Network devices (host:port) need an explicit connect first. A failure here is +# reported by the connected-device check below. +case "$DEVICE_ID" in + *:*) adb connect "$DEVICE_ID" >/dev/null 2>&1 || true ;; +esac + # Confirm the device is actually there before doing anything. if ! $ADB get-state >/dev/null 2>&1; then echo "error: adb device '$DEVICE_ID' not connected." >&2 diff --git a/scripts/resetOnboardingIos.sh b/scripts/resetOnboardingIos.sh new file mode 100755 index 00000000..ad0d5a64 --- /dev/null +++ b/scripts/resetOnboardingIos.sh @@ -0,0 +1,35 @@ +#!/usr/bin/env bash +# +# resetOnboardingIos.sh — reset Faceclaw on an iPhone back to its pre-onboarding +# state, for testing the onboarding flow repeatedly. The iOS counterpart of +# resetOnboarding.sh. +# +# By default this only clears the onboarding-related preference keys +# (onboarding.complete, onboarding.previewOnly, the on-glasses onboarding's +# onboarding.glassesFinishedVersion, ...) and leaves everything else, notably +# the saved glasses/ring identities, intact. It restarts Faceclaw twice, and +# leaves it running in onboarding. Pass --all to uninstall the app instead, +# which wipes ALL of its data and permissions; you then have to reinstall it. +# +# Usage: +# scripts/resetOnboardingIos.sh # reset onboarding flags only +# scripts/resetOnboardingIos.sh --all # uninstall (wipes everything) +# scripts/resetOnboardingIos.sh -d # target a specific iPhone +# scripts/resetOnboardingIos.sh --simulator # target the booted simulator +# +# The device defaults to IOS_DEVICE from build_paths.sh, then to the only iPhone +# connected. Needs Xcode and an unlocked phone with a development build installed; +# see config-transfer.md. + +# Sourced ahead of strict mode, since the build scripts source it without one. +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +if [ -f "$ROOT/build_paths.sh" ]; then + source "$ROOT/build_paths.sh" +fi + +set -euo pipefail + +# ios_config.py reads these from its environment. +export IOS_DEVICE IOS_BUNDLE_ID + +exec python3 "$ROOT/scripts/ios_config.py" reset-onboarding "$@" diff --git a/tests/config-transfer-scripts.test.cjs b/tests/config-transfer-scripts.test.cjs index 311b8671..31f46532 100644 --- a/tests/config-transfer-scripts.test.cjs +++ b/tests/config-transfer-scripts.test.cjs @@ -41,6 +41,13 @@ with tempfile.TemporaryDirectory() as d: try: m.read_document(p) except (ValueError, m.ET.ParseError): pass else: raise AssertionError(f'accepted invalid config {invalid!r}') +pulled = {'schema': 2, 'platform': 'ios', 'settings': {'onboarding.lookalike': True, 'display.timeFormat': '24h'}, 'platformSettings': { + 'onboarding.complete': True, 'onboarding.previewOnly': False, 'onboarding.glassesFinishedVersion': '0.8.6', 'onboarding.step': 3, 'deviceAddress.left': 'AA'}} +reset = json.loads(ios.onboarding_reset_document(json.dumps(pulled))) +assert reset == {'schema': 2, 'platform': 'ios', 'settings': {}, 'platformSettings': { + 'onboarding.complete': False, 'onboarding.glassesFinishedVersion': '', 'onboarding.step': 0}}, reset +assert m.check_document(json.dumps(reset)) == (2, 'ios', 3) +assert ios.onboarding_reset_document(json.dumps({**pulled, 'platformSettings': {'onboarding.complete': False, 'onboarding.glassesFinishedVersion': '', 'deviceAddress.left': 'AA'}})) is None `], { stdio: 'inherit' }); }); diff --git a/tests/even-advertisement.test.cjs b/tests/even-advertisement.test.cjs index d87c12ac..99a9befa 100644 --- a/tests/even-advertisement.test.cjs +++ b/tests/even-advertisement.test.cjs @@ -215,8 +215,63 @@ test("a G1 arm on g1v0: the name says all, the serial is in the 0xFFFF record", assert.equal(classifyAdvertisement(g1Raw("G1v0S_L", "")).serial, null); }); +const g1Record = (flags, version, serial = "S110LABC030139") => "ffff" + "02" + flags + version + g1Ascii(serial); + +test("a G1 arm on g1v0 0.5.66+: its name tells pairs apart, its record says what it runs", () => { + const ad = classifyAdvertisement(g1Raw("G1CFW_L_EF50E5", g1Record("05", "000542"))); + assert.equal(ad.role, "left"); + assert.equal(ad.g1Firmware, "g1v0"); + assert.equal(ad.g1Version, "0.5.66"); + assert.equal(ad.serial, "S110LABC030139"); + assert.equal(classifyAdvertisement(g1Raw("G1CFW_R_CBE689", g1Record("04", "000542"))).role, "right"); +}); + +test("a G1 arm in safe mode says so in its record, not its name", () => { + const ad = classifyAdvertisement(g1Raw("G1CFW_L_EF50E5", g1Record("0d", "000542"))); + assert.equal(ad.g1Firmware, "g1v0-safe"); + assert.equal(ad.g1Version, "0.5.66"); +}); + +test("a G1 arm whose record hasn't arrived yet still shows, without a version or serial", () => { + const ad = classifyAdvertisement(g1Raw("G1CFW_L_EF50E5", "")); + assert.equal(ad.g1Firmware, "g1v0"); + assert.equal(ad.g1Version, undefined); + assert.equal(ad.serial, null); +}); + +test("g1v0 before 0.5.66 and Even's firmware advertise no version", () => { + assert.equal(classifyAdvertisement(g1Raw("G1v0_R", "ffff" + "01" + "04" + g1Ascii("S110LABC030139"))).g1Version, undefined); + assert.equal(classifyAdvertisement(g1Raw("Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139"))).g1Version, undefined); +}); + +test("a G1 pair joins on its serial across firmware, so an install in progress stays one pair", () => { + const stock = classifyAdvertisement(g1Raw("Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139") + "0000000000")); + const custom = classifyAdvertisement(g1Raw("G1CFW_R_CBE689", g1Record("04", "000542"))); + assert.equal(stock.serial, custom.serial); +}); + +test("on iOS a G1 arm gets an address from its peripheral identifier, and is found at all", () => { + const { identifyIosPeripheral, g1IosAddress } = require("../.test-build/app/g2/ios-peripheral-identity.js"); + const identifier = "14b99254-0798-d1a8-3eec-b141bdabfae8"; + assert.equal(g1IosAddress(identifier), "14:B9:92:54:07:98"); + for (const [name, manufacturerData, firmware] of [ + ["G1CFW_L_EF50E5", g1Record("05", "000542"), "g1v0"], + ["Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139"), "stock"], + ["G1v0_L", "ffff" + "01" + "05" + g1Ascii("S110LABC030139"), "g1v0"], + ]) { + const device = identifyIosPeripheral({ identifier, name, manufacturerData, rssi: -50, connectable: true }); + assert.ok(device, name); + assert.equal(device.address, "14:B9:92:54:07:98", name); + assert.equal(device.identifier, identifier.toUpperCase(), name); + assert.equal(device.role, "left", name); + assert.equal(device.g1Firmware, firmware, name); + assert.equal(device.serial, "S110LABC030139", name); + } + assert.equal(identifyIosPeripheral({ identifier: "not-a-uuid", name: "G1CFW_L_EF50E5", manufacturerData: "", rssi: 0, connectable: true }), null); +}); + test("names that only look like a G1 are not admitted", () => { - for (const name of ["G1v0_X", "G1v0", "G1 Tracker", "Even G1", "Pixel G1v0_L"]) { + for (const name of ["G1v0_X", "G1v0", "G1 Tracker", "Even G1", "Pixel G1v0_L", "G1CFW_L", "G1CFW_X_EF50E5", "G1CFW_L_EF50E", "Pixel G1CFW_L_EF50E5"]) { assert.equal(classifyAdvertisement(g1Raw(name, "")), null, name); } }); diff --git a/tests/g1-firmware.test.cjs b/tests/g1-firmware.test.cjs index 4f71e2f6..b012e2ff 100644 --- a/tests/g1-firmware.test.cjs +++ b/tests/g1-firmware.test.cjs @@ -153,6 +153,24 @@ test('the state of the two arms is that of the arm that needs the most', () => { assert.equal(state({ firmware: 'stock' }, on('0.5.63', { safeMode: true })), 'stock'); }); +test('what the advertising alone says about the arms', () => { + const arm = (g1Firmware, g1Version) => ({ g1Firmware, g1Version }); + const state = (left, right) => plan.g1StateFromAdvertising({ left, right }, '0.5.66'); + assert.deepEqual(state(arm('g1v0', '0.5.66'), arm('g1v0', '0.5.66')), { state: 'current', version: '0.5.66' }); + assert.deepEqual(state(arm('g1v0', '0.5.67'), arm('g1v0', '0.5.66')), { state: 'current', version: '0.5.66' }); + assert.deepEqual(state(arm('g1v0', '0.5.66'), arm('g1v0', '0.5.100')), { state: 'current', version: '0.5.66' }); + assert.deepEqual(state(arm('stock'), arm('g1v0', '0.5.66')), { state: 'stock', version: '' }); + assert.deepEqual(state(arm('g1v0-safe', '0.5.66'), arm('g1v0', '0.5.66')), { state: 'safe-mode', version: '' }); + // Firmware before 0.5.66, or a record that hasn't arrived: an arm has to be asked. + assert.equal(state(arm('g1v0'), arm('g1v0', '0.5.66')), null); + assert.equal(state(arm('g1v0'), arm('g1v0')), null); +}); + +test('an older arm wins over a newer one', () => { + const arm = (g1Version) => ({ g1Firmware: 'g1v0', g1Version }); + assert.deepEqual(plan.g1StateFromAdvertising({ left: arm('0.5.67'), right: arm('0.5.65') }, '0.5.66'), { state: 'older', version: '0.5.65' }); +}); + test('the native flow\'s answer is read, and nonsense is no answer', () => { assert.deepEqual(plan.parseG1FlashResult('{"flashed":true,"version":"0.5.64"}'), { flashed: true, version: '0.5.64' }); assert.deepEqual(plan.parseG1FlashResult('nonsense'), {}); diff --git a/tests/ios-glanceboard.test.cjs b/tests/ios-glanceboard.test.cjs index 4aa88cd7..caaee81f 100644 --- a/tests/ios-glanceboard.test.cjs +++ b/tests/ios-glanceboard.test.cjs @@ -21,6 +21,8 @@ const planes = load('app/graphics/plane.ts', { './image': images }); const timings = load('app/native/frame-timings.ts', {}); const LAUNCHER_GRAY = 75; +let glassesType = 'g2'; + function fixture() { const relay = { available: true, starts: 0, client: null, message: undefined }; const observers = new Map(), phoneState = { protectedDataAvailable: true }; @@ -105,7 +107,7 @@ function fixture() { const noop = () => () => {}; class FaceclawCommunicatorBridge extends Display { phase = 'disconnected'; listeners = {}; - constructor() { super(); bridge = this; } + constructor(addresses) { super(); bridge = this; this.addresses = addresses; } on(kind, fn) { this.listeners[kind] = fn; return () => { if (this.listeners[kind] === fn) delete this.listeners[kind]; }; } onStateChange(fn) { return this.on('state', fn); } onRingEvent(fn) { return this.on('ring', fn); } onWearState(fn) { return this.on('wear', fn); } onBatteryState(fn) { return this.on('battery', fn); } onCaseState(fn) { return this.on('case', fn); } onFirmwareInfo(fn) { return this.on('firmware', fn); } @@ -176,7 +178,7 @@ function fixture() { '../apps/all-apps': { ALL_APPS: [{ appId: 'glanceboard', glanceboard: provider }] }, '../apps/onboarding/onboarding-progress': { claimGlassesOnboardingAutoLaunch: () => false }, '../ui/shell/worker-window': {}, '../ui/shell/in-process-window': {}, - '../ui/dashboard-settings': { brightnessSetting: { get: () => 'auto' }, brightnessSettingToLevel: () => null, getBrightnessPreferences: () => ({ auto: true, level: 50, minimum: 2, maximum: 100, curve: '0:0,1000:100', fadeMs: 280 }), lockScreenEnabledSetting: { get: () => settings.lock }, ringConnectionModeSetting: { get: () => 'glasses' }, onAnySettingChanged: fn => { settingsChanged = fn; return () => {}; }, previewColorSetting: { get: () => 'white' } }, + '../ui/dashboard-settings': { glassesTypeSetting: { get: () => glassesType }, brightnessSetting: { get: () => 'auto' }, brightnessSettingToLevel: () => null, getBrightnessPreferences: () => ({ auto: true, level: 50, minimum: 2, maximum: 100, curve: '0:0,1000:100', fadeMs: 280 }), lockScreenEnabledSetting: { get: () => settings.lock }, ringConnectionModeSetting: { get: () => 'glasses' }, onAnySettingChanged: fn => { settingsChanged = fn; return () => {}; }, previewColorSetting: { get: () => 'white' } }, '../native/phone-battery': { readPhoneBatteryState: () => ({ battery: 80, charging: false }) }, '../apps/ios-availability': { iosAppUnavailableReason: () => null }, '../graphics/glyph-wire': { prepareFrameDraws: () => null }, @@ -222,6 +224,17 @@ function fixture() { get shellOptions() { return shellOptions; }, registered, inProcessApps, get bridge() { return bridge; }, connect, wear: wearing => bridge.emitWear(wearing), settingsChanged: () => settingsChanged(), sent, previews, received, boardStats, hardware, phone, advance, render }; } +test('the session is told which glasses it drives, as a G2 session gets nowhere on a G1', async () => { + for (const type of ['g1', 'g2']) { + glassesType = type; + const f = fixture(); + await f.connect(); + assert.equal(f.bridge.addresses.glassesType, type); + assert.ok('right' in f.bridge.addresses && 'left' in f.bridge.addresses, 'the arms still come with it'); + } + glassesType = 'g2'; +}); + test('a link that comes back asks for the notification relay again; a G1 without one is told to update', async () => { const f = fixture(); await f.connect(); diff --git a/tests/ios-sensors.test.cjs b/tests/ios-sensors.test.cjs index 94bec3b8..d84dffd2 100644 --- a/tests/ios-sensors.test.cjs +++ b/tests/ios-sensors.test.cjs @@ -57,6 +57,16 @@ function alsRecord(alsValue) { return body; } +test('only a G1 session runs the G1 connect path', () => { + for (const [glassesType, expected] of [['g1', 1], ['g2', 0], [undefined, 0]]) { + const { session, FaceclawCommunicatorBridge } = harness(); + let used = 0; + session.useG1 = () => { used++; }; + new FaceclawCommunicatorBridge({ right: 'r', left: 'l', glassesType }); + assert.equal(used, expected, String(glassesType)); + } +}); + test('the bridge is the active session from start() until close()', async () => { const h = harness(); const bridge = new h.FaceclawCommunicatorBridge({ right: 'r', left: 'l' }); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt index b07df483..d72b405f 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1FlashTest.kt @@ -72,6 +72,15 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false) var silentAtOffset = -1 var onChunk: (() -> Unit)? = null var connects = 0 + /** The OS remembers a table without g1v0's services, as after an install at the same address. */ + var staleTable = false + var refreshes = 0 + /** Android says bonded and the arm has lost its half. */ + var staleBond = false + var removedBonds = 0 + var inCase = false + /** Even's firmware's answer to its battery query; null: it says nothing. */ + var stockBatteryReply: ByteArray? = null val wantHash = G1Smp.imageHash(image) @@ -83,13 +92,31 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false) } override fun prepareLink(address: String, desiredMtu: Int, timeoutMs: Int) {} override fun discoverServices(address: String, timeoutMs: Int): Boolean = connected + /** As FaceclawBleManager: a characteristic the table lacks throws, a refused one (no encryption) returns false. */ override fun enableNotifications(address: String, characteristicUuid: String, timeoutMs: Int): Boolean { - if (!connected) return false - if (stock && characteristicUuid == G1Ble.EVT_CHAR_UUID) return false - if (!stock && characteristicUuid == G1Smp.NUS_TX_UUID) return false + if (!connected) throw IllegalStateException("Not connected") + if (!hasCharacteristic(address, characteristicUuid)) throw IllegalStateException("Characteristic not found: $characteristicUuid") + if (stock && staleBond && characteristicUuid == G1Smp.NUS_TX_UUID) return false subscribed.add(characteristicUuid) return true } + override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = when (characteristicUuid) { + G1Ble.EVT_CHAR_UUID -> !stock && !staleTable + G1Smp.NUS_TX_UUID -> stock + else -> true + } + override fun refreshServices(address: String, timeoutMs: Int): Boolean { + refreshes++ + staleTable = false + return connected + } + override fun removeBond(address: String): Boolean { + removedBonds++ + bond = BondState.NONE + staleBond = false + connected = false + return true + } override fun isConnected(address: String): Boolean = connected override fun bondState(address: String): BondState = bond override fun requestBond(address: String) { @@ -108,8 +135,15 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false) override fun writeFrames(address: String, characteristicUuid: String, frames: List, mode: GattWriteMode, timeoutMs: Int): Boolean { if (!connected) throw IllegalStateException("Not connected") when (characteristicUuid) { - G1Smp.NUS_RX_UUID -> heartbeats.add(frames.single()) - G1Ble.PAIR_CHAR_UUID -> return bond == BondState.BONDED + G1Smp.NUS_RX_UUID -> { + val frame = frames.single() + if (frame[0].toInt() == 0x2c) { + stockBatteryReply?.let { inbound?.onNotification(ARM, G1Smp.NUS_TX_UUID, it) } + } else { + heartbeats.add(frame) + } + } + G1Ble.PAIR_CHAR_UUID -> return bond == BondState.BONDED && !staleBond G1Ble.CTRL_CHAR_UUID -> control(frames.single()) G1Smp.SMP_CHAR_UUID -> { for (frame in frames) assertTrue(frame.size <= 97, "a write longer than the MTU allows") @@ -126,7 +160,7 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false) val body = when (op) { G1Protocol.OP_HELLO -> { val parts = runningVersion.split(".").map { it.toInt().toByte() } - val flags = (if (safeMode) 1 else 0) or 2 or 64 + val flags = (if (safeMode) 1 else 0) or 2 or (if (staleBond) 0 else 64) or (if (inCase) 128 else 0) byteArrayOf(5, parts[0], parts[1], parts[2], 1, flags.toByte(), 0) } G1Protocol.OP_PROPS -> byteArrayOf(battery.toByte(), 0, 0, 0) @@ -230,6 +264,19 @@ private val FAST = G1FlashTimings( controlReplyMs = 20, controlTries = 2, uploadReplyMs = 150, smpReplyMs = 150, resetReplyMs = 50, heartbeatMs = 30, pollMs = 5, uploadRetries = 5, ) +class G1SmpStockTest { + @Test + fun stocksBatteryReplyIsReadOnlyWhenItIsOne() { + // What the real firmware answered in emulation (g1-fw BLE_COMMAND_SET_REPORT), first bytes. + assertEquals(100, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66, 0x64, 0x64, 0xf9.toByte(), 0x80.toByte()))) + assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66, 0))) + assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66, 101))) + assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0xc9.toByte(), 50))) + assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x25, 0x66, 50))) + assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66))) + } +} + class G1SmpTest { private val sha = ByteArray(32) { it.toByte() } @@ -519,6 +566,75 @@ class G1ArmFlashFlowTest { assertTrue("an arm pairs only in its case" in listener.detail, listener.detail) } + @Test + fun aStaleBondInTheCaseIsRemovedAndMadeAgain() { + val arm = FakeArm(image) + arm.staleBond = true + arm.inCase = true + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE) + assertEquals(true, result.success, result.detail) + assertEquals(1, arm.removedBonds) + assertEquals(1, arm.bondRequests) + confirmIsLast(arm) + } + + @Test + fun aBondIsNeverGivenUpOutOfTheCase() { + val arm = FakeArm(image) + arm.staleBond = true + arm.inCase = false + val result = run(arm, G1ArmFlashFlow.Mode.UPDATE, window = 1) + assertEquals(false, result.success) + assertEquals(0, arm.removedBonds, "no new bond can be made out of the case") + } + + @Test + fun aStaleBondOnStockIsRemovedAndMadeAgain() { + val arm = FakeArm(image, stock = true) + arm.staleBond = true + val result = run(arm, G1ArmFlashFlow.Mode.STOCK) + assertEquals(true, result.success, result.detail) + assertEquals(1, arm.removedBonds) + assertEquals(1, arm.bondRequests) + } + + @Test + fun anOldServiceTableIsReadAgainBeforeItIsBelieved() { + val arm = FakeArm(image) + arm.staleTable = true + val result = run(arm, G1ArmFlashFlow.Mode.PROBE) + assertEquals(true, result.success, result.detail) + assertEquals(1, arm.refreshes) + assertTrue("\"firmware\":\"g1v0\"" in result.detail, result.detail) + } + + @Test + fun aLowBatteryOnStockStopsBeforeAnyUpload() { + val arm = FakeArm(image, stock = true) + arm.stockBatteryReply = byteArrayOf(0x2c, 0x66, 12, 12) + val result = run(arm, G1ArmFlashFlow.Mode.STOCK) + assertEquals(false, result.success) + assertTrue("12%" in result.detail, result.detail) + assertFalse("upload" in arm.calls) + } + + @Test + fun aChargedArmOnStockGoesOn() { + val arm = FakeArm(image, stock = true) + arm.stockBatteryReply = byteArrayOf(0x2c, 0x66, 100, 100) + val result = run(arm, G1ArmFlashFlow.Mode.STOCK) + assertEquals(true, result.success, result.detail) + assertTrue(result.logs.any { "battery 100%" in it }, result.logs.toString()) + } + + @Test + fun aStockArmThatSaysNothingAboutItsBatteryGoesOn() { + val arm = FakeArm(image, stock = true) + val result = run(arm, G1ArmFlashFlow.Mode.STOCK) + assertEquals(true, result.success, result.detail) + assertTrue(result.logs.any { "battery unknown" in it }, result.logs.toString()) + } + @Test fun aProbeSaysWhatAnArmRuns() { val arm = FakeArm(image) diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt index 907dc898..26b5f5c9 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/G1SessionTest.kt @@ -139,6 +139,19 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { val ancsWrites = ArrayList>() /** Out of the case, or the OS said no: no bond can be made. */ @Volatile var pairingRefused = false + /** Both arms run Even's firmware: no g1v0 service. */ + @Volatile var stockFirmware = false + /** The OS remembers a table without g1v0's services, as after an install at the same address. */ + @Volatile var staleTable = false + @Volatile var refreshes = 0 + @Volatile var removedBonds = 0 + /** The OS says bonded and the arm has lost its half: PAIR fails with the link up. */ + @Volatile var staleBond = false + @Volatile var helloInCase = false + /** An arm that won't connect, whatever it's asked. */ + val away = HashSet() + /** Links up. Everything stays up unless a test takes it down. */ + private val up = hashSetOf(LEFT, RIGHT) private val out = ArrayList>() private fun arm(address: String) = if (address == LEFT) leftArm else rightArm @@ -169,9 +182,53 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { event(address, G1Protocol.EV_INPUT, body) } - override fun connect(address: String, timeoutMs: Int): Boolean = true + /** The link drops, as the BLE callback thread reports it. */ + fun drop(address: String) { + lock.withLock { up.remove(address) } + core.onConnectionStateChange(address, false) + } - override fun isConnected(address: String): Boolean = true + /** The arm comes back in range: the next connection attempt gets it. */ + fun comeBack(address: String) { + lock.withLock { away.remove(address) } + } + + override fun connect(address: String, timeoutMs: Int): Boolean = lock.withLock { + if (address in away) return@withLock false + up.add(address) + true + } + + override fun beginConnect(address: String, background: Boolean): Boolean { + val connected = connect(address, 0) + if (connected) core.onConnectionStateChange(address, true) + return connected + } + + override fun isConnected(address: String): Boolean = lock.withLock { address in up } + + override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = when (characteristicUuid) { + G1Ble.EVT_CHAR_UUID -> !stockFirmware && !staleTable + G1Ble.ANCS_CHAR_UUID -> !ancsCharacteristicMissing + else -> true + } + + override fun refreshServices(address: String, timeoutMs: Int): Boolean { + refreshes++ + staleTable = false + return true + } + + override fun removeBond(address: String): Boolean { + removedBonds++ + lock.withLock { + arm(address).bonded = false + up.remove(address) + } + staleBond = false + core.onConnectionStateChange(address, false) + return true + } override fun requestHighPriority(address: String) {} @@ -181,12 +238,12 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { override fun discoverServices(address: String, timeoutMs: Int): Boolean = true + /** As FaceclawBleManager: a characteristic the table lacks throws, it doesn't return false. */ override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean { - if (characteristicUuid == G1Ble.ANCS_CHAR_UUID && !ancsCharacteristicMissing) { - lock.withLock { ancsSubscribed.add(address) } - return true - } - return characteristicUuid == G1Ble.EVT_CHAR_UUID + if (!isConnected(address)) throw IllegalStateException("Not connected: $address") + if (!hasCharacteristic(address, characteristicUuid)) throw IllegalStateException("Characteristic not found: $characteristicUuid") + if (characteristicUuid == G1Ble.ANCS_CHAR_UUID) lock.withLock { ancsSubscribed.add(address) } + return true } override fun requestBond(address: String) { @@ -194,11 +251,12 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { } override fun writeFrames(address: String, characteristicUuid: String, frames: List, mode: GattWriteMode, timeoutMs: Int): Boolean { + if (!isConnected(address)) throw IllegalStateException("Not connected: $address") val a = arm(address) when (characteristicUuid) { G1Ble.PAIR_CHAR_UUID -> { assertEquals(GattWriteMode.WITH_RESPONSE, mode, "only a write with response can make the OS pair") - if (pairingRefused) return false + if (pairingRefused || staleBond) return false lock.withLock { a.pairedWrites++ a.bonded = true @@ -233,7 +291,7 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink { body[2] = 5 body[3] = 63 body[4] = (if (a.left) 1 else 0).toByte() - body[5] = (2 or 64).toByte() + body[5] = (2 or (if (staleBond) 0 else 64) or (if (helloInCase) 128 else 0)).toByte() body[6] = ((if (a.left) 0 else 4) or (if (hasAncsRelay) 8 else 0)).toByte() reply(address, op, tag, 0, body) } @@ -473,6 +531,199 @@ private class G1Session { } } +class G1LinkTest { + private fun started(s: G1Session, seed: Int = 1) { + s.core.monitor.withLock { s.core.g1.armRecoveryMs = 2_000 } + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, "never ready:\n" + s.tail()) + s.submit(seed, seed) + assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, "frame never displayed:\n" + s.tail()) + } + + @Test + fun evensFirmwareSaysWhyInsteadOfRetrying() { + val s = G1Session() + try { + s.glasses.stockFirmware = true + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.listener.firmware.isNotEmpty() }, "no firmware report:\n" + s.tail()) + assertEquals("Even's firmware|Even's firmware|", s.listener.firmware.single()) + assertTrue(s.glasses.refreshes >= 1, "the table is read again before it's believed") + assertFalse(s.ready()) + } finally { + s.core.disconnect() + } + } + + @Test + fun anOldServiceTableIsReadAgain() { + val s = G1Session() + try { + s.glasses.staleTable = true + assertTrue(s.core.start()) + assertTrue(awaitTrue(5_000) { s.ready() }, "never ready:\n" + s.tail()) + assertEquals(1, s.glasses.refreshes) + assertTrue(s.listener.firmware.single().endsWith("Faceclaw/38"), s.listener.firmware.toString()) + } finally { + s.core.disconnect() + } + } + + @Test + fun aStalePairingInTheCaseIsRemovedAndMadeAgain() { + val s = G1Session() + try { + s.glasses.leftArm.bonded = true + s.glasses.rightArm.bonded = true + s.glasses.staleBond = true + s.glasses.helloInCase = true + assertTrue(s.core.start()) + assertTrue(awaitTrue(8_000) { s.ready() }, "never ready:\n" + s.tail()) + assertEquals(1, s.glasses.removedBonds) + assertFalse("unpaired" in s.listener.phases, "this isn't for the wearer to fix: " + s.listener.phases) + } finally { + s.core.disconnect() + } + } + + @Test + fun aStalePairingOutOfTheCaseIsKeptAndExplained() { + val s = G1Session() + try { + s.glasses.leftArm.bonded = true + s.glasses.rightArm.bonded = true + s.glasses.staleBond = true + assertTrue(s.core.start()) + assertTrue(awaitTrue(8_000) { "charging case" in s.listener.lastStatus }, "status: " + s.listener.lastStatus + "\n" + s.tail()) + assertEquals(0, s.glasses.removedBonds, "no new bond can be made out of the case") + assertFalse("Exception" in s.listener.lastStatus, s.listener.lastStatus) + assertFalse("unpaired" in s.listener.phases, s.listener.phases.toString()) + } finally { + s.core.disconnect() + } + } + + @Test + fun aFailedConnectSaysWhatHappened() { + val s = G1Session() + try { + s.glasses.leftArm.bonded = true + s.glasses.rightArm.bonded = true + s.core.start() + // An arm that goes away during setup, before the session is ready. + s.glasses.drop(RIGHT) + s.glasses.away.add(RIGHT) + assertTrue(awaitTrue(25_000) { "right arm" in s.listener.lastStatus || s.ready() }, "status: " + s.listener.lastStatus) + assertFalse("Exception" in s.listener.lastStatus, s.listener.lastStatus) + } finally { + s.core.disconnect() + } + } + + @Test + fun oneArmDroppingLeavesTheSessionAndTheOtherEyeAlone() { + val s = G1Session() + try { + started(s) + val phasesBefore = s.listener.phases.size + val rightBefore = s.glasses.lock.withLock { s.glasses.rightArm.wireBytes } + s.glasses.away.add(LEFT) + s.glasses.drop(LEFT) + assertTrue(s.ready(), "the session goes on") + + // The right eye keeps getting frames, and nothing waits for the left. + s.submit(2, 2) + assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { s.glasses.rightArm.panel.contentEquals(s.expected(2)) } }, + "the right eye stopped:\n" + s.tail()) + assertTrue(s.glasses.lock.withLock { s.glasses.rightArm.wireBytes } > rightBefore) + assertTrue(s.ready()) + assertTrue(s.listener.phases.drop(phasesBefore).none { it == "retrying" || it == "connecting" }, + "no reconnect shown for a blip: " + s.listener.phases.drop(phasesBefore)) + } finally { + s.core.disconnect() + } + } + + @Test + fun anArmThatComesBackCatchesUpByItself() { + val s = G1Session() + try { + started(s) + val leftEvents = s.glasses.lock.withLock { s.glasses.leftArm.healthOk } + val rightPairs = s.glasses.lock.withLock { s.glasses.rightArm.pairedWrites } + s.glasses.away.add(LEFT) + s.glasses.drop(LEFT) + s.submit(2, 2) + assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { s.glasses.rightArm.panel.contentEquals(s.expected(2)) } }) + + s.glasses.lock.withLock { s.glasses.leftArm.records.clear() } + s.glasses.comeBack(LEFT) + assertTrue(awaitTrue(5_000) { s.shownOnBoth(s.expected(2)) }, "the left eye never caught up:\n" + s.tail()) + assertTrue(s.ready()) + assertTrue(s.glasses.lock.withLock { s.glasses.leftArm.healthOk } > leftEvents, "it was set up again") + assertEquals(rightPairs, s.glasses.lock.withLock { s.glasses.rightArm.pairedWrites }, "the other arm wasn't touched") + assertEquals(CFW_MSG_PRESENT, s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.last() }) + } finally { + s.core.disconnect() + } + } + + @Test + fun theRightArmComingBackStartsItsMicAgain() { + val s = G1Session() + try { + started(s) + val listener = object : FaceclawAudioPacketListener { + override fun onAudioPacket(data: ByteArray?, arm: String?, arrivalMs: Long) {} + } + assertTrue(s.core.g1StartAudioCapture(listener)) + assertTrue(awaitTrue(3_000) { s.glasses.lock.withLock { s.glasses.rightArm.micRequests.isNotEmpty() } }) + s.glasses.away.add(RIGHT) + s.glasses.drop(RIGHT) + val before = s.glasses.lock.withLock { s.glasses.rightArm.micRequests.size } + s.glasses.comeBack(RIGHT) + assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { s.glasses.rightArm.micRequests.size } > before }, s.tail()) + } finally { + s.core.disconnect() + } + } + + @Test + fun anArmThatStaysAwayEndsInAFullReconnect() { + val s = G1Session() + try { + started(s) + s.glasses.away.add(LEFT) + s.glasses.drop(LEFT) + assertTrue(awaitTrue(8_000) { "left arm" in s.listener.lastStatus }, "status: " + s.listener.lastStatus + "\n" + s.tail()) + assertFalse("Exception" in s.listener.lastStatus, s.listener.lastStatus) + s.glasses.comeBack(LEFT) + assertTrue(awaitTrue(15_000) { s.ready() }, "never back:\n" + s.tail()) + s.submit(3, 3) + assertTrue(awaitTrue(5_000) { s.shownOnBoth(s.expected(3)) }, s.tail()) + } finally { + s.core.disconnect() + } + } + + @Test + fun bothArmsDroppingIsAFullReconnectAndAFastOne() { + val s = G1Session() + try { + started(s) + s.glasses.drop(LEFT) + s.glasses.drop(RIGHT) + val droppedAt = s.platform.elapsedRealtimeMs() + assertTrue(awaitTrue(5_000) { s.ready() }, "never back:\n" + s.tail()) + assertTrue(s.platform.elapsedRealtimeMs() - droppedAt < 3_000, "the first retry comes quickly") + s.submit(4, 4) + assertTrue(awaitTrue(5_000) { s.shownOnBoth(s.expected(4)) }, s.tail()) + } finally { + s.core.disconnect() + } + } +} + class G1SessionTest { @Test fun pairsOnFirstConnectAndShowsEachLensItsFrame() { diff --git a/tests/pairing-candidates.test.cjs b/tests/pairing-candidates.test.cjs index 54cdcea7..a2e3a9a5 100644 --- a/tests/pairing-candidates.test.cjs +++ b/tests/pairing-candidates.test.cjs @@ -332,6 +332,28 @@ test("G1 arms on g1v0 join on the frame serial and can be selected", () => { assert.match(row.armsSummary, /case/); }); +test("G1 arms on current firmware join on the serial, with the arm's own name", () => { + const record = (flags) => "ffff" + "02" + flags + "000542" + ascii(G1_SERIAL); + const aggregator = new DiscoveryAggregator(); + aggregator.ingest(g1Arm("G1CFW_L_EF50E5", "C0:66:16:EF:50:E5", record("05"))); + aggregator.ingest(g1Arm("G1CFW_R_CBE689", "E4:46:BA:CB:E6:89", record("04"))); + const [pair] = aggregator.pairs(); + assert.equal(pair.g1Firmware, "g1v0"); + assert.equal(pair.completeness, "complete"); + assert.equal(pair.left.g1Version, "0.5.66"); + assert.equal(glassesRow(pair).canSelect, true); +}); + +test("a G1 pair halfway through an install is one pair, shown as needing it", () => { + const aggregator = new DiscoveryAggregator(); + aggregator.ingest(g1Arm("G1CFW_L_EF50E5", "C0:66:16:EF:50:E5", "ffff" + "02" + "05" + "000542" + ascii(G1_SERIAL))); + aggregator.ingest(g1Arm("Even G1_70_R_CBE689", "E4:46:BA:CB:E6:89", "01" + ascii(G1_SERIAL))); + const pairs = aggregator.pairs(); + assert.equal(pairs.length, 1); + assert.equal(pairs[0].g1Firmware, "stock"); + assert.equal(glassesRow(pairs[0]).canSelect, true); +}); + test("G1 arms on Even's firmware can be selected, to install on", () => { const aggregator = new DiscoveryAggregator(); aggregator.ingest(g1Arm("Even G1_70_L_EF50E5", "C0:66:16:EF:50:E5", "02" + ascii(G1_SERIAL))); From 41ef3b88a00f79b25f2fd04d04e337482bd949dc Mon Sep 17 00:00:00 2001 From: James Babcock Date: Sat, 7 Nov 2026 13:42:39 -0800 Subject: [PATCH 15/34] Add choose-your-devices page to start of the onboarding flow --- app/phone-ui/onboarding-devices-page.ts | 10 + app/phone-ui/onboarding-devices-page.xml | 43 ++++ app/phone-ui/onboarding-devices-view-model.ts | 109 +++++++++ app/phone-ui/onboarding-register.ios.ts | 2 + app/phone-ui/onboarding-state.ts | 27 +++ app/phone-ui/onboarding-unpair-page.xml | 3 +- app/phone-ui/onboarding-unpair-view-model.ts | 20 +- app/phone-ui/onboarding-view-model.ts | 159 +++++++------ app/phone-ui/pairing-page.xml | 48 ++-- app/phone-ui/pairing-view-model.ts | 37 ++- app/phone-ui/permissions-view-model.ts | 9 + tests/onboarding-devices.test.cjs | 224 ++++++++++++++++++ 12 files changed, 589 insertions(+), 102 deletions(-) create mode 100644 app/phone-ui/onboarding-devices-page.ts create mode 100644 app/phone-ui/onboarding-devices-page.xml create mode 100644 app/phone-ui/onboarding-devices-view-model.ts create mode 100644 tests/onboarding-devices.test.cjs diff --git a/app/phone-ui/onboarding-devices-page.ts b/app/phone-ui/onboarding-devices-page.ts new file mode 100644 index 00000000..dfb46b2f --- /dev/null +++ b/app/phone-ui/onboarding-devices-page.ts @@ -0,0 +1,10 @@ +import { EventData, Page } from "@nativescript/core"; + +import { OnboardingDevicesViewModel } from "./onboarding-devices-view-model"; + +export function navigatingTo(args: EventData): void { + const page = args.object as Page; + if (!page.bindingContext) { + page.bindingContext = new OnboardingDevicesViewModel(); + } +} diff --git a/app/phone-ui/onboarding-devices-page.xml b/app/phone-ui/onboarding-devices-page.xml new file mode 100644 index 00000000..eb99d4ef --- /dev/null +++ b/app/phone-ui/onboarding-devices-page.xml @@ -0,0 +1,43 @@ + + + + + + + + +