forked from Blendman974/faceclaw
<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>
881 lines
31 KiB
TypeScript
881 lines
31 KiB
TypeScript
import {
|
|
Application,
|
|
Dialogs,
|
|
Frame,
|
|
ImageSource,
|
|
Observable,
|
|
Screen,
|
|
SwipeDirection,
|
|
type GestureEventData,
|
|
type SwipeGestureEventData,
|
|
type TouchGestureEventData,
|
|
type View,
|
|
} from "@nativescript/core";
|
|
import { dashboardController, type MirrorTouchKind } from "../g2/dashboard-controller";
|
|
import { shell } from "../ui/shell/shell";
|
|
import {
|
|
brightnessSetting,
|
|
DISPLAY_MODE_VALUES,
|
|
displayModeLabel,
|
|
displayModeSetting,
|
|
onAnySettingChanged,
|
|
type BrightnessSetting,
|
|
type DisplayModeSetting,
|
|
} from "../ui/dashboard-settings";
|
|
import { getBooleanSetting, setBooleanSetting } from "../native/settings-store";
|
|
import { isValidMacAddress, loadDeviceAddresses } from "../g2/device-addresses";
|
|
import { isAutoReconnectSuppressed, resumeAutoReconnect } from "../g2/reconnect-policy";
|
|
import { formatErrorMessage } from "../util/format-error";
|
|
import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../graphics/image";
|
|
|
|
const LENS_ASPECT_RATIO = G2_LENS_WIDTH / G2_LENS_HEIGHT;
|
|
|
|
type LayoutOrientation = "portrait" | "landscape";
|
|
|
|
export class MainViewModel extends Observable {
|
|
private _status = "Disconnected.";
|
|
private _displayPreview: ImageSource | null = null;
|
|
private _displayPreviewMessage = "";
|
|
private _layoutOrientation: LayoutOrientation = this.readLayoutOrientation();
|
|
private _activeTextSettingId: string | null = null;
|
|
private _activeTextEditorTitle = "";
|
|
private _activeTextSettingTitle = "";
|
|
private _activeTextSettingValue = "";
|
|
private _activeTextSettingInputKind: "text" | "email" | "password" = "text";
|
|
private _secondaryTextSettingId: string | null = null;
|
|
private _secondaryTextSettingTitle = "";
|
|
private _secondaryTextSettingValue = "";
|
|
private _secondaryTextSettingInputKind: "text" | "email" | "password" = "text";
|
|
private _evenAppConflictMessage = "";
|
|
private _evenAppConflictWarningVisible = false;
|
|
private _firmwareWarningMessage = "";
|
|
private _firmwareWarningVisible = false;
|
|
private _screenRecordingActive = false;
|
|
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();
|
|
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;
|
|
this.phase = snapshot.phase;
|
|
this.activeTextSettingId = snapshot.activeTextSettingId;
|
|
this.activeTextEditorTitle = snapshot.activeTextEditorTitle;
|
|
this.activeTextSettingTitle = snapshot.activeTextSettingTitle;
|
|
this.activeTextSettingValue = snapshot.activeTextSettingValue;
|
|
this.activeTextSettingInputKind = snapshot.activeTextSettingInputKind;
|
|
this.secondaryTextSettingId = snapshot.secondaryTextSettingId;
|
|
this.secondaryTextSettingTitle = snapshot.secondaryTextSettingTitle;
|
|
this.secondaryTextSettingValue = snapshot.secondaryTextSettingValue;
|
|
this.secondaryTextSettingInputKind = snapshot.secondaryTextSettingInputKind;
|
|
this.evenAppConflictMessage = snapshot.evenAppConflictMessage;
|
|
this.evenAppConflictWarningVisible = snapshot.evenAppConflictWarningVisible;
|
|
this.firmwareWarningMessage = snapshot.firmwareWarningMessage;
|
|
this.firmwareWarningVisible = snapshot.firmwareWarningVisible;
|
|
this.screenRecordingActive = snapshot.screenRecordingActive;
|
|
this.batteryOptimizationWarningVisible = snapshot.batteryOptimizationWarningVisible;
|
|
this.refreshPadFocusLine();
|
|
}));
|
|
// Brightness / display mode can change from the glasses' Settings app too.
|
|
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 {
|
|
return this._status;
|
|
}
|
|
|
|
set status(value: string) {
|
|
if (this._status !== value) {
|
|
this._status = value;
|
|
this.notifyPropertyChange("status", value);
|
|
}
|
|
}
|
|
|
|
get displayPreview(): ImageSource | null {
|
|
return this._displayPreview;
|
|
}
|
|
|
|
set displayPreview(value: ImageSource | null) {
|
|
if (this._displayPreview !== value) {
|
|
this._displayPreview = value;
|
|
this.notifyPropertyChange("displayPreview", value);
|
|
this.notifyPropertyChange("hasDisplayPreview", this.hasDisplayPreview);
|
|
this.notifyPropertyChange("displayPreviewVisibility", this.displayPreviewVisibility);
|
|
}
|
|
}
|
|
|
|
get displayPreviewMessage(): string {
|
|
return this._displayPreviewMessage;
|
|
}
|
|
|
|
set displayPreviewMessage(value: string) {
|
|
if (this._displayPreviewMessage !== value) {
|
|
this._displayPreviewMessage = value;
|
|
this.notifyPropertyChange("displayPreviewMessage", value);
|
|
this.notifyPropertyChange("displayPreviewMessageVisibility", this.displayPreviewMessageVisibility);
|
|
this.notifyPropertyChange("displayPreviewVisibility", this.displayPreviewVisibility);
|
|
}
|
|
}
|
|
|
|
get hasDisplayPreview(): boolean {
|
|
return this._displayPreview !== null;
|
|
}
|
|
|
|
/**
|
|
* The preview and its stand-in message are mutually exclusive and occupy the
|
|
* same box, so the form doesn't reflow when one replaces the other.
|
|
*/
|
|
get displayPreviewVisibility(): "visible" | "collapse" {
|
|
return this.hasDisplayPreview && !this._displayPreviewMessage ? "visible" : "collapse";
|
|
}
|
|
|
|
get displayPreviewMessageVisibility(): "visible" | "collapse" {
|
|
return this._displayPreviewMessage ? "visible" : "collapse";
|
|
}
|
|
|
|
get displayPreviewHeight(): number {
|
|
return Screen.mainScreen.widthDIPs / LENS_ASPECT_RATIO;
|
|
}
|
|
|
|
get landscapeDisplayPreviewWidth(): number {
|
|
return Math.floor(this.landscapeDisplayPreviewHeight * LENS_ASPECT_RATIO);
|
|
}
|
|
|
|
get landscapeDisplayPreviewHeight(): number {
|
|
// Height keeps the vertical footprint the preview had at the old 2:1
|
|
// 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;
|
|
// 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);
|
|
}
|
|
|
|
get portraitLayoutVisibility(): "visible" | "collapse" {
|
|
return this._layoutOrientation === "portrait" ? "visible" : "collapse";
|
|
}
|
|
|
|
get landscapeLayoutVisibility(): "visible" | "collapse" {
|
|
return this._layoutOrientation === "landscape" ? "visible" : "collapse";
|
|
}
|
|
|
|
refreshLayoutMetrics(): void {
|
|
const nextOrientation = this.readLayoutOrientation();
|
|
if (this._layoutOrientation !== nextOrientation) {
|
|
this._layoutOrientation = nextOrientation;
|
|
this.notifyPropertyChange("portraitLayoutVisibility", this.portraitLayoutVisibility);
|
|
this.notifyPropertyChange("landscapeLayoutVisibility", this.landscapeLayoutVisibility);
|
|
}
|
|
this.notifyPropertyChange("displayPreviewHeight", this.displayPreviewHeight);
|
|
this.notifyPropertyChange("landscapeDisplayPreviewWidth", this.landscapeDisplayPreviewWidth);
|
|
this.notifyPropertyChange("landscapeDisplayPreviewHeight", this.landscapeDisplayPreviewHeight);
|
|
}
|
|
|
|
get activeTextSettingId(): string | null {
|
|
return this._activeTextSettingId;
|
|
}
|
|
|
|
set activeTextSettingId(value: string | null) {
|
|
if (this._activeTextSettingId !== value) {
|
|
this._activeTextSettingId = value;
|
|
this.notifyPropertyChange("activeTextSettingId", value);
|
|
this.notifyPropertyChange("textSettingEditorVisibility", this.textSettingEditorVisibility);
|
|
this.notifyPropertyChange("isTextSettingEditorActive", this.isTextSettingEditorActive);
|
|
}
|
|
}
|
|
|
|
get activeTextSettingTitle(): string {
|
|
return this._activeTextSettingTitle;
|
|
}
|
|
|
|
get activeTextEditorTitle(): string {
|
|
return this._activeTextEditorTitle;
|
|
}
|
|
|
|
set activeTextEditorTitle(value: string) {
|
|
if (this._activeTextEditorTitle !== value) {
|
|
this._activeTextEditorTitle = value;
|
|
this.notifyPropertyChange("activeTextEditorTitle", value);
|
|
}
|
|
}
|
|
|
|
set activeTextSettingTitle(value: string) {
|
|
if (this._activeTextSettingTitle !== value) {
|
|
this._activeTextSettingTitle = value;
|
|
this.notifyPropertyChange("activeTextSettingTitle", value);
|
|
}
|
|
}
|
|
|
|
get activeTextSettingValue(): string {
|
|
return this._activeTextSettingValue;
|
|
}
|
|
|
|
set activeTextSettingValue(value: string) {
|
|
if (this._activeTextSettingValue !== value) {
|
|
this._activeTextSettingValue = value;
|
|
this.notifyPropertyChange("activeTextSettingValue", value);
|
|
}
|
|
}
|
|
|
|
get activeTextSettingInputKind(): "text" | "email" | "password" {
|
|
return this._activeTextSettingInputKind;
|
|
}
|
|
|
|
set activeTextSettingInputKind(value: "text" | "email" | "password") {
|
|
if (this._activeTextSettingInputKind !== value) {
|
|
this._activeTextSettingInputKind = value;
|
|
this.notifyPropertyChange("activeTextSettingKeyboardType", this.activeTextSettingKeyboardType);
|
|
this.notifyPropertyChange("activeTextSettingSecure", this.activeTextSettingSecure);
|
|
}
|
|
}
|
|
|
|
get activeTextSettingKeyboardType(): "email" | "text" {
|
|
return this._activeTextSettingInputKind === "email" ? "email" : "text";
|
|
}
|
|
|
|
get activeTextSettingSecure(): boolean {
|
|
return this._activeTextSettingInputKind === "password";
|
|
}
|
|
|
|
get secondaryTextSettingId(): string | null {
|
|
return this._secondaryTextSettingId;
|
|
}
|
|
|
|
set secondaryTextSettingId(value: string | null) {
|
|
if (this._secondaryTextSettingId !== value) {
|
|
this._secondaryTextSettingId = value;
|
|
this.notifyPropertyChange("secondaryTextSettingId", value);
|
|
this.notifyPropertyChange("secondaryTextSettingVisibility", this.secondaryTextSettingVisibility);
|
|
this.notifyPropertyChange("hasSecondaryTextSetting", this.hasSecondaryTextSetting);
|
|
this.notifyPropertyChange("primaryTextSettingReturnKeyType", this.primaryTextSettingReturnKeyType);
|
|
}
|
|
}
|
|
|
|
get secondaryTextSettingTitle(): string {
|
|
return this._secondaryTextSettingTitle;
|
|
}
|
|
|
|
set secondaryTextSettingTitle(value: string) {
|
|
if (this._secondaryTextSettingTitle !== value) {
|
|
this._secondaryTextSettingTitle = value;
|
|
this.notifyPropertyChange("secondaryTextSettingTitle", value);
|
|
}
|
|
}
|
|
|
|
get secondaryTextSettingValue(): string {
|
|
return this._secondaryTextSettingValue;
|
|
}
|
|
|
|
set secondaryTextSettingValue(value: string) {
|
|
if (this._secondaryTextSettingValue !== value) {
|
|
this._secondaryTextSettingValue = value;
|
|
this.notifyPropertyChange("secondaryTextSettingValue", value);
|
|
}
|
|
}
|
|
|
|
get secondaryTextSettingInputKind(): "text" | "email" | "password" {
|
|
return this._secondaryTextSettingInputKind;
|
|
}
|
|
|
|
set secondaryTextSettingInputKind(value: "text" | "email" | "password") {
|
|
if (this._secondaryTextSettingInputKind !== value) {
|
|
this._secondaryTextSettingInputKind = value;
|
|
this.notifyPropertyChange("secondaryTextSettingKeyboardType", this.secondaryTextSettingKeyboardType);
|
|
this.notifyPropertyChange("secondaryTextSettingSecure", this.secondaryTextSettingSecure);
|
|
}
|
|
}
|
|
|
|
get secondaryTextSettingKeyboardType(): "email" | "text" {
|
|
return this._secondaryTextSettingInputKind === "email" ? "email" : "text";
|
|
}
|
|
|
|
get secondaryTextSettingSecure(): boolean {
|
|
return this._secondaryTextSettingInputKind === "password";
|
|
}
|
|
|
|
get hasSecondaryTextSetting(): boolean {
|
|
return this._secondaryTextSettingId !== null;
|
|
}
|
|
|
|
get secondaryTextSettingVisibility(): "visible" | "collapse" {
|
|
return this.hasSecondaryTextSetting ? "visible" : "collapse";
|
|
}
|
|
|
|
get primaryTextSettingReturnKeyType(): "next" | "done" {
|
|
return this.hasSecondaryTextSetting ? "next" : "done";
|
|
}
|
|
|
|
get isTextSettingEditorActive(): boolean {
|
|
return this._activeTextSettingId !== null;
|
|
}
|
|
|
|
get textSettingEditorVisibility(): "visible" | "collapse" {
|
|
return this.isTextSettingEditorActive ? "visible" : "collapse";
|
|
}
|
|
|
|
get evenAppConflictMessage(): string {
|
|
return this._evenAppConflictMessage;
|
|
}
|
|
|
|
set evenAppConflictMessage(value: string) {
|
|
if (this._evenAppConflictMessage !== value) {
|
|
this._evenAppConflictMessage = value;
|
|
this.notifyPropertyChange("evenAppConflictMessage", value);
|
|
}
|
|
}
|
|
|
|
get evenAppConflictWarningVisible(): boolean {
|
|
return this._evenAppConflictWarningVisible;
|
|
}
|
|
|
|
set evenAppConflictWarningVisible(value: boolean) {
|
|
if (this._evenAppConflictWarningVisible !== value) {
|
|
this._evenAppConflictWarningVisible = value;
|
|
this.notifyPropertyChange("evenAppConflictWarningVisible", value);
|
|
this.notifyPropertyChange("evenAppConflictWarningVisibility", this.evenAppConflictWarningVisibility);
|
|
}
|
|
}
|
|
|
|
get evenAppConflictWarningVisibility(): "visible" | "collapse" {
|
|
return this._evenAppConflictWarningVisible ? "visible" : "collapse";
|
|
}
|
|
|
|
get firmwareWarningMessage(): string {
|
|
return this._firmwareWarningMessage;
|
|
}
|
|
|
|
set firmwareWarningMessage(value: string) {
|
|
if (this._firmwareWarningMessage !== value) {
|
|
this._firmwareWarningMessage = value;
|
|
this.notifyPropertyChange("firmwareWarningMessage", value);
|
|
}
|
|
}
|
|
|
|
get firmwareWarningVisible(): boolean {
|
|
return this._firmwareWarningVisible;
|
|
}
|
|
|
|
set firmwareWarningVisible(value: boolean) {
|
|
if (this._firmwareWarningVisible !== value) {
|
|
this._firmwareWarningVisible = value;
|
|
this.notifyPropertyChange("firmwareWarningVisible", value);
|
|
this.notifyPropertyChange("firmwareWarningVisibility", this.firmwareWarningVisibility);
|
|
}
|
|
}
|
|
|
|
get firmwareWarningVisibility(): "visible" | "collapse" {
|
|
return this._firmwareWarningVisible ? "visible" : "collapse";
|
|
}
|
|
|
|
get screenRecordingActive(): boolean {
|
|
return this._screenRecordingActive;
|
|
}
|
|
|
|
set screenRecordingActive(value: boolean) {
|
|
if (this._screenRecordingActive !== value) {
|
|
this._screenRecordingActive = value;
|
|
this.notifyPropertyChange("screenRecordingActive", value);
|
|
this.notifyPropertyChange("stopRecordingButtonVisibility", this.stopRecordingButtonVisibility);
|
|
}
|
|
}
|
|
|
|
get stopRecordingButtonVisibility(): "visible" | "collapse" {
|
|
return this._screenRecordingActive ? "visible" : "collapse";
|
|
}
|
|
|
|
onTakeScreenshotTap(): void {
|
|
try {
|
|
dashboardController.saveScreenshot();
|
|
} catch (error) {
|
|
console.error("screenshot failed", error);
|
|
}
|
|
}
|
|
|
|
onRecordScreenTap(): void {
|
|
try {
|
|
dashboardController.startScreenRecording();
|
|
} catch (error) {
|
|
console.error("screen recording start failed", error);
|
|
}
|
|
}
|
|
|
|
onStopRecordingTap(): void {
|
|
try {
|
|
dashboardController.stopScreenRecording();
|
|
} catch (error) {
|
|
console.error("screen recording stop failed", error);
|
|
}
|
|
}
|
|
|
|
get batteryOptimizationWarningVisible(): boolean {
|
|
return this._batteryOptimizationWarningVisible;
|
|
}
|
|
|
|
set batteryOptimizationWarningVisible(value: boolean) {
|
|
if (this._batteryOptimizationWarningVisible !== value) {
|
|
this._batteryOptimizationWarningVisible = value;
|
|
this.notifyPropertyChange("batteryOptimizationWarningVisible", value);
|
|
this.notifyPropertyChange("batteryOptimizationWarningVisibility", this.batteryOptimizationWarningVisibility);
|
|
}
|
|
}
|
|
|
|
get batteryOptimizationWarningVisibility(): "visible" | "collapse" {
|
|
return this._batteryOptimizationWarningVisible ? "visible" : "collapse";
|
|
}
|
|
|
|
onAllowBackgroundUsageTap(): void {
|
|
dashboardController.requestBatteryOptimizationExemption();
|
|
}
|
|
|
|
get phase(): "disconnected" | "connecting" | "connected" | "charging" | "disconnecting" {
|
|
return this._phase;
|
|
}
|
|
|
|
set phase(value: "disconnected" | "connecting" | "connected" | "charging" | "disconnecting") {
|
|
if (this._phase !== value) {
|
|
this._phase = value;
|
|
this.notifyPropertyChange("phase", value);
|
|
this.notifyPropertyChange("buttonLabel", this.buttonLabel);
|
|
this.notifyPropertyChange("canRun", this.canRun);
|
|
this.notifyPropertyChange("connectItemEnabled", this.connectItemEnabled);
|
|
}
|
|
}
|
|
|
|
get buttonLabel(): string {
|
|
switch (this.phase) {
|
|
case "connecting":
|
|
case "connected":
|
|
case "charging":
|
|
return "Disconnect";
|
|
case "disconnecting":
|
|
return "Disconnecting...";
|
|
default:
|
|
return "Connect";
|
|
}
|
|
}
|
|
|
|
get canRun(): boolean {
|
|
return this.phase !== "connecting" && this.phase !== "disconnecting";
|
|
}
|
|
|
|
/**
|
|
* Unlike the other canRun-gated menu items, Connect/Disconnect stays live
|
|
* while connecting: Disconnect is the only way out of a reconnection-attempt
|
|
* loop short of force-stopping the app.
|
|
*/
|
|
get connectItemEnabled(): boolean {
|
|
return this.phase !== "disconnecting";
|
|
}
|
|
|
|
async onTap(): Promise<void> {
|
|
if (!this.connectItemEnabled) return;
|
|
|
|
try {
|
|
if (this.phase === "disconnected") {
|
|
await dashboardController.connect();
|
|
} else {
|
|
await dashboardController.disconnect();
|
|
}
|
|
} catch (error) {
|
|
const message = this.formatError(error);
|
|
if (!this.status.startsWith("Failed:")) {
|
|
this.status = `Failed: ${message}`;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Try to connect automatically on reaching the main page. No-op if already
|
|
* connecting/connected, if the app is in the manual-disconnected state
|
|
* (the user picked Disconnect, the flash flow owns the glasses, or the
|
|
* firmware was found incompatible), or if no glasses are configured
|
|
* (e.g. preview-only users, who have nothing to connect to).
|
|
*/
|
|
async autoConnect(): Promise<void> {
|
|
if (this.phase !== "disconnected") return;
|
|
if (isAutoReconnectSuppressed()) return;
|
|
const addresses = loadDeviceAddresses();
|
|
if (!isValidMacAddress(addresses.right) || !isValidMacAddress(addresses.left)) return;
|
|
try {
|
|
await dashboardController.connect();
|
|
} catch {
|
|
// The controller surfaces failures via status/log; nothing to add here.
|
|
}
|
|
}
|
|
|
|
onConfigureTap(): void {
|
|
if (!this.canRun) return;
|
|
Frame.topmost()?.navigate("phone-ui/config-page");
|
|
}
|
|
|
|
/**
|
|
* Live scan that names each nearby pair by model, colour, and serial and
|
|
* checks both arms belong together. A connected arm stops advertising, so
|
|
* drop the current link first. disconnect() enters the manual-disconnected
|
|
* state; pairing is a detour, not a Disconnect, so lift the suppression
|
|
* right away — nothing dials the glasses until the main page's autoConnect
|
|
* runs again on the way back.
|
|
*/
|
|
async onPairGlassesTap(): Promise<void> {
|
|
if (!this.canRun) return;
|
|
if (this.phase === "connected" || this.phase === "charging" || this.phase === "connecting") {
|
|
try {
|
|
await dashboardController.disconnect();
|
|
} catch {
|
|
// proceed anyway; the pairing page reports what it hears
|
|
}
|
|
resumeAutoReconnect();
|
|
}
|
|
Frame.topmost()?.navigate({ moduleName: "phone-ui/pairing-page", context: { onboarding: false } });
|
|
}
|
|
|
|
async onInstallFirmwareTap(): Promise<void> {
|
|
await this.openFlashPage("install");
|
|
}
|
|
|
|
async onUninstallFirmwareTap(): Promise<void> {
|
|
await this.openFlashPage("uninstall");
|
|
}
|
|
|
|
private async openFlashPage(mode: "install" | "uninstall"): Promise<void> {
|
|
// The flasher needs the glasses to itself, so drop the main connection first.
|
|
if (this.phase === "connected" || this.phase === "charging") {
|
|
try {
|
|
await dashboardController.disconnect();
|
|
} catch {
|
|
// proceed anyway; the flash page surfaces any connection trouble
|
|
}
|
|
}
|
|
Frame.topmost()?.navigate({
|
|
moduleName: "phone-ui/onboarding-flash-page",
|
|
context: { mode, fromOnboarding: false },
|
|
});
|
|
}
|
|
|
|
onTextSettingTextChange(args: { value?: string; object?: { text?: string } }): void {
|
|
dashboardController.setActiveTextSettingValue(
|
|
args.object?.text ?? args.value ?? "",
|
|
this.activeTextSettingId ?? undefined,
|
|
);
|
|
}
|
|
|
|
onPrimaryTextSettingReturnPress(args: { object?: { text?: string; page?: { getViewById?: (id: string) => { focus?: () => void } | null } } }): void {
|
|
// Commit the field's actual text at done-time, in case the final
|
|
// keystroke's textChange hadn't landed yet.
|
|
const text = args?.object?.text;
|
|
if (typeof text === "string") {
|
|
dashboardController.setActiveTextSettingValue(text, this.activeTextSettingId ?? undefined);
|
|
}
|
|
if (this.hasSecondaryTextSetting) {
|
|
args.object?.page?.getViewById?.("secondarySettingsTextField")?.focus?.();
|
|
return;
|
|
}
|
|
dashboardController.finishActiveTextSettingEdit();
|
|
}
|
|
|
|
onSecondaryTextSettingTextChange(args: { value?: string; object?: { text?: string } }): void {
|
|
dashboardController.setActiveTextSettingValue(
|
|
args.object?.text ?? args.value ?? "",
|
|
this.secondaryTextSettingId ?? undefined,
|
|
);
|
|
}
|
|
|
|
onSecondaryTextSettingReturnPress(args: { object?: { text?: string } }): void {
|
|
const text = args?.object?.text;
|
|
if (typeof text === "string") {
|
|
dashboardController.setActiveTextSettingValue(text, this.secondaryTextSettingId ?? undefined);
|
|
}
|
|
dashboardController.finishActiveTextSettingEdit();
|
|
}
|
|
|
|
onOpenEvenAppSettingsTap(): void {
|
|
dashboardController.openEvenAppSettings();
|
|
}
|
|
|
|
async onSyntheticUpTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("scroll-up");
|
|
}
|
|
|
|
async onSyntheticDownTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("scroll-down");
|
|
}
|
|
|
|
async onSyntheticLeftTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("double-click");
|
|
}
|
|
|
|
async onSyntheticRightTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("click");
|
|
}
|
|
|
|
async onSyntheticLongPressTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("long-press");
|
|
}
|
|
|
|
async onSyntheticMicTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("wakeword");
|
|
}
|
|
|
|
// ---- the phone's own controller: touchpad, d-pad, mirror touch ----
|
|
//
|
|
// Everything here is the watch scheme (origin "watch"): spatial swipes,
|
|
// tap = select, double-tap / two fingers = back, hold = menu. The ring row
|
|
// above stays on the ring's own scheme.
|
|
|
|
private padTwoFingerDown = false;
|
|
|
|
/** What the next gesture lands on, as the watch pad shows it. */
|
|
get padFocusLine(): string {
|
|
if (this.phase !== "connected" && this.phase !== "charging") return "Glasses disconnected";
|
|
if (!shell.isScreenOn()) return "Display off";
|
|
const foreground = shell.getForegroundApp();
|
|
return foreground ? foreground.title : "Launcher";
|
|
}
|
|
|
|
private refreshPadFocusLine(): void {
|
|
this.notifyPropertyChange("padFocusLine", this.padFocusLine);
|
|
}
|
|
|
|
async onPadTap(): Promise<void> {
|
|
if (this.padTwoFingerDown) return;
|
|
await dashboardController.injectSyntheticRingInput("click", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onPadDoubleTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("double-click", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onPadLongPress(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("long-press", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onPadSwipe(args: SwipeGestureEventData): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput(swipeKind(args.direction), "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
/** Two fingers down and up without moving: back (the watch's two-finger tap). */
|
|
async onPadTouch(args: TouchGestureEventData): Promise<void> {
|
|
const count = args.getPointerCount();
|
|
if (args.action === "down" || args.action === "move") {
|
|
if (count >= 2) this.padTwoFingerDown = true;
|
|
return;
|
|
}
|
|
if (args.action === "up" || args.action === "cancel") {
|
|
const twoFinger = this.padTwoFingerDown;
|
|
if (twoFinger) {
|
|
// Let the single-tap recognizer's delayed tap see the flag first.
|
|
setTimeout(() => {
|
|
this.padTwoFingerDown = false;
|
|
}, 400);
|
|
if (args.action === "up") {
|
|
await dashboardController.injectSyntheticRingInput("double-click", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async onDpadUp(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("swipe-up", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onDpadDown(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("swipe-down", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onDpadLeft(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("swipe-left", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onDpadRight(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("swipe-right", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onDpadSelect(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("click", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onBackTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("double-click", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
async onMenuTap(): Promise<void> {
|
|
await dashboardController.injectSyntheticRingInput("long-press", "watch");
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
// ---- touching the mirror itself ----
|
|
|
|
get mirrorTouchEnabled(): boolean {
|
|
return getBooleanSetting(MIRROR_TOUCH_KEY, true);
|
|
}
|
|
|
|
onMirrorTouchChange(args: { value?: boolean; object?: { checked?: boolean } }): void {
|
|
const on = typeof args.value === "boolean" ? args.value : Boolean(args.object?.checked);
|
|
setBooleanSetting(MIRROR_TOUCH_KEY, on);
|
|
this.notifyPropertyChange("mirrorTouchEnabled", on);
|
|
}
|
|
|
|
private mirrorFraction(args: GestureEventData & { getX?: () => number; getY?: () => number }): { nx: number; ny: number } | null {
|
|
const view = args.object as View | undefined;
|
|
const size = view?.getActualSize?.();
|
|
if (!view || !size || !size.width || !size.height || !args.getX || !args.getY) return null;
|
|
// 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> {
|
|
if (!this.mirrorTouchEnabled) return;
|
|
const at = this.mirrorFraction(args) ?? { nx: 0.5, ny: 0.5 };
|
|
await dashboardController.handleMirrorTouch(kind, at.nx, at.ny);
|
|
this.refreshPadFocusLine();
|
|
}
|
|
|
|
onMirrorTap(args: GestureEventData): Promise<void> {
|
|
return this.mirrorGesture("tap", args);
|
|
}
|
|
|
|
onMirrorDoubleTap(args: GestureEventData): Promise<void> {
|
|
return this.mirrorGesture("double-tap", args);
|
|
}
|
|
|
|
onMirrorLongPress(args: GestureEventData): Promise<void> {
|
|
return this.mirrorGesture("long-press", args);
|
|
}
|
|
|
|
onMirrorSwipe(args: SwipeGestureEventData): Promise<void> {
|
|
return this.mirrorGesture(swipeKind(args.direction), args);
|
|
}
|
|
|
|
// ---- display mode and brightness, beside the mirror ----
|
|
|
|
get displayModeLabel(): string {
|
|
return displayModeLabel(displayModeSetting.get()) + " ▾";
|
|
}
|
|
|
|
async onDisplayModeTap(): Promise<void> {
|
|
const current = displayModeSetting.get();
|
|
const options = DISPLAY_MODE_VALUES.map((value) => displayModeLabel(value) + (value === current ? " ✓" : ""));
|
|
const picked = await Dialogs.action({ title: "Display mode", cancelButtonText: "Cancel", actions: options });
|
|
const index = options.indexOf(picked);
|
|
if (index < 0) return;
|
|
const value = DISPLAY_MODE_VALUES[index] as DisplayModeSetting;
|
|
if (value !== current) displayModeSetting.set(value);
|
|
this.notifyPropertyChange("displayModeLabel", this.displayModeLabel);
|
|
}
|
|
|
|
get brightnessAuto(): boolean {
|
|
return brightnessSetting.get() === "auto";
|
|
}
|
|
|
|
get brightnessSliderEnabled(): boolean {
|
|
return !this.brightnessAuto;
|
|
}
|
|
|
|
/** The slider's position; while Auto, the last manual level (or 50). */
|
|
get brightnessPercent(): number {
|
|
const value = brightnessSetting.get();
|
|
if (value === "auto") return this.lastManualBrightness;
|
|
const numeric = parseInt(value, 10);
|
|
return Number.isFinite(numeric) ? numeric : 50;
|
|
}
|
|
|
|
private lastManualBrightness = 50;
|
|
|
|
onBrightnessChange(args: { value?: number; object?: { value?: number } }): void {
|
|
if (this.brightnessAuto) return;
|
|
const raw = typeof args.value === "number" ? args.value : Number(args.object?.value ?? NaN);
|
|
if (!Number.isFinite(raw)) return;
|
|
// The setting only has every tenth level; snap to the nearest.
|
|
const level = Math.min(100, Math.max(0, Math.round(raw / 10) * 10));
|
|
this.lastManualBrightness = level;
|
|
const value = String(level) as BrightnessSetting;
|
|
if (brightnessSetting.get() !== value) brightnessSetting.set(value);
|
|
}
|
|
|
|
onBrightnessAutoChange(args: { value?: boolean; object?: { checked?: boolean } }): void {
|
|
const on = typeof args.value === "boolean" ? args.value : Boolean(args.object?.checked);
|
|
if (on) {
|
|
if (brightnessSetting.get() !== "auto") {
|
|
this.lastManualBrightness = this.brightnessPercent;
|
|
brightnessSetting.set("auto");
|
|
}
|
|
} else if (brightnessSetting.get() === "auto") {
|
|
brightnessSetting.set(String(this.lastManualBrightness) as BrightnessSetting);
|
|
}
|
|
this.refreshDisplayControls();
|
|
}
|
|
|
|
private refreshDisplayControls(): void {
|
|
this.notifyPropertyChange("brightnessAuto", this.brightnessAuto);
|
|
this.notifyPropertyChange("brightnessSliderEnabled", this.brightnessSliderEnabled);
|
|
this.notifyPropertyChange("brightnessPercent", this.brightnessPercent);
|
|
this.notifyPropertyChange("displayModeLabel", this.displayModeLabel);
|
|
}
|
|
|
|
private readLayoutOrientation(): LayoutOrientation {
|
|
const applicationOrientation = Application.orientation();
|
|
if (applicationOrientation === "landscape" || applicationOrientation === "portrait") {
|
|
return applicationOrientation;
|
|
}
|
|
return Screen.mainScreen.widthDIPs > Screen.mainScreen.heightDIPs ? "landscape" : "portrait";
|
|
}
|
|
|
|
private formatError(error: unknown): string {
|
|
return formatErrorMessage(error, 240);
|
|
}
|
|
}
|
|
|
|
const MIRROR_TOUCH_KEY = "phone.mirrorTouch";
|
|
|
|
/** NativeScript swipe direction -> the watch-scheme directional gesture. */
|
|
function swipeKind(direction: SwipeDirection): "swipe-up" | "swipe-down" | "swipe-left" | "swipe-right" {
|
|
switch (direction) {
|
|
case SwipeDirection.up:
|
|
return "swipe-up";
|
|
case SwipeDirection.down:
|
|
return "swipe-down";
|
|
case SwipeDirection.left:
|
|
return "swipe-left";
|
|
default:
|
|
return "swipe-right";
|
|
}
|
|
}
|