Commit Graph
248 Commits
Author SHA1 Message Date
James Babcock ed8302bc6b Refactor build scripts 2026-08-28 12:02:59 -07:00
James Babcock f858f10ce2 Wear watchface design
Makes the button-row appear and disappear with a slide-in/out gesture.
Rearranges the other UI elements for a more watchface-like view.

<details>
<summary>Prompts used</summary>

In faceclaw/wear, we have an Android Wear watch app which can be used as a glasses controller. Currently, its UI is a bit chaotic: we have a bottom row of buttons, the time, a foreground-window title, some help text, and a ring of indicators. The core interaction is tapping, double tapping, long tapping, and swiping (which have the same effect as on the R1 ring), which aren't location sensitive except that they can't hit the row of buttons. There is also a crown, which can be rotated as a prev/next input.

First, let's make a crown-direction setting (in the Watch section of the on-glasses Settings app), which is a toggle that can swap which crown-rotation direction is considered next vs prev. The default will be off, which will be opposite the direction that is currently default.

Next, we will make it so that the row of buttons is hidden by default. They will slide in from the bottom when the user swipes up from off-screen (distinguished from a swipe-up gesture sent to the glasses by the starting position of the swipe). They will slide out with a swipe down starting from anywhere below the top of the buttons (distinguishing from a swipe-down gesture sent to the glasses by the starting position of the swipe).

Next, we will remove the circle and four arrows; change the time from being small, curved and at the top of the screen to being larger, straight and vertically centered. We'll delete the gesture current hint ("● select  ●● back"), and take the current foreground-window display (which is currently either "Disconnected", "Screen off", or an app title) and place it below the time. When the current state is "Screen off", it will display as "●● Wake". We'll then make it so that when the glasses screen is off, all gestures except for double tap (which wakes the screen) are ignored.

gpt-5.6-Sol:

> Implemented the Wear controller redesign.
>
> - Added on-glasses Settings → Watch toggle: “Clockwise crown = next.” Default off maps clockwise to previous, opposite the former default.
> - Replaced the obsolete “Watch input wakes display” setting.
> - Bottom buttons are hidden initially, slide up from a bottom-edge swipe, and dismiss with a downward swipe anywhere in the tray.
> - Removed the ring, arrows, and gesture hint.
> - Added a large centered straight clock with foreground status beneath it; screen-off status is now “●● Wake.”
> - While the glasses display is off, non-double-tap gestures are ignored locally and defensively on the phone.
> - Updated faceclaw/wear/README.md and faceclaw/wear/PROTOCOL.md.
>
> Verification:
>
> - TypeScript type-check passed.
> - All 59 tests passed.
> - git diff --check passed.
> - Wear Gradle compilation could not start because the sandbox blocks Gradle’s local lock socket/cache access.

</details>
2026-08-28 10:28:37 -07:00
James Babcock b9e5e56ac8 Refine the UI of the main screen bottom area
<details>
<summary>Prompts Used</summary>
Thanks. Next up, we're going to work on the main screen bottom input area.

We will have a distinct state for keyboard-input mode (ie when you select a setting with a text field). While in that state, we'll hide other inputs (ie the simulated watch and ring input buttons) and put the text input (which is currently a modal on top of the screen preview) in the space below the screen preview. If it doesn't fit, given the reduced screen height while the keyboard is open, it will overlap the screen preview. When leaving a text-input screen, we will close the keyboard.

When the keyboard isn't open, we will have a tab bar-style row of buttons underneath the screen preview, with three tabs: Settings, Watch, and Ring. The Settings tab will have brightness and screen size options (we will drop the options in the Phone Display section of the Settings app which would hide these settings). The Ring tab will have a set of buttons corresponding to simulated R1 ring inputs (the main page has recently had this, but currently doesn't seem to). The Watch tab will have a simulated watch face for simulated Android Wear watch inputs (this is currently on the main page).

