From 4681f14dae60054ab31a358443e63630309d65cf Mon Sep 17 00:00:00 2001 From: James Babcock Date: Fri, 11 Sep 2026 19:34:50 -0700 Subject: [PATCH] Implement press-and-hold for glanceboard in watch and simulated inputs --- app/phone-ui/main-view-model.ts | 28 +++++++++++++++++-- wear/PROTOCOL.md | 2 +- .../kotlin/com/faceclaw/wear/MainActivity.kt | 17 +++++------ .../com/faceclaw/wear/ui/RemoteScreen.kt | 12 ++++++-- 4 files changed, 43 insertions(+), 16 deletions(-) diff --git a/app/phone-ui/main-view-model.ts b/app/phone-ui/main-view-model.ts index 7a0768e4..2670134c 100644 --- a/app/phone-ui/main-view-model.ts +++ b/app/phone-ui/main-view-model.ts @@ -1001,8 +1001,15 @@ export class MainViewModel extends Observable { // Each pad therefore defers its double-click until the finger-up (the touch // handler) and converts the deferred pair into the G2 tap-then-hold gesture // when a longPress lands first. + // + // A hold is two events, like the hardware's: longPress sends the press + // (long-press-start, which the controller delivers as a plain long-press) + // and the finger-up sends the release, so a hold really holds (the + // Glanceboard stays up until the finger lifts). The firmware sends the + // same release after a tap-then-hold, so that pair gets one too. private ringPadDoubleTapPending = false; + private ringPadHeld = false; async onRingPadTap(): Promise { await dashboardController.injectSyntheticRingInput("click"); @@ -1013,8 +1020,9 @@ export class MainViewModel extends Observable { } async onRingPadLongPress(): Promise { - const kind = this.ringPadDoubleTapPending ? "short-then-long-press" : "long-press"; + const kind = this.ringPadDoubleTapPending ? "short-then-long-press" : "long-press-start"; this.ringPadDoubleTapPending = false; + this.ringPadHeld = true; await dashboardController.injectSyntheticRingInput(kind); } @@ -1022,6 +1030,11 @@ export class MainViewModel extends Observable { if (args.action !== "up" && args.action !== "cancel") return; const pending = this.ringPadDoubleTapPending; this.ringPadDoubleTapPending = false; + if (this.ringPadHeld) { + this.ringPadHeld = false; + await dashboardController.injectSyntheticRingInput("long-press-release"); + return; + } if (args.action === "up" && pending) { await dashboardController.injectSyntheticRingInput("double-click"); } @@ -1048,8 +1061,9 @@ export class MainViewModel extends Observable { private padTwoFingerDown = false; // See the ring pad above: defers the double-click so a longPress can turn - // the pair into tap-then-hold. + // the pair into tap-then-hold, and pairs every hold with a release. private padDoubleTapPending = false; + private padHeld = false; /** What the next gesture lands on, as the watch pad shows it. */ get padFocusLine(): string { @@ -1071,8 +1085,10 @@ export class MainViewModel extends Observable { } async onPadLongPress(): Promise { - const kind = this.padDoubleTapPending ? "short-then-long-press" : "long-press"; + if (this.padTwoFingerDown) return; + const kind = this.padDoubleTapPending ? "short-then-long-press" : "long-press-start"; this.padDoubleTapPending = false; + this.padHeld = true; await dashboardController.injectSyntheticRingInput(kind, "watch"); this.refreshPadFocusLine(); } @@ -1092,6 +1108,12 @@ export class MainViewModel extends Observable { if (args.action === "up" || args.action === "cancel") { const pendingDouble = this.padDoubleTapPending; this.padDoubleTapPending = false; + if (this.padHeld) { + this.padHeld = false; + await dashboardController.injectSyntheticRingInput("long-press-release", "watch"); + this.refreshPadFocusLine(); + return; + } const twoFinger = this.padTwoFingerDown; if (twoFinger) { // Let the single-tap recognizer's delayed tap see the flag first. diff --git a/wear/PROTOCOL.md b/wear/PROTOCOL.md index b67647b1..43215491 100644 --- a/wear/PROTOCOL.md +++ b/wear/PROTOCOL.md @@ -18,7 +18,7 @@ answered on `/faceclaw/ack`. | Path | Payload | Effect | | --- | --- | --- | -| `/faceclaw/input` | `{gesture, steps?}` | A ring gesture through the same path as the phone UI's test buttons. `gesture` ∈ `click`, `double-click`, `scroll-up`, `scroll-down`, `long-press` (complete short hold), `long-press-start`, `long-press-release`, `short-then-long-press` (tap then hold: the app's context menu; a plain `long-press` is the glasses' system menu), `wakeword` ("Hey Even"), `swipe-up`, `swipe-down`, `swipe-left`, `swipe-right` (spatial input only a watch can produce: delivered to the glasses UI as `swipe-*` events for components that navigate spatially — launcher grid, settings columns, sidebar, Music — with a scroll / click / double-click fallback elsewhere). `steps` (1–12) repeats a scroll. Refused while the glasses are disconnected. The lock screen is honoured exactly as for the ring. While the display is off, only a double-click is accepted and it wakes the display. | +| `/faceclaw/input` | `{gesture, steps?}` | A ring gesture through the same path as the phone UI's test buttons. `gesture` ∈ `click`, `double-click`, `scroll-up`, `scroll-down`, `long-press` (complete short hold), `long-press-start`, `long-press-release`, `short-then-long-press` (tap then hold: the app's context menu; a plain `long-press` is the glasses' system menu), `wakeword` ("Hey Even"), `swipe-up`, `swipe-down`, `swipe-left`, `swipe-right` (spatial input only a watch can produce: delivered to the glasses UI as `swipe-*` events for components that navigate spatially — launcher grid, settings columns, sidebar, Music — with a scroll / click / double-click fallback elsewhere). `steps` (1–12) repeats a scroll. Refused while the glasses are disconnected. The lock screen is honoured exactly as for the ring. While the display is off, a double-click wakes the display, a `click` shows the phone's Glanceboard for a few seconds, and `long-press-start`/`long-press-release` hold it up; everything else is ignored. | | `/faceclaw/command` | `{command, …}` | `launch-app {appId}`, `focus-window {windowId}`, `close-window {windowId}`, `sidebar`, `wake`, `sleep`, `lock`, `unlock`, `connect`, `disconnect`, `close-assistant`, `display-mode {value}` (`value` ∈ `576x288`, `576x480`, `640x480`; sets the phone's Display > Display mode). Everything but connect/disconnect needs a connection; everything but lock/unlock is refused while locked; `unlock` also needs the phone's "Watch can unlock glasses" setting. | | `/faceclaw/assistant` | `{text}` | Send a query to the assistant (`shell.sendToAssistant`) — the reply shows on the glasses and streams back to the watch as events. | | `/faceclaw/text` | `{text}` | Type text into the foreground window (`receiveTextInput`, e.g. the terminal). Refused when the window doesn't take text. | diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt index 41274bd9..98b88121 100644 --- a/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt +++ b/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt @@ -139,16 +139,13 @@ class MainActivity : ComponentActivity() { if (event.repeatCount == 0) { cancelStemHold() stemHoldSent = false - stemOneIgnored = glassesScreenIsOff() - if (stemOneIgnored) return true + // A dark display takes the stem too: a press shows the + // phone's Glanceboard, a hold keeps it up until release. + stemOneIgnored = false val runnable = Runnable { - if (glassesScreenIsOff()) { - stemOneIgnored = true - } else { - stemHoldSent = true - haptics.heavy() - link.sendGesture(Gesture.LONG_PRESS_START) - } + stemHoldSent = true + haptics.heavy() + link.sendGesture(Gesture.LONG_PRESS_START) } stemHoldRunnable = runnable stemHandler.postDelayed(runnable, STEM_HOLD_MS) @@ -184,7 +181,7 @@ class MainActivity : ComponentActivity() { stemHoldSent = false haptics.click() link.sendGesture(Gesture.LONG_PRESS_RELEASE) - } else if (!glassesScreenIsOff()) { + } else { haptics.click() link.sendGesture(Gesture.CLICK) } diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt index 471fd45c..3f637f5f 100644 --- a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt +++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt @@ -143,8 +143,16 @@ fun RemoteScreen( fun glassesScreenIsOff(): Boolean = currentState?.connected == true && currentState?.screenOn == false + // A dark display still takes a double-click (wake), and a tap or a hold + // (the phone's Glanceboard: a tap shows it for a few seconds, a hold + // until released). Scrolls, swipes and the menu gesture mean nothing + // there, so they are dropped here without a buzz. fun gestureAllowed(gesture: Gesture): Boolean = - !glassesScreenIsOff() || gesture == Gesture.DOUBLE_CLICK + !glassesScreenIsOff() || + gesture == Gesture.DOUBLE_CLICK || + gesture == Gesture.CLICK || + gesture == Gesture.LONG_PRESS_START || + gesture == Gesture.LONG_PRESS_RELEASE fun scroll(gesture: Gesture, steps: Int) { if (!gestureAllowed(gesture)) return @@ -186,7 +194,7 @@ fun RemoteScreen( } }, onLongPressStart = { - longPressSent = !glassesScreenIsOff() + longPressSent = gestureAllowed(Gesture.LONG_PRESS_START) if (longPressSent) { haptics.heavy() link.sendGesture(Gesture.LONG_PRESS_START)