<details>

<summary>Prompts Used</summary>
Act as a code reviewer for https://github.com/jimrandomh/faceclaw/pull/14 (checked out in this working directory).

> * The review finished — 42 raw candidates were verified down to 10 confirmed findings. Reporting them now.
>
> * Code review(review · 10 findings)
>   ⎿  app/phone-ui/main-view-model.ts
>        ●  766 [correctness]   mirrorFraction subtracts view.getLocationOnScreen() from tap coordinates that NativeScript already delivers
>                               view-local, so every phone-mirror tap is shifted up/left and misroutes
>        ●   84 [resource-leak] MainViewModel's constructor registers onAnySettingChanged and discards the unsubscriber; a new view model is
>                               built on every page navigation, leaking listeners and retained preview bitmaps
>      wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt
>        ●   52 [correctness]   onStop abandons an in-progress stem-button hold without sending LONG_PRESS_RELEASE, so the glasses shell
>                               escape menu opens by itself
>      wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt
>        ●   62 [correctness]   Breaking out of the touchpad gesture loop on a consumed pointer event (or coroutine cancellation mid-hold)
>                               skips onLongPressEnd, leaving a stuck long-press
>      wear/app/src/main/kotlin/com/faceclaw/wear/PhoneLink.kt
>        ●  270 [correctness]   loadStateItem queries the Data Layer with a hostless Uri (`wear:/faceclaw/state`), which matches no stored
>                               items, so the cached phone state is never read
>      app/ui/shell/modal-layer.ts
>        ●   14 [correctness]   MODAL_INTERIOR is a module-level constant frozen at import time from the (now runtime-dynamic) display mode,
>                               while modalRect() is computed live, so modals render corrupted after a display-mode switch
>      app/g2/dashboard-controller.ts
>        ● 1404 [correctness]   handleMirrorTouch wakes the glasses display unconditionally, bypassing the watchWakesDisplaySetting gate
>                               that the parallel injectSyntheticRingInput path honors
>        ● 1440 [correctness]   A mirror tap while any second layer is stacked (e.g. an in-window long-press menu) degrades to a blind
>                               synthetic click that activates whatever is highlighted, not what was tapped
>      App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawWearBridge.java
>        ●  147 [correctness]   Watch gestures/commands queued while the JS listener is down are replayed up to 30 seconds later on listener
>                               registration, executing stale non-idempotent input the watch already reported as failed
>      wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt
>        ●  232 [efficiency]    WristTwistDetector (gyroscope, default-on) samples at 100 Hz via DisposableEffect and is not stopped when
>                               the activity stops, draining the watch battery while the process is cached
>
> * Review of PR #14 (Wear OS companion app + remote controls, 85 files, +5813/−102) is done — 10 confirmed findings reported above, ranked by
>   severity. The headline items are the phone-mirror tap coordinate double-correction (which misroutes every mirror tap in the default
>   configuration) and two independent paths on the watch that can drop LONG_PRESS_RELEASE, each of which makes the shell escape menu open on the
>   glasses by itself.
>
> A few things beyond the reported list, for context:
>
> Refuted during verification (looked like bugs, aren't): the watch ack-timeout-during-render theory (input injection never blocks on BLE
> transmit), mirror swipes stealing page scroll (no enclosing ScrollView), and a suspected raw-settings-key notification gap (the store-level
> broadcast covers raw keys).
>
> Confirmed but below the 10-finding cap — worth folding in if you're touching those areas anyway:
> - shell.closeAssistant() no-ops via popIfTop when another layer sits above the assistant, yet still acks ok to the watch.
> - Landscape preview sizing still assumes the old 260-wide panel after the XML moved to 360 (overlap under ~568 dip).
> - The shell escape menu and tool-debug dialogs hardcode SIDEBAR_WIDTH + 8, wrong in the new full-panel mode.
> - A CapabilityClient IPC fires every 250 ms during streamed assistant replies even on watchless phones; backgrounded preview updates bypass
>   their 150 ms floor.
> - Cleanups: the sidebarWidth() > 0 || focus === "sidebar" predicate appears three times, sidebar slot math is duplicated in chrome-layer.ts,
>   dead protocol-version plumbing, dead padPointers field, and display-mode is missing from wear/PROTOCOL.md.
>
> If you'd like, I can apply fixes for any subset of these, or post the findings as inline PR comments (/code-review 14 --comment).

<hr>

Thanks, let's go ahead and write fixes for all of the issues you described.

