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..b9837e79 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 @@ -249,6 +249,8 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun enableWearDetectionAndRequestState() = core.enableWearDetectionAndRequestState() + fun configureHeadUpWake(enabled: Int, angle: Int) = core.configureHeadUpWake(enabled, angle) + fun startBandwidthBenchmark(messageSize: Int, windowSize: Int, durationMs: Int): Boolean = core.startBandwidthBenchmark(messageSize, windowSize, durationMs) diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index 3666f299..ac7ba7de 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, 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, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, getHeadUpPreferences, 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, @@ -296,6 +296,7 @@ class DashboardController { private silentMode = false; // Brightness value last pushed to the glasses; see pushBrightness. private lastPushedBrightness: string | null = null; + private lastPushedHeadUp: string | null = null; // Last battery level the glasses reported, kept across disconnects so a // drop-off right after a low reading can be explained as a flat battery. private lastHeadsetBattery: number | null = null; @@ -476,6 +477,7 @@ class DashboardController { // Apply a firmware-debug-flags toggle live while connected (Java dedups). this.pushFirmwareDebugFlags(); this.pushBrightness(); + this.pushHeadUpPreferences(); this.syncEvenHubScreenOffSetting(); // Display mode size first: a reflow repositions every surface too, so // the band-position check after it then has nothing left to do. @@ -1084,6 +1086,19 @@ class DashboardController { }); } + private pushHeadUpPreferences(force = false): void { + if (!global.isAndroid || !this.communicator) return; + const { enabled, angle } = getHeadUpPreferences(); + if (enabled < 0 && angle < 0) return; + const value = JSON.stringify({ enabled, angle }); + if (!force && value === this.lastPushedHeadUp) return; + this.lastPushedHeadUp = value; + void this.communicator.configureHeadUpWake(enabled, angle).catch(error => { + this.lastPushedHeadUp = null; + this.appendLog(`head-up configuration failed: ${this.formatError(error)}`); + }); + } + /** Save the occupied part of the composited screen as a 4-bit grayscale PNG. */ saveScreenshot(): string { const path = this.display?.saveScreenshot(shell.screenshotCropRect()) ?? ""; @@ -1533,6 +1548,7 @@ class DashboardController { // ahead of them. Mirrors ensurePreviewDisplay. await communicator.configureCompositorScreen(G2_LENS_WIDTH, G2_LENS_HEIGHT); await communicator.configureBrightness(getBrightnessPreferences()); + this.pushHeadUpPreferences(true); this.offState = communicator.onStateChange((state) => { if (state.phase !== "connected") resetRingInputFilter(); if (isHaltedSessionPhase(state.phase)) { @@ -1570,6 +1586,7 @@ class DashboardController { // mode-7 control message once the dashboard container is warmed up. this.pushFirmwareDebugFlags(); this.pushBrightness(true); + this.pushHeadUpPreferences(true); this.handRingBackToGlassesIfNeeded(); } if (mappedPhase !== "connected" && mappedPhase !== "charging") { diff --git a/app/native/faceclaw-communicator.ts b/app/native/faceclaw-communicator.ts index a459d348..376b02ba 100644 --- a/app/native/faceclaw-communicator.ts +++ b/app/native/faceclaw-communicator.ts @@ -519,6 +519,11 @@ export class FaceclawCommunicatorBridge { await this.enqueueJavaCall(() => this.communicator.enableWearDetectionAndRequestState()); } + /** -1 leaves a field unchanged. The native session retains explicit values across reconnects. */ + async configureHeadUpWake(enabled: number, angle: number): Promise { + await this.enqueueJavaCall(() => this.communicator.configureHeadUpWake(enabled, angle)); + } + /** Whether the transport prelude has finished (each arm reports "connected" before it). */ isSessionReady(): boolean { return Boolean(this.communicator.isSessionReady()); diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 6bed4672..17ff529a 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -555,6 +555,38 @@ export const brightnessSetting = new ConfigSettingEnum({ description: "Auto uses Faceclaw's ambient-light curve; numbers set a fixed level. 2 is the dimmest level.", }); +/** String storage distinguishes an untouched firmware preference from explicit ON/OFF. */ +class HeadUpWakeSetting extends ConfigSettingBoolean { + get(): boolean { return getStringSetting(this.storageKey, "true") !== "false"; } + set(value: boolean): boolean { setStringSetting(this.storageKey, String(value)); return value; } +} + +export const headUpWakeSetting = new HeadUpWakeSetting({ + id: "head-up-wake", label: "Head-up wake", storageKey: "display.headUpWake", defaultValue: true, + description: "Enable waking the glasses when you look up. Until changed, the glasses keep their current setting. Glanceboard's Show on head tilt chooses what appears after waking.", +}); + +export function normalizeHeadUpAngle(value: string | null | undefined): string { + if (value == null || value.trim() === "" || !Number.isFinite(Number(value))) return "30"; + return String(Math.max(0, Math.min(60, Math.round(Number(value))))); +} + +export const headUpAngleSetting = new ConfigSettingEnum({ + id: "head-up-angle", label: "Head-up angle", storageKey: "display.headUpAngle", defaultValue: "30", + values: Array.from({ length: 61 }, (_, angle) => String(angle)), + normalize: normalizeHeadUpAngle, + formatValue: angle => `${angle}°`, + description: "Look-up trigger angle, 0–60 degrees. Until changed, the glasses keep their current angle. Requires validation on your Faceclaw firmware.", +}); + +/** -1 means leave that firmware field unchanged; no writes on an untouched installation. */ +export function getHeadUpPreferences(): { enabled: number; angle: number } { + const enabled = getStringSetting("display.headUpWake", ""); + const angle = getStringSetting("display.headUpAngle", ""); + return { enabled: enabled === "true" ? 1 : enabled === "false" ? 0 : -1, + angle: angle === "" ? -1 : Number(normalizeHeadUpAngle(angle)) }; +} + const AUTO_BRIGHTNESS_LEVELS = ["2", "5", "10", "20", "25", "30", "40", "50", "60", "70", "80", "90", "100"] as const; export const autoBrightnessMinSetting = new ConfigSettingEnum({ id: "autoBrightnessMin", label: "Auto minimum", storageKey: "display.autoBrightnessMin", diff --git a/app/ui/dashboard/settings-menus.ts b/app/ui/dashboard/settings-menus.ts index f974bb8f..a7e5e255 100644 --- a/app/ui/dashboard/settings-menus.ts +++ b/app/ui/dashboard/settings-menus.ts @@ -49,6 +49,8 @@ import { veniceWebSearchSetting, batteryDisplayModeSetting, brightnessSetting, + headUpWakeSetting, + headUpAngleSetting, autoBrightnessMinSetting, autoBrightnessMaxSetting, autoBrightnessCurveSetting, @@ -118,6 +120,7 @@ function settingsSections(): SettingsSection[] { // the dashboard controller when changed and on each connect. enumSettingMenuItem(brightnessSetting), autoBrightnessMenuItem(), + ...(!global.isIOS ? [toggleSettingMenuItem(headUpWakeSetting), enumSettingMenuItem(headUpAngleSetting)] : []), enumSettingMenuItem(screenTimeoutSetting, { onChange: () => { shell.noteUserActivity(); diff --git a/docs/validation-head-up.md b/docs/validation-head-up.md new file mode 100644 index 00000000..5dce40d4 --- /dev/null +++ b/docs/validation-head-up.md @@ -0,0 +1,53 @@ +# Head-up wake: software and hardware validation + +The Android Display settings now contain “Head-up wake” and “Head-up angle”. +Glanceboard's “Show on head tilt” still only chooses which UI appears on wake. + +Protocol reference: [OpenG2 Companion G2Protocol.swift](https://github.com/mmirman/open-g2-companion/blob/1400d1006ba045379a3ff34d0832add6fa10ced4/modules/ffs-ble/ios/G2Protocol.swift), +`setHeadUpSwitch` / `setHeadUpAngle`; dispatch to both lenses in +[`G2Central.swift`](https://github.com/mmirman/open-g2-companion/blob/1400d1006ba045379a3ff34d0832add6fa10ced4/modules/ffs-ble/ios/G2Central.swift). + +Wire format uses Faceclaw's UI-settings sid 0x09, request flag, command 1, transaction +magic, device-receive-info field 3 / head-up field 4. Switch (field 1) and +angle (field 2) are sent in separate messages, including explicit zero values. +Angles are clamped to the reference's 0–60 degree range. No firmware patch, +firmware download or flash is needed by this implementation. + +Untouched installations send neither field. The UI describes this inherited +state; its displayed ON/30 degree fallback is not a read-back of device state. +Changing just one control preserves the other device field. Explicit choices +are persisted in the existing settings store and resent on every connection. +The native session also retains them through transport reconnects and retries +after setting ACK timeouts. ACK reception confirms transport, not physical wake. + +Software checks: + +- `tests/head-up-wake.test.cjs`: persistence, untouched fields, angle bounds, + independence from Glanceboard, deduplication, reconnect and error recovery. +- `HeadUpProtocolTest`: byte-for-byte settings messages, including OFF and 0°. +- `GlassesSessionCoreTest`: both lenses, separate writes, pre-existing device + settings preserved, angle clamp and automatic transport reconnection. + +Hardware validation: **pending**. Implementation was requested without device +access; protocol compatibility and physical effect on the target Faceclaw CFW +are not established by these software tests. The reference targets stock +2.2.6.10, while this repository normally uses newer Faceclaw firmware. + +Source inspection of [Faceclaw's gesture forwarding](https://github.com/jimrandomh/g2flash/blob/845f665e0dfdcfd06b7d3a294388de6f17a5bd59/patches/gesture_fwd.c) +confirms that head-up/down forwarding while a page owns the screen checks the +stock `head_up_switch`. This supports using the existing setting rather than a +firmware patch, but does not establish the physical angle or wake behavior. + +On the target glasses, record both lens firmware versions and test: + +1. Leave preferences untouched and verify prior wake behavior remains unchanged. +2. Disable Head-up wake; sleep the display, raise the head repeatedly, and confirm + no wake. Check taps still wake normally. +3. Enable it and compare 0°, 30° and 60° trigger angles. Confirm other wake + gestures remain usable, including at the extreme values. +4. Reconnect Bluetooth, then restart the phone app; repeat ON/OFF and angle checks. +5. Toggle Glanceboard and “Show on head tilt” independently; disabled wake should + stay disabled, enabled wake should show the selected UI. +6. Check both lenses remain synchronized, including reconnecting only one arm. + +Do not change firmware to run these checks without explicit permission. diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt index 16fa3610..431fb653 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt @@ -497,6 +497,23 @@ class BleProtocol { ) } + /** Stock HeadUpSetting: switch and angle are separate oneof writes (field 4 of device info). */ + @JvmStatic + fun buildSetHeadUpWake(magic: Int, enabled: Boolean): ByteArray = concat( + CollectionUtils.listOf( + encodeVarintField(1, 1), encodeVarintField(2, magic), + encodeMessageField(3, encodeMessageField(4, encodeVarintField(1, if (enabled) 1 else 0))), + ) + ) + + @JvmStatic + fun buildSetHeadUpAngle(magic: Int, angle: Int): ByteArray = concat( + CollectionUtils.listOf( + encodeVarintField(1, 1), encodeVarintField(2, magic), + encodeMessageField(3, encodeMessageField(4, encodeVarintField(2, angle.coerceIn(0, 60)))), + ) + ) + /** Enable the firmware's wear detector (DeviceReceiveInfoFromAPP field 5). */ @JvmStatic fun buildSetWearDetection(magic: Int, enabled: Boolean): ByteArray { diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/MessageBuilder.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/MessageBuilder.kt index 485565c9..1b07cedc 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/MessageBuilder.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/MessageBuilder.kt @@ -188,6 +188,17 @@ class MessageBuilder { ) } + fun headUpControl(leftArm: Boolean, enabled: Boolean?, angle: Int): OutboundMessage { + val magic = magicPool.allocate() + return OutboundMessage( + "head-up-control", if (enabled == null) "head-up angle=$angle" else "head-up wake=$enabled", + BleProtocol.SID_UI_SETTING, BleProtocol.FLAG_REQUEST, magic, + if (enabled == null) BleProtocol.buildSetHeadUpAngle(magic, angle) + else BleProtocol.buildSetHeadUpWake(magic, enabled), + ACK_TIMEOUT_MS, -1, leftArm, + ) + } + fun createLayout(): OutboundMessage { var magic: Int = magicPool.allocate() return OutboundMessage( 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 71b4e074..7a61c259 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 @@ -304,6 +304,8 @@ class GlassesSessionCore( internal var brightnessSentLevel = -1 internal var brightnessAlsStartedAt = -2000L internal var brightnessDemoPolling = false + internal var headUpPreferences: Pair? = null + internal var headUpSent: Pair? = null internal var cfwCleanupDelivered = false internal var lastCfwCleanupAckMagic = 0 @@ -920,6 +922,15 @@ class GlassesSessionCore( interruptibleSleep.interrupt() } + /** Explicit preferences only; -1 leaves the corresponding firmware field alone. */ + fun configureHeadUpWake(enabled: Int, angle: Int) { + require(enabled in -1..1) + monitor.withLock { + headUpPreferences = Pair(enabled, if (angle < 0) -1 else angle.coerceIn(0, 60)) + } + interruptibleSleep.interrupt() + } + /** * Enable the stock wear detector, then ask CFW to emit its current cached * state. The queue order matters: the query must run after the setting is @@ -2232,6 +2243,7 @@ class GlassesSessionCore( shutdownRequested = false fixedLayoutCreated = false clearAllMessagesLocked("session ready") + headUpSent = null displayedFingerprint = "" lastAckAtMs = now() lastIncomingAtMs = lastAckAtMs diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionHeadUp.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionHeadUp.kt new file mode 100644 index 00000000..01232a71 --- /dev/null +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionHeadUp.kt @@ -0,0 +1,22 @@ +package com.faceclaw.app + +/** Both arms receive separate stock settings messages; no CFW changes required. */ +internal fun GlassesSessionCore.enqueueHeadUpPreferencesLocked() { + val desired = headUpPreferences ?: return + if (!sessionReady || shutdownRequested || chargingMode || headUpSent == desired + || hasPendingOrInflightKindLocked("head-up-control")) return + for (leftArm in listOf(true, false)) { + // Set the angle before enabling wake. Omitted fields preserve device preferences. + if (desired.second >= 0) { + val message = messageBuilder.headUpControl(leftArm, null, desired.second) + message.onTimeout = MessageCallback { headUpSent = null; logLine("head-up angle ack timeout") } + pendingMessages.addLast(message) + } + if (desired.first >= 0) { + val message = messageBuilder.headUpControl(leftArm, desired.first == 1, -1) + message.onTimeout = MessageCallback { headUpSent = null; logLine("head-up wake ack timeout") } + pendingMessages.addLast(message) + } + } + headUpSent = desired +} 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 fbfac3d2..a2c693a1 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 @@ -74,6 +74,7 @@ internal fun GlassesSessionCore.driveSession(): Long { clearPendingMessagesLocked("after CFW cleanup") return 250 } + enqueueHeadUpPreferencesLocked() if (sessionReady && now - lastFaceclawFramebufferLeaseQueuedAtMs >= FACECLAW_WAKE_LEASE_RENEW_MS && !hasPendingOrInflightKindLocked("framebuffer-lease-control")) { diff --git a/tests/head-up-wake.test.cjs b/tests/head-up-wake.test.cjs new file mode 100644 index 00000000..8a4c6e84 --- /dev/null +++ b/tests/head-up-wake.test.cjs @@ -0,0 +1,76 @@ +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'); +const source = file => fs.readFileSync(path.join(__dirname, '..', file), 'utf8'); +function evaluate(code, globals) { + const context = { exports: {}, ...globals }; + vm.runInNewContext(ts.transpileModule(code, { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText, context); + return context.exports; +} +function settings(values = new Map()) { + const file = ts.createSourceFile('settings.ts', source('app/ui/dashboard-settings.ts'), ts.ScriptTarget.Latest, true); + const names = new Set(['ConfigSetting', 'ConfigSettingBoolean', 'ConfigSettingEnum', 'HeadUpWakeSetting', + 'headUpWakeSetting', 'normalizeHeadUpAngle', 'headUpAngleSetting', 'getHeadUpPreferences']); + const code = file.statements.filter(node => names.has(node.name?.text) || + (ts.isVariableStatement(node) && node.declarationList.declarations.some(d => names.has(d.name.getText(file))))) + .map(node => node.getText(file)).join('\n'); + return evaluate(code, { + fixedChoiceSettings: new Map(), + getStringSetting: (key, fallback) => values.get(key) ?? fallback, + setStringSetting: (key, value) => values.set(key, value), + }); +} + +test('head-up preferences preserve untouched device fields and persist each explicit choice separately', () => { + const values = new Map(); + let prefs = settings(values); + assert.equal(prefs.getHeadUpPreferences().enabled, -1); + assert.equal(prefs.getHeadUpPreferences().angle, -1); + prefs.headUpWakeSetting.set(false); + prefs = settings(values); + assert.equal(prefs.headUpWakeSetting.get(), false); + assert.equal(prefs.getHeadUpPreferences().enabled, 0); + assert.equal(prefs.getHeadUpPreferences().angle, -1); + prefs.headUpAngleSetting.set('75'); + prefs = settings(values); + assert.equal(prefs.headUpAngleSetting.get(), '60'); + assert.equal(prefs.getHeadUpPreferences().enabled, 0); + assert.equal(prefs.getHeadUpPreferences().angle, 60); + for (const [input, expected] of [['-5', '0'], ['20.8', '21'], ['NaN', '30'], ['', '30']]) { + assert.equal(prefs.headUpAngleSetting.set(input), expected); + } + assert.equal(values.has('glanceboard.showOnHeadTilt'), false); +}); + +test('controller skips unset preferences, deduplicates changes and forces reconnect synchronization', async () => { + const file = ts.createSourceFile('controller.ts', source('app/g2/dashboard-controller.ts'), ts.ScriptTarget.Latest, true); + const controller = file.statements.find(node => ts.isClassDeclaration(node) && node.name.text === 'DashboardController'); + const method = controller.members.find(node => node.name?.getText(file) === 'pushHeadUpPreferences').getText(file); + let prefs = { enabled: -1, angle: -1 }; + const { Harness } = evaluate(`export class Harness { ${method} }`, { + global: { isAndroid: true }, getHeadUpPreferences: () => prefs, + }); + const h = new Harness(), calls = []; + h.communicator = { configureHeadUpWake: async (...args) => calls.push(args) }; + h.pushHeadUpPreferences(); assert.equal(calls.length, 0); + prefs = { enabled: 0, angle: 25 }; + h.pushHeadUpPreferences(); h.pushHeadUpPreferences(); + assert.deepEqual(calls, [[0, 25]]); + h.pushHeadUpPreferences(true); assert.equal(calls.length, 2); + prefs = { enabled: 1, angle: 40 }; h.pushHeadUpPreferences(); + assert.deepEqual(calls.at(-1), [1, 40]); + let failures = 0; + h.communicator.configureHeadUpWake = async () => { throw new Error('offline'); }; + h.appendLog = () => failures++; + h.formatError = error => error.message; + h.pushHeadUpPreferences(true); + await new Promise(resolve => setImmediate(resolve)); + assert.equal(h.lastPushedHeadUp, null); assert.equal(failures, 1); + const connect = controller.members.find(node => node.name?.getText(file) === 'connect').getText(file); + assert.match(connect, /pushHeadUpPreferences\(true\)/); +}); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesSessionCoreTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesSessionCoreTest.kt index b457440d..266a560b 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesSessionCoreTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesSessionCoreTest.kt @@ -316,6 +316,33 @@ private class Session { } class GlassesSessionCoreTest { + @Test fun headUpWritesOnlyExplicitFieldsToBothArmsAndResendsAfterReconnect() { + val s = Session() + try { + s.startAndAwaitLayout() + fun writes() = s.link.writes.filter { it.kind == "head-up-control" } + assertEquals(0, writes().size, "untouched firmware preferences must not be written") + s.core.configureHeadUpWake(0, 30) + assertTrue(waitUntil(5_000) { writes().size == 4 }) + for (arm in listOf(LEFT, RIGHT)) { + val commands = writes().filter { it.address == arm } + assertContentEquals(BleProtocol.buildSetHeadUpAngle(commands[0].magic, 30), commands[0].pb) + assertContentEquals(BleProtocol.buildSetHeadUpWake(commands[1].magic, false), commands[1].pb) + } + s.core.handleTransportFailure("head-up reconnect test") + assertTrue(waitUntil(5_000) { !s.layoutCreated() }) + s.platform.offsetMs += 10_000 + s.core.interruptibleSleep.interrupt() + assertTrue(waitUntil(5_000) { s.layoutCreated() && writes().size == 8 }, s.host.logs().takeLast(10).toString()) + s.core.configureHeadUpWake(-1, 100) + assertTrue(waitUntil(5_000) { writes().size == 10 }) + assertTrue(writes().takeLast(2).all { it.label == "head-up angle=60" }) + s.core.configureHeadUpWake(1, -1) + assertTrue(waitUntil(5_000) { writes().size == 12 }) + assertTrue(writes().takeLast(2).all { it.label == "head-up wake=true" }) + } finally { s.core.close() } + } + @Test fun brightnessConfigPrecedesFirstFrameAndSleepWakeFollowsComposites() { val s = Session() s.core.configureBrightness(false, 70, 2, 100, "0:0,1000:100", 280) diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/HeadUpProtocolTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/HeadUpProtocolTest.kt new file mode 100644 index 00000000..b00ede21 --- /dev/null +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/HeadUpProtocolTest.kt @@ -0,0 +1,17 @@ +package com.faceclaw.app + +import kotlin.test.Test +import kotlin.test.assertContentEquals + +class HeadUpProtocolTest { + private fun bytes(hex: String) = hex.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + + @Test fun separateSwitchAndAngleMessagesMatchReferenceWireFormat() { + // G2SettingPackage{1=1, 2=magic, 3={4=HeadUpSetting{1=switch | 2=angle}}}. + assertContentEquals(bytes("080110071a0422020800"), BleProtocol.buildSetHeadUpWake(7, false)) + assertContentEquals(bytes("080110071a0422020801"), BleProtocol.buildSetHeadUpWake(7, true)) + assertContentEquals(bytes("080110071a042202101e"), BleProtocol.buildSetHeadUpAngle(7, 30)) + assertContentEquals(bytes("080110071a0422021000"), BleProtocol.buildSetHeadUpAngle(7, -10)) + assertContentEquals(bytes("080110071a042202103c"), BleProtocol.buildSetHeadUpAngle(7, 100)) + } +}