Revert "feat: add shared tilt-down hide and current-angle measurement"

This reverts commit f029e3ce91.
This commit is contained in:
Blendman974 committed 2026-11-06 22:20:24 +01:00
1 parent f029e3ce91
commit fe87e75fc2
21 files changed
+24 -356

No files matched your search

@@ -40,7 +40,6 @@ function settingsEnv(initialUrl = '', initialModel = 'openai-compatible') {
},
});
const load = loader({ global: { isIOS: false, isAndroid: true } }, {
'../../g2/head-angle': { setAngleFromCurrentHead: async () => 'test' },
'./remote-input-menu': { remoteInputMenuItem: () => ({ label: 'Remote input' }) },
'@nativescript/core': { knownFolders: {} },
'../../graphics/ui-fonts': { getDefaultSmallFont: () => ({}) },
-11
View File
@@ -65,14 +65,3 @@ test("the press timeout is the host's when supplied", () => {
assert.equal(reduceGlance(shown, { type: "timeout" }, T0 + GLANCE_TIMEOUT_MS), shown);
assert.deepEqual(reduceGlance(shown, { type: "timeout" }, T0 + 10_000), GLANCE_HIDDEN);
});
test('shared tilt-down option holds a tilted board up to the safety cap; legacy defaults keep the timer', () => {
const { GLANCE_TILT_MAX_MS } = require('../.test-build/app/g2/glance-state.js');
assert.deepEqual(glanceEventForGesture('head-tilt', false), { type: 'press' });
assert.deepEqual(glanceEventForGesture('head-tilt', false, true), { type: 'tilt' });
const state = reduceGlance(GLANCE_HIDDEN, { type: 'tilt' }, 1000);
assert.equal(state.hideAtMs, 1000 + GLANCE_TILT_MAX_MS);
assert.equal(reduceGlance(state, { type: 'timeout' }, 2000), state);
assert.deepEqual(reduceGlance(state, { type: 'dismiss' }, 2000), GLANCE_HIDDEN);
assert.deepEqual(reduceGlance(state, { type: 'timeout' }, state.hideAtMs), GLANCE_HIDDEN);
});
-52
View File
@@ -1,52 +0,0 @@
const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const vm = require('node:vm');
const ts = require('typescript');
function fixture() {
const timers = new Map(), saved = []; let id = 0, listener, ended = 0, released = 0;
const context = { exports: {}, global: { isAndroid: false },
require: () => ({ headUpAngleSetting: { set: value => saved.push(value) } }),
setTimeout(fn, ms) { timers.set(++id, { fn, ms }); return id; }, clearTimeout: id => timers.delete(id) };
vm.runInNewContext(ts.transpileModule(fs.readFileSync('app/g2/head-angle.ts', 'utf8'), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText, context);
const device = { beginHeadAngleMeasurement: () => true, endHeadAngleMeasurement: () => ended++, getHeadUpCalibration: () => 10,
subscribe(fn) { listener = fn; return () => released++; } };
const sample = (degrees, source = 1) => {
const r = degrees * Math.PI / 180;
listener({ x: Math.sin(r), y: 0, z: Math.cos(r), source });
};
return { api: context.exports, device, saved, sample, ended: () => ended, released: () => released,
tick(ms) { for (const [key, timer] of [...timers]) if (timer.ms === ms) { timers.delete(key); timer.fn(); } } };
}
test('short measurement compensates firmware calibration, persists one shared angle and releases resources', async () => {
const h = fixture(); const pending = h.api.setAngleFromCurrentHead(h.device);
h.sample(30); h.sample(30); h.sample(30); h.tick(1200);
assert.match(await pending, /Saved.*20°/);
assert.deepEqual(h.saved, ['20']); assert.equal(h.ended(), 1); assert.equal(h.released(), 1);
});
test('no data, motion, unknown calibration and unsupported offsets leave the old angle unchanged', async () => {
for (const kind of ['none', 'motion', 'unknown', 'range']) {
const h = fixture();
if (kind === 'unknown') h.device.getHeadUpCalibration = () => NaN;
if (kind === 'range') h.device.getHeadUpCalibration = () => 70;
const pending = h.api.setAngleFromCurrentHead(h.device);
if (kind !== 'none') { h.sample(30); h.sample(kind === 'motion' ? 0 : 30); h.sample(30); h.tick(1200); }
else h.tick(4200);
assert.doesNotMatch(await pending, /Saved/); assert.equal(h.saved.length, 0);
assert.equal(h.ended(), 1); assert.equal(h.released(), 1);
}
});
test('ring readings never calibrate the glasses; concurrent measurements are rejected', async () => {
const h = fixture(); const pending = h.api.setAngleFromCurrentHead(h.device);
assert.match(await h.api.setAngleFromCurrentHead(h.device), /already running/);
h.sample(30, 2); h.sample(30, 2); h.sample(30, 2); h.tick(4200);
assert.doesNotMatch(await pending, /Saved/); assert.equal(h.saved.length, 0);
});
test('failure to subscribe releases the IMU lease and allows a later attempt', async () => {
const h = fixture(); h.device.subscribe = () => { throw new Error('offline'); };
assert.match(await h.api.setAngleFromCurrentHead(h.device), /failed/);
assert.equal(h.ended(), 1);
assert.match(await h.api.setAngleFromCurrentHead(null), /Connect/);
});
-23
View File
@@ -1,23 +0,0 @@
const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const vm = require('node:vm');
const ts = require('typescript');
test('head-down hides both displays under one option and is never treated as input or wake', async () => {
const source = ts.createSourceFile('controller.ts', fs.readFileSync('app/g2/dashboard-controller.ts', 'utf8'), ts.ScriptTarget.Latest, true);
const cls = source.statements.find(n => ts.isClassDeclaration(n) && n.name?.text === 'DashboardController');
const method = cls.members.find(n => n.name?.getText(source) === 'handleInputEvent').getText(source);
for (const enabled of [false, true]) for (const awake of [false, true]) {
let dismissed = 0, slept = 0, finished = 0;
const context = { exports: {}, OsEventTypeList: { HEAD_DOWN_EVENT: 15 }, headDownHideSetting: { get: () => enabled },
shell: { isScreenOn: () => awake, sleep: () => slept++ }, eventLabel: () => '',
frameTimings: { logFrame() {}, finishFrame() { finished++; } },
rawInputEventToInputEvent() { throw new Error('head-down entered the regular input path'); } };
vm.runInNewContext(ts.transpileModule(`export class Controller { ${method} }`, {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText, context);
const c = new context.exports.Controller(); c.glance = { dismiss: () => dismissed++ };
await c.handleInputEvent({ kind: 'sys-event', eventType: 15, frameId: 42 });
assert.equal(dismissed, enabled ? 1 : 0); assert.equal(slept, enabled && awake ? 1 : 0); assert.equal(finished, 1);
}
});
+1 -14
View File
@@ -15,14 +15,12 @@ function evaluate(code, globals) {
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', 'headDownHideSetting', 'normalizeHeadUpAngle', 'headUpAngleSetting', 'getHeadUpPreferences']);
'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(),
getBooleanSetting: (key, fallback) => values.get(key) ?? fallback,
setBooleanSetting: (key, value) => values.set(key, value),
getStringSetting: (key, fallback) => values.get(key) ?? fallback,
setStringSetting: (key, value) => values.set(key, value),
});
@@ -76,14 +74,3 @@ test('controller skips unset preferences, deduplicates changes and forces reconn
const connect = controller.members.find(node => node.name?.getText(file) === 'connect').getText(file);
assert.match(connect, /pushHeadUpPreferences\(true\)/);
});
test('one shared tilt-down preference defaults off and survives restart independently of head-up', () => {
const values = new Map(); let prefs = settings(values);
assert.equal(prefs.headDownHideSetting.get(), false);
prefs.headDownHideSetting.set(true); prefs = settings(values);
assert.equal(prefs.headDownHideSetting.get(), true);
assert.equal(prefs.getHeadUpPreferences().enabled, -1);
assert.equal(prefs.getHeadUpPreferences().angle, -1);
assert.equal(values.has('glanceboard.headDownHide'), false);
});
-1
View File
@@ -34,7 +34,6 @@ function fixture() {
setTimeout: (fn, ms) => { tasks.set(++nextTask, { fn, at: now + ms }); return nextTask; },
clearTimeout: id => tasks.delete(id), setInterval: () => ++nextTask, clearInterval() {} };
const { GlanceHost } = load('app/g2/glance-host.ts', {
'../ui/dashboard-settings': { headDownHideSetting: { get: () => false } },
'../graphics/image': images, '../graphics/plane': planes,
'../graphics/glyph-wire': { prepareFrameDraws: () => null }, '../native/frame-timings': timings,
'../ui/shell/geometry': { minWindowTop: () => 48 },
@@ -316,41 +316,6 @@ private class Session {
}
class GlassesSessionCoreTest {
@Test fun headDownIsForwardedWithoutCountingAsUserActivity() {
val s = Session()
try {
s.startAndAwaitLayout()
s.core.monitor.withLock { s.core.lastConnectionOrInputAtMs = 1L }
val pb = hex("6a061a04080f1001") // deviceEvent{sysEvent{type=HEAD_DOWN, source=right arm}}
s.core.onNotification(RIGHT, BleProtocol.NOTIFY_CHAR_UUID,
BleProtocol.framePb(pb, BleProtocol.SID_EVENHUB, BleProtocol.FLAG_NOTIFY, 77)[0])
assertTrue(waitUntil(1_000) { s.listener.events.contains("sys-event:15") })
assertEquals(1L, s.core.monitor.withLock { s.core.lastConnectionOrInputAtMs })
} finally { s.core.close() }
}
@Test fun angleMeasurementRestoresLatestApplicationImuRequest() {
val s = Session()
val core = s.core
core.running = true
core.sessionReady = true
try {
core.setImuReportEnabled(true, 100)
assertTrue(core.beginHeadAngleMeasurement())
assertFalse(core.beginHeadAngleMeasurement())
core.setImuReportEnabled(false, 200)
assertEquals("IMU enable", core.pendingMessages.first { it.kind == "imu-control" }.label)
core.endHeadAngleMeasurement()
assertEquals("IMU disable", core.pendingMessages.first { it.kind == "imu-control" }.label)
assertTrue(core.beginHeadAngleMeasurement())
core.setImuReportEnabled(true, 100)
core.endHeadAngleMeasurement()
assertEquals("IMU enable", core.pendingMessages.first { it.kind == "imu-control" }.label)
assertEquals(100, core.imuRequestedPace)
} finally { core.running = false }
}
@Test fun headUpWritesOnlyExplicitFieldsToBothArmsAndResendsAfterReconnect() {
val s = Session()
try {
@@ -1,18 +1,9 @@
package com.faceclaw.app
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNull
import kotlin.test.assertContentEquals
class HeadUpProtocolTest {
@Test fun calibrationReadHandlesOmittedZeroSignedValuesAndMissingSettings() {
assertEquals(0, BleProtocol.parseHeadUpCalibration(bytes("22000000")))
assertEquals(12, BleProtocol.parseHeadUpCalibration(bytes("2202480c0000")))
assertEquals(-12, BleProtocol.parseHeadUpCalibration(bytes("220648f4ffffff0f0000")))
assertNull(BleProtocol.parseHeadUpCalibration(bytes("08010000")))
}
private fun bytes(hex: String) = hex.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
@Test fun separateSwitchAndAngleMessagesMatchReferenceWireFormat() {