> Everything builds and tests pass. All 16 issues from the review are fixed — the 10 reported findings plus the six below-cap items. Here's what changed, by fix:
>
> **Watch app (Kotlin)**
> - **Stuck long-press via onStop** — `MainActivity.onStop` now sends `LONG_PRESS_RELEASE` when a stem hold is in progress before dropping the link, so the phone's escape-menu countdown can't run to completion on its own.
> - **Stuck long-press via the gesture loop** — `detectTouchpadGestures` wraps the loop in try/finally that pairs every `onLongPressStart` with an `onLongPressEnd`, covering both the consumed-event `break` and coroutine cancellation mid-hold.
> - **Cached state never loading** — `PhoneLink.loadStateItem` now queries `wear://*/faceclaw/state` (wildcard host) instead of a hostless Uri that matched nothing, so the watch shows the cached dashboard state when the phone is unreachable.
> - **Sensors draining battery while stopped** — the gyroscope/accelerometer/off-body detectors are now driven by a `WhileStartedEffect` helper tied to the activity lifecycle: they stop on `ON_STOP` (palmed screen, back to watch face) and restart on `ON_START`, instead of running at 100 Hz for as long as the process is cached.
> - **Dead protocol plumbing** — removed the unused `Protocol.PROTOCOL_VERSION` const and the never-read `PhoneState.protocol` field; the wire field stays and PROTOCOL.md now documents it as reserved.
>
> **Phone Java**
> - **Stale input replay** — `FaceclawWearBridge` now queues only idempotent `/faceclaw/state/request` messages for replay after the JS listener registers; gestures and commands that arrived while the dashboard was down are acked as failed and dropped, never executed up to 30 seconds later.
>
> **Phone TypeScript**
> - **Mirror taps misrouting (the top finding)** — `mirrorFraction` no longer subtracts `getLocationOnScreen()`; NativeScript's `getX`/`getY` are view-local DIPs (I verified this in the installed `@nativescript/core` gesture source), so every mirror tap was being shifted up-left by the status bar + action bar. Taps now land where you touch.
> - **Mirror touch ignoring the wake setting** — `handleMirrorTouch` now honours `watchWakesDisplaySetting`: with it off, only a double-tap reaches a dark display, matching the rest of the watch scheme.
> - **Blind click through open menus** — `LayerStack.hitTest` now consumes a mirror tap when any layer is stacked (menu, dialog) instead of reporting a miss, so a tap on visible app content can no longer activate whatever menu row happened to be highlighted (e.g. "Close window").
> - **Modal corruption after display-mode switch** — `MODAL_INTERIOR` is now a live `modalInterior()` function, and `ShellModalLayer.paint` re-syncs the inner stack's size each paint, so notification modals render correctly after switching Band ↔ Full panel.
> - **View-model leak** — `MainViewModel` keeps its controller/settings unsubscribers and exposes `attach()`/`dispose()`; `main-page.ts` disposes on unload and re-attaches on load (re-attach is needed because suspend/resume fires unloaded/loaded without a navigation, and `subscribe` delivers a fresh snapshot so nothing is missed).
> - **`closeAssistant` no-op** — new `LayerStack.popThrough` closes the assistant overlay plus anything stacked above it (follow-up voice dialog, alert); the watch ack now says "The assistant was not open." when there was nothing to close.
> - **Watchless-phone IPC churn** — assistant stream events and alerts are skipped when no watch is reachable, so a streaming reply no longer triggers a CapabilityClient lookup every 250 ms.
> - **Backgrounded preview floor bypass** — the 150 ms floor check (and timestamp) in `updateCompositePreview` now runs before the foreground-activity check, so backgrounded per-frame refreshes actually throttle.
> - **Full-panel hardcodes** — the shell escape menu and tool-debug dialogs position at `sidebarWidth() + 8` (0 in full-panel mode) instead of the fixed 64 px strip.
> - **Cleanups** — the strip-visible predicate is now one `sidebarStripVisible()` helper in geometry.ts (used in three places); sidebar slot math is a single `slotPosition()` shared by drawing and hit-testing; dead `padPointers` removed; landscape preview sizing updated to the XML's 360 dp panel; `wear/PROTOCOL.md` documents the `display-mode` command and `displayMode` state field.
>
> Verification: `./build.sh` (webpack + Gradle) succeeds, `npx tsc --noEmit` is clean, the wear `:app:assembleDebug` builds, and all 59 tests pass. The behavioral fixes — especially mirror-tap coordinates, the two long-press-release paths, and the watch state cache — still need a hardware pass to confirm on device.
</details>
This commit is contained in:
James Babcock committed 2026-08-25 00:09:47 -07:00
1 parent 646335cb64
commit eef7aa2679
17 files changed
+306 -158

No files matched your search