> Done — builds and typechecks cleanly. Here's the shape of it:
>
> **Keyboard-input mode**
> - When a text setting becomes active, the whole tabbed controls area collapses (`controlsVisibility` on the `rc:remote-controls` instances in both orientations), leaving the space below the preview for the editor.
> - The text editor overlay is now anchored to the **bottom** of the page instead of the top. Combined with the keyboard resizing the page, it sits in the space below the preview and only rides up over the preview when the keyboard leaves too little room. To make that resize behavior deterministic, I added `android:windowSoftInputMode="adjustResize"` to the activity in the manifest (previously unset, so Android picked pan-vs-resize itself; note this applies app-wide, which is generally the better behavior for the other pages with text fields too).
> - When the glasses navigate away from the text-input screen (`activeTextSettingId` goes null), the page now dismisses the soft keyboard, and the tab area comes back.
>
> **Tab bar** (`remote-controls.xml` rewritten)
> - Three tabs — Settings, Watch, Ring — as a segmented row of buttons; the selected tab is remembered across page navigations (module-level, in-memory), defaulting to Watch.
> - **Settings**: screen-size picker (labeled row) and the brightness slider + Auto switch, now always shown.
> - **Watch**: the simulated watch face unchanged (touchpad with d-pad overlay and legend) plus the Back/Menu row.
> - **Ring**: a 3×2 grid of larger labeled buttons for the R1 inputs — ▲ Up, ▼ Down, ● Click, ●● Double, ‒ Hold, and Hey Even (the wakeword, which moved here from the old shared action row since it's a ring-scheme input).
>
> **Settings app**: `showBrightnessControlSetting` and `showScreenSizeSetting` are deleted outright (definitions, menu items, and the view-model visibility getters). The Phone display section keeps Preview color and Touch mirror. Users' old stored values for the deleted keys are simply orphaned, which is harmless.
>
> Things worth checking on hardware: the editor's position with the keyboard open (especially on a short screen where it should overlap the preview), keyboard dismissal when backing out of a text setting on the glasses, and dark-mode contrast of the tab buttons (I inverted the selected/unselected colors for `.ns-dark`).
<hr>
Keyboard-open view: Looks good. One minor (preexisting) issue: The input title (eg "Agent bridge port") appears twice.

Keyboard-closed view: It looks like the tabs are vertically centered when they should be closer to the screen preview; and, the tab contents don't seem to be visible at all.

> Both issues fixed, verified on the tablet, and the fixed build is installed on both devices.
>
> **Tab bar centered / contents invisible** — I reproduced it on the tablet and traced it with a native view-hierarchy dump. The visibility bindings and tab switching were actually working fine; the bug was a NativeScript layout quirk: a `GridLayout` with no `rows` attribute gets a single implicit row that behaves like `*` (star). The old page measured the controls inside an `auto` grid row (unbounded, so the star row collapsed to content), but the restructured page puts them in the outer grid's `*` row (bounded measure) — so the rows-less tab-bar grid ballooned to fill all remaining height, centered its buttons in the stretch, and left zero height for the tab contents below it. The fix is explicit `rows="auto"` on the tab bar, both Settings rows, and the Back/Menu row in `remote-controls.xml`. Verified all three tabs on-device: Watch shows the touchpad + Back/Menu, Settings shows the screen-size picker and brightness row, Ring shows the six input buttons, all sitting directly under the preview.
>
> **Duplicate input title** — for a single-field edit, the editor title and the field's own label are the same string (`editorTitle` defaults to the field label), and the page rendered both. The per-field label is now only shown when a second field exists (where the labels actually distinguish the fields); single-field edits show just the one heading.
>
> One thing I noticed but couldn't test while disconnected: the keyboard-mode change is untouched except for that label, so it should still look as you saw it. There's also a pre-existing console error on page load — `keyboardType="text"` is not a valid NativeScript keyboard type (only email/number/etc. are), so the binding logs an error and falls back to the default keyboard. Harmless, but the clean fix would be to leave `keyboardType` unset for plain text; happy to do that if you want.
<hr>
Thanks, that is now working. Next up let's add a microphone button to the tab bar, as the rightmost button. Use an icon rather than text, and make it narrower than the others. The button will leave the tab selection unchanged, and trigger as if the wakeword ("Hey Even") was spoken. This will replace the "Hey Even" button in the Ring section.

In the Watch section, we will vertically center the emulated-watch UI within the remaining space beneath the tab bar, and set a maximum width corresponding to an aspect ratio for the simulated watch face of 1.5:1.

> Done and verified on the tablet; both devices have the new build.
>
> **Mic button** — added as a fourth, narrower (56dp) column at the right end of the tab bar, showing the 🎤 emoji. It uses the plain tab style, never shows the selected state, and taps route to the existing `onSyntheticMicTap` (ring "wakeword"), leaving the tab selection untouched. The "Hey Even" button is gone from the Ring tab, which now has just the five ring inputs (Up / Down / Click on the top row, Double / Hold below).
>
> **Watch tab centering + aspect cap** — the component root is now a `rows="auto,*"` grid (tab bar on top, the three sections sharing the star cell), and the portrait page gives the controls the full star row (with Stop recording moved to an `auto` row beneath, so it still appears when recording). The watch section — face plus the Back/Menu row — is `verticalAlignment="center"` in the leftover height and width-capped at `min(available width, 1.5 × 230dp face height ≈ 345dp)` via a new `watchFaceWidth` getter that recomputes on orientation change (in landscape the side panel's 328dp effectively governs). Verified on the tablet: the face sits centered between the tab bar and screen bottom at the capped width, and Settings/Ring stay top-aligned.
>
> One aesthetic note: on the Samsung tablet the 🎤 emoji renders as a gray studio mic rather than a colorful one — legible, but if you'd rather have a crisper icon I could switch to a font-icon or a tinted drawable.
<hr>
Thanks. For the microphone button, let's use `~/Downloads/noun-microphone-1368757.svg`.

> Done — the mic button now uses your Noun Project SVG instead of the emoji, verified on the tablet and installed on both devices.
>
> Since NativeScript Buttons are text-only, I converted the SVG's two paths into an Android VectorDrawable (`App_Resources/Android/src/main/res/drawable/ic_tab_mic.xml`, with a comment crediting the source file) and made the mic control a button-styled GridLayout tile holding a tinted `Image`. It keeps the 56dp width and the `.tab-button` look, plus a small `android-elevation` so it casts the same shadow as the real MaterialButtons beside it. The icon tints `#333333` in light mode and `#cccccc` in dark mode via `tint-color`, matching the tab label colors, and the tap still fires the wakeword without touching tab selection.
>
> One licensing note: Noun Project icons are CC BY unless you have a Pro license — if you don't, the icon's creator should be credited somewhere user-visible (e.g. an about/credits page) before a public release.
<hr>
(I do have a Nounproject pro license)
Thanks, the icon renders correctly, but it's off-center (top and left rather than centered on both axes), and the height and drop shadow of the mic button now doesn't match the other buttons in the tab strip.

> Fixed and verified on the tablet; both devices have the build.
>
> Two things were wrong, both variations of the same NativeScript grid quirk from before:
>
> - **Off-center icon**: the tile's row was effectively auto-sized — row heights are locked in at measure time, and inside the tab bar's `auto` row the tile was measured unbounded, so its cell hugged the 20dp icon and the layout-time stretch dumped the leftover space below/right of it. Giving the tile an explicit `height: 48` bounds its measure, so its `rows="*"` cell genuinely fills and the icon's center alignments work — confirmed by native bounds (icon at exactly (72−30)/2 within the tile on both axes).
> - **Height/shadow mismatch**: MaterialButtons render 48dp tall inside a 60dp layout box (6dp built-in top/bottom insets), while the tile was stretching to the full 60dp row. It now gets `margin: 6 2` plus the 48dp height, so its edges and its elevation shadow align with the neighboring buttons.
>
> The 48dp is derived from the tab buttons' current font/padding metrics, so if the tab-button styling ever changes materially, that value would need to follow — I left a comment in `app.css` tying them together.
</details>
2026-08-26 00:44:22 -07:00
James Babcock b99aa85964 Move phone screen connection status and warnings to the top bar
<details>
<summary>Prompts Used</summary>
On the main page, there's a triple-dot menu. Its icon is currently black-on-dark (this is true on both a light-mode device and a dark-mode device; the top bark has a dark background in both cases). Make that icon white instead.

We have a connection-status indicator on the main page, that says "Disconnected" or "Connected" or "Reconnecting". Let's move this onto the top-bar, as white text, right-aligned next to the triple-dot menu.

We have several problem-status warnings, eg for not having battery-optimization permission, that appear on the main page in the form of a large button below the screen preview. Let's convert all of thes into a yellow triangle ! icon that appears on the top bar, in between the connection-status indicator and the triple-dot menu. Tapping it will open a modal that shows the message that was previously shown, with a button to do the suggested action.

> All three changes are in, and the project builds and typechecks cleanly. Here's what I did:
>
> **White overflow icon** — The root cause is that NativeScript builds its toolbar programmatically, so the `theme` overlay in `NativeScriptToolbarStyle` (an XML-inflation-time attribute) never applied, and the overflow icon fell back to the light activity theme's dark `textColorSecondary`. I added an `actionOverflowButtonStyle` with a white `android:tint` to `AppThemeBase` in `App_Resources/Android/src/main/res/values/styles.xml`, so the icon is white on every page's bar (they all share the dark #424242 background), in both light and dark device themes.
>
> **Connection status in the top bar** — The ActionBar now has a custom titleView (`main-page.xml:5`): "Faceclaw" on the left, and a right-aligned white status label next to the menu. Since the old status string could be a whole sentence ("Reconnecting after ...", "Failed: ..."), the bar shows a short label derived from the connection phase — Connected / Connecting / Reconnecting / Disconnected / Charging / Disconnecting / Failed — and tapping it opens an alert with the full status message, so failure details aren't lost. The old status label below the controls is removed.
>
> **Warnings → ⚠️ icon + modal** — The three inline warning blocks (Even-app conflict, firmware, battery optimization) are gone from the page body in both portrait and landscape. A yellow warning-triangle emoji now sits between the status label and the overflow menu whenever any warning is active. Tapping it opens an in-page modal (same overlay pattern as the existing text-setting editor) titled "Attention needed", listing each active warning with its original message and action button, plus a Close button. The modal closes when you take an action, and auto-closes if the last warning clears while it's open. One side effect: the landscape layout previously showed the firmware warning without its install button — in the modal it now has the button like everything else.
>
> Worth an on-device check: the overflow-icon tint (theme change, so a full reinstall rather than hot reload), and that the titleView labels sit vertically centered against the toolbar height.
<hr>
Thanks. That all looks good, except there are some stylign issues on the warning modal. On a wide tablet, the modal is full-width, which is too wide. When the device is dark-mode, the "Attention needed" title is white-on-light-gray. The title and the warning text need some left/right padding between them and the edges of the modal.

> All three styling issues are fixed and the build is clean:
>
> - **Too wide on tablets**: the modal's width now comes from a `warningsModalWidth` getter in the view model — screen width minus the margins on phones, capped at 480 DIPs on tablets — and it's centered horizontally. It re-computes on orientation change along with the other layout metrics.
> - **White title in dark mode**: the theme's `.ns-dark .h2` rule was beating my `.warnings-modal Label` rule on specificity. I added a `.ns-dark .warnings-modal Label` selector so all text in the modal stays dark-on-light in both modes (the modal deliberately keeps its light look, matching the text-setting modal).
> - **Missing edge padding**: NativeScript ScrollViews don't apply their own padding to their content, so the `padding: 16` on the modal was silently doing nothing. It now lives on an inner `warnings-modal-content` StackLayout; the border/background/margin stay on the ScrollView.
>
> One note: the text-setting editor modal (`system-name-modal`) uses the same `h2`-on-light-background pattern, so its title likely has the same white-on-light problem in dark mode — I left it alone since you only flagged the warnings modal, but it'd be the same one-line fix if you want it.
</details>
2026-08-25 23:09:21 -07:00
James Babcock b33d858fbc Merge branch 'main' of https://github.com/jimrandomh/faceclaw into android-wear-integration 2026-08-25 22:29:42 -07:00
James Babcock 3089bee76b Merge pull request #16 from jimrandomh/onboarding-flow-fixes
Various fixes to the onboarding flow
2026-08-25 22:29:20 -07:00
James Babcock 816c4709ae Add links to the GPL and privacy policy to the "Before You Continue" page
<details>
<summary>Prompts Used</summary>
Let's add two links to the footer of the "Before you continue" page: A link to the license (GPLv3, contained in LICENSE), and a link to the privacy policy (PRIVACY).
<hr>
Continue

> Done — the build passes. The "Before You Continue" page (step 2 of onboarding) now has a footer with two tappable links, "License (GPLv3)" and "Privacy Policy", centered between the disclaimer text and the Back/Agree buttons. They're only visible on that step, so the splash and firmware steps are unchanged.
>
> What I added:
>
> - **`app/phone-ui/document-page.xml` / `.ts`** — a new phone-side viewer page with an ActionBar (title + back button) and a scrollable label. It reads the doc from `about/<fileName>` in the app bundle; webpack already copies LICENSE and PRIVACY there (webpack.config.js:12), since the glasses-side Settings About section uses them too.
> - **`onboarding-page.xml`** — a third grid row with the two links, bound to `footerVisibility` so it collapses on steps 1 and 3.
> - **`onboarding-view-model.ts`** — `onLicenseTap`/`onPrivacyTap` handlers that navigate to the document page, and the `footerVisibility` getter wired into `publish()`.
> - **`app.css`** — link styling (blue, underlined, padded for a comfortable tap target, lighter blue in dark mode) and a modest 13pt size for the doc text since both files are hard-wrapped plain text.
>
> Untested on hardware: worth a quick visual check that the links look right in dark mode and that the LICENSE text (which is 80-column preformatted) reads acceptably in the proportional font.
</details>
2026-08-25 22:26:30 -07:00
James Babcock a7a5005e8d Move the "Disconnect the Even App" page to before pairing rather than after, and make some minor changes to it 2026-08-25 21:29:06 -07:00
James Babcock b74868bfb3 Flasher only uses right lens for confirmation, rather than confusedly trying to check via each lens separately 2026-08-25 21:14:50 -07:00
James Babcock 97fad7ae2b Add Permissions screen to the onboarding flow, replacing scattered permissions prompts happening later
<details>
<summary>Prompts Used</summary>
Let's add a Permissions screen, to concentrate the various Android permissions requests. This will be shown during onboarding, in between the "Before You Continue" screen and the "Custom Firmware Required" screen. There will also be a "Permissions" menu item in the main screen menu.

Each permission will be a card, styled similarly to the device-selection cards on the Pair Your Glasses screen. Each card will have the title for the permission, some text explaining what the permission is used for, and a checkmark if the permission is already present. The permissions needed are:

Nearby Devices: Needed to communicate with your smart glasses over bluetooth
Send Notifications: A notification will be pinned, to keep Faceclaw running while your phone screen is off.
Battery Optimization: Needed to keep running while your phone screen is off.
Read Notifications: (Optional) Needed to display your Android notification on the glasses.
Microphone: (Optional) Needed to use voice input.
Location: (Optional) Needed to use location-based features like navigation inside glasses apps.
Calendar: (Optional) Needed to display your calendar on the glasses.

> Done — the Permissions screen is in place, builds cleanly, and all the permissions it requests were already declared in the manifest.
>
> **What was added:**
>
> - **New screen** (`app/phone-ui/permissions-page.{xml,ts}` + `permissions-view-model.ts`): one card per permission, reusing the pairing page's card styling (`pairing-row`, `pairing-title`, `pairing-badge`) so they match the device-selection cards. Each card shows the title, the explanation text you specified, and a green ✓ when granted. Tapping an ungranted card launches its grant flow; granted cards ignore taps. The four optional permissions get an "Optional" badge (matching the pairing page's badge style) instead of a "(Optional)" text prefix.
> - **Onboarding wiring**: "Agree" on Before You Continue now navigates to the permissions page, and its "Next" button navigates forward to a fresh onboarding page starting at the Custom Firmware Required step (`onboarding-page.ts` now accepts a `step` context; `OnboardingViewModel` takes an initial step). "Back" returns to the disclaimer.
> - **Main menu**: a "Permissions" popup item on the main page opens the same screen in standalone mode — action bar shown, single "Done" button.
> - **Permission plumbing** (`app/g2/android-permissions.ts`): new granular helpers — `hasBlePermissions`/`requestBlePermissions` (BLE only, split out of the old combined BLE+notifications request), `hasPostNotificationsPermission`/`requestPostNotificationsPermission` (reports granted pre-Android 13, where no runtime permission exists), and `hasMicrophonePermission`/`requestMicrophonePermission`. Existing `ensureBlePermissions` behavior is unchanged for its current callers.
>
> Two of the cards — Battery Optimization and Read Notifications — aren't runtime permissions; they open system screens (the existing `battery-optimization.ts` and `notification-access.ts` natives). Since Android reports their state only on return, the page re-checks all statuses on `Application.resume` (listener attached on page load, detached on unload) so checkmarks appear when you come back.
>
> Two judgment calls worth flagging: the Location checkmark tracks **fine** location (navigation needs precise fixes — "approximate only" leaves it unchecked and re-tappable), and I wrote "your Android notifications" (plural) in the Read Notifications card. This is all hardware-test pending, as usual — the flows to exercise are onboarding step 2 → Permissions → step 3, each card's grant dialog, and the resume-refresh after the battery/notification-access settings detours.
<hr>
Thanks. Let's make it so that the Continue button looks grayed out if you haven't selected all of the required permissions. It will still be active in this case, but will open a "You haven't enabled all of the necessary permissions. Are you sure you want to continue?" prompt. Also, let's add 8px of extra margin between the permission titles and the Optional badge.

> Both changes are in and the build passes.
>
> - **Grayed-out Continue**: the onboarding primary button now binds a `primaryClass` — while any of the three required permissions (Nearby Devices, Send Notifications, Battery Optimization) is missing, it gets a `permissions-primary-dimmed` class (opacity 0.45) so it looks disabled while staying tappable. Tapping it in that state shows a confirm dialog — "You haven't enabled all of the necessary permissions. Are you sure you want to continue?" with Continue/Go Back buttons — and only proceeds to the firmware step on Continue. The class re-evaluates on every refresh, so granting the last required permission un-dims the button immediately. I also renamed the onboarding label from "Next" to "Continue" to match how you referred to it (and the pairing page's onboarding button). Menu mode's "Done" never dims, since there's nothing to warn about when just closing the screen.
> - **Badge spacing**: the "Optional" badge's left margin went from the `m-l-6` class to an explicit `marginLeft="14"` (+8), set inline since the theme doesn't generate an `m-l-14` class.
</details>
2026-08-25 11:28:53 -07:00
James Babcock 1f9f3b35d3 UI refinements to watch app and phone preview
<details>
<summary>Prompts Used</summary>
Thanks. Next up, let's add a "Phone display" section to the Settings app (above the Watch section). We'll add a "Preview color" setting (options: White, Green; default White), which controls whether the mirror display is white/grayscale (best looking) or green (matches the physical glasses). We'll move the "Touch mirror" toggle setting (currently on the phone main screen) into the phone display settings menu. We'll add a "Show brightness control" toggle setting (default off) and a "Show screen size" toggle setting (default off), which control the visibility of the corresponding elements on the phone main screen.

Let's also make it so that double-tapping the watch (or simulated watch on the phone, mirror, etc) while the app-switcher is selected turns off the glasses display, in the same way that double-tappign the R1 ring does.

> All four pieces are in and everything builds (webpack, Gradle with the Java changes, and a clean `tsc`). Summary:
>
> **"Phone display" Settings section** — added between Roam and Watch in the on-glasses Settings app, with four entries:
> - **Preview color** (White/Green, default White) — new enum setting `phone.previewColor`. The colorization happens in the Java preview path: `PreviewBitmapUtil.fromGray` gained a `green` variant whose LUT maps luminance to green-on-black instead of grayscale, threaded through `getCompositePreviewBitmap` → `getCompositePreview(green)` → the controller, which reads the setting per refresh. A settings change also schedules an immediate preview refresh, so flipping the color updates the mirror right away instead of waiting for the next composited frame.
> - **Touch mirror** — moved from the phone main screen. It's now a proper `ConfigSettingBoolean` reusing the existing `phone.mirrorTouch` storage key, so anyone who already turned it off keeps that choice. The label+switch pair is gone from the ring row in `remote-controls.xml`, and the view model reads the setting per gesture.
> - **Show brightness control** and **Show screen size** (both default off) — new booleans controlling visibility of the brightness slider/Auto toggle and the display-mode picker on the phone main screen. The whole display-controls row collapses when both are off; the bindings refresh through the existing `onAnySettingChanged` → `refreshDisplayControls` path, so toggling them from the glasses updates the phone screen live. Note this means the main screen is more minimal out of the box — brightness and screen size remain reachable via the Settings app either way.
>
> **Watch double-tap at the app switcher** — the watch-scheme special case in `handleSidebarInput` is removed: a double-click from any source (watch, phone pad/d-pad, mirror double-tap — they all arrive as source `"watch"`) now turns the display off when the sidebar is selected, exactly like the ring's. The original code deliberately excluded the watch on the theory that sleeping was a trap since any watch gesture re-wakes; with your "Watch input wakes display" setting now gated (and double-tap waking a dark display regardless), the toggle behavior is symmetric: double-tap at the switcher sleeps, double-tap again wakes.
>
> Hardware-test notes: the green preview tint and the collapsed-controls layout are worth one visual check on the phone, and the double-tap-to-sleep from the watch is a quick on-device confirm.
</details>
2026-08-25 01:37:29 -07:00
James Babcock dc1d4d30a9 Wear app UI refinements
<details>
<summary>Prompts Used</summary>

Thanks. Next up, let's make soem refinements to the watch app UI.
We'll remove the glasses-battery indicator from the watch UI (it's already on the glasses screen so not needed there).
We'll merge the connection status into the current-app display; rather than one line saying "Connected" and one line saying "Display off" or an app name like "Launcher", we'll merge these into one indicator (in the second line's position), which is "Screen off" or an app name if connected, or a connection status otherwise.
We'll make rotating the crown scroll/select in the same way that swiping up/down on the ring or glasses touchpad does. Apps that want to pay attention to the exact source and details of an input should be able to, but apps that don't pay attention should get sensible behavior by default. (There might already be some code attempting to do this, but currently in my testing the crown has no effect)

> All three refinements are in, and the wear app builds cleanly. Here's what changed:
>
> **Battery indicator removed.** The glasses-battery readout is gone from both places it appeared: the touchpad's status line and the Status screen's connection chip (which now says just "Connected", with "· charging" kept since that signals glasses-in-the-case rather than battery level). The watch-side `PhoneState.battery` field was dropped too since nothing reads it now — the phone still publishes it in the state item (documented in PROTOCOL.md), so nothing changes on the wire.
>
> **Merged status/current-app indicator.** The touchpad's separate top `StatusRow` ("● Connected · 78%") is removed, and `statusLine`/`focusLine` in Common.kt are merged into one `padLine()` used in the centre position: when connected it shows "Screen off", "Locked", "Listening…", or the foreground app name ("Launcher" when nothing's open); otherwise it shows the connection state ("No phone", "Open Faceclaw on phone", "Connecting…", "Glasses disconnected", …). The old status dot's color coding survives as the text color — app names render in the normal text color, problem/busy/off states in the red/amber/gray tones — so the at-a-glance signal isn't lost.
>
> **Crown scrolling.** The pipeline you suspected does exist and the phone side of it is already exactly what you described: crown steps arrive as `scroll-up`/`scroll-down` carrying `source: "watch"`, so apps that inspect the source can, and apps that just switch on the event type get the same behavior as a ring/touchpad swipe. I traced that path end-to-end and found no phone-side gap. The break is on the watch: rotary events are only delivered to a *focused* Compose node, and RemoteScreen requested focus once via `LaunchedEffect(Unit)` with a plain `FocusRequester` — fragile against the nav host and never re-run after anything steals focus (the keyboard activity round-trip, ambient mode, screen off/on). It now uses `rememberActiveFocusRequester()` (Google's documented rotary pattern, present in the bundled wear-compose 1.4.1, with the required `@OptIn(ExperimentalWearFoundationApi)`), plus a lifecycle observer that re-requests focus on every `ON_RESUME`. The accumulator/sensitivity logic is unchanged.
>
> One caveat on the crown: since I can't reproduce the failure off-hardware, this fix targets the most likely cause (focus never landing or being lost). Worth a quick on-device check — and if the crown *still* does nothing, the useful datapoint would be whether `adb logcat` on the phone shows `sys-event .../SCROLL_*` lines when you turn it, which would split watch-side from phone-side cleanly.
</details>
2026-08-25 01:16:31 -07:00
James Babcock eef7aa2679 <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>
2026-08-25 00:09:47 -07:00
James Babcock 646335cb64 Merge branch 'main' of https://github.com/jimrandomh/faceclaw into android-wear-integration
# Conflicts:
#	app/phone-ui/main-page.xml
#	app/phone-ui/main-view-model.ts
2026-08-24 22:24:03 -07:00
James Babcock ab963974e5 Overridden ring long-press handling also applies for the glasses touchpad 2026-08-24 19:23:09 -07:00
James Babcock 208b14e928 Update ACKNOWLEDGEMENTS 2026-08-24 13:17:09 -07:00
James Babcock ca183e5aed Merge branch 'bluetooth-pairing-improvements' 2026-08-24 12:59:33 -07:00
James Babcock 16d3b7c25f Fix reconnect-loop issue when device MAC address is configured but not paired 2026-08-24 12:56:09 -07:00
James Babcock 1a1416c8f0 Main-form "Disconnect" option is available if in a reconnection-attempt loop. Remove broken/unused "Show Logs" button. 2026-08-24 11:46:40 -07:00
James Babcock 92a2530e0e Merge branch 'main' of https://github.com/jimrandomh/faceclaw into android-wear-integration 2026-08-24 00:23:16 -07:00
James Babcock fa241161e4 Merge branch 'main' of https://github.com/jimrandomh/faceclaw 2026-08-24 00:19:07 -07:00
James Babcock ce43192852 Merge pull request #13 from kalanihelekunihi/bluetooth-pairing-improvements
Add proximity-based pairing for Even devices
2026-08-24 00:18:12 -07:00
James Babcock fea29c5ff3 Add a bunch of refinements to the pairing process
<details>
<summary>Prompts Used</summary>
Thanks. Let's address 1-8. We can leave the setLegacy(false) in place as too-old phones are already unsupported for other reasons. Let's pause the scan and timer when the app is backgrounded and resume it when it's foregrounded again. Let's deduplicate and clean up the things mentioned in that section. We don't need to support single-arm pairing at all; the glasses themselves won't boot/function unless both temples are working.

I tested on-device and also noticed some dark-mode issues and minor UI cleanup. The instructional text at the top ("Take the glasses out of there case [...]") is dark-on-dark if in dark mode. The background behind the glasses, ring, and selected cards is light-blue (regardless of dark mode); some of the text on it is white and some is black. Let's keep the card background the same in light mode and make it dark-gray in dark mode.

> All fixes are implemented, tested, and committed as `1718253` on `bluetooth-pairing-improvements` — but one thing needs your decision before the PR itself updates (details at the end).
>
> ## What landed
>
> **Findings 1–8**, as requested:
>
> 1. **Auto-reconnect** — `onPairGlassesTap` now calls `resumeAutoReconnect()` right after the pre-scan disconnect (pairing is a detour, not a Disconnect), so the main page's `autoConnect` picks the glasses back up on return. The config page's "Scan for glasses" now also drops the live link first (lazy-required controller so onboarding still never instantiates the singleton).
> 2. **Mixed-arms warning** — `pairs()` groups by a new canonical `serialKey()`, and when exactly one lone left and one lone right with different serials are visible, both rows now carry the "arms from two different pairs" warning. (The old per-row check was provably unreachable, since a serial-keyed group can't contain two serials.)
> 3. **Degrading selection** — `refresh()` deselects a pair that regresses below complete, and `onPrimaryTap` refuses to save a one-armed pair instead of padding it with stored addresses. Since single-arm pairing is unsupported, the identity is now always saved on a pair save.
> 4. **ingest() clobbering** — a manufacturer-data-less record (bonded re-emit or split report) no longer overwrites note/flag/name learned from a full advertisement; additionally, a split report that fails to classify on its own is retried with the remembered name/manufacturer data, so a nameless half no longer drops the arm.
> 5. **TX power** — `estimateProximity` no longer takes a TX-power argument at all; the calibration table is the only reference, and confidence no longer rewards an advertised value.
> 6. **Ring identity** — a ring-only save updates `ringName`/`ringAddress` in the stored identity.
> 7. **Ring detection** — TS requires the stock `EVEN R1` prefix; Java admission tightened to match (still a strict superset).
> 8. **One-shot scans** — `scanCandidates` keeps every sample, and `buildAddressSet` runs them through `DiscoveryAggregator`: left/right come from the closest serial-joined *complete* pair. Bonded-only batches (no serials anywhere) keep the old per-role fallback so "Load paired devices" still works. `setLegacy(false)` left as-is per your call.
>
> **Backgrounding** — the pairing model hooks Application suspend/resume: scan + 500 ms timer stop on suspend and restart on resume, with the hooks detached when the page is truly left (back navigation, Save, Cancel).
>
> **Cleanup** — one MAC normalizer (`normalizeMacAddress`, now in the pure advertisement module, re-exported by device-addresses, used for the ring "Yours" compare); one serial-equality definition (`serialKey`/`serialsMatch`, containment fallback removed); shared `formatErrorMessage` replaces five copies (there were 5, not 3); shared `app/util/hex-util` replaces the duplicate TS hex codecs (firmware-builder keeps its strict validation as a thin wrapper); one Java `bytesToHex` in `FaceclawFirmwareUtil` replaces three; `glassesRow`/`ringRow` share a presentation-base helper; dead row-address fields, `glassesSectionVisibility`, the identical-branch ternary, and `zoneRank`/`ZONE_ORDER` deleted; `.test-build/` added to `.gitignore`.
>
> **Dark mode** — light mode is untouched; in dark mode the instructions and empty-state text get light grays, all cards go dark-gray (selected keeps a blue border on a blue-tinted dark gray), and every card text color has an explicit dark-mode counterpart so nothing mixes white and black on one card. Worth a quick on-device look since I can't verify colors visually.
>
> **Verification**: `npm test` — 60/60 pass including 5 new tests (mixed-arms warning, bonded-re-emit preservation, split-report merge, strict ring prefix, TX-power arity pin); `build.sh` and `tsc --noEmit` clean; Java compiles in the Gradle build.
>
> ## The catch: PR #13 is from a fork
>
> PR #13's head branch lives in **kalanihelekunihi/faceclaw**, not your repo. My `git push origin` created a same-named branch in *your* repo (which doesn't touch the PR), and when I then tried to push to the fork's branch (allowed — the PR has "maintainer edits" enabled), the permission gate blocked it, sensibly, since it writes into someone else's repository. Your options:
>
> - **Update the PR**: `git push https://github.com/kalanihelekunihi/faceclaw.git bluetooth-pairing-improvements:bluetooth-pairing-improvements` — the local branch contains their commit plus your merge of main plus the fixes.
> - **Or merge directly**: the fixed branch is already at `origin/bluetooth-pairing-improvements` in your repo; merge it to main and close PR #13 with a comment. (If you go this route, note the accidental branch on origin is the thing you'd merge — otherwise you may want to delete it.)
<hr>
Thanks. Next up, after selecting devices and clicking Continue and advancing to the "Checking Firmware" stage, the check fails with "no response to the device-info query". This was when testing on a device that hasn't previously been paired with the glasses (as opposed to the more common case of a device taking over an already-bonded connection that was created by the stock Even app and remembered in Android's paired devices list), when connecting to glasses with stock firmware 2.2.9. I believe this was preexisting and not introduced in this branch. I have a logcat from the run in ~/tmp/a9_logcat.

Possibly relevant: Firmware version 2.2.9 changed some details of connection and pairing, which broke `g2flash`. A writeup of what changed is in ../notes/ble-connections-2.2.9.md.

> Done. Here's the summary:
>
> ## Root cause — confirmed
>
> The logcat corroborated the 2.2.9 writeup exactly. At 14:09:43 the phone opened an ACL connection to `Even G2_32_R_820967` (the probe connecting to the right arm), and it dropped 5.5 s later — connect + discovery + prelude ack + the probe's 4 s query timeout, then the probe closing. Critically, **no SMP pairing or bonding activity appears anywhere in that window**: nothing ever asked the lens to authenticate or encrypt. On 2.2.9, the firmware acks the prelude but won't answer the settings query until the sid-0x80 security-auth exchange completes over an encrypted link — and on a never-bonded phone, that exchange is also what triggers SMP pairing in the first place. The probe (like every Faceclaw connection path) never sent it, so it only ever worked by inheriting a bond the stock Even app had created.
>
> ## The fix (committed as `1bde70a`, pushed to `origin/bluetooth-pairing-improvements`)
>
> Implemented the authentication exchange from `../notes/ble-connections-2.2.9.md` (the g2flash-validated wire format) across all four connection paths:
>
> - **`BleProtocol`**: `buildAuthenticationRequest(magic)` (f1=4, f2=magic, f3={f1=1,f2=4} on sid `0x80`, flag `0x00`) and `isAuthenticationSuccess` (strict per the writeup: command 4, matching magic, empty `1a 00` result — a completed GATT write is not success).
> - **Device-info probe** (the failing path): authenticates after subscribing, before the prelude, with a 30 s window since a first-time connection may sit waiting on the OS pairing dialog — the check page now shows *"Authenticating with your glasses... If Android asks to pair, tap Pair."* I made this one **soft**: the probe also runs against the custom firmware, whose response to the exchange isn't hardware-verified, so an unconfirmed auth falls through to the query as before — but a query timeout after unconfirmed auth now says the pairing didn't complete instead of the bare "no response" you saw.
> - **Flash-prompt communicator**: authenticates each arm before the prelude, mandatory (it only ever talks to stock firmware).
> - **Firmware flasher**: control-channel notifications are now mandatory, each lens authenticates before OTA `BEGIN`, and I removed the OTA-time heartbeat entirely per the writeup's follow-up list — official captures show no control traffic mid-transfer, heartbeats demonstrably don't satisfy the 2.2.9 deadline, and a concurrent control writer interleaves with the marker/data transactions. The envelope counter also resets after bring-up, mirroring the stock sequence.
> - **Main communicator**: authenticates both arms after connecting, before the prelude, with a short (6 s) soft wait that logs and continues on timeout — so firmware that never answers can't stall every reconnect, while stock 2.2.9 (e.g. the incompatible-firmware detection path) gets a working session.
>
> Build passes (webpack + Gradle/Java). Left `setLegacy(false)` and everything else untouched.
>
> **Hardware tests to run**: fresh-phone onboarding against stock 2.2.9 end-to-end (check → on-lens prompt → flash — expect one Android pairing request per lens the first time), and a regression pass on custom-firmware connect + re-check. One thing to watch: if the CFW turns out not to answer the auth request, the probe adds ~30 s per check on CFW glasses — if you see that, tell me and I'll gate the long wait on bond state.
<hr>
Hmm, that did make it pair fully (which if nothing else is necessary for the next step where we actually flash firmware), but I'm still getting "no response to the device-info query".
One thing to check: Are we sending the message and expecting the response on the correct lens? Some messages are right-lens-only and this might be one of them.

> Pushed as `a7684f6`. Here's where the investigation stands:
>
> ## Answer to your lens question
>
> I checked the routing against every reference we have, and the probe *is* doing what the pre-2.2.9 world says is correct:
>
> - The probe sends prelude + settings query to the **right** arm — same as Faceclaw's main communicator (`MessageBuilder.batteryQuery()` has `isLeftArmMessage=false`), which is the path that works when bonded.
> - `g2-kit-unofficial`'s `transport.md` is explicit: "For most things we only use the **right arm**… The L arm is silent on async channels," and its `settings.ts` sends the same query shape (commandId=2, `settingInfoType=BASIC`) to the right-arm session.
> - But: all of that predates 2.2.9, and `g2flash.py` — the only thing hardware-validated against 2.2.9 — never does a settings read at all (auth + OTA only). The 2.2.8-app capture slice also contains no settings read. So **nobody has a verified 2.2.9 settings-read exchange**, and your hypothesis can't be ruled out from references.
>
> One telling detail from your report: the error text you got was the *plain* "no response…" variant, which the probe only produces when the auth exchange **succeeded** (an unconfirmed auth appends a pairing hint). So on 2.2.9 the right lens acks the prelude, completes security auth, and still won't answer the settings read — the auth gate wasn't the (whole) story for this particular message.
>
> ## What I changed — one run should settle it
>
> Rather than guess again, the probe is now an instrumented experiment:
>
> 1. **Full frame tracing** — every control-channel frame in both directions (sid, flag, protobuf type, magic, fragment info, payload hex prefix) plus every write logs under the `FaceclawDeviceInfo` tag. If the lens is answering with an unexpected flag, a different magic, a fragmented frame, or a device-initiated push we've been dropping, it will be in the trace.
> 2. **Query retry** — the read is attempted twice per lens before declaring silence.
> 3. **Push acceptance** — any sid-0x09 frame that parses to firmware versions is accepted as the answer even if it doesn't match our magic (in case 2.2.9 pushes the snapshot on its own magic instead of acking reads).
> 4. **Left-lens fallback** — if the right lens stays silent, the probe runs the identical connect → auth → prelude → read against the **left** lens and uses its answer, logging which lens replied. That's your hypothesis tested directly, in the same run.
>
> Build passes. When you re-run the check, please grab the app-side log — last time's capture only had the system buffer, so none of the probe's own lines were in it:
>
> ```
> adb logcat -s FaceclawDeviceInfo
> ```
>
> That trace will show exactly what each lens said (or didn't), and whichever way it comes out, we'll know whether the fix is "query the left lens", "match the response differently", or something 2.2.9-new.
<hr>
Thanks. There's now a filtered logcat file at ~/tmp/logcat_deviceinfo and an unfiltered logcat at ~/tmp/logcat.

> Mystery solved — and the check is passing on your fresh device now. Here's what the trace showed:
>
> ## What the frames said
>
> 1. **The right lens is the correct endpoint after all.** Every successful read came from the right lens; the left-lens fallback never fired.
> 2. **The real culprit was a post-prelude drop window.** In each failing sequence: auth succeeds → prelude acked → our settings read (magic 101) goes out → and right around it the *lens* starts sending its own sid `0x80` notifications (flag `0x01`, command 4, device-chosen magics like 252/104, payload `{f1:1}` — a shape distinct from both our request and the success ack, repeating ~2 s apart). A read that lands inside that window is silently swallowed. The retry 4 s later (magic 102) was answered within ~100 ms, every single run. In the one run where the lens's notification arrived *before* our read, the first read succeeded immediately — so it's a brief busy window, not a rejection.
> 3. So the fresh-phone failure was two stacked problems: missing auth prevented pairing entirely (fixed last round), and once auth existed, the first read still intermittently fell into this window (fixed by the retry). The earlier `17:13:36` line in your log even shows one lucky success on the previous build — it was always timing-dependent.
>
> ## Follow-ups (pushed as `3e44083`)
>
> - **Flash-prompt page-create now retries once too** — it writes at exactly the same post-prelude moment, so it would have hit the same window intermittently when you proceed to the actual flash step.
> - **Documented the finding** in `../notes/ble-connections-2.2.9.md` as a new "Post-prelude drop window and device-initiated sid-0x80 notifications" section, including the observed frame bytes and the guidance to retry the first post-prelude request.
> - The probe's frame tracing is still in place — it'll be useful when you test the flash itself.
>
> One open question I noted in the writeup: we currently ignore the lens's own sid-0x80 notifications and saw no ill effect in these short sessions, but if a long-lived stock-firmware connection (the main communicator's incompatible-firmware detection) ever misbehaves, those unanswered notifications would be the first suspect — we don't know whether the stock app replies to them.
>
> Next step when you're ready: the flash path itself on this fresh device — the flasher now authenticates per lens and streams without heartbeats (matching the hardware-validated g2flash sequence), but that's the one leg still untested on hardware.
<hr>
Another developer reported running into a Samsung-device-specific issue where inbound (glasses-to-phone) messages larger than 64 bytes were truncated. The response to the Settings message (containing the firmware-extensiosn string) is larger than that, and it might be packaged in a way where truncation causes the packet to be dropped entirely. I tested on a different device and it looks like the no-settings-reply issue only replicates on the Samsung tablet.

> Pushed as `b952cc2`, and the workspace note is corrected. Summary of how the Samsung report changes the picture:
>
> ## Reconciling the report with the trace
>
> The 64-byte theory fits everything, with one important detail: nothing arrived at the app for the missing replies — the probe's tracing logs every value delivered on the control characteristic, even unparseable ones, and `FaceclawBleManager` filters nothing. So on this tablet, oversized values are being *dropped below the app layer*, not truncated-and-delivered.
>
> The size arithmetic supports it: every frame the tablet did deliver was ≤55 bytes (the steady-state settings reply is 8+47). The missing first reply would only trip a 64-byte limit if it were larger — either the firmware's first reply carries a fuller snapshot, or it gets coalesced into one notification value with one of those lens-initiated sid-0x80 notifies (11-byte frame + 55-byte frame = 66 bytes > 64). Both variants explain why the other device never reproduces it, why the retry (compact reply) always lands, and why the one run where the notify had already been delivered separately succeeded first try. If you still have the other device's `FaceclawDeviceInfo` trace, one line would settle which variant it is: the `len=` of its *first* settings reply (47 → coalescing; >55 → fuller first snapshot).
>
> ## What I changed
>
> - **`BleProtocol.splitFrames()`** — splits a notification value into its individual `aa21`/`aa12` envelope frames. This fixes a real latent bug the theory exposed: we only ever parsed the *first* envelope per value, so a coalesced second frame was silently dropped even on healthy devices. The probe, flash-prompt communicator, and flasher control channel now process every frame in a value.
> - **Better tracing** — the probe logs multi-frame values with the raw value size, and marks any frame whose actual length falls short of its declared length as `TRUNCATED`. If Samsung ever delivers a truncated value rather than dropping it, the next trace will say so explicitly.
> - The first-request retries from last round remain the workaround for values the Samsung stack drops outright — that's what already makes the check pass on the tablet, and the flash prompt has the same insurance.
>
> ## The residual exposure worth deciding on
>
> The onboarding flow itself should now be Samsung-safe: all flasher OTA acks are 12 bytes, the auth reply is 19, the prompt-page acks are small. But **after** flashing, the custom firmware's settings reply carries the capability string — well over 64 bytes in a single frame. On this tablet the main communicator would never see it and would report "firmware not detected", and no app-side code can recover bytes the stack never delivers. Since you control the CFW, the durable fix is firmware-side: have the CFW chunk its lens-to-phone notifications at ≤64 bytes (or split the caps into a separate small frame) — that work lives in the g2flash patches repo, not here. I've noted this in `../notes/ble-connections-2.2.9.md` and memory so it doesn't get lost when you hit it.
<hr>
Let's replace the single "Retry" option with three buttons "Retry", "Install", and "Skip" (Install proceeding as if we had detected stock firmware, skip proceeding as if we had detected compatible custom firmware).
<hr>
Continue
<hr>
Continue

> Done — pushed as `9adff01`.
>
> When the firmware check lands in the error state, the button row now offers four actions:
>
> - **Install / Skip** (new row, error phase only):
>   - **Install** navigates straight to the flash page with `mode: "install"` — identical to what the "Install Firmware" button does after a real stock-flashable detection.
>   - **Skip** routes through the same `applyClassification("custom", …)` path as a genuine custom-firmware detection, which matters for one subtlety: if the phone-side G2 fonts haven't been extracted yet, Skip still runs the font download/extraction step before showing "you're all set" with Finish, rather than completing onboarding with EvenHub fonts missing.
> - **Back / Retry** keep their existing places, with Retry remaining the primary action.
>
> Both new handlers are guarded on the error phase so a stale tap can't fire them from another state, and the row collapses everywhere else. Build passes; visual check on the tablet pending as usual.
<hr>
Let's make some refinements to the onboarding flow.

On the initial splash screen (Faceclaw / Perching on the faces of giants / logo), the logo is a black-on-transparent image. This looks reasonable in light mode on a phone-sized screen, but on a dark-mode tablet it's too low contrast, is too close to the top (we'd like it vertically centered), and is too small.

On the "Pair Your Glasses" screen, we will remove some unnecessary UI elements. In the list of glasses and list of rings, there's a "Closest" badge; hide that badge unless there is more than one entry in the list for it to be closer-than. Keep the signal-strength-out-of-four estimate, but remove the conversion to estimate distance in cm/m. Remove the line that says "Advertising" from the ring. Remove the log display from the bottom (it says "scan started (unfiltered, low latency)" and if you press the pause button also "scan stopped").

On the "Flashing Firmware" page, we have a progress bar with step-size based on the number of segments uploaded so far. Since the update package is one large segment and five small ones, this makes it progress very unevenly. Weight the sizes by segment size.

On the "Configure Devices" screen, the Save and Back button positions are swapped (Back should be on the left, Save on the right). If the device is in dark mode, the text boxes for right arm/left arm/R1 ring MAC addresses are white-on-white.

> All four refinements are in place; the build (webpack + Gradle) succeeds and all 59 node tests pass.
>
> **Splash screen** (`onboarding-page.xml`, `onboarding-view-model.ts`, `app.css`): Step 1 now renders as its own vertically-centered stack (headline, tagline, logo) instead of sharing the top-anchored ScrollView with steps 2–3. The logo height scales to ~40% of the screen height (capped at 480dp so the 306×512 PNG doesn't upscale into mush), and a new `.ns-dark .onboarding-logo { tint-color: #e6e6e6 }` rule tints the black-on-transparent art light in dark mode.
>
> **Pair Your Glasses** (`pairing-candidates.ts`, `ble-proximity.ts`, `pairing-view-model.ts`, `pairing-page.xml`): `nearestCandidateId` now returns null for a single-entry list, so the "Closest" badge only appears when there's something to be closer than (the "Yours" badge is unaffected). The proximity line keeps the ●●●○ glyph and zone label but drops the cm/m distance — I deleted `formatDistance`/`proximitySummary` from ble-proximity entirely since the pairing list was their only consumer. The ring's "Advertising" line is gone (rows only show "Paired with this phone" when bonded, with a visibility binding so empty lines don't take space), and the diagnostics log at the bottom is removed along with its view-model plumbing and CSS.
>
> **Flashing Firmware progress** (`FaceclawFirmwareFlasher.java`, `FaceclawFirmwareFlasherListener.java`, `firmware-flasher.ts`, `onboarding-flash-view-model.ts`): the Java flasher now reports `bytesSent`/`bytesTotal` across the whole lens image alongside the existing component/block indices, and the progress bar is driven by the byte ratio instead of stepping evenly per component — so the one large segment no longer makes the bar crawl and then sprint. The "part 2/6, block x/y" status text is unchanged.
>
> **Configure Devices** (`config-page.xml`, `app.css`): Back is now on the left and Save on the right. The white-on-white fields came from the app's unconditional `TextField { background-color: #ffffff }` colliding with the theme's `.ns-dark TextField { color: white }`; a new `.ns-dark TextField` rule gives dark fields with light text (placed before the `.system-name-modal` rule so that deliberately light modal still wins its tie).
>
> These are phone-UI changes verified by build and unit tests only — worth a quick visual pass on the dark-mode tablet, and the byte-weighted progress bar will only show its behavior during a real flash.
</details>
2026-08-24 00:16:20 -07:00
James BabcockandClaude Fable 5 9adff011b4 Firmware check: add Install and Skip escape hatches to the error state
When the check itself fails, the only option was Retry. Add two more:
Install proceeds as if stock flashable firmware had been detected (straight
to the flash page), and Skip proceeds as if compatible custom firmware had
been detected — routed through the same classification path, so the
phone-side G2 font extraction still runs when the fonts are missing. Both
appear only in the error phase; Back and Retry keep their places.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016ZqzwmRQ3HQxasBz5rYyZV
2026-08-23 23:57:41 -07:00
James BabcockandClaude Fable 5 b952cc2269 Handle coalesced envelope frames; trace truncated values (Samsung >64B issue)
Another developer reports Samsung devices truncating inbound notifications
larger than 64 bytes, and the missing-settings-reply issue indeed reproduces
only on the Samsung tablet. Every frame the tablet DID deliver was <=55 bytes;
a reply would only trip a 64-byte limit if it were bigger -- e.g. a fuller
first-reply snapshot, or a reply coalesced into one notification value with
one of the lens's own sid-0x80 notifies (11+55 = 66 bytes).

The coalescing case also exposed a latent app-side bug: parseFrame only ever
read the FIRST envelope in a notification value, so a second frame packed into
the same value was silently dropped even on healthy devices.

- BleProtocol.splitFrames(): split a notification value into its individual
  aa21/aa12 envelope frames (self-describing via the length byte), returning
  a trailing partial frame as-is so callers can log stack truncation.
- Device-info probe, flash-prompt communicator, and flasher control channel
  now process every frame in a value. The probe additionally logs multi-frame
  values (with the raw value size) and marks frames whose actual length falls
  short of the declared length as TRUNCATED, so the next tablet run can
  confirm whether the stack truncates or drops oversized values.

The existing first-request retries remain the workaround for replies the
Samsung stack drops outright. Known residual exposure, not addressed here:
the custom firmware's settings reply carries the capability string and is
well over 64 bytes in a single frame, so on affected Samsung devices the
main communicator would never see CFW capabilities; the durable fix is
firmware-side (chunk lens-to-phone notifications at <=64 bytes), since an
app cannot recover bytes the stack never delivers.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016ZqzwmRQ3HQxasBz5rYyZV
2026-08-23 19:47:57 -07:00
James BabcockandClaude Fable 5 3e440830a3 Flash prompt: retry the page-create once (2.2.9 post-prelude drop window)
The device-info frame trace settled the remaining firmware-check mystery: the
right lens is the correct settings endpoint, but on stock 2.2.9 a request
written immediately after the prelude ack is sometimes silently dropped while
the lens emits its own sid-0x80 notifications (flag 0x01, cmd 4, device-chosen
magic, result {f1:1}, ~2 s apart). The probe's retry answers within ~100 ms
every time, so the check now passes; the left-lens fallback never fired.

The flash-prompt page-create goes out at exactly the same post-prelude moment,
so give it the same single retry. Finding documented in
../notes/ble-connections-2.2.9.md.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016ZqzwmRQ3HQxasBz5rYyZV
2026-08-23 17:32:15 -07:00
James BabcockandClaude Fable 5 a7684f603d Device-info probe: frame tracing, query retry, push acceptance, left-lens fallback
On stock 2.2.9 the settings read on the right lens goes unanswered even after
a successful security-auth exchange and fresh pairing. Since no 2.2.9-era
capture of a settings read exists (g2flash only exercises auth + OTA), turn
the probe into an experiment that a single on-device run can settle:

- Log every control-channel frame (sid/flag/type/magic/frag/payload prefix)
  and every write under the FaceclawDeviceInfo logcat tag.
- Retry the settings read once before concluding a lens is silent.
- Accept a sid-0x09 frame carrying firmware versions on the device's own
  magic (an unsolicited push) as an answer, not just the awaited ack.
- If the right lens stays silent, run the same connect/auth/prelude/read
  against the LEFT lens and use its answer, logging which lens replied, to
  test whether 2.2.9 moved the settings endpoint.

The probe now takes both arm addresses; the firmware-check page passes them.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016ZqzwmRQ3HQxasBz5rYyZV
2026-08-23 17:24:19 -07:00
James Babcock 33f06b9655 Fix up the first few pages of the onboarding flow 2026-08-23 16:52:34 -07:00
James BabcockandClaude Fable 5 1bde70aa45 Implement the 2.2.9 security-auth exchange on every stock-facing BLE connection
Firmware 2.2.9 requires the sid-0x80 DEVICE_SETTINGS/AUTHENTICATION(4)
exchange shortly after each GATT connection: it gates query responses on
completing it over an encrypted link, and closes unauthenticated links after
~30 s. On a phone with no existing bond (no inherited stock-app pairing) the
exchange is also what triggers SMP pairing. This is why the onboarding
firmware check failed with "no response to the device-info query" on a fresh
device: the probe connected, the prelude was acked, but the settings query was
never answered and no pairing ever happened. (See
../notes/ble-connections-2.2.9.md, validated by g2flash on hardware.)

- BleProtocol: buildAuthenticationRequest / isAuthenticationSuccess (strict:
  command 4, matching magic, empty result message), SID_SECURITY_AUTH.
- Device-info probe: authenticates before the prelude with a 30 s window (the
  user may need to accept an OS pairing prompt; the check page says so). Soft
  on non-response since the probe also runs against the custom firmware —
  but a query timeout after unconfirmed auth now names the pairing problem.
- Flash-prompt communicator: authenticates each arm before the prelude
  (mandatory — it only ever talks to stock firmware).
- Firmware flasher: control-channel notifications are now mandatory, each
  lens authenticates before OTA BEGIN, and the OTA-time heartbeat is gone —
  official captures show no control traffic during a transfer, heartbeats
  demonstrably do not satisfy the 2.2.9 deadline, and a concurrent control
  writer interleaves with the marker/data transactions. The OTA envelope
  counter now resets after bring-up, mirroring the stock sequence.
- Main communicator: authenticates both arms after connecting, before the
  prelude, with a short soft wait (logs and continues on timeout so firmware
  that never answers cannot stall reconnects).

Hardware test pending: fresh-device onboarding against stock 2.2.9 (check,
prompt, flash), and a regression pass on custom-firmware connect + probe.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016ZqzwmRQ3HQxasBz5rYyZV
2026-08-23 16:19:16 -07:00
James BabcockandClaude Fable 5 17182532f4 Address review findings for the proximity-pairing PR
Correctness:
- Pair-glasses flows no longer strand the app in the manual-disconnected
  state: the pre-scan disconnect is followed by resumeAutoReconnect(), and
  the config page's scan hand-off drops the live link too.
- The mixed-arms serial warning is reachable now: pairs() groups by the
  canonical serial key, and a lone left + lone right with different serials
  get the mismatch warning on both rows (it previously required two
  different serials inside one serial-keyed group, which cannot happen).
- A selected pair that degrades to one arm (prune while the page is open)
  is deselected, and Save never pads a missing arm from stored addresses.
- DiscoveryAggregator.ingest no longer lets a bonded re-emit or split
  advertisement overwrite the note/name/flag learned from a full
  advertisement, and reclassifies split reports using remembered fields so
  a nameless half doesn't drop the arm.
- estimateProximity ignores the advertised TX Power Level (radiated power,
  not measured-power-at-1m); the calibration table is the only reference.
- Saving a ring without a glasses pair updates the stored identity's ring
  name/address instead of leaving the previous ring on record.
- Ring detection requires the stock "EVEN R1" name prefix in both the TS
  classifier and the Java pre-filter; a bare "R1" substring matched
  unrelated devices, and ring rows are always selectable.
- One-shot scans keep every sample (buildAddressSet merges them through
  DiscoveryAggregator), and flash-flow address resolution takes left/right
  from one serial-joined complete pair instead of latest-per-role.

Lifecycle:
- The pairing scan and its refresh timer pause on app suspend and resume
  with the app, and the model's app-event hooks are detached when the page
  is left for good.

Cleanup:
- One MAC normalizer (even-advertisement.normalizeMacAddress, re-exported
  by device-addresses), used for the ring "Yours" comparison too.
- One serial-equality definition (serialKey/serialsMatch); the containment
  fallback in isPreviouslyPaired is gone.
- Shared formatErrorMessage replaces five per-view-model copies; shared
  hex-util replaces the duplicate TS hex codecs; one Java bytesToHex in
  FaceclawFirmwareUtil replaces three hand-rolled encoders.
- glassesRow/ringRow share a presentation-base helper; dead row address
  fields, the constant glassesSectionVisibility, the identical-branch
  status ternary, and zoneRank/ZONE_ORDER are removed.
- .gitignore now actually covers .test-build/ as tests/README claims.

UI:
- Dark-mode styles for the pairing page: readable instructions, dark-gray
  cards with consistent light text; light mode keeps its current look.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016ZqzwmRQ3HQxasBz5rYyZV
2026-08-23 15:28:59 -07:00
James Babcock ee022cdc84 Merge branch 'main' into bluetooth-pairing-improvements 2026-08-23 13:39:50 -07:00
James Babcock fa332f945e Add some entries to .gitignore and .ackrc 2026-08-23 13:36:19 -07:00
Kalani Helekunihi 8fa04d1b46 Add Wear OS companion app and remote controls
Add a Wearable Data Layer bridge for syncing dashboard state and commands.

Introduce a standalone watch app with assistant, app launcher, touchpad remote, settings, and connectivity UI.
2026-08-23 15:02:35 -05:00
James Babcock 2b71eddab5 Optimize APK size
Removes unused keyword-spotting model. Makes on-device voice model a
runtime download rather than bundling it. Removes native-code library
versions for 32-bit and x86_64 processors.
2026-08-22 23:04:01 -07:00
James Babcock 69ec828cb7 Add release-build script; and bump version number to 0.5.0 2026-08-22 22:28:36 -07:00
James Babcock cc4b69fb80 UI tweaks 2026-08-22 21:53:54 -07:00
James Babcock c199dc2369 Fix bug that caused album art to sometimes not be displayed in Music app when it should 2026-08-22 21:23:16 -07:00
James Babcock 99801361cb Fix layout of the music app when font size is larger 2026-08-22 21:22:49 -07:00
Kalani Helekunihi aaaa7288ee Add proximity-based pairing for Even devices
Stream BLE advertisements into a dedicated pairing flow with arm, ring, serial, and hardware variant detection.

Add proximity ranking, device artwork, pairing safeguards, and unit coverage for discovery and candidate grouping.
2026-08-22 21:50:17 -05:00
James Babcock 35e6977c6c UI refinement pass
Remove gesture-help bottom-bars from many places in the UI, adjust
layouts to be able to handle larger fonts, and other small UI fixes.
2026-08-22 18:48:20 -07:00
James Babcock dc18737dfc Stay disconnected when you pick Disconnect, back off reconnecting to incompatible firmwares, don't try to also connect for UI when the flasher is open 2026-08-22 16:28:02 -07:00
James Babcock 0ed242a36f QR code loading works 2026-08-22 00:24:36 -07:00
James Babcock 5db6df93dd Merge branch 'main' into evenhub-from-qr 2026-08-21 23:55:08 -07:00
James Babcock 85af350ce2 Make the compass app visually fancy 2026-08-21 23:54:27 -07:00
James Babcock 5ffba82f45 Merge branch 'main' into fancy-compass 2026-08-21 23:14:22 -07:00
James Babcock 8ebfbb4fa6 Speed up connection/wake
Removes "image warmup", which was a workaround for a firmware bug that
no longer exists (even in stock, I think).
2026-08-21 22:58:44 -07:00
James Babcock a6d63281ba Add "clean" target to package.json 2026-08-21 22:49:10 -07:00
James Babcock a77b813898 Add visual fanciness to the compass 2026-08-21 12:04:03 -07:00
James Babcock 92cd05b6ca Add options to load an app from a URL or a QR code
(The QR code reading does not work yet)
2026-08-21 12:03:24 -07:00
James Babcock 6e4ece5dc7 Brightness-correct and dither music player album art images 2026-08-21 10:54:25 -07:00