@@ -35,9 +35,11 @@ import java.util.Set;
* {@link #handleMessage}; it is forwarded to the JS listener on the thread
* that registered it (the main isolate), mirroring FaceclawSettings. Messages
* that arrive before a listener exists (the watch poked a phone whose JS
* dashboard is not up yet) are kept for a short while and replayed on
* registration; the watch is told with an ack carrying jsReady=false so it
* can say "open Faceclaw on your phone".
* dashboard is not up yet) are acked with jsReady=false so the watch can say
* "open Faceclaw on your phone"; only idempotent state requests are kept for
* replay on registration — the watch already reported gestures and commands
* as failed, and executing them tens of seconds later would act on whatever
* the glasses happen to show by then.
*
* Outbound: {@link #publishState} mirrors the dashboard state into a Data
* Layer item (delivered even if the watch is out of range right now, and
@@ -283,17 +285,20 @@ public final class FaceclawWearBridge {
boolean delivered = dispatchMessage(path, json, nodeId);
if (delivered) return;
// No JS listener yet: keep the message briefly, and tell the watch so
// it can explain why nothing is happening.
synchronized (lock) {
long now = System.currentTimeMillis();
while (!pending.isEmpty() && now - pending.peekFirst().receivedAt > PENDING_MAX_AGE_MS) {
pending.pollFirst();
// No JS listener yet: tell the watch so it can explain why nothing is
// happening. Only state requests are kept for replay (see class doc);
// everything else is dropped after the failure ack.
if (PATH_STATE_REQUEST.equals(path)) {
synchronized (lock) {
long now = System.currentTimeMillis();
while (!pending.isEmpty() && now - pending.peekFirst().receivedAt > PENDING_MAX_AGE_MS) {
pending.pollFirst();
}
if (pending.size() >= PENDING_LIMIT) {
pending.pollFirst();
}
pending.addLast(new PendingMessage(path, json, nodeId, now));
}
if (pending.size() >= PENDING_LIMIT) {
pending.pollFirst();
}
pending.addLast(new PendingMessage(path, json, nodeId, now));
}
sendAck(nodeId, readSeq(json), false, false, "Faceclaw is not running on the phone. Open it to connect the glasses.");
}
+21 -10
View File
@@ -56,7 +56,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, SIDEBAR_WIDTH, sidebarWidth, type WindowHeightMode } from "../ui/shell/geometry";
import { appViewportRect, SIDEBAR_WIDTH, sidebarStripVisible, type WindowHeightMode } from "../ui/shell/geometry";
import { type LayerActions } from "../ui/layers";
import { assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, brightnessSetting, brightnessSettingToLevel, displayModeSetting, watchWakesDisplaySetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, verticalPositionSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings";
import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization";
@@ -1449,6 +1449,13 @@ class DashboardController {
return;
}
if (!shell.isScreenOn()) {
// The same wake policy as the rest of the watch scheme: honour the
// "input wakes display" setting; with it off, only a double-tap (a
// normal double-click) reaches the dark display.
if (!watchWakesDisplaySetting.get()) {
if (kind === "double-tap") await this.injectSyntheticRingInput("double-click", "watch");
return;
}
shell.wake(shell.getFocus());
this.requestShellRender();
}
@@ -1458,7 +1465,7 @@ class DashboardController {
}
const x = Math.round(Math.min(1, Math.max(0, nx)) * G2_LENS_WIDTH);
const y = Math.round(Math.min(1, Math.max(0, ny)) * G2_LENS_HEIGHT);
const stripShown = sidebarWidth() > 0 || shell.getFocus() === "sidebar";
const stripShown = sidebarStripVisible(shell.getFocus());
this.appendLog(`mirror tap at ${x},${y}`);
if (!shell.hasOverlay() && stripShown && x < SIDEBAR_WIDTH) {
const target = shell.windowAtSidebarPoint(x, y);
@@ -2163,6 +2170,18 @@ class DashboardController {
private updateCompositePreview(): void {
if (!this.communicator) return;
// The floor comes first (and stamps even when backgrounded below): with
// it after the background check, per-frame refresh requests from a
// backgrounded app never advance the timestamp and every one of them
// pays the foreground-activity lookup.
const now = Date.now();
if (
this.lastConnectedPreviewUpdateAtMs > 0 &&
now - this.lastConnectedPreviewUpdateAtMs < CONNECTED_PREVIEW_MIN_UPDATE_MS
) {
return;
}
this.lastConnectedPreviewUpdateAtMs = now;
// The connected foreground service intentionally keeps this controller
// alive after the phone UI is backgrounded. Do not keep constructing
// 640x480 Android Bitmaps for a window that cannot display them: besides
@@ -2172,14 +2191,6 @@ class DashboardController {
const activity = Application.android.foregroundActivity;
if (!activity || !activity.hasWindowFocus()) return;
}
const now = Date.now();
if (
this.lastConnectedPreviewUpdateAtMs > 0 &&
now - this.lastConnectedPreviewUpdateAtMs < CONNECTED_PREVIEW_MIN_UPDATE_MS
) {
return;
}
this.lastConnectedPreviewUpdateAtMs = now;
if (this.screenRecordingActive && now - this.lastRecordCaptureAtMs >= RECORDING_MIN_CAPTURE_MS) {
this.lastRecordCaptureAtMs = now;
this.communicator.recordScreenFrame();
+8 -3
View File
@@ -141,7 +141,7 @@ export class WearRemote {
});
shell.onAssistantActivity((event) => this.forwardAssistantActivity(event));
shell.onAlertShown((text) => {
if (watchMirrorAssistantSetting.get()) {
if (this.watchReachable && watchMirrorAssistantSetting.get()) {
wearBridge.sendEvent({ type: "alert", text });
}
});
@@ -425,8 +425,9 @@ export class WearRemote {
ack(true);
return;
case "close-assistant":
shell.closeAssistant();
ack(true);
// Idempotent: closing an assistant that isn't open still succeeds,
// but tell the watch which of the two happened.
ack(true, shell.closeAssistant() ? "" : "The assistant was not open.");
return;
case "display-mode": {
const value = String(payload.value ?? "");
@@ -446,6 +447,10 @@ export class WearRemote {
private forwardAssistantActivity(event: AssistantActivityEvent): void {
if (!watchMirrorAssistantSetting.get()) return;
// No watch to mirror to: sending anyway is not free — with no known
// watch nodes the Java side runs a capability lookup per event, which a
// streaming reply would repeat several times a second.
if (!this.watchReachable) return;
if (event.phase === "streaming") {
// Coalesce: the newest text wins, sent no more often than the interval.
this.assistantPendingText = event.text;
+6
View File
@@ -33,6 +33,9 @@ function cleanupPage(page: Page): void {
}
state.model.off(Observable.propertyChangeEvent, state.propertyChangeHandler)
Application.off(Application.orientationChangedEvent, state.orientationHandler)
// navigatingTo builds a fresh model each visit; drop the old one's
// controller/settings subscriptions or every navigation leaks a listener.
state.model.dispose()
setPageState(page, undefined)
}
@@ -77,6 +80,9 @@ export function loaded(args: EventData) {
dashboardController.refreshEvenAppStatus()
const model = page.bindingContext as MainViewModel | null
// Re-subscribe after a suspend/resume cycle (unloaded disposed the model);
// a no-op on the first load after construction.
model?.attach()
// Automatically connect on reaching the main page (no-op if already
// connected or if no glasses are configured).
void model?.autoConnect()
+31 -13
View File
@@ -54,9 +54,25 @@ export class MainViewModel extends Observable {
private _batteryOptimizationWarningVisible = false;
private _phase: "disconnected" | "connecting" | "connected" | "charging" | "disconnecting" = "disconnected";
// A new view model is built on every navigation to the main page; these
// module-level subscriptions must die with it (see dispose) or each
// round-trip to another page leaks a listener that pins the dead model.
private readonly unsubscribers: Array<() => void> = [];
constructor() {
super();
dashboardController.subscribe((snapshot) => {
this.attach();
}
/**
* Subscribe to the controller and settings. Idempotent; the page calls it
* again from `loaded` because an app suspend fires unloaded/loaded (which
* dispose the model) without a navigation building a fresh one. Subscribing
* delivers the current snapshot, so a re-attached model catches up.
*/
attach(): void {
if (this.unsubscribers.length > 0) return;
this.unsubscribers.push(dashboardController.subscribe((snapshot) => {
this.status = snapshot.status;
this.displayPreview = snapshot.displayPreview;
this.displayPreviewMessage = snapshot.displayPreviewMessage;
@@ -77,9 +93,16 @@ export class MainViewModel extends Observable {
this.screenRecordingActive = snapshot.screenRecordingActive;
this.batteryOptimizationWarningVisible = snapshot.batteryOptimizationWarningVisible;
this.refreshPadFocusLine();
});
}));
// Brightness / display mode can change from the glasses' Settings app too.
onAnySettingChanged(() => this.refreshDisplayControls());
this.unsubscribers.push(onAnySettingChanged(() => this.refreshDisplayControls()));
}
/** Detach from the controller and settings; the page calls this when it lets go of the model. */
dispose(): void {
for (const unsubscribe of this.unsubscribers.splice(0)) {
unsubscribe();
}
}
get status(): string {
@@ -148,7 +171,8 @@ export class MainViewModel extends Observable {
// aspect; the width is derived from it, so a wider lens aspect can't
// grow the preview past the side panel.
const screenWidth = Screen.mainScreen.widthDIPs;
const sidePanelWidth = 260;
// Must match the landscape grid's fixed side-panel column in main-page.xml.
const sidePanelWidth = 360;
const availableWidth = Math.max(240, Math.floor(screenWidth - sidePanelWidth - 56));
return Math.floor(availableWidth / 2);
}
@@ -624,7 +648,6 @@ export class MainViewModel extends Observable {
// tap = select, double-tap / two fingers = back, hold = menu. The ring row
// above stays on the ring's own scheme.
private padPointers = 0;
private padTwoFingerDown = false;
/** What the next gesture lands on, as the watch pad shows it. */
@@ -664,13 +687,11 @@ export class MainViewModel extends Observable {
async onPadTouch(args: TouchGestureEventData): Promise<void> {
const count = args.getPointerCount();
if (args.action === "down" || args.action === "move") {
this.padPointers = Math.max(this.padPointers, count);
if (count >= 2) this.padTwoFingerDown = true;
return;
}
if (args.action === "up" || args.action === "cancel") {
const twoFinger = this.padTwoFingerDown;
this.padPointers = 0;
if (twoFinger) {
// Let the single-tap recognizer's delayed tap see the flag first.
setTimeout(() => {
@@ -735,12 +756,9 @@ export class MainViewModel extends Observable {
const view = args.object as View | undefined;
const size = view?.getActualSize?.();
if (!view || !size || !size.width || !size.height || !args.getX || !args.getY) return null;
// On Android the gesture's getX/getY are screen-absolute (in DIPs), not
// view-local; the view's own screen position makes them local.
const origin = view.getLocationOnScreen?.() ?? { x: 0, y: 0 };
const localX = args.getX() - origin.x;
const localY = args.getY() - origin.y;
return { nx: localX / size.width, ny: localY / size.height };
// NativeScript's gesture getX/getY are view-local DIPs (the view's own
// MotionEvent coordinates), so they divide straight into the view's size.
return { nx: args.getX() / size.width, ny: args.getY() / size.height };
}
private async mirrorGesture(kind: MirrorTouchKind, args: GestureEventData): Promise<void> {
+23 -2
View File
@@ -238,6 +238,21 @@ export class LayerStack {
}
}
/**
* Pop layers down to and including the given one, wherever it sits in the
* stack (e.g. dismissing the assistant while a follow-up voice dialog is
* open above it). Returns false if the layer isn't stacked (the base layer
* can never be popped). Removal callbacks fire top-down.
*/
popThrough(layer: Layer): boolean {
const index = this.layers.indexOf(layer);
if (index <= 0) return false;
for (const removed of this.layers.splice(index).reverse()) {
notifyRemoved(removed);
}
return true;
}
isAtBase(): boolean {
return this.layers.length === 1;
}
@@ -271,9 +286,15 @@ export class LayerStack {
await top.handleInput(delivered, this.ctx);
}
/** Pass a mirror touch to the base layer when nothing is stacked on it. */
/**
* Pass a mirror touch to the base layer when nothing is stacked on it.
* With a layer stacked (a menu, a dialog) the touch is consumed without
* acting: positions mean nothing to the overlay, and falling back to a
* blind synthetic click would activate whatever happens to be highlighted
* rather than what was tapped.
*/
async hitTest(x: number, y: number): Promise<boolean> {
if (this.layers.length !== 1) return false;
if (this.layers.length !== 1) return true;
const base = this.layers[0]!;
if (!base.hitTest) return false;
return await base.hitTest(x, y, this.ctx);
+28 -22
View File
@@ -13,7 +13,7 @@ import {
minWindowTop,
SHELL_OPAQUE_BLACK,
SIDEBAR_WIDTH,
sidebarWidth,
sidebarStripVisible,
TOP_BAR_HEIGHT,
windowTop,
type WindowHeightMode,
@@ -51,6 +51,25 @@ function columnLeft(variant: SidebarVariant, column: number): number {
return SIDEBAR_WIDTH - (variant.columns - column) * variant.columnWidth;
}
/**
* Column and top y of a visible sidebar slot; `position` counts from the
* first visible (scrolled-to) icon. Slots fill the rightmost column top to
* bottom, then overflow leftward. The single source of slot geometry for
* both drawing and hit testing.
*/
function slotPosition(variant: SidebarVariant, listTop: number, position: number): { column: number; y: number } {
const rows = rowsPerColumn(variant);
return {
column: variant.columns - 1 - ((position / rows) | 0),
y: listTop + (position % rows) * (variant.iconSize + ICON_SPACING),
};
}
/** Top y of the sidebar's icon list (below the band's top bar). */
function sidebarListTop(): number {
return minWindowTop() + TOP_BAR_HEIGHT + LIST_MARGIN;
}
/**
* Left edge of the sidebar region that actually holds icons: the one-column
* variant leaves a dead strip left of its single right-aligned column.
@@ -169,7 +188,7 @@ export class ShellChromeLayer implements Layer {
const state = this.getState();
// Full-panel mode: the strip is an overlay, present only while the user
// is in it (the window underneath keeps its full width the rest of the time).
if (sidebarWidth() > 0 || state.focus === "sidebar") {
if (sidebarStripVisible(state.focus)) {
this.drawSidebar(image, state);
}
this.drawTopBar(image, state);
@@ -189,14 +208,10 @@ export class ShellChromeLayer implements Layer {
windowIndexAt(x: number, y: number, windowCount: number): number | null {
if (x < 0 || x >= SIDEBAR_WIDTH || windowCount === 0) return null;
const variant = sidebarVariant(windowCount);
const rows = rowsPerColumn(variant);
const listTop = minWindowTop() + TOP_BAR_HEIGHT + LIST_MARGIN;
const itemStride = variant.iconSize + ICON_SPACING;
const lastVisible = Math.min(windowCount, this.scrollRow + rows * variant.columns);
const listTop = sidebarListTop();
const lastVisible = Math.min(windowCount, this.scrollRow + rowsPerColumn(variant) * variant.columns);
for (let index = this.scrollRow; index < lastVisible; index++) {
const position = index - this.scrollRow;
const column = variant.columns - 1 - ((position / rows) | 0);
const slotY = listTop + (position % rows) * itemStride;
const { column, y: slotY } = slotPosition(variant, listTop, index - this.scrollRow);
const left = columnLeft(variant, column);
if (x >= left && x < left + variant.columnWidth && y >= slotY - 2 && y < slotY + variant.iconSize + 2) {
return index;
@@ -223,20 +238,11 @@ export class ShellChromeLayer implements Layer {
const iconMarginX = ((variant.columnWidth - iconSize) / 2) | 0;
// Column index of the rightmost column (the one that fills first).
const firstColumn = variant.columns - 1;
const listTop = bandTop + TOP_BAR_HEIGHT + LIST_MARGIN;
const itemStride = iconSize + ICON_SPACING;
const rows = rowsPerColumn(variant);
const visibleCount = rows * variant.columns;
const listTop = sidebarListTop();
const visibleCount = rowsPerColumn(variant) * variant.columns;
this.scrollRow = scrollToKeepSelectionVisible(this.scrollRow, state.selectedIndex, visibleCount, count);
const lastVisible = Math.min(count, this.scrollRow + visibleCount);
const slotOf = (index: number) => {
const position = index - this.scrollRow;
const columnsFromRight = (position / rows) | 0;
return {
column: firstColumn - columnsFromRight,
y: listTop + (position % rows) * itemStride,
};
};
const slotOf = (index: number) => slotPosition(variant, listTop, index - this.scrollRow);
// The selection is a "diversion" of the sidebar/main separator line: the
// line bulges right around the selected icon (rounded on the left, open
@@ -297,7 +303,7 @@ export class ShellChromeLayer implements Layer {
const barTop = windowTop(state.foregroundHeightMode);
// The bar spans the app viewport; with the sidebar overlaid (full-panel
// mode, sidebar focused) it still starts past the strip.
const barLeft = sidebarWidth() > 0 || state.focus === "sidebar" ? SIDEBAR_WIDTH : 0;
const barLeft = sidebarStripVisible(state.focus) ? SIDEBAR_WIDTH : 0;
image.fillRect(barLeft, barTop, G2_LENS_WIDTH - barLeft, TOP_BAR_HEIGHT, SHELL_OPAQUE_BLACK);
image.drawLine(barLeft, barTop + TOP_BAR_HEIGHT - 1, G2_LENS_WIDTH - 1, barTop + TOP_BAR_HEIGHT - 1, BORDER_VALUE);
+8
View File
@@ -26,6 +26,14 @@ export function sidebarWidth(): number {
return displayMode() === "640x480" ? 0 : SIDEBAR_WIDTH;
}
/**
* Whether the sidebar strip is on screen: always when it reserves width; in
* the full-panel mode (where it overlays the window) only while it has focus.
*/
export function sidebarStripVisible(focus: "sidebar" | "window"): boolean {
return sidebarWidth() > 0 || focus === "sidebar";
}
/**
* The height an app's requested mode actually gets: the band mode honours
* it, the taller modes give every window the whole screen.
+19 -14
View File
@@ -4,16 +4,20 @@ import { DashboardInputEvent, Layer, LayerActions, LayerContext, LayerStack, Pai
import { appViewportRect, appViewportSize, SHELL_OPAQUE_BLACK } from "./geometry";
// The modal covers most of the min-height app viewport, leaving a little of
// the foreground app visible around the edges. Its size is fixed (min-height
// windows have a fixed viewport size); its position follows the vertical
// position setting, so it is computed per paint.
// the foreground app visible around the edges. Both its size and position are
// computed per paint: the display-mode setting changes the viewport size at
// runtime, and the vertical position setting moves the band.
const MODAL_MARGIN = 14;
const MODAL_PADDING = 4;
export const MODAL_INTERIOR = {
width: appViewportSize("min").width - 2 * MODAL_MARGIN - 2 * MODAL_PADDING,
height: appViewportSize("min").height - 2 * MODAL_MARGIN - 2 * MODAL_PADDING,
} as const;
/** Content (inner layer stack) size of the modal box. */
function modalInterior(): { width: number; height: number } {
const viewport = appViewportSize("min");
return {
width: viewport.width - 2 * MODAL_MARGIN - 2 * MODAL_PADDING,
height: viewport.height - 2 * MODAL_MARGIN - 2 * MODAL_PADDING,
};
}
/** Screen rect of the modal box, aligned to the min-height window band. */
export function modalRect(): { x: number; y: number; width: number; height: number } {
@@ -36,17 +40,18 @@ export class ShellModalLayer implements Layer {
private readonly stack: LayerStack;
constructor(baseLayer: Layer, actions: LayerActions) {
this.stack = new LayerStack(baseLayer, actions, {
width: MODAL_INTERIOR.width,
height: MODAL_INTERIOR.height,
});
this.stack = new LayerStack(baseLayer, actions, modalInterior());
}
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
paint(_ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
const image = paintBelow();
// Track a display-mode switch while the modal is up, so the inner stack
// paints at the same size the box below is drawn with.
const interior = modalInterior();
this.stack.setBaseSize(interior);
// Flattening bakes the inner stack's planes (glyphs included) so the blit
// below transplants the finished modal content into this layer's plane.
const inner = flattenPlanes(this.stack.paint(), MODAL_INTERIOR);
const inner = flattenPlanes(this.stack.paint(), interior);
const rect = modalRect();
image.fillRoundedRect(rect.x, rect.y, rect.width, rect.height, SHELL_OPAQUE_BLACK, 8);
image.drawRoundedRect(rect.x, rect.y, rect.width, rect.height, 110, 8);
@@ -54,7 +59,7 @@ export class ShellModalLayer implements Layer {
return image;
}
async handleInput(event: DashboardInputEvent, ctx: LayerContext): Promise<void> {
async handleInput(event: DashboardInputEvent, _ctx: LayerContext): Promise<void> {
await this.stack.handleInput(event);
}
}
+16 -9
View File
@@ -43,7 +43,7 @@ import { ToolDebugMenuLayer } from "./tool-debug-layer";
import { toolRegistry } from "../../assistant/tool-registry";
import {
minWindowTop,
SIDEBAR_WIDTH,
sidebarWidth,
TOP_BAR_HEIGHT,
windowBandHeight,
windowTop,
@@ -157,9 +157,10 @@ const LONG_PRESS_ESCAPE_MENU_MS = 4000;
class ShellOverlayMenuLayer extends MenuLayer {
constructor(items: MenuItem[], private readonly onClosed: () => void) {
// Aligned to the min-height window band (like the sidebar), wherever the
// vertical position setting currently puts it.
// vertical position setting currently puts it; past the sidebar strip
// where one reserves width (none in the full-panel mode).
super(null, items, {
x: SIDEBAR_WIDTH + 8,
x: sidebarWidth() + 8,
y: minWindowTop() + TOP_BAR_HEIGHT + 8,
width: 272,
minHeight: 0,
@@ -858,9 +859,12 @@ class Shell {
}
}
/** Dismiss the assistant overlay (cancelling any in-flight turn), as Done would. */
closeAssistant(): void {
this.closeAssistantLayer();
/**
* Dismiss the assistant overlay (cancelling any in-flight turn), as Done
* would. Returns whether an overlay was actually open to close.
*/
closeAssistant(): boolean {
return this.closeAssistantLayer();
}
private ensureAssistantSession(): AssistantSession | null {
@@ -998,13 +1002,16 @@ class Shell {
this.config.requestShellRender();
}
private closeAssistantLayer(): void {
private closeAssistantLayer(): boolean {
// Popping fires the layer's onRemoved, which cancels the turn and clears
// this.assistantLayer.
// this.assistantLayer. popThrough also closes anything stacked above the
// overlay (a follow-up voice dialog, an alert), so a close command works
// no matter what the conversation is showing.
const layer = this.assistantLayer;
if (layer) this.stack.popIfTop((top) => top === layer);
const closed = layer ? this.stack.popThrough(layer) : false;
this.noteUserActivity();
this.config.requestShellRender();
return closed;
}
/** Show a brief text popup on the lenses (assistant show_alert / notices). */
+18 -9
View File
@@ -5,7 +5,7 @@ import { clamp } from "../../util/numeric-util";
import type { ToolDebugEntry } from "../../assistant/tool-registry";
import { DashboardInputEvent, Layer, LayerContext, PaintBelow } from "../layers";
import { MenuLayer, drawListScrollbar, type MenuItem } from "../menu";
import { MIN_WINDOW_HEIGHT, minWindowTop, SIDEBAR_WIDTH, TOP_BAR_HEIGHT } from "./geometry";
import { MIN_WINDOW_HEIGHT, minWindowTop, sidebarWidth, TOP_BAR_HEIGHT } from "./geometry";
import { lineStep } from "../metrics";
/**
@@ -15,13 +15,20 @@ import { lineStep } from "../metrics";
* page with its full name, gating state, and description.
*/
const DIALOG_X = SIDEBAR_WIDTH + 8;
const DIALOG_WIDTH = 420;
const DETAIL_WIDTH = G2_LENS_WIDTH - DIALOG_X - 8;
// Shell overlays align to the min-height window band; the detail box fills
// the band below the top bar with an 8px margin on each side.
const DETAIL_HEIGHT = MIN_WINDOW_HEIGHT - TOP_BAR_HEIGHT - 16;
/** Dialog left edge: past the sidebar strip where one reserves width. */
function dialogX(): number {
return sidebarWidth() + 8;
}
function detailWidth(): number {
return G2_LENS_WIDTH - dialogX() - 8;
}
/** Dialog top edge, aligned to the min-height band's content area. */
function dialogY(): number {
return minWindowTop() + TOP_BAR_HEIGHT + 8;
@@ -31,7 +38,7 @@ const DETAIL_PADDING = 14;
export class ToolDebugMenuLayer extends MenuLayer {
constructor(appId: string | null, entries: ToolDebugEntry[], private readonly onClosed: () => void) {
super(appId ? `Assistant tools: ${appId}` : "Assistant tools", buildItems(appId, entries), {
x: DIALOG_X,
x: dialogX(),
y: dialogY(),
width: DIALOG_WIDTH,
minHeight: 0,
@@ -78,12 +85,14 @@ class ToolDetailLayer implements Layer {
paint(_ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
const image = paintBelow();
const font = getDefaultSmallFont();
const left = dialogX();
const width = detailWidth();
const top = dialogY();
image.fillRoundedRect(DIALOG_X, top, DETAIL_WIDTH, DETAIL_HEIGHT, 1, 10);
image.drawRoundedRect(DIALOG_X, top, DETAIL_WIDTH, DETAIL_HEIGHT, 72, 10);
image.fillRoundedRect(left, top, width, DETAIL_HEIGHT, 1, 10);
image.drawRoundedRect(left, top, width, DETAIL_HEIGHT, 72, 10);
const textX = DIALOG_X + DETAIL_PADDING;
const textWidth = DETAIL_WIDTH - 2 * DETAIL_PADDING - 8;
const textX = left + DETAIL_PADDING;
const textWidth = width - 2 * DETAIL_PADDING - 8;
const lines = this.buildLines(textWidth);
const detailLineH = lineStep(font);
const visibleRowCount = Math.max(1, ((DETAIL_HEIGHT - 2 * DETAIL_PADDING) / detailLineH) | 0);
@@ -98,7 +107,7 @@ class ToolDetailLayer implements Layer {
if (lines.length > visibleRowCount) {
drawListScrollbar(
image,
DIALOG_X + DETAIL_WIDTH - 7,
left + width - 7,
top + DETAIL_PADDING,
DETAIL_HEIGHT - 2 * DETAIL_PADDING,
this.scrollRow,
+6 -1
View File
@@ -19,7 +19,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`, `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 (only a double-click reaches it, toggling the locked display). |
| `/faceclaw/command` | `{command, …}` | `launch-app {appId}`, `focus-window {windowId}`, `close-window {windowId}`, `sidebar`, `wake`, `sleep`, `lock`, `unlock`, `connect`, `disconnect`, `close-assistant`. 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/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. |
| `/faceclaw/state/request` | `{}` | Re-publish the state item even if unchanged. |
@@ -53,10 +53,15 @@ dashboard state, re-sent whenever it changes (and at least every 30 s):
"foreground": {"appId": "music", "title": "Music"},
"windows": [{"windowId": "…", "title": "…", "appId": "…", "focused": true, "closeable": true, "acceptsText": false}],
"apps": [{"appId": "timer", "title": "Timer"}],
"displayMode": "576x288",
"remoteEnabled": true, "canUnlock": true, "mirrorAssistant": true,
"assistantAvailable": true
}
```
`protocol` is reserved for incompatible revisions of this format (nothing
checks it yet); `displayMode` mirrors the phone's Display > Display mode and
is what the `display-mode` command changes.
`apps` is the launcher grid plus installed EvenHub packages, i.e. exactly what
the assistant's `apps.launch` tool accepts.
@@ -50,6 +50,13 @@ class MainActivity : ComponentActivity() {
override fun onStop() {
cancelStemHold()
// A stopped activity never sees the key-up, and the phone keeps the
// hold (and its escape-menu countdown) running until it hears the
// release — so end an in-progress hold before dropping the link.
if (stemHoldSent) {
stemHoldSent = false
link.sendGesture(Gesture.LONG_PRESS_RELEASE)
}
link.stop()
super.onStop()
}
@@ -267,7 +267,10 @@ class PhoneLink(context: Context) :
private suspend fun loadStateItem() {
try {
val uri = Uri.Builder().scheme("wear").path(Protocol.PATH_STATE).build()
// The item lives under the phone node's authority
// (wear://<nodeId>/faceclaw/state); the "*" host matches any node,
// where a hostless Uri would match nothing.
val uri = Uri.parse("wear://*${Protocol.PATH_STATE}")
val items = dataClient.getDataItems(uri).await()
try {
for (item in items) applyStateItem(item)
@@ -7,8 +7,6 @@ import org.json.JSONObject
* (paths) and app/g2/wear-remote.ts (payloads); see ../../PROTOCOL.md.
*/
object Protocol {
const val PROTOCOL_VERSION = 1
/** Advertised by the phone app so the watch can find it. */
const val CAPABILITY_PHONE = "faceclaw_phone"
@@ -92,7 +90,6 @@ data class WindowEntry(
/** The phone's mirrored dashboard state (Data Layer item /faceclaw/state). */
data class PhoneState(
val protocol: Int,
val version: String,
val phase: String,
val status: String,
@@ -120,7 +117,6 @@ data class PhoneState(
val o = JSONObject(json)
val foreground = o.optJSONObject("foreground")
PhoneState(
protocol = o.optInt("protocol", 1),
version = o.optString("version", ""),
phase = o.optString("phase", "disconnected"),
status = o.optString("status", ""),
@@ -37,6 +37,9 @@ import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LocalLifecycleOwner
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.wear.compose.material.Button
import androidx.wear.compose.material.ButtonDefaults
@@ -207,16 +210,12 @@ fun RemoteScreen(
// Motion-sensor gestures only count on a wrist (see OnBodyMonitor).
val onBody = remember { OnBodyMonitor(view.context) }
DisposableEffect(onBody) {
onBody.start()
onDispose { onBody.stop() }
}
WhileStartedEffect(onBody, start = onBody::start, stop = onBody::stop)
// Fingertip (pinch) taps from the motion sensors, only while the pad is up.
val fingerTapsEnabled = prefs.fingerTaps
DisposableEffect(fingerTapsEnabled, link, haptics) {
if (!fingerTapsEnabled) return@DisposableEffect onDispose { }
val detector = FingerTapDetector(
val fingerTapDetector = remember(fingerTapsEnabled, link, haptics) {
if (!fingerTapsEnabled) null else FingerTapDetector(
context = view.context,
sensitivity = { currentPrefs.tapSensitivity },
quietUntil = { haptics.quietUntil() },
@@ -224,23 +223,20 @@ fun RemoteScreen(
onTap = { flashUntil = System.currentTimeMillis() + FLASH_MS; click() },
onDoubleTap = { flashUntil = System.currentTimeMillis() + FLASH_MS; doubleClick() },
)
detector.start()
onDispose { detector.stop() }
}
WhileStartedEffect(fingerTapDetector, start = { fingerTapDetector?.start() }, stop = { fingerTapDetector?.stop() })
// Two quick wrist twists = back, from the gyroscope, only while the pad is up.
val wristTwistEnabled = prefs.wristTwist
DisposableEffect(wristTwistEnabled, link, haptics) {
if (!wristTwistEnabled) return@DisposableEffect onDispose { }
val detector = WristTwistDetector(
val wristTwistDetector = remember(wristTwistEnabled, link, haptics) {
if (!wristTwistEnabled) null else WristTwistDetector(
context = view.context,
sensitivity = { currentPrefs.twistSensitivity },
quietUntil = { haptics.quietUntil() },
onBody = { onBody.onBody },
onDoubleTwist = { flashUntil = System.currentTimeMillis() + FLASH_MS; doubleClick() },
)
detector.start()
onDispose { detector.stop() }
}
WhileStartedEffect(wristTwistDetector, start = { wristTwistDetector?.start() }, stop = { wristTwistDetector?.stop() })
LaunchedEffect(litTick) {
if (litTick == 0L) return@LaunchedEffect
delay(ARROW_LIT_MS)
@@ -357,6 +353,32 @@ fun RemoteScreen(
}
}
/**
* Run start/stop with the composition AND the activity lifecycle: started on
* ON_START (or immediately if already started), stopped on ON_STOP and on
* leaving the composition. A plain DisposableEffect keeps sensors registered
* while the activity sits stopped-but-cached (palmed screen, back on the watch
* face), which at gyroscope/accelerometer rates is a real battery drain.
*/
@Composable
private fun WhileStartedEffect(key: Any?, start: () -> Unit, stop: () -> Unit) {
val lifecycleOwner = LocalLifecycleOwner.current
DisposableEffect(lifecycleOwner, key) {
val observer = LifecycleEventObserver { _, event ->
when (event) {
Lifecycle.Event.ON_START -> start()
Lifecycle.Event.ON_STOP -> stop()
else -> Unit
}
}
lifecycleOwner.lifecycle.addObserver(observer)
onDispose {
lifecycleOwner.lifecycle.removeObserver(observer)
stop()
}
}
}
@Composable
private fun ArrowGlyph(glyph: String, lit: Boolean, modifier: Modifier) {
Text(
@@ -39,57 +39,71 @@ suspend fun PointerInputScope.detectTouchpadGestures(callbacks: TouchpadCallback
var maxPointers = 1
var moved = false
var longPressed = false
var longPressEnded = false
var displacement = Offset.Zero
var releaseTime = downTime
while (true) {
val remaining = if (longPressed || moved || maxPointers > 1) {
HOLD_POLL_MS
} else {
longPressTimeout - (System.currentTimeMillis() - wallClockAt(downTime))
}
val event = withTimeoutOrNull(remaining.coerceAtLeast(1L)) { awaitPointerEvent() }
if (event == null) {
if (!longPressed && !moved && maxPointers == 1) {
longPressed = true
callbacks.onLongPressStart()
// The finally clause pairs every onLongPressStart with an
// onLongPressEnd, whatever ends the gesture: a parent consuming the
// events (the break below) or the pointerInput coroutine being
// cancelled mid-hold. The phone treats a start without a release as a
// hold still in progress, so dropping the release leaves a stuck
// long-press (and eventually the shell escape menu).
try {
while (true) {
val remaining = if (longPressed || moved || maxPointers > 1) {
HOLD_POLL_MS
} else {
longPressTimeout - (System.currentTimeMillis() - wallClockAt(downTime))
}
continue
}
// Something above us (the system, a parent) took the gesture:
// Compose reports that as already-consumed changes. Drop it rather
// than mistaking the cancellation for a tap.
if (event.changes.any { it.isConsumed }) break
val pressedCount = event.changes.count { it.pressed }
if (pressedCount > maxPointers) maxPointers = pressedCount
val primary = event.changes.firstOrNull { it.id == down.id } ?: event.changes.first()
if (primary.positionChanged()) {
displacement = primary.position - down.position
if (!moved && !longPressed && displacement.getDistance() > slop) moved = true
}
for (change in event.changes) change.consume()
if (pressedCount > 0) continue
val event = withTimeoutOrNull(remaining.coerceAtLeast(1L)) { awaitPointerEvent() }
if (event == null) {
if (!longPressed && !moved && maxPointers == 1) {
longPressed = true
callbacks.onLongPressStart()
}
continue
}
// Something above us (the system, a parent) took the gesture:
// Compose reports that as already-consumed changes. Drop it rather
// than mistaking the cancellation for a tap.
if (event.changes.any { it.isConsumed }) break
val pressedCount = event.changes.count { it.pressed }
if (pressedCount > maxPointers) maxPointers = pressedCount
val primary = event.changes.firstOrNull { it.id == down.id } ?: event.changes.first()
if (primary.positionChanged()) {
displacement = primary.position - down.position
if (!moved && !longPressed && displacement.getDistance() > slop) moved = true
}
for (change in event.changes) change.consume()
if (pressedCount > 0) continue
releaseTime = event.changes.maxOf { it.uptimeMillis }
val duration = releaseTime - downTime
when {
longPressed -> callbacks.onLongPressEnd()
maxPointers >= 2 -> if (moved) callbacks.onTwoFingerSwipe(displacement.x, displacement.y) else callbacks.onTwoFingerTap()
moved -> callbacks.onSwipe(displacement.x, displacement.y, duration)
else -> {
// A plain tap; give a second tap a chance to make it a double.
val second = withTimeoutOrNull(doubleTapTimeout) { awaitFirstDown() }
if (second == null) {
callbacks.onTap(down.position)
} else {
second.consume()
val up = waitForUpOrCancellation()
if (up != null) up.consume()
callbacks.onDoubleTap(down.position)
releaseTime = event.changes.maxOf { it.uptimeMillis }
val duration = releaseTime - downTime
when {
longPressed -> {
longPressEnded = true
callbacks.onLongPressEnd()
}
maxPointers >= 2 -> if (moved) callbacks.onTwoFingerSwipe(displacement.x, displacement.y) else callbacks.onTwoFingerTap()
moved -> callbacks.onSwipe(displacement.x, displacement.y, duration)
else -> {
// A plain tap; give a second tap a chance to make it a double.
val second = withTimeoutOrNull(doubleTapTimeout) { awaitFirstDown() }
if (second == null) {
callbacks.onTap(down.position)
} else {
second.consume()
val up = waitForUpOrCancellation()
if (up != null) up.consume()
callbacks.onDoubleTap(down.position)
}
}
}
break
}
break
} finally {
if (longPressed && !longPressEnded) callbacks.onLongPressEnd()
}
}
}