diff --git a/App_Resources/Android/app.gradle b/App_Resources/Android/app.gradle
index 7569cf33..00b6d984 100644
--- a/App_Resources/Android/app.gradle
+++ b/App_Resources/Android/app.gradle
@@ -12,6 +12,9 @@ dependencies {
// code" entry. Scanner UI and camera live in Play Services, so Faceclaw
// needs no camera permission and no third-party scanner app.
implementation 'com.google.android.gms:play-services-code-scanner:16.1.0'
+ // Wearable Data Layer (MessageClient / DataClient / CapabilityClient) for
+ // the Wear OS watch remote; see FaceclawWearBridge and wear/.
+ implementation 'com.google.android.gms:play-services-wearable:19.0.0'
}
def faceclawSherpaOnnxVersion = "1.13.0"
diff --git a/App_Resources/Android/src/main/AndroidManifest.xml b/App_Resources/Android/src/main/AndroidManifest.xml
index 48dda00b..5074e8ea 100644
--- a/App_Resources/Android/src/main/AndroidManifest.xml
+++ b/App_Resources/Android/src/main/AndroidManifest.xml
@@ -110,6 +110,22 @@
+
+
+
+
+
+
+
+
+
+
+
pending = new ArrayDeque<>();
+ private final List watchNodes = new ArrayList<>();
+ private String lastPublishedState = null;
+
+ private static final class PendingMessage {
+ final String path;
+ final String json;
+ final String nodeId;
+ final long receivedAt;
+
+ PendingMessage(String path, String json, String nodeId, long receivedAt) {
+ this.path = path;
+ this.json = json;
+ this.nodeId = nodeId;
+ this.receivedAt = receivedAt;
+ }
+ }
+
+ private FaceclawWearBridge(Context context) {
+ this.context = context.getApplicationContext();
+ boolean playServices;
+ try {
+ playServices = GoogleApiAvailability.getInstance()
+ .isGooglePlayServicesAvailable(this.context) == ConnectionResult.SUCCESS;
+ } catch (Throwable error) {
+ Log.w(TAG, "Play services availability check failed", error);
+ playServices = false;
+ }
+ this.available = playServices;
+ if (!available) {
+ Log.i(TAG, "Google Play services unavailable; watch integration disabled");
+ }
+ }
+
+ /** Initialize (idempotent) and return the singleton. */
+ public static FaceclawWearBridge getInstance(Context context) {
+ if (instance == null) {
+ synchronized (FaceclawWearBridge.class) {
+ if (instance == null) {
+ instance = new FaceclawWearBridge(context);
+ }
+ }
+ }
+ return instance;
+ }
+
+ /** Whether the Wearable Data Layer can be used on this phone at all. */
+ public boolean isAvailable() {
+ return available;
+ }
+
+ /**
+ * Register the JS listener. Must be called from the thread whose isolate
+ * owns it; that thread's Looper is captured for dispatch. Replays any
+ * recently queued watch messages and refreshes the reachable-watch set.
+ */
+ public void setListener(FaceclawWearListener newListener) {
+ Looper looper = Looper.myLooper();
+ if (looper == null) {
+ Log.w(TAG, "wear listener registered from a Looper-less thread; it will never be notified");
+ }
+ List replay;
+ synchronized (lock) {
+ listener = newListener;
+ listenerHandler = looper != null ? new Handler(looper) : null;
+ replay = new ArrayList<>(pending);
+ pending.clear();
+ }
+ long now = System.currentTimeMillis();
+ for (PendingMessage message : replay) {
+ if (now - message.receivedAt <= PENDING_MAX_AGE_MS) {
+ dispatchMessage(message.path, message.json, message.nodeId);
+ }
+ }
+ refreshWatchNodes();
+ }
+
+ public void clearListener() {
+ synchronized (lock) {
+ listener = null;
+ listenerHandler = null;
+ }
+ }
+
+ public boolean isWatchReachable() {
+ synchronized (lock) {
+ return !watchNodes.isEmpty();
+ }
+ }
+
+ /** Display name of a reachable watch ("" if none). */
+ public String getWatchName() {
+ synchronized (lock) {
+ return watchNodes.isEmpty() ? "" : watchNodes.get(0).getDisplayName();
+ }
+ }
+
+ /** Re-query which watches advertise the Faceclaw watch-app capability. */
+ public void refreshWatchNodes() {
+ if (!available) return;
+ try {
+ Wearable.getCapabilityClient(context)
+ .getCapability(CAPABILITY_WATCH, CapabilityClient.FILTER_REACHABLE)
+ .addOnSuccessListener(this::updateWatchNodes)
+ .addOnFailureListener(error -> Log.w(TAG, "capability query failed", error));
+ } catch (Throwable error) {
+ Log.w(TAG, "capability query failed", error);
+ }
+ }
+
+ /**
+ * Mirror the dashboard state to the watch. Identical consecutive states
+ * are not re-sent (the Data Layer would drop them anyway).
+ */
+ public void publishState(String json) {
+ publishState(json, false);
+ }
+
+ /** As {@link #publishState(String)}; `force` re-sends an unchanged state. */
+ public void publishState(String json, boolean force) {
+ if (!available || json == null) return;
+ synchronized (lock) {
+ if (!force && json.equals(lastPublishedState)) return;
+ lastPublishedState = json;
+ }
+ try {
+ PutDataMapRequest request = PutDataMapRequest.create(PATH_STATE);
+ DataMap map = request.getDataMap();
+ map.putString(STATE_KEY_JSON, json);
+ map.putLong(STATE_KEY_UPDATED_AT, System.currentTimeMillis());
+ PutDataRequest put = request.asPutDataRequest().setUrgent();
+ Wearable.getDataClient(context)
+ .putDataItem(put)
+ .addOnFailureListener(error -> Log.w(TAG, "state publish failed", error));
+ } catch (Throwable error) {
+ Log.w(TAG, "state publish failed", error);
+ }
+ }
+
+ /** Send a message to every reachable watch running the Faceclaw watch app. */
+ public void sendToWatch(String path, String json) {
+ if (!available) return;
+ List targets;
+ synchronized (lock) {
+ targets = new ArrayList<>(watchNodes);
+ }
+ if (targets.isEmpty()) {
+ // Nothing known yet (first message after boot): look the watch up, then send.
+ try {
+ Wearable.getCapabilityClient(context)
+ .getCapability(CAPABILITY_WATCH, CapabilityClient.FILTER_REACHABLE)
+ .addOnSuccessListener(info -> {
+ updateWatchNodes(info);
+ for (Node node : info.getNodes()) {
+ sendToNode(node.getId(), path, json);
+ }
+ })
+ .addOnFailureListener(error -> Log.w(TAG, "capability query failed", error));
+ } catch (Throwable error) {
+ Log.w(TAG, "capability query failed", error);
+ }
+ return;
+ }
+ for (Node node : targets) {
+ sendToNode(node.getId(), path, json);
+ }
+ }
+
+ /** Send a message to one specific node (e.g. an ack back to the sender). */
+ public void sendToNode(String nodeId, String path, String json) {
+ if (!available || nodeId == null || nodeId.isEmpty()) return;
+ try {
+ byte[] payload = (json != null ? json : "{}").getBytes(StandardCharsets.UTF_8);
+ Wearable.getMessageClient(context)
+ .sendMessage(nodeId, path, payload)
+ .addOnFailureListener(error -> Log.w(TAG, "send " + path + " to " + nodeId + " failed", error));
+ } catch (Throwable error) {
+ Log.w(TAG, "send " + path + " failed", error);
+ }
+ }
+
+ /** Reply to a watch message; `seq` echoes the watch's sequence number. */
+ public void sendAck(String nodeId, long seq, boolean ok, boolean jsReady, String message) {
+ JSONObject ack = new JSONObject();
+ try {
+ ack.put("seq", seq);
+ ack.put("ok", ok);
+ ack.put("jsReady", jsReady);
+ ack.put("message", message != null ? message : "");
+ } catch (JSONException ignored) {
+ // The keys are constants; this cannot happen.
+ }
+ sendToNode(nodeId, PATH_ACK, ack.toString());
+ }
+
+ /** Entry point for FaceclawWearListenerService; may run on any thread. */
+ void handleMessage(MessageEvent event) {
+ if (event == null) return;
+ String path = event.getPath();
+ if (path == null || !path.startsWith(PATH_PREFIX)) return;
+ byte[] data = event.getData();
+ String json = data != null && data.length > 0 ? new String(data, StandardCharsets.UTF_8) : "{}";
+ String nodeId = event.getSourceNodeId();
+ Log.d(TAG, "recv " + path + " seq=" + readSeq(json));
+
+ boolean delivered = dispatchMessage(path, json, nodeId);
+ if (delivered) return;
+
+ // No JS listener yet: keep the message briefly, and tell the watch so
+ // it can explain why nothing is happening.
+ synchronized (lock) {
+ long now = System.currentTimeMillis();
+ while (!pending.isEmpty() && now - pending.peekFirst().receivedAt > PENDING_MAX_AGE_MS) {
+ pending.pollFirst();
+ }
+ if (pending.size() >= PENDING_LIMIT) {
+ pending.pollFirst();
+ }
+ pending.addLast(new PendingMessage(path, json, nodeId, now));
+ }
+ sendAck(nodeId, readSeq(json), false, false, "Faceclaw is not running on the phone. Open it to connect the glasses.");
+ }
+
+ /** Entry point for FaceclawWearListenerService's capability callback. */
+ void handleCapabilityChanged(CapabilityInfo info) {
+ if (info == null || !CAPABILITY_WATCH.equals(info.getName())) return;
+ updateWatchNodes(info);
+ }
+
+ private void updateWatchNodes(CapabilityInfo info) {
+ Set nodes = info != null ? info.getNodes() : Collections.emptySet();
+ // Every reachable watch gets messages; a nearby (Bluetooth-linked)
+ // one is listed first so it is the name the phone UI shows.
+ List reachable = new ArrayList<>();
+ for (Node node : nodes) {
+ if (node.isNearby()) reachable.add(0, node); else reachable.add(node);
+ }
+ boolean changed;
+ String name;
+ synchronized (lock) {
+ changed = !sameNodeIds(watchNodes, reachable);
+ watchNodes.clear();
+ watchNodes.addAll(reachable);
+ name = watchNodes.isEmpty() ? "" : watchNodes.get(0).getDisplayName();
+ }
+ if (changed) {
+ Log.i(TAG, reachable.isEmpty() ? "no Faceclaw watch reachable" : "watch reachable: " + name);
+ boolean reachableNow = !reachable.isEmpty();
+ FaceclawWearListener target;
+ Handler handler;
+ synchronized (lock) {
+ target = listener;
+ handler = listenerHandler;
+ }
+ if (target != null && handler != null) {
+ handler.post(() -> {
+ try {
+ target.onWatchConnection(reachableNow, name);
+ } catch (Exception error) {
+ Log.w(TAG, "watch connection listener failed", error);
+ }
+ });
+ }
+ }
+ }
+
+ private static boolean sameNodeIds(List a, List b) {
+ if (a.size() != b.size()) return false;
+ for (int i = 0; i < a.size(); i++) {
+ if (!a.get(i).getId().equals(b.get(i).getId())) return false;
+ }
+ return true;
+ }
+
+ /** Post to the JS listener; false when there is none to post to. */
+ private boolean dispatchMessage(String path, String json, String nodeId) {
+ FaceclawWearListener target;
+ Handler handler;
+ synchronized (lock) {
+ target = listener;
+ handler = listenerHandler;
+ }
+ if (target == null || handler == null) return false;
+ handler.post(() -> {
+ try {
+ target.onMessage(path, json, nodeId);
+ } catch (Exception error) {
+ Log.w(TAG, "wear message listener failed for " + path, error);
+ }
+ });
+ return true;
+ }
+
+ private static long readSeq(String json) {
+ try {
+ return new JSONObject(json).optLong("seq", 0);
+ } catch (JSONException error) {
+ return 0;
+ }
+ }
+}
diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawWearListener.java b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawWearListener.java
new file mode 100644
index 00000000..590c87d6
--- /dev/null
+++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawWearListener.java
@@ -0,0 +1,19 @@
+package com.faceclaw.app;
+
+/**
+ * Callbacks from the Android Wear (Wear OS) bridge; implemented in JS. Every
+ * call is delivered on the thread that registered the listener (see
+ * FaceclawWearBridge.setListener).
+ */
+public interface FaceclawWearListener {
+ /**
+ * A message from the watch app. `path` is the Data Layer message path
+ * (e.g. "/faceclaw/input"); `json` is the UTF-8 payload (always a JSON
+ * object, "{}" when the watch sent none); `nodeId` identifies the watch
+ * so a reply can be addressed to it.
+ */
+ void onMessage(String path, String json, String nodeId);
+
+ /** The set of reachable watches running the Faceclaw watch app changed. */
+ void onWatchConnection(boolean reachable, String watchName);
+}
diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawWearListenerService.java b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawWearListenerService.java
new file mode 100644
index 00000000..7520d780
--- /dev/null
+++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawWearListenerService.java
@@ -0,0 +1,26 @@
+package com.faceclaw.app;
+
+import android.util.Log;
+
+import com.google.android.gms.wearable.CapabilityInfo;
+import com.google.android.gms.wearable.MessageEvent;
+import com.google.android.gms.wearable.WearableListenerService;
+
+/**
+ * Play services starts this service (in the app process) for every Data
+ * Layer message under /faceclaw and for capability changes, whether or not
+ * the app is running. It only forwards to FaceclawWearBridge, which owns the
+ * hand-off to the JS side.
+ */
+public class FaceclawWearListenerService extends WearableListenerService {
+ @Override
+ public void onMessageReceived(MessageEvent event) {
+ Log.d("FaceclawWear", "service onMessageReceived " + event.getPath() + " from " + event.getSourceNodeId());
+ FaceclawWearBridge.getInstance(this).handleMessage(event);
+ }
+
+ @Override
+ public void onCapabilityChanged(CapabilityInfo info) {
+ FaceclawWearBridge.getInstance(this).handleCapabilityChanged(info);
+ }
+}
diff --git a/App_Resources/Android/src/main/res/values/wear.xml b/App_Resources/Android/src/main/res/values/wear.xml
new file mode 100644
index 00000000..049457ee
--- /dev/null
+++ b/App_Resources/Android/src/main/res/values/wear.xml
@@ -0,0 +1,9 @@
+
+
+
+
+ - faceclaw_phone
+
+
diff --git a/CLAUDE.md b/CLAUDE.md
index 2fe8b769..6433edb7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,6 +5,13 @@ for interfacing with Android SDK).
Typescript parts are in app/. Java parts are in App_Resources/Android/src/main/java/com/faceclaw/app/.
+wear/ is a separate Gradle project (Kotlin + Compose for Wear OS): the watch
+remote that drives Faceclaw over the Wearable Data Layer. Its phone-side
+counterparts are FaceclawWearBridge.java, app/native/wear-bridge.ts and
+app/g2/wear-remote.ts; the message format is in wear/PROTOCOL.md. Build it
+with `cd wear && ./gradlew :app:assembleDebug` (needs JAVA_HOME and
+ANDROID_HOME); it is not part of `npm run build`.
+
If build.sh exists, it's a machine-specific wrapper that sets some environment
variables to point to where tools are installed, then runs `npm run build`.
If build_and_run.sh exists, it does everything build.sh does plus
diff --git a/PRIVACY b/PRIVACY
index 18e29a55..8b9251c7 100644
--- a/PRIVACY
+++ b/PRIVACY
@@ -74,3 +74,18 @@ https://support.evenrealities.com/hc/en-us/articles/14127464826511-Privacy-Polic
Apps downloaded from the EvenHub app store come with their own privacy
policies.
+
+## Wear OS Watch
+
+The optional Faceclaw watch app (wear/) talks to the phone over Google Play
+services' Wearable Data Layer, the same channel the watch uses for
+notifications and other companion apps. Gestures, commands, the watch's own
+speech-recognition results, and the mirrored glasses status and assistant
+replies travel between your watch and your phone over their Bluetooth (or,
+when paired that way, Wi-Fi) link; Faceclaw does not send any of it to a
+server. Speech recognized on the watch uses the watch's system speech
+recognizer, which may send audio to Google under Google's privacy policy:
+
+ Google: https://policies.google.com/privacy
+
+The phone does nothing watch-related on phones without Google Play services.
diff --git a/README.md b/README.md
index 96270b26..d102e885 100644
--- a/README.md
+++ b/README.md
@@ -65,11 +65,41 @@ To install, run
battery life similar to the stock Even app.
* Connection management with auto-reconnect, and autodetection of conflict
with the official Even Realities app
- * On-phone screen mirroring and simulated ring input
+ * On-phone screen mirroring with touch control: tap what you see on the
+ mirror (sidebar icons, launcher cells), or use the phone's own touchpad,
+ d-pad and Back/Menu buttons — the same spatial scheme as the watch — plus
+ a compact ring simulator. A display-mode picker (576×288 band, 576×480
+ tall, or the full 640×480 panel with an auto-hiding sidebar) and a
+ brightness slider with an Auto toggle sit beside the mirror.
+ * A Wear OS watch app that replaces (and outdoes) the R1 ring: tap, swipe,
+ hold and crown gestures, side buttons, app launching and window switching,
+ voice or keyboard queries to the assistant with the reply on your wrist,
+ typing into apps, and glasses status/lock/display control (see "Watch
+ remote" below)
* Dual-language NativeScript architecture with Java for the multithreaded
Android API and bluetooth stack bits, Typescript for the bits you want to
hack on
+## Watch remote (Wear OS)
+
+The `wear/` directory holds a companion app for Wear OS 3+ watches that turns
+the watch into a remote for the glasses. The whole watch face is a touchpad
+that mirrors the ring (tap, double-tap, hold, swipe, crown scrolling, side
+buttons), and beyond the ring it can launch apps, switch and close windows,
+wake/sleep/lock the display, send spoken or typed queries straight to the
+assistant (using the watch's own microphone) and show the reply on the wrist,
+and type text into apps such as the terminal. Its swipes are a spatial
+control scheme the ring never had, with no mode to enter first: the
+launcher highlights one app and moves it by rows and columns, right goes
+into things (sidebar → window, settings section → items, next track in
+Music), left backs out, tap selects, hold opens the context menu, double-tap
+or a two-finger tap is back everywhere, and two wrist twists go back; up/down
+scroll and right/left select/back everywhere else. The ring's own scheme is
+unchanged — watch input is tagged as a separate source. Faceclaw's Settings > Watch
+section has the phone-side switches. See [wear/README.md](wear/README.md) for
+building and installing it; it is a separate Gradle build, sideloaded over
+adb, and needs no Play Store. The phone side requires Google Play services.
+
## Connecting an external agent (OpenClaw)
Instead of calling an LLM API directly from the phone, the voice assistant
diff --git a/app/app.css b/app/app.css
index 62ad97c2..a3665e0d 100644
--- a/app/app.css
+++ b/app/app.css
@@ -55,3 +55,78 @@ Button.-primary {
border-width: 1;
border-radius: 8;
}
+
+/* The phone's controller for the glasses (phone-ui/remote-controls.xml). */
+.remote-controls {
+ margin: 0 8 0 8;
+}
+.display-controls {
+ margin-bottom: 6;
+}
+.mode-button {
+ font-size: 13;
+ padding: 6 10;
+ margin-right: 6;
+}
+.brightness-icon {
+ font-size: 16;
+ margin: 0 4 0 4;
+ color: #444444;
+}
+.auto-toggle Label {
+ font-size: 13;
+ margin-right: 2;
+}
+.touchpad {
+ height: 230;
+ background-color: #1f1f1f;
+ border-radius: 14;
+ border-width: 1;
+ border-color: #3a3a3a;
+ color: #f0f0f0;
+ margin-top: 2;
+}
+.pad-focus {
+ font-size: 20;
+ color: #ffffff;
+}
+.pad-dpad-button {
+ width: 46;
+ height: 46;
+ margin: 6;
+ padding: 0;
+ font-size: 16;
+ border-radius: 23;
+ background-color: #333333;
+ color: #e8e8e8;
+}
+.pad-dpad-down {
+ margin-bottom: 30;
+}
+.pad-legend {
+ font-size: 11;
+ color: #8a8a8a;
+ margin-bottom: 8;
+}
+.action-row {
+ margin-top: 6;
+}
+.action-button {
+ margin: 2;
+ font-size: 14;
+}
+.ring-row {
+ margin-top: 4;
+}
+.ring-label {
+ font-size: 12;
+ color: #666666;
+ margin: 0 6 0 4;
+}
+.ring-button {
+ width: 44;
+ height: 36;
+ margin: 1;
+ padding: 0;
+ font-size: 13;
+}
diff --git a/app/apps/evenhub/evenhub-window.ts b/app/apps/evenhub/evenhub-window.ts
index 3b549980..bd45271b 100644
--- a/app/apps/evenhub/evenhub-window.ts
+++ b/app/apps/evenhub/evenhub-window.ts
@@ -4,6 +4,7 @@
* makes the content area exactly the 576x288 surface EvenHub apps expect.
*/
import { GrayImage } from "../../graphics/image";
+import { EVENHUB_SCREEN_WIDTH } from "./compositor";
import { type DashboardInputEvent, type Layer, type LayerContext } from "../../ui/layers";
import {
createInProcessWindow,
@@ -20,6 +21,15 @@ class EvenHubAppLayer implements Layer {
paint(ctx: LayerContext): GrayImage {
const size = ctx.stack.getBaseSize();
+ // EvenHub apps lay out for the stock 576-wide surface. In the full-panel
+ // display mode the window is 640 wide; paint at stock width and centre
+ // it rather than leaving all the slack on the right.
+ if (size.width > EVENHUB_SCREEN_WIDTH) {
+ const content = this.session.paint({ width: EVENHUB_SCREEN_WIDTH, height: size.height }, ctx.stack.isFocused());
+ const image = new GrayImage(size.width, size.height, 0);
+ content.composeInto(image, Math.floor((size.width - EVENHUB_SCREEN_WIDTH) / 2), 0);
+ return image;
+ }
return this.session.paint(size, ctx.stack.isFocused());
}
diff --git a/app/apps/evenhub/session.ts b/app/apps/evenhub/session.ts
index 88f1ac6a..a7c80c4d 100644
--- a/app/apps/evenhub/session.ts
+++ b/app/apps/evenhub/session.ts
@@ -20,7 +20,7 @@
import { ApplicationSettings } from "@nativescript/core";
import { GrayImage } from "../../graphics/image";
import { EvenHubFont } from "../../graphics/evenhub-font";
-import { type DashboardInputEvent, type Layer } from "../../ui/layers";
+import { type DashboardInputEvent, type InputSource, type Layer } from "../../ui/layers";
import {
anthropicApiKeySetting,
elevenLabsApiKeySetting,
@@ -1346,12 +1346,17 @@ function luminance(r: number, g: number, b: number): number {
return Math.round(0.2126 * r + 0.7152 * g + 0.0722 * b);
}
-/** ring/left-arm/right-arm -> PB EventSourceType. */
-function gestureSource(source: "ring" | "left-arm" | "right-arm"): number {
+/**
+ * ring/left-arm/right-arm -> PB EventSourceType. The watch is reported to
+ * EvenHub apps as the ring: they only know stock hardware, and the watch's
+ * ring-vocabulary gestures mean the same thing.
+ */
+function gestureSource(source: InputSource): number {
switch (source) {
case "right-arm":
return 1;
case "ring":
+ case "watch":
return 2;
case "left-arm":
return 3;
diff --git a/app/apps/launcher/launcher-app.ts b/app/apps/launcher/launcher-app.ts
index 4b9520af..6fe15796 100644
--- a/app/apps/launcher/launcher-app.ts
+++ b/app/apps/launcher/launcher-app.ts
@@ -5,7 +5,7 @@ import { GrayImage } from "../../graphics/image";
import { type Plane } from "../../graphics/plane";
import { renderIcon, type IconName } from "../../graphics/icons";
import { clamp } from "../../util/numeric-util";
-import { DashboardInputEvent, Layer, LayerActions, LayerContext } from "../../ui/layers";
+import { DashboardInputEvent, isWatchInput, Layer, LayerActions, LayerContext } from "../../ui/layers";
import { drawSelectionHighlight, MenuLayer, scrollToKeepSelectionVisible, type MenuItem } from "../../ui/menu";
import { iconGridMinRowHeight } from "../../ui/metrics";
import { WINDOW_MENU_LAYOUT } from "../../ui/window-menu";
@@ -64,12 +64,19 @@ type LauncherGridEntry =
* picks the item); a tap launches an app or opens a folder (the same grid,
* restricted to that folder's apps). Double-click backs out one level (item →
* row, folder → top grid), and from the top level yields to the sidebar.
+ * That is the ring's scheme; the watch (see handleWatchInput) skips row mode
+ * and moves one cell at a time in four directions.
*
* The folder grouping lives in the settings store (see launcher-folders.ts)
* and is re-read every paint, so assistant folder tools take effect without
* the layer holding any copy of the state.
*/
class LauncherGridLayer implements Layer {
+ // Watch swipes are spatial: up/down move between rows, left/right between
+ // columns. From row mode, right goes into the row (left backs out, like
+ // double-click); from the first column, left returns to row mode, which
+ // keeps "left" pointing toward the sidebar all the way out.
+ readonly acceptsDirectional = true;
private mode: LauncherMode = "row";
private selectedRow = 0;
private selectedCol = 1;
@@ -307,6 +314,10 @@ class LauncherGridLayer implements Layer {
}
async handleInput(event: DashboardInputEvent, ctx: LayerContext): Promise {
+ if (isWatchInput(event)) {
+ await this.handleWatchInput(event, ctx);
+ return;
+ }
const entries = this.entries();
const rows = this.rowCount(entries.length);
switch (event.type) {
@@ -341,20 +352,7 @@ class LauncherGridLayer implements Layer {
this.itemsInRow(entries.length, this.selectedRow) - 1,
);
} else {
- const entry = entries[this.selectedRow * COLS + this.selectedCol];
- if (!entry) return;
- if (entry.kind === "folder") {
- this.currentFolder = entry.name;
- this.mode = "row";
- this.selectedRow = 0;
- this.scrollRow = 0;
- } else {
- // Return to the top grid before launching, so the launcher never
- // shows (even briefly) stale folder contents when re-entered.
- if (this.currentFolder !== null) this.exitFolder();
- this.mode = "row";
- await this.options.launchApp(entry.appId);
- }
+ await this.openSelected(entries);
}
return;
}
@@ -371,6 +369,108 @@ class LauncherGridLayer implements Layer {
return;
}
}
+
+ /**
+ * The watch's scheme: there is no row mode to enter first. The selection is
+ * always one cell; up/down/left/right (and the crown) move it spatially,
+ * select opens it, back leaves the folder or the grid, and stepping left
+ * past the first column leaves for the sidebar, which is where "left" goes.
+ * Row mode is restored on the way out so a ring user finds the grid as
+ * they left it.
+ */
+ private async handleWatchInput(event: DashboardInputEvent, ctx: LayerContext): Promise {
+ const entries = this.entries();
+ const rows = this.rowCount(entries.length);
+ if (this.mode === "row") {
+ this.mode = "item";
+ this.selectedCol = clamp(this.selectedCol, 0, this.itemsInRow(entries.length, this.selectedRow) - 1);
+ }
+ const leave = () => {
+ this.mode = "row";
+ shell.yieldFocusToSidebar();
+ };
+ switch (event.type) {
+ case "swipe-up":
+ case "swipe-down":
+ case "scroll-up":
+ case "scroll-down": {
+ const delta = event.type === "swipe-down" || event.type === "scroll-down" ? 1 : -1;
+ this.selectedRow = clamp(this.selectedRow + delta, 0, rows - 1);
+ // Keep the column; a shorter last row clamps it.
+ this.selectedCol = clamp(this.selectedCol, 0, this.itemsInRow(entries.length, this.selectedRow) - 1);
+ return;
+ }
+ case "swipe-right":
+ this.selectedCol = clamp(this.selectedCol + 1, 0, this.itemsInRow(entries.length, this.selectedRow) - 1);
+ return;
+ case "swipe-left":
+ if (this.selectedCol > 0) {
+ this.selectedCol--;
+ } else if (this.currentFolder !== null) {
+ this.exitFolder();
+ this.mode = "item";
+ } else {
+ leave();
+ }
+ return;
+ case "click":
+ await this.openSelected(entries);
+ return;
+ case "double-click":
+ if (this.currentFolder !== null) {
+ this.exitFolder();
+ this.mode = "item";
+ } else {
+ leave();
+ }
+ return;
+ default:
+ return;
+ }
+ }
+
+ /**
+ * A touch on the phone's mirror: the cell under it becomes the selection
+ * and opens (the same as a watch select on it). Uses the geometry paint
+ * lays the grid out with, so it lands on what the mirror showed.
+ */
+ async hitTest(x: number, y: number, ctx: LayerContext): Promise {
+ const font = getDefaultSmallFont();
+ const { width, height } = ctx.stack.getBaseSize();
+ const entries = this.entries();
+ const gridTop = this.currentFolder !== null ? GRID_TOP + font.lineHeight + 4 : GRID_TOP;
+ const gridBottom = height - 4;
+ if (y < gridTop || y >= gridBottom || x < 0 || x >= width) return false;
+ const rowH = iconGridMinRowHeight(font, ICON_SIZE, LABEL_GAP);
+ const colW = width / COLS;
+ const row = this.scrollRow + Math.floor((y - gridTop) / rowH);
+ const col = Math.floor(x / colW);
+ if (row < 0 || row >= this.rowCount(entries.length)) return false;
+ if (col < 0 || col >= this.itemsInRow(entries.length, row)) return false;
+ this.mode = "item";
+ this.selectedRow = row;
+ this.selectedCol = col;
+ await this.openSelected(entries);
+ return true;
+ }
+
+ /** Open the selected cell: enter a folder, or launch the app. */
+ private async openSelected(entries: readonly LauncherGridEntry[]): Promise {
+ const entry = entries[this.selectedRow * COLS + this.selectedCol];
+ if (!entry) return;
+ if (entry.kind === "folder") {
+ this.currentFolder = entry.name;
+ this.mode = "row";
+ this.selectedRow = 0;
+ this.scrollRow = 0;
+ } else {
+ // Return to the top grid before launching, so the launcher never
+ // shows (even briefly) stale folder contents when re-entered.
+ if (this.currentFolder !== null) this.exitFolder();
+ this.mode = "row";
+ await this.options.launchApp(entry.appId);
+ }
+ }
}
/**
diff --git a/app/apps/music/music-app.ts b/app/apps/music/music-app.ts
index 1f48186b..c67a9452 100644
--- a/app/apps/music/music-app.ts
+++ b/app/apps/music/music-app.ts
@@ -17,7 +17,14 @@ import {
} from "../../native/media-controller";
import { mediaBrowserBridge, type MediaBrowserApp } from "../../native/media-browser";
import { MediaBrowseLayer } from "./media-browse";
-import { Layer, type DashboardInputEvent, type LayerContext, type PaintBelow } from "../../ui/layers";
+import {
+ directionalFallback,
+ isDirectionalInput,
+ Layer,
+ type DashboardInputEvent,
+ type LayerContext,
+ type PaintBelow,
+} from "../../ui/layers";
import {
createInProcessWindow,
YieldAtRootLayer,
@@ -59,6 +66,8 @@ type FocusColumn = "actions" | "playlist";
* player's queue when it exposes one (scroll to a track, click to jump).
*/
class MusicAppLayer implements Layer {
+ // Watch swipes skip tracks: right = next, left = previous.
+ readonly acceptsDirectional = true;
private focusColumn: FocusColumn = "actions";
private selectedActionIndex = 0;
private selectedQueueIndex = 0;
@@ -215,6 +224,10 @@ class MusicAppLayer implements Layer {
return;
}
const media = mediaControllerBridge.snapshot();
+ if ((!media.accessEnabled || !media.available) && isDirectionalInput(event)) {
+ // Nothing to skip between yet: the setup prompts take select / back.
+ return this.handleInput(directionalFallback(event), ctx);
+ }
if (!media.accessEnabled) {
if (event.type === "click") {
mediaControllerBridge.openNotificationAccessSettings();
@@ -233,6 +246,16 @@ class MusicAppLayer implements Layer {
const actions = this.buildActions(media, queue);
this.reconcileSelection(actions, queue);
switch (event.type) {
+ case "swipe-right":
+ if (media.canSkipNext) await mediaControllerBridge.skipNext();
+ return;
+ case "swipe-left":
+ if (media.canSkipPrevious) await mediaControllerBridge.skipPrevious();
+ return;
+ case "swipe-up":
+ return this.handleInput({ type: "scroll-up" }, ctx);
+ case "swipe-down":
+ return this.handleInput({ type: "scroll-down" }, ctx);
case "scroll-up":
if (this.focusColumn === "playlist") {
this.selectedQueueIndex = Math.max(0, this.selectedQueueIndex - 1);
@@ -437,6 +460,7 @@ class VolumeModalLayer implements Layer {
/** Let back leave the playlist column before the root wrapper yields to the shell. */
class MusicRootLayer implements Layer {
+ readonly acceptsDirectional = true;
private readonly yieldAtRoot: YieldAtRootLayer;
constructor(private readonly music: MusicAppLayer) {
diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts
index 26735a88..f7e917e5 100644
--- a/app/g2/dashboard-controller.ts
+++ b/app/g2/dashboard-controller.ts
@@ -1,5 +1,5 @@
import { Application, ImageSource } from "@nativescript/core";
-import { EvenAIStatus, EvenAIStatusName, EventSourceType, EventSourceTypeName, OsEventTypeList, OsEventTypeName } from "./events";
+import { EvenAIStatus, EvenAIStatusName, EventSourceType, EventSourceTypeName, OsEventTypeList, OsEventTypeName, WatchGestureType, WatchGestureTypeName } from "./events";
import { loadDeviceAddresses } from "./device-addresses";
import { ensureBlePermissions, ensureVoicePermissions } from "./android-permissions";
import { FaceclawCommunicatorBridge, type RawInputEvent } from "../native/faceclaw-communicator";
@@ -12,6 +12,29 @@ import { openEvenAppSettings, readEvenAppNotificationState } from "../native/eve
import { grayImageToPreviewSource } from "../native/gray-image-preview";
import { firmwareIncompatibilityMessage } from "./firmware-compat";
import { resumeAutoReconnect, suppressAutoReconnect } from "./reconnect-policy";
+import { WearRemote, type WearRemoteInputKind } from "./wear-remote";
+
+/** Who a synthetic (non-firmware) input stands for. */
+type SyntheticInputOrigin = "ring" | "watch";
+
+/** Gestures the phone's mirror view reports (see handleMirrorTouch). */
+export type MirrorTouchKind =
+ | "tap"
+ | "double-tap"
+ | "long-press"
+ | "swipe-up"
+ | "swipe-down"
+ | "swipe-left"
+ | "swipe-right";
+
+const MIRROR_TOUCH_GESTURES: Record, WearRemoteInputKind> = {
+ "double-tap": "double-click",
+ "long-press": "long-press",
+ "swipe-up": "swipe-up",
+ "swipe-down": "swipe-down",
+ "swipe-left": "swipe-left",
+ "swipe-right": "swipe-right",
+};
import { findSoundEffect, playSoundEffect } from "../ui/sound-effects";
import { isWelcomeSoundPending, setWelcomeSoundPending } from "../phone-ui/onboarding-state";
import { beginRenderPass, endRenderPass } from "../util/render-freshness";
@@ -33,9 +56,9 @@ import { ALL_APPS } from "../apps/all-apps";
import { type AppContext, type AppDefinition, type AppLaunchParams, type TextEditorHost } from "../apps/app-definition";
import { type InProcessAppOptions, type InProcessWindow } from "../ui/shell/in-process-window";
import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-apps-persistence";
-import { appViewportRect, type WindowHeightMode } from "../ui/shell/geometry";
+import { appViewportRect, SIDEBAR_WIDTH, sidebarWidth, type WindowHeightMode } from "../ui/shell/geometry";
import { type LayerActions } from "../ui/layers";
-import { assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, brightnessSetting, brightnessSettingToLevel, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, verticalPositionSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings";
+import { assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, brightnessSetting, brightnessSettingToLevel, displayModeSetting, watchWakesDisplaySetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, verticalPositionSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings";
import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization";
import {
getInstalledEvenHubAppById,
@@ -84,13 +107,20 @@ const LOCK_SCREEN_MESSAGE = "Glasses locked; unlock the phone to unlock the glas
// Top-bar clock refresh; the phone-side preview polls the Java composite so
// it reflects every app (including worker apps the TS side never renders).
const SHELL_REFRESH_INTERVAL_MS = 60_000;
+// Safety-net poll only; the preview is event-driven (every composited frame
+// schedules a refresh), so this just covers anything that slips through.
const PREVIEW_INTERVAL_MS = 1_000;
const SCREEN_TIMEOUT_CHECK_MS = 1_000;
const EVENHUB_SCREEN_OFF_SUSPEND_DELAY_MS = 5_000;
const EVENHUB_WAKE_READY_TIMEOUT_MS = 4_500;
const FOREGROUND_NOTIFICATION_MIN_UPDATE_MS = 30_000;
const FRAME_TRANSMIT_BACKPRESSURE_TIMEOUT_MS = 6_000;
-const CONNECTED_PREVIEW_MIN_UPDATE_MS = 1_000;
+// Preview refresh floor. Refreshes are scheduled per composited frame with a
+// trailing update, so the mirror tracks the glasses within this bound instead
+// of the old 1s poll (which lagged up to two polls behind).
+const CONNECTED_PREVIEW_MIN_UPDATE_MS = 150;
+// The GIF recorder keeps its old cadence; per-frame captures would balloon it.
+const RECORDING_MIN_CAPTURE_MS = 1_000;
// Below this, a disconnect is more likely a flat battery than a BLE problem.
const LOW_BATTERY_PERCENT = 5;
const EVEN_APP_DETECTED_MESSAGE =
@@ -138,6 +168,9 @@ function eventLabel(kind: string, eventType: number): string {
if (kind === "even-ai") {
return EvenAIStatusName[eventType] ?? `EVEN_AI_UNKNOWN_${eventType}`;
}
+ if (kind === "watch-gesture") {
+ return WatchGestureTypeName[eventType] ?? `WATCH_UNKNOWN_${eventType}`;
+ }
return eventName(eventType);
}
@@ -182,6 +215,8 @@ class DashboardController {
private glassesWorn: boolean | null = null;
private phoneLocked = false;
private glassesLocked = false;
+ // Wear OS watch remote; constructed last so it sees a fully wired shell.
+ private wearRemote: WearRemote | null = null;
private lockSurfaceConfigured = false;
private lastLockScreenEnabled = lockScreenEnabledSetting.get();
private offState: (() => void) | null = null;
@@ -265,10 +300,14 @@ class DashboardController {
},
getScreenTimeoutMs: () => screenTimeoutSettingToMs(screenTimeoutSetting.get()),
requestShellRender: () => this.requestShellRender(),
- onWindowsChanged: () => this.persistOpenApps(),
+ onWindowsChanged: () => {
+ this.persistOpenApps();
+ this.wearRemote?.schedulePublish();
+ },
onScreenStateChanged: (on) => {
this.handleScreenStateChanged(on);
if (on) this.requestShellRender();
+ this.wearRemote?.schedulePublish();
},
});
// Boot hooks register windows that exist from startup (the launcher,
@@ -290,6 +329,7 @@ class DashboardController {
this.pushBrightness();
this.syncEvenHubScreenOffSetting();
this.applyVerticalPositionIfChanged();
+ this.applyDisplayModeIfChanged();
this.syncAssistantBridgeIfChanged();
this.syncLockScreenSettingIfChanged();
});
@@ -297,6 +337,24 @@ class DashboardController {
// connection stays up (with re-dial) so proactive tool calls work
// outside voice turns.
this.syncAssistantBridge();
+ // The watch drives the same synthetic-input path as the phone UI's test
+ // buttons, plus app/window/lock commands; it mirrors the state below.
+ this.wearRemote = new WearRemote({
+ apps: LAUNCHABLE_APPS,
+ injectInput: (kind) => this.injectSyntheticRingInput(kind, "watch"),
+ launchApp: (appId) => this.launchApp(appId),
+ connect: () => this.connect(),
+ disconnect: () => this.disconnect(),
+ setGlassesLocked: (locked, reason) => this.setGlassesLocked(locked, reason),
+ requestShellRender: () => this.requestShellRender(),
+ getState: () => ({
+ phase: this.phase,
+ status: this.status,
+ glassesLocked: this.glassesLocked,
+ glassesWorn: this.glassesWorn,
+ }),
+ appendLog: (line) => this.appendLog(line),
+ });
}
// Bridge settings changes re-dial the connection; unrelated setting changes
@@ -339,6 +397,48 @@ class DashboardController {
// don't trigger a full reposition.
private lastVerticalPosition = verticalPositionSetting.get();
+ private lastDisplayMode = displayModeSetting.get();
+
+ /**
+ * Display mode changed (Settings > Display, or the phone page's picker):
+ * every window's viewport size changes. In-process windows re-measure in
+ * place; worker windows get their canvas once at open, so they are closed
+ * and launched again at the new size.
+ */
+ private applyDisplayModeIfChanged(): void {
+ const mode = displayModeSetting.get();
+ if (mode === this.lastDisplayMode) return;
+ this.lastDisplayMode = mode;
+ this.appendLog(`display mode: ${mode}`);
+ const foregroundWindowId = shell.foregroundWindow()?.windowId;
+ void (async () => {
+ const relaunch: string[] = [];
+ for (const window of Array.from(shell.getWindows())) {
+ if (window.relayout) {
+ window.relayout();
+ await this.configureWindowSurface(
+ window.surfaceId,
+ window.windowId === foregroundWindowId,
+ window.heightMode,
+ );
+ } else if (window.closeable) {
+ relaunch.push(window.appId);
+ shell.closeWindow(window.windowId);
+ }
+ }
+ for (const appId of relaunch) {
+ await this.launchApp(appId);
+ }
+ if (foregroundWindowId && shell.getWindows().some((w) => w.windowId === foregroundWindowId)) {
+ shell.focusWindow(foregroundWindowId);
+ }
+ shell.foregroundWindow()?.requestRender();
+ this.requestShellRender();
+ })().catch((error) => {
+ this.appendLog(`display mode change failed: ${this.formatError(error)}`);
+ });
+ }
+
private applyVerticalPositionIfChanged(): void {
const position = verticalPositionSetting.get();
if (position === this.lastVerticalPosition) return;
@@ -400,6 +500,7 @@ class DashboardController {
private handleWearState(wearing: boolean): void {
this.glassesWorn = wearing;
this.appendLog(wearing ? "glasses wear state: ON_HEAD" : "glasses wear state: OFF_HEAD");
+ this.wearRemote?.schedulePublish();
if (!wearing && this.phoneLocked && lockScreenEnabledSetting.get()) {
this.setGlassesLocked(true, "glasses removed while phone locked");
}
@@ -420,6 +521,7 @@ class DashboardController {
if (locked === this.glassesLocked) return;
this.glassesLocked = locked;
this.appendLog(`glasses ${locked ? "locked" : "unlocked"}: ${reason}`);
+ this.wearRemote?.schedulePublish();
void this.syncLockSurface().catch((error) => {
this.appendLog(`lock screen update failed: ${this.formatError(error)}`);
});
@@ -947,6 +1049,7 @@ class DashboardController {
// Repaint the top bar (battery indicators live in the shell chrome).
this.requestShellRender();
}
+ this.wearRemote?.schedulePublish();
});
this.offEvenAppConflict = communicator.onEvenAppConflict((message) => {
this.refreshEvenAppStatus();
@@ -959,6 +1062,10 @@ class DashboardController {
this.emit();
});
this.offFrameMetrics = communicator.onFrameMetrics(() => {
+ // Every composited frame refreshes the phone-side mirror (bounded by
+ // CONNECTED_PREVIEW_MIN_UPDATE_MS) so it tracks the glasses instead
+ // of trailing the 1s safety-net poll.
+ this.schedulePreviewUpdate();
if (this.phase === "connected") {
this.setStatus("Connected.");
// A rendered frame means the session is warmed up (fixedLayoutCreated),
@@ -1255,20 +1362,94 @@ class DashboardController {
}
}
- async injectSyntheticRingInput(
- kind: "click" | "double-click" | "scroll-up" | "scroll-down" | "long-press" | "wakeword",
- ): Promise {
+ /**
+ * Feed a ring gesture from somewhere other than the ring (the phone UI's
+ * test buttons, the watch). "long-press" is a complete short hold;
+ * "long-press-start" / "long-press-release" let a source with a real
+ * finger-down/finger-up (the watch) hold for as long as the user does.
+ */
+ async injectSyntheticRingInput(kind: WearRemoteInputKind, origin: SyntheticInputOrigin = "ring"): Promise {
+ // Watch-scheme input (the Wear app, the phone's pad/d-pad, mirror touches)
+ // wakes a dark display and then lands normally, resuming the previous
+ // focus. The ring's own scheme keeps its double-tap-only wake.
+ if (
+ origin === "watch" &&
+ !shell.isScreenOn() &&
+ !this.glassesLocked &&
+ (this.phase === "connected" || this.phase === "charging") &&
+ watchWakesDisplaySetting.get() &&
+ kind !== "double-click" &&
+ kind !== "wakeword" &&
+ kind !== "long-press-release"
+ ) {
+ shell.wake(shell.getFocus());
+ this.requestShellRender();
+ this.appendLog(`${kind} (watch scheme) woke the display`);
+ }
if (kind === "long-press") {
// Hardware delivers a press event and then a release when the finger
// lifts; emulate a short hold so the escape-menu countdown never fires.
- await this.handleInputEvent(this.buildSyntheticRingInput("long-press"));
- await this.handleInputEvent(this.buildSyntheticRingInput("long-press-release"));
+ await this.handleInputEvent(this.buildSyntheticRingInput("long-press", origin));
+ await this.handleInputEvent(this.buildSyntheticRingInput("long-press-release", origin));
return;
}
- const event = this.buildSyntheticRingInput(kind);
+ const event = this.buildSyntheticRingInput(kind === "long-press-start" ? "long-press" : kind, origin);
await this.handleInputEvent(event);
}
+ /**
+ * A touch on the phone's mirror of the glasses display. Gestures other than
+ * a tap are the watch scheme (swipes navigate, double-tap is back, a hold
+ * is the menu). A tap lands on what the mirror shows: a sidebar icon
+ * switches to that window, a launcher cell opens, anything else selects.
+ * Coordinates are fractions of the mirror (0..1).
+ */
+ async handleMirrorTouch(kind: MirrorTouchKind, nx: number, ny: number): Promise {
+ if (this.phase !== "connected" && this.phase !== "charging") return;
+ if (this.glassesLocked) {
+ // Same as the ring: only a double-tap reaches a locked display.
+ if (kind === "double-tap") await this.injectSyntheticRingInput("double-click", "watch");
+ return;
+ }
+ if (!shell.isScreenOn()) {
+ shell.wake(shell.getFocus());
+ this.requestShellRender();
+ }
+ if (kind !== "tap") {
+ await this.injectSyntheticRingInput(MIRROR_TOUCH_GESTURES[kind], "watch");
+ return;
+ }
+ const x = Math.round(Math.min(1, Math.max(0, nx)) * G2_LENS_WIDTH);
+ const y = Math.round(Math.min(1, Math.max(0, ny)) * G2_LENS_HEIGHT);
+ const stripShown = sidebarWidth() > 0 || shell.getFocus() === "sidebar";
+ this.appendLog(`mirror tap at ${x},${y}`);
+ if (!shell.hasOverlay() && stripShown && x < SIDEBAR_WIDTH) {
+ const target = shell.windowAtSidebarPoint(x, y);
+ if (target) {
+ this.appendLog(`mirror tap: sidebar -> ${target.title}`);
+ shell.focusWindow(target.windowId);
+ shell.foregroundWindow()?.requestRender();
+ this.requestShellRender();
+ }
+ return;
+ }
+ const window = shell.foregroundWindow();
+ if (window && !shell.hasOverlay()) {
+ const rect = appViewportRect(window.heightMode);
+ const inside = x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height;
+ if (shell.getFocus() !== "window") {
+ shell.focusWindow(window.windowId);
+ this.requestShellRender();
+ }
+ if (inside && window.hitTest && (await window.hitTest(x - rect.x, y - rect.y))) {
+ this.appendLog(`mirror tap: ${window.title} at ${x - rect.x},${y - rect.y}`);
+ this.requestShellRender();
+ return;
+ }
+ }
+ await this.injectSyntheticRingInput("click", "watch");
+ }
+
/** A document arrived via Android's Share intent: open it as a new window. */
async openSharedTextDocument(text: string): Promise {
this.appendLog(`shared text document received (${text.length} chars)`);
@@ -1410,7 +1591,8 @@ class DashboardController {
if (this.glassesLocked) {
const ringDoubleTap =
inputEvent.type === "double-click" &&
- event.eventSource === EventSourceType.TOUCH_EVENT_FROM_RING;
+ (event.eventSource === EventSourceType.TOUCH_EVENT_FROM_RING ||
+ event.eventSource === EventSourceType.TOUCH_EVENT_FROM_WATCH);
const suspendedDisplayWake = inputEvent.type === "display-wake";
if (ringDoubleTap || suspendedDisplayWake) {
if (shell.isScreenOn()) {
@@ -1463,6 +1645,9 @@ class DashboardController {
outcome = { ...outcome, shell: true };
}
+ if (event.kind === "watch-gesture") {
+ this.appendLog(`watch-gesture ${eventLabel(event.kind, event.eventType)}`);
+ }
if (event.kind === "sys-event") {
this.lastSys = `${sourceName(event.eventSource)}/${eventName(event.eventType)}`;
this.appendLog(`sys-event ${this.lastSys}`);
@@ -1473,7 +1658,10 @@ class DashboardController {
) {
this.appendLog("display state invalidated by firmware exit event");
}
- if (event.eventSource === EventSourceType.TOUCH_EVENT_FROM_RING) {
+ if (
+ event.eventSource === EventSourceType.TOUCH_EVENT_FROM_RING ||
+ event.eventSource === EventSourceType.TOUCH_EVENT_FROM_WATCH
+ ) {
this.lastInput = eventName(event.eventType);
}
}
@@ -1813,7 +2001,7 @@ class DashboardController {
`still unsent after ${FRAME_TRANSMIT_BACKPRESSURE_TIMEOUT_MS}ms; shell render loop released`,
);
}
- this.updateCompositePreview();
+ this.schedulePreviewUpdate();
}
private async handleWakeWord(keyword: string): Promise {
@@ -1878,6 +2066,10 @@ class DashboardController {
clearInterval(this.previewTimer);
this.previewTimer = null;
}
+ if (this.previewTrailingTimer) {
+ clearTimeout(this.previewTrailingTimer);
+ this.previewTrailingTimer = null;
+ }
if (this.screenTimeoutTimer) {
clearInterval(this.screenTimeoutTimer);
this.screenTimeoutTimer = null;
@@ -1928,6 +2120,27 @@ class DashboardController {
* foreground, including worker apps the TS side never renders). Throttled
* to avoid rebuilding the bitmap faster than the phone UI needs it.
*/
+ private previewTrailingTimer: ReturnType | null = null;
+ private lastRecordCaptureAtMs = 0;
+
+ /**
+ * Refresh the preview now if the floor allows, otherwise once the floor
+ * expires — so the last frame of a burst always reaches the mirror instead
+ * of waiting for the safety-net poll.
+ */
+ private schedulePreviewUpdate(): void {
+ if (this.previewTrailingTimer) return;
+ const wait = this.lastConnectedPreviewUpdateAtMs + CONNECTED_PREVIEW_MIN_UPDATE_MS - Date.now();
+ if (wait <= 0) {
+ this.updateCompositePreview();
+ return;
+ }
+ this.previewTrailingTimer = setTimeout(() => {
+ this.previewTrailingTimer = null;
+ this.updateCompositePreview();
+ }, wait);
+ }
+
private updateCompositePreview(): void {
if (!this.communicator) return;
// The connected foreground service intentionally keeps this controller
@@ -1947,9 +2160,8 @@ class DashboardController {
return;
}
this.lastConnectedPreviewUpdateAtMs = now;
- // The recorder captures at the same cadence the phone-side preview is
- // refreshed, so the GIF matches what the phone display showed.
- if (this.screenRecordingActive) {
+ if (this.screenRecordingActive && now - this.lastRecordCaptureAtMs >= RECORDING_MIN_CAPTURE_MS) {
+ this.lastRecordCaptureAtMs = now;
this.communicator.recordScreenFrame();
}
const preview = this.communicator.getCompositePreview();
@@ -1973,10 +2185,37 @@ class DashboardController {
| "scroll-down"
| "long-press"
| "long-press-release"
- | "wakeword",
+ | "wakeword"
+ | "swipe-left"
+ | "swipe-right"
+ | "swipe-up"
+ | "swipe-down",
+ origin: SyntheticInputOrigin = "ring",
): RawInputEvent {
const frameId = frameTimings.startFrame(`input:synthetic:${kind}`);
+ // The phone UI's test buttons stand in for the ring; the watch is its own
+ // source so the UI can give it a richer scheme (see InputSource).
+ const eventSource =
+ origin === "watch" ? EventSourceType.TOUCH_EVENT_FROM_WATCH : EventSourceType.TOUCH_EVENT_FROM_RING;
switch (kind) {
+ case "swipe-left":
+ case "swipe-right":
+ case "swipe-up":
+ case "swipe-down":
+ // Watch-only directional input; see WatchGestureType.
+ return {
+ kind: "watch-gesture",
+ containerName: "",
+ eventType: {
+ "swipe-left": WatchGestureType.SWIPE_LEFT,
+ "swipe-right": WatchGestureType.SWIPE_RIGHT,
+ "swipe-up": WatchGestureType.SWIPE_UP,
+ "swipe-down": WatchGestureType.SWIPE_DOWN,
+ }[kind],
+ eventSource: 0,
+ systemExitReasonCode: 0,
+ frameId,
+ };
case "wakeword":
// Same event the glasses report for the spoken wakeword (sid 0x07).
return {
@@ -1992,7 +2231,7 @@ class DashboardController {
kind: "sys-event",
containerName: "",
eventType: OsEventTypeList.RING_LONG_PRESS_EVENT,
- eventSource: EventSourceType.TOUCH_EVENT_FROM_RING,
+ eventSource,
systemExitReasonCode: 0,
frameId,
};
@@ -2001,7 +2240,7 @@ class DashboardController {
kind: "sys-event",
containerName: "",
eventType: OsEventTypeList.RING_LONG_PRESS_RELEASE_EVENT,
- eventSource: EventSourceType.TOUCH_EVENT_FROM_RING,
+ eventSource,
systemExitReasonCode: 0,
frameId,
};
@@ -2010,7 +2249,7 @@ class DashboardController {
kind: "sys-event",
containerName: "",
eventType: OsEventTypeList.CLICK_EVENT,
- eventSource: EventSourceType.TOUCH_EVENT_FROM_RING,
+ eventSource,
systemExitReasonCode: 0,
frameId,
};
@@ -2019,7 +2258,7 @@ class DashboardController {
kind: "sys-event",
containerName: "",
eventType: OsEventTypeList.DOUBLE_CLICK_EVENT,
- eventSource: EventSourceType.TOUCH_EVENT_FROM_RING,
+ eventSource,
systemExitReasonCode: 0,
frameId,
};
@@ -2028,7 +2267,7 @@ class DashboardController {
kind: "text-click",
containerName: "",
eventType: OsEventTypeList.SCROLL_TOP_EVENT,
- eventSource: EventSourceType.TOUCH_EVENT_FROM_RING,
+ eventSource,
systemExitReasonCode: 0,
frameId,
};
@@ -2038,7 +2277,7 @@ class DashboardController {
kind: "text-click",
containerName: "",
eventType: OsEventTypeList.SCROLL_BOTTOM_EVENT,
- eventSource: EventSourceType.TOUCH_EVENT_FROM_RING,
+ eventSource,
systemExitReasonCode: 0,
frameId,
};
@@ -2050,6 +2289,7 @@ class DashboardController {
for (const listener of this.listeners) {
listener(snapshot);
}
+ this.wearRemote?.schedulePublish();
}
}
diff --git a/app/g2/events.ts b/app/g2/events.ts
index 65581b01..139c261e 100644
--- a/app/g2/events.ts
+++ b/app/g2/events.ts
@@ -3,6 +3,12 @@ export const EventSourceType = {
TOUCH_EVENT_FROM_GLASSES_R: 1,
TOUCH_EVENT_FROM_RING: 2,
TOUCH_EVENT_FROM_GLASSES_L: 3,
+ /**
+ * Synthetic: the Wear OS remote (app/g2/wear-remote.ts). Not a firmware
+ * value. Lets the UI give watch input its own, richer scheme (direct
+ * spatial selection) while ring input keeps the stock one.
+ */
+ TOUCH_EVENT_FROM_WATCH: 4,
} as const;
export const EventSourceTypeName: Record = {
@@ -10,6 +16,7 @@ export const EventSourceTypeName: Record = {
1: "TOUCH_EVENT_FROM_GLASSES_R",
2: "TOUCH_EVENT_FROM_RING",
3: "TOUCH_EVENT_FROM_GLASSES_L",
+ 4: "TOUCH_EVENT_FROM_WATCH",
};
/**
@@ -32,6 +39,24 @@ export const EvenAIStatusName: Record = {
3: "EVEN_AI_EXIT",
};
+/**
+ * Synthetic gestures from the Wear OS remote (RawInputEvent kind
+ * "watch-gesture"). Not a firmware enum: the glasses never send these.
+ */
+export const WatchGestureType = {
+ SWIPE_LEFT: 0,
+ SWIPE_RIGHT: 1,
+ SWIPE_UP: 2,
+ SWIPE_DOWN: 3,
+} as const;
+
+export const WatchGestureTypeName: Record = {
+ 0: "SWIPE_LEFT",
+ 1: "SWIPE_RIGHT",
+ 2: "SWIPE_UP",
+ 3: "SWIPE_DOWN",
+};
+
export const OsEventTypeList = {
CLICK_EVENT: 0,
SCROLL_TOP_EVENT: 1,
diff --git a/app/g2/wear-remote.ts b/app/g2/wear-remote.ts
new file mode 100644
index 00000000..cae1d982
--- /dev/null
+++ b/app/g2/wear-remote.ts
@@ -0,0 +1,490 @@
+/**
+ * The Wear OS watch as an input device and status mirror for the glasses.
+ *
+ * Inbound, the watch sends ring-style gestures (tap, double-tap, hold,
+ * swipe/crown scrolls, "Hey Even") which feed the exact synthetic-ring path
+ * the phone UI's test buttons use, plus higher-level commands the ring has no
+ * way to express: launch an app, switch or close a window, wake/sleep/lock
+ * the display, send a spoken or typed query straight to the assistant, or
+ * type text into the foreground app.
+ *
+ * Outbound, the dashboard state (connection, battery, screen, lock, open
+ * windows, launchable apps) is mirrored into a Data Layer item so the watch
+ * UI can show it and offer the right actions; assistant replies and alerts
+ * stream to the watch as events so a query made from the wrist can be read
+ * from the wrist.
+ *
+ * Transport is app/native/wear-bridge.ts (Java FaceclawWearBridge); the
+ * message shapes are documented in wear/PROTOCOL.md.
+ */
+import { type AppDefinition } from "../apps/app-definition";
+import { getInstalledEvenHubApps, installedEvenHubAppId } from "../apps/evenhub/installed-apps";
+import { WEAR_PATHS, wearBridge, type WearMessage } from "../native/wear-bridge";
+import {
+ DISPLAY_MODE_VALUES,
+ displayModeSetting,
+ onAnySettingChanged,
+ watchCanUnlockSetting,
+ watchMirrorAssistantSetting,
+ watchRemoteEnabledSetting,
+} from "../ui/dashboard-settings";
+import { shell, type AssistantActivityEvent } from "../ui/shell/shell";
+import { voiceActivity } from "../ui/shell/voice-activity";
+import { FACECLAW_VERSION } from "../version";
+
+/** Protocol revision carried in the state item; bump on incompatible changes. */
+export const WEAR_PROTOCOL_VERSION = 1;
+
+export type WearRemoteInputKind =
+ | "click"
+ | "double-click"
+ | "scroll-up"
+ | "scroll-down"
+ | "long-press"
+ | "long-press-start"
+ | "long-press-release"
+ | "wakeword"
+ | "swipe-left"
+ | "swipe-right"
+ | "swipe-up"
+ | "swipe-down";
+
+const INPUT_KINDS: readonly WearRemoteInputKind[] = [
+ "click",
+ "double-click",
+ "scroll-up",
+ "scroll-down",
+ "long-press",
+ "long-press-start",
+ "long-press-release",
+ "wakeword",
+ "swipe-left",
+ "swipe-right",
+ "swipe-up",
+ "swipe-down",
+];
+
+const COMMANDS = [
+ "launch-app",
+ "focus-window",
+ "close-window",
+ "sidebar",
+ "wake",
+ "sleep",
+ "lock",
+ "unlock",
+ "connect",
+ "disconnect",
+ "close-assistant",
+ "display-mode",
+] as const;
+type WearCommand = (typeof COMMANDS)[number];
+
+const MAX_SCROLL_STEPS = 12;
+const MAX_TEXT_LENGTH = 2000;
+const STATE_PUBLISH_DEBOUNCE_MS = 150;
+const STATE_REFRESH_INTERVAL_MS = 30_000;
+const ASSISTANT_STREAM_MIN_INTERVAL_MS = 250;
+
+/** What the dashboard controller lends the watch remote. */
+export type WearRemoteHost = {
+ /** The launcher-grid apps; installed EvenHub packages are added dynamically. */
+ apps: readonly AppDefinition[];
+ injectInput: (kind: WearRemoteInputKind) => Promise;
+ launchApp: (appId: string) => Promise;
+ connect: () => Promise;
+ disconnect: () => Promise;
+ setGlassesLocked: (locked: boolean, reason: string) => void;
+ requestShellRender: () => void;
+ getState: () => {
+ phase: string;
+ status: string;
+ glassesLocked: boolean;
+ glassesWorn: boolean | null;
+ };
+ appendLog: (line: string) => void;
+};
+
+export class WearRemote {
+ private readonly active: boolean;
+ private publishTimer: ReturnType | null = null;
+ private watchReachable = false;
+ private watchName = "";
+ // Assistant text streams as deltas many times a second; the watch gets a
+ // snapshot every ASSISTANT_STREAM_MIN_INTERVAL_MS plus every phase change.
+ private assistantStreamTimer: ReturnType | null = null;
+ private assistantPendingText: string | null = null;
+ private lastAssistantSentAtMs = 0;
+
+ constructor(private readonly host: WearRemoteHost) {
+ this.active = wearBridge.isAvailable();
+ if (!this.active) {
+ host.appendLog("watch: Google Play services unavailable; watch remote disabled");
+ return;
+ }
+ wearBridge.onMessage((message) => {
+ void this.handleMessage(message).catch((error) => {
+ host.appendLog(`watch: ${message.path} failed: ${formatError(error)}`);
+ });
+ });
+ wearBridge.onWatchConnection((connection) => {
+ const changed = connection.reachable !== this.watchReachable || connection.watchName !== this.watchName;
+ this.watchReachable = connection.reachable;
+ this.watchName = connection.watchName;
+ if (changed) {
+ host.appendLog(
+ connection.reachable ? `watch: ${connection.watchName || "watch"} reachable` : "watch: no watch reachable",
+ );
+ }
+ // A watch that just came into range gets the current state at once.
+ if (connection.reachable) this.publishNow(true);
+ });
+ shell.onAssistantActivity((event) => this.forwardAssistantActivity(event));
+ shell.onAlertShown((text) => {
+ if (watchMirrorAssistantSetting.get()) {
+ wearBridge.sendEvent({ type: "alert", text });
+ }
+ });
+ voiceActivity.subscribe(() => this.schedulePublish());
+ onAnySettingChanged(() => this.schedulePublish());
+ // Catch-all refresh for state the controller does not announce (cheap:
+ // identical states are dropped on the Java side).
+ setInterval(() => this.schedulePublish(), STATE_REFRESH_INTERVAL_MS);
+ this.schedulePublish();
+ }
+
+ /** Whether a watch running the Faceclaw watch app is reachable right now. */
+ isWatchReachable(): boolean {
+ return this.watchReachable;
+ }
+
+ getWatchName(): string {
+ return this.watchName;
+ }
+
+ /** Mirror the dashboard state to the watch soon; coalesces bursts. */
+ schedulePublish(): void {
+ if (!this.active || this.publishTimer) return;
+ this.publishTimer = setTimeout(() => {
+ this.publishTimer = null;
+ this.publishNow(false);
+ }, STATE_PUBLISH_DEBOUNCE_MS);
+ }
+
+ private publishNow(force: boolean): void {
+ if (!this.active) return;
+ try {
+ wearBridge.publishState(this.buildState(), force);
+ } catch (error) {
+ this.host.appendLog(`watch: state publish failed: ${formatError(error)}`);
+ }
+ }
+
+ private buildState(): Record {
+ const state = this.host.getState();
+ const battery = shell.getBatteryLevels();
+ const foregroundId = shell.foregroundWindow()?.windowId ?? null;
+ const foreground = shell.getForegroundApp();
+ return {
+ protocol: WEAR_PROTOCOL_VERSION,
+ version: FACECLAW_VERSION,
+ phase: state.phase,
+ status: state.status,
+ connected: state.phase === "connected" || state.phase === "charging",
+ screenOn: shell.isScreenOn(),
+ locked: state.glassesLocked,
+ worn: state.glassesWorn,
+ listening: voiceActivity.isActive(),
+ battery: battery.headset,
+ charging: battery.headsetCharging === true,
+ foreground: foreground ? { appId: foreground.appId, title: foreground.title } : null,
+ windows: shell.getWindows().map((window) => ({
+ windowId: window.windowId,
+ title: window.title,
+ appId: window.appId,
+ focused: window.windowId === foregroundId,
+ closeable: window.closeable,
+ acceptsText: typeof window.receiveTextInput === "function",
+ })),
+ apps: this.listApps(),
+ displayMode: displayModeSetting.get(),
+ remoteEnabled: watchRemoteEnabledSetting.get(),
+ canUnlock: watchCanUnlockSetting.get(),
+ mirrorAssistant: watchMirrorAssistantSetting.get(),
+ assistantAvailable: shell.isAssistantAvailable(),
+ };
+ }
+
+ /** Launchable apps, matching the launcher grid and the apps.launch tool. */
+ private listApps(): Array<{ appId: string; title: string }> {
+ const apps = this.host.apps.map((app) => ({ appId: app.appId, title: app.title }));
+ for (const installed of getInstalledEvenHubApps()) {
+ apps.push({ appId: installedEvenHubAppId(installed.packageId), title: installed.name });
+ }
+ return apps;
+ }
+
+ private async handleMessage(message: WearMessage): Promise {
+ const seq = readNumber(message.payload.seq, 0);
+ const ack = (ok: boolean, text = "") => wearBridge.sendAck(message.nodeId, seq, ok, text);
+
+ if (message.path === WEAR_PATHS.stateRequest) {
+ this.publishNow(true);
+ ack(true);
+ return;
+ }
+ if (!watchRemoteEnabledSetting.get()) {
+ ack(false, "Watch control is turned off in Faceclaw's Settings > Watch.");
+ return;
+ }
+
+ switch (message.path) {
+ case WEAR_PATHS.input:
+ await this.handleInput(message.payload, ack);
+ return;
+ case WEAR_PATHS.command:
+ await this.handleCommand(message.payload, ack);
+ return;
+ case WEAR_PATHS.assistant: {
+ const text = readText(message.payload.text);
+ if (!text) {
+ ack(false, "Nothing to send.");
+ return;
+ }
+ if (!shell.isAssistantAvailable()) {
+ ack(false, "Set up the assistant in Faceclaw's Settings first.");
+ return;
+ }
+ this.host.appendLog(`watch: assistant query (${text.length} chars)`);
+ shell.sendToAssistant(text);
+ ack(true);
+ return;
+ }
+ case WEAR_PATHS.text: {
+ const text = readText(message.payload.text);
+ if (!text) {
+ ack(false, "Nothing to type.");
+ return;
+ }
+ const window = shell.foregroundWindow();
+ if (!window?.receiveTextInput) {
+ ack(false, `${window ? window.title : "The current app"} does not accept typed text.`);
+ return;
+ }
+ if (!shell.isScreenOn()) shell.wake("window");
+ this.host.appendLog(`watch: typed ${text.length} chars into ${window.title}`);
+ shell.sendTextToForegroundWindow(text);
+ ack(true);
+ return;
+ }
+ default:
+ ack(false, `Unknown message: ${message.path}`);
+ }
+ }
+
+ private async handleInput(payload: Record, ack: (ok: boolean, text?: string) => void): Promise {
+ const gesture = String(payload.gesture ?? "");
+ if (!(INPUT_KINDS as readonly string[]).includes(gesture)) {
+ ack(false, `Unknown gesture: ${gesture}`);
+ return;
+ }
+ const kind = gesture as WearRemoteInputKind;
+ const state = this.host.getState();
+ if (state.phase !== "connected" && state.phase !== "charging") {
+ ack(false, "The glasses are not connected.");
+ return;
+ }
+ // The lock only yields to a double-click, exactly as the ring's does
+ // (handled inside the controller); a dark display wakes on any watch-
+ // scheme gesture (injectSyntheticRingInput, shared with the phone's own
+ // pad and d-pad).
+ const repeatable = kind === "scroll-up" || kind === "scroll-down" || kind === "swipe-up" || kind === "swipe-down";
+ const steps = repeatable ? Math.min(MAX_SCROLL_STEPS, Math.max(1, Math.round(readNumber(payload.steps, 1)))) : 1;
+ for (let i = 0; i < steps; i++) {
+ await this.host.injectInput(kind);
+ }
+ ack(true);
+ }
+
+ private async handleCommand(payload: Record, ack: (ok: boolean, text?: string) => void): Promise {
+ const command = String(payload.command ?? "");
+ if (!(COMMANDS as readonly string[]).includes(command)) {
+ ack(false, `Unknown command: ${command}`);
+ return;
+ }
+ const state = this.host.getState();
+ const connected = state.phase === "connected" || state.phase === "charging";
+ this.host.appendLog(`watch: ${command}`);
+ switch (command as WearCommand) {
+ case "connect":
+ if (connected) {
+ ack(true, "Already connected.");
+ return;
+ }
+ ack(true, "Connecting...");
+ await this.host.connect();
+ return;
+ case "disconnect":
+ if (!connected && state.phase === "disconnected") {
+ ack(true, "Already disconnected.");
+ return;
+ }
+ ack(true, "Disconnecting...");
+ await this.host.disconnect();
+ return;
+ default:
+ break;
+ }
+ if (!connected) {
+ ack(false, "The glasses are not connected.");
+ return;
+ }
+ if (state.glassesLocked && command !== "unlock" && command !== "lock") {
+ ack(false, "The glasses are locked.");
+ return;
+ }
+ switch (command as WearCommand) {
+ case "launch-app": {
+ const appId = String(payload.appId ?? "").trim();
+ const app = this.listApps().find((entry) => entry.appId === appId);
+ if (!app) {
+ ack(false, `Unknown app: ${appId}`);
+ return;
+ }
+ shell.wake("window");
+ await this.host.launchApp(appId);
+ this.schedulePublish();
+ ack(true, `Opened ${app.title}.`);
+ return;
+ }
+ case "focus-window": {
+ const windowId = String(payload.windowId ?? "").trim();
+ const window = shell.getWindows().find((entry) => entry.windowId === windowId);
+ if (!window) {
+ ack(false, "That window is no longer open.");
+ return;
+ }
+ shell.wake("window");
+ shell.focusWindow(windowId);
+ this.host.requestShellRender();
+ this.schedulePublish();
+ ack(true);
+ return;
+ }
+ case "close-window": {
+ const windowId = String(payload.windowId ?? "").trim();
+ const window = shell.getWindows().find((entry) => entry.windowId === windowId);
+ if (!window) {
+ ack(false, "That window is no longer open.");
+ return;
+ }
+ if (!window.closeable) {
+ ack(false, `${window.title} cannot be closed.`);
+ return;
+ }
+ shell.closeWindow(windowId);
+ this.host.requestShellRender();
+ this.schedulePublish();
+ ack(true, `Closed ${window.title}.`);
+ return;
+ }
+ case "sidebar":
+ shell.wake("sidebar");
+ shell.yieldFocusToSidebar();
+ this.host.requestShellRender();
+ ack(true);
+ return;
+ case "wake":
+ if (!shell.wake("sidebar")) {
+ ack(true, "The display is already on.");
+ return;
+ }
+ this.host.requestShellRender();
+ ack(true);
+ return;
+ case "sleep":
+ if (!shell.isScreenOn()) {
+ ack(true, "The display is already off.");
+ return;
+ }
+ shell.sleep();
+ ack(true);
+ return;
+ case "lock":
+ this.host.setGlassesLocked(true, "locked from the watch");
+ this.schedulePublish();
+ ack(true);
+ return;
+ case "unlock":
+ if (!watchCanUnlockSetting.get()) {
+ ack(false, "Unlocking from the watch is turned off in Settings > Watch.");
+ return;
+ }
+ this.host.setGlassesLocked(false, "unlocked from the watch");
+ this.schedulePublish();
+ ack(true);
+ return;
+ case "close-assistant":
+ shell.closeAssistant();
+ ack(true);
+ return;
+ case "display-mode": {
+ const value = String(payload.value ?? "");
+ if (!(DISPLAY_MODE_VALUES as readonly string[]).includes(value)) {
+ ack(false, `Unknown display mode: ${value}`);
+ return;
+ }
+ displayModeSetting.set(value as (typeof DISPLAY_MODE_VALUES)[number]);
+ this.schedulePublish();
+ ack(true, `Display mode: ${value}`);
+ return;
+ }
+ default:
+ ack(false, `Unhandled command: ${command}`);
+ }
+ }
+
+ private forwardAssistantActivity(event: AssistantActivityEvent): void {
+ if (!watchMirrorAssistantSetting.get()) return;
+ if (event.phase === "streaming") {
+ // Coalesce: the newest text wins, sent no more often than the interval.
+ this.assistantPendingText = event.text;
+ if (this.assistantStreamTimer) return;
+ const wait = Math.max(0, ASSISTANT_STREAM_MIN_INTERVAL_MS - (Date.now() - this.lastAssistantSentAtMs));
+ this.assistantStreamTimer = setTimeout(() => {
+ this.assistantStreamTimer = null;
+ if (this.assistantPendingText === null) return;
+ this.sendAssistantEvent("streaming", this.assistantPendingText);
+ this.assistantPendingText = null;
+ }, wait);
+ return;
+ }
+ // A phase change supersedes any queued stream snapshot.
+ if (this.assistantStreamTimer) {
+ clearTimeout(this.assistantStreamTimer);
+ this.assistantStreamTimer = null;
+ }
+ this.assistantPendingText = null;
+ this.sendAssistantEvent(event.phase, event.text);
+ this.schedulePublish();
+ }
+
+ private sendAssistantEvent(phase: AssistantActivityEvent["phase"], text: string): void {
+ this.lastAssistantSentAtMs = Date.now();
+ wearBridge.sendEvent({ type: "assistant", phase, text });
+ }
+}
+
+function readNumber(value: unknown, fallback: number): number {
+ const numeric = typeof value === "number" ? value : Number(value);
+ return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function readText(value: unknown): string {
+ const text = typeof value === "string" ? value : "";
+ return text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "").trim().slice(0, MAX_TEXT_LENGTH);
+}
+
+function formatError(error: unknown): string {
+ return (error as Error)?.message ?? String(error);
+}
diff --git a/app/graphics/image.ts b/app/graphics/image.ts
index 4a42271d..4a5d472e 100644
--- a/app/graphics/image.ts
+++ b/app/graphics/image.ts
@@ -533,6 +533,20 @@ export class GrayImage {
return baked;
}
+ /**
+ * Place this image into target at (dx, dy): raster via bitBlt, deferred
+ * draws carried over as deferred draws (translated), so firmware-text runs
+ * and cached glyphs stay on their cheap wire paths instead of being baked
+ * to raster. The composed-in draws render above target's earlier raster,
+ * matching the usual draw-above-own-raster rule.
+ */
+ composeInto(target: GrayImage, dx: number, dy: number): void {
+ target.bitBlt(this, dx, dy);
+ for (const placed of this.drawList) {
+ target.drawList.push({ ...placed, x: placed.x + dx, y: placed.y + dy });
+ }
+ }
+
/** Rasterize this image's deferred draws into target, translated by (dx, dy). */
bakeDrawsInto(target: GrayImage, dx: number, dy: number): void {
for (const placed of this.drawList) {
diff --git a/app/native/faceclaw-communicator.ts b/app/native/faceclaw-communicator.ts
index 4cfef948..c1338bd2 100644
--- a/app/native/faceclaw-communicator.ts
+++ b/app/native/faceclaw-communicator.ts
@@ -89,6 +89,18 @@ export type RawInputEvent =
systemExitReasonCode: number;
frameId: number;
}
+ | {
+ /**
+ * Synthetic directional gesture from the Wear OS remote; `eventType` is
+ * a WatchGestureType (app/g2/events.ts). Never produced by Java.
+ */
+ kind: "watch-gesture";
+ containerName: string;
+ eventType: number;
+ eventSource: number;
+ systemExitReasonCode: number;
+ frameId: number;
+ }
| {
/**
* Stock display-lifecycle wake observed after a ring or arm double tap
diff --git a/app/native/wear-bridge.ts b/app/native/wear-bridge.ts
new file mode 100644
index 00000000..7981809f
--- /dev/null
+++ b/app/native/wear-bridge.ts
@@ -0,0 +1,178 @@
+/**
+ * TS wrapper for the Java FaceclawWearBridge: the phone side of the Wear OS
+ * watch remote. Inbound watch messages arrive as (path, JSON) pairs on the
+ * main isolate's thread; outbound calls publish dashboard state and send
+ * messages to the watch. The semantic mapping (what a watch "click" does)
+ * lives in app/g2/wear-remote.ts; this file only crosses the Java boundary.
+ *
+ * Every call is a no-op when Google Play services is missing (the Wearable
+ * Data Layer is part of it), so the rest of the app never has to care.
+ */
+import { Utils } from "@nativescript/core";
+
+declare const com: any;
+
+/** Message paths shared with the watch app (wear/app/.../Protocol.kt). */
+export const WEAR_PATHS = {
+ /** Watch -> phone: a ring-style gesture. */
+ input: "/faceclaw/input",
+ /** Watch -> phone: a shell command (launch app, wake, lock, ...). */
+ command: "/faceclaw/command",
+ /** Watch -> phone: a text query for the assistant. */
+ assistant: "/faceclaw/assistant",
+ /** Watch -> phone: text to type into the foreground app. */
+ text: "/faceclaw/text",
+ /** Watch -> phone: please re-publish the state item. */
+ stateRequest: "/faceclaw/state/request",
+ /** Phone -> watch: reply to any of the above. */
+ ack: "/faceclaw/ack",
+ /** Phone -> watch: assistant activity, alerts, voice-dialog transcripts. */
+ event: "/faceclaw/event",
+ /** Phone -> watch Data Layer item: the mirrored dashboard state. */
+ state: "/faceclaw/state",
+} as const;
+
+export type WearMessage = {
+ path: string;
+ /** Parsed JSON payload ({} when the watch sent none or it was malformed). */
+ payload: Record;
+ nodeId: string;
+};
+
+export type WearWatchConnection = {
+ reachable: boolean;
+ watchName: string;
+};
+
+type MessageListener = (message: WearMessage) => void;
+type ConnectionListener = (connection: WearWatchConnection) => void;
+
+class WearBridge {
+ private java: any | null | undefined = undefined;
+ // The Java-side listener proxy must stay referenced or it gets GC'd.
+ private retainedListenerProxy: any = null;
+ private readonly messageListeners = new Set();
+ private readonly connectionListeners = new Set();
+ private lastConnection: WearWatchConnection = { reachable: false, watchName: "" };
+
+ private getJava(): any | null {
+ if (this.java !== undefined) return this.java;
+ if (!global.isAndroid) {
+ this.java = null;
+ return null;
+ }
+ try {
+ const context = Utils.android.getApplicationContext();
+ const bridge = context ? com.faceclaw.app.FaceclawWearBridge.getInstance(context) : null;
+ this.java = bridge && bridge.isAvailable() ? bridge : null;
+ } catch (error) {
+ console.warn("wear bridge unavailable", error);
+ this.java = null;
+ }
+ return this.java;
+ }
+
+ /** Whether the Wearable Data Layer exists on this phone (Play services). */
+ isAvailable(): boolean {
+ return this.getJava() !== null;
+ }
+
+ private ensureListener(): void {
+ if (this.retainedListenerProxy) return;
+ const java = this.getJava();
+ if (!java) return;
+ this.retainedListenerProxy = new com.faceclaw.app.FaceclawWearListener({
+ onMessage: (path: string, json: string, nodeId: string) => {
+ const message: WearMessage = {
+ path: String(path),
+ payload: parsePayload(String(json)),
+ nodeId: String(nodeId),
+ };
+ for (const listener of Array.from(this.messageListeners)) {
+ try {
+ listener(message);
+ } catch (error) {
+ console.warn("wear message listener failed", error);
+ }
+ }
+ },
+ onWatchConnection: (reachable: boolean, watchName: string) => {
+ this.lastConnection = { reachable: Boolean(reachable), watchName: String(watchName ?? "") };
+ for (const listener of Array.from(this.connectionListeners)) {
+ try {
+ listener(this.lastConnection);
+ } catch (error) {
+ console.warn("wear connection listener failed", error);
+ }
+ }
+ },
+ });
+ java.setListener(this.retainedListenerProxy);
+ }
+
+ /** Subscribe to watch messages. Registers the Java listener on first use. */
+ onMessage(listener: MessageListener): () => void {
+ this.messageListeners.add(listener);
+ this.ensureListener();
+ return () => {
+ this.messageListeners.delete(listener);
+ };
+ }
+
+ /** Subscribe to watch reachability; the current value is delivered immediately. */
+ onWatchConnection(listener: ConnectionListener): () => void {
+ this.connectionListeners.add(listener);
+ this.ensureListener();
+ listener(this.getWatchConnection());
+ return () => {
+ this.connectionListeners.delete(listener);
+ };
+ }
+
+ getWatchConnection(): WearWatchConnection {
+ const java = this.getJava();
+ if (!java) return { reachable: false, watchName: "" };
+ try {
+ return {
+ reachable: Boolean(java.isWatchReachable()),
+ watchName: String(java.getWatchName() ?? ""),
+ };
+ } catch {
+ return this.lastConnection;
+ }
+ }
+
+ /** Re-query reachable watches (e.g. when the phone UI wants a fresh answer). */
+ refreshWatchNodes(): void {
+ this.getJava()?.refreshWatchNodes();
+ }
+
+ /**
+ * Mirror the dashboard state to the watch. Unchanged states are dropped on
+ * the Java side unless `force` (a watch explicitly asked for a refresh).
+ */
+ publishState(state: Record, force = false): void {
+ this.getJava()?.publishState(JSON.stringify(state), force);
+ }
+
+ /** Send an event to every reachable watch. */
+ sendEvent(payload: Record): void {
+ this.getJava()?.sendToWatch(WEAR_PATHS.event, JSON.stringify(payload));
+ }
+
+ /** Acknowledge a watch message; `seq` echoes the watch's sequence number. */
+ sendAck(nodeId: string, seq: number, ok: boolean, message = ""): void {
+ this.getJava()?.sendAck(nodeId, seq, ok, true, message);
+ }
+}
+
+function parsePayload(json: string): Record {
+ try {
+ const parsed = JSON.parse(json);
+ return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+ } catch {
+ return {};
+ }
+}
+
+export const wearBridge = new WearBridge();
diff --git a/app/phone-ui/main-page.xml b/app/phone-ui/main-page.xml
index 98f51b4a..56d697fc 100644
--- a/app/phone-ui/main-page.xml
+++ b/app/phone-ui/main-page.xml
@@ -1,4 +1,4 @@
-
+
@@ -11,7 +11,8 @@
-
+
-
-
-
-
-
-
-
-
+
@@ -65,13 +59,14 @@
-
+
+ height="{{ landscapeDisplayPreviewHeight }}"
+ tap="{{ onMirrorTap }}" doubleTap="{{ onMirrorDoubleTap }}" longPress="{{ onMirrorLongPress }}" swipe="{{ onMirrorSwipe }}" />
-
-
-
-
-
-
-
-
+
diff --git a/app/phone-ui/main-view-model.ts b/app/phone-ui/main-view-model.ts
index 049c7421..47e19b43 100644
--- a/app/phone-ui/main-view-model.ts
+++ b/app/phone-ui/main-view-model.ts
@@ -1,5 +1,28 @@
-import { Application, Frame, ImageSource, Observable, Screen } from "@nativescript/core";
-import { dashboardController } from "../g2/dashboard-controller";
+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 } from "../g2/reconnect-policy";
import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../graphics/image";
@@ -55,7 +78,10 @@ export class MainViewModel extends Observable {
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.
+ onAnySettingChanged(() => this.refreshDisplayControls());
}
get status(): string {
@@ -601,6 +627,220 @@ export class MainViewModel extends Observable {
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 padPointers = 0;
+ 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 {
+ if (this.padTwoFingerDown) return;
+ await dashboardController.injectSyntheticRingInput("click", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onPadDoubleTap(): Promise {
+ await dashboardController.injectSyntheticRingInput("double-click", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onPadLongPress(): Promise {
+ await dashboardController.injectSyntheticRingInput("long-press", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onPadSwipe(args: SwipeGestureEventData): Promise {
+ 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 {
+ const count = args.getPointerCount();
+ if (args.action === "down" || args.action === "move") {
+ this.padPointers = Math.max(this.padPointers, count);
+ if (count >= 2) this.padTwoFingerDown = true;
+ return;
+ }
+ if (args.action === "up" || args.action === "cancel") {
+ const twoFinger = this.padTwoFingerDown;
+ this.padPointers = 0;
+ if (twoFinger) {
+ // Let the single-tap recognizer's delayed tap see the flag first.
+ setTimeout(() => {
+ this.padTwoFingerDown = false;
+ }, 400);
+ if (args.action === "up") {
+ await dashboardController.injectSyntheticRingInput("double-click", "watch");
+ this.refreshPadFocusLine();
+ }
+ }
+ }
+ }
+
+ async onDpadUp(): Promise {
+ await dashboardController.injectSyntheticRingInput("swipe-up", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onDpadDown(): Promise {
+ await dashboardController.injectSyntheticRingInput("swipe-down", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onDpadLeft(): Promise {
+ await dashboardController.injectSyntheticRingInput("swipe-left", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onDpadRight(): Promise {
+ await dashboardController.injectSyntheticRingInput("swipe-right", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onDpadSelect(): Promise {
+ await dashboardController.injectSyntheticRingInput("click", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onBackTap(): Promise {
+ await dashboardController.injectSyntheticRingInput("double-click", "watch");
+ this.refreshPadFocusLine();
+ }
+
+ async onMenuTap(): Promise {
+ 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;
+ // On Android the gesture's getX/getY are screen-absolute (in DIPs), not
+ // view-local; the view's own screen position makes them local.
+ const origin = view.getLocationOnScreen?.() ?? { x: 0, y: 0 };
+ const localX = args.getX() - origin.x;
+ const localY = args.getY() - origin.y;
+ return { nx: localX / size.width, ny: localY / size.height };
+ }
+
+ private async mirrorGesture(kind: MirrorTouchKind, args: GestureEventData): Promise {
+ 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 {
+ return this.mirrorGesture("tap", args);
+ }
+
+ onMirrorDoubleTap(args: GestureEventData): Promise {
+ return this.mirrorGesture("double-tap", args);
+ }
+
+ onMirrorLongPress(args: GestureEventData): Promise {
+ return this.mirrorGesture("long-press", args);
+ }
+
+ onMirrorSwipe(args: SwipeGestureEventData): Promise {
+ return this.mirrorGesture(swipeKind(args.direction), args);
+ }
+
+ // ---- display mode and brightness, beside the mirror ----
+
+ get displayModeLabel(): string {
+ return displayModeLabel(displayModeSetting.get()) + " ▾";
+ }
+
+ async onDisplayModeTap(): Promise {
+ 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 appendLog(line: string): void {
const stamp = new Date().toISOString().slice(11, 19);
this.log = this.log ? `${this.log}\n[${stamp}] ${line}` : `[${stamp}] ${line}`;
@@ -621,3 +861,19 @@ export class MainViewModel extends Observable {
return `${sanitized.slice(0, 237)}...`;
}
}
+
+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";
+ }
+}
diff --git a/app/phone-ui/remote-controls.xml b/app/phone-ui/remote-controls.xml
new file mode 100644
index 00000000..aadfe111
--- /dev/null
+++ b/app/phone-ui/remote-controls.xml
@@ -0,0 +1,47 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts
index 58324389..848fcd0f 100644
--- a/app/ui/dashboard-settings.ts
+++ b/app/ui/dashboard-settings.ts
@@ -223,6 +223,36 @@ export const timeFormatSetting = new ConfigSettingEnum({
description: "Whether the top-bar clock shows 24-hour or 12-hour time.",
});
+/**
+ * How much of the 640x480 panel the UI uses. "576x288" is the stock band
+ * (sidebar + a 288px-tall window at the vertical position); "576x480" keeps
+ * the sidebar and gives every window the full height; "640x480" is the whole
+ * panel, with the sidebar an overlay that shows only while it has focus.
+ */
+export const DISPLAY_MODE_VALUES = ["576x288", "576x480", "640x480"] as const;
+export type DisplayModeSetting = (typeof DISPLAY_MODE_VALUES)[number];
+
+const DISPLAY_MODE_LABELS: Record = {
+ "576x288": "Band · 576×288",
+ "576x480": "Tall · 576×480",
+ "640x480": "Full panel · 640×480",
+};
+
+export function displayModeLabel(value: DisplayModeSetting): string {
+ return DISPLAY_MODE_LABELS[value] ?? value;
+}
+
+export const displayModeSetting = new ConfigSettingEnum({
+ id: "display-mode",
+ label: "Display mode",
+ storageKey: "display.mode",
+ defaultValue: "576x288",
+ values: DISPLAY_MODE_VALUES,
+ formatValue: displayModeLabel,
+ description:
+ "Band: the stock 576×288 window beside the sidebar. Tall: the sidebar plus full-height windows. Full panel: the whole 640×480 display; the sidebar overlays the app only while you are in it. Open apps reopen in the new size.",
+});
+
export const brightnessSetting = new ConfigSettingEnum({
id: "brightness",
label: "Brightness",
@@ -252,6 +282,43 @@ export const lockScreenEnabledSetting = new ConfigSettingBoolean({
"Lock the glasses after they are taken off while the phone is locked. Unlocking the phone unlocks the glasses.",
});
+// Wear OS watch remote (app/g2/wear-remote.ts, wear/). All three are read on
+// every watch message, so a change applies immediately.
+export const watchRemoteEnabledSetting = new ConfigSettingBoolean({
+ id: "watch-remote-enabled",
+ label: "Watch remote control",
+ storageKey: "watch.remoteEnabled",
+ defaultValue: true,
+ description:
+ "Accept input from the Faceclaw Wear OS app: spatial swipes, taps, holds, crown, voice queries and app commands. The ring's scheme is unaffected. Turn off to ignore the watch.",
+});
+
+export const watchCanUnlockSetting = new ConfigSettingBoolean({
+ id: "watch-can-unlock",
+ label: "Watch can unlock glasses",
+ storageKey: "watch.canUnlock",
+ defaultValue: true,
+ description:
+ "Let the watch unlock the glasses' lock screen (which otherwise waits for the phone to be unlocked). Your watch is on your wrist; turn this off if you would rather it stay a phone-only unlock.",
+});
+
+export const watchWakesDisplaySetting = new ConfigSettingBoolean({
+ id: "watch-wakes-display",
+ label: "Watch input wakes display",
+ storageKey: "watch.wakesDisplay",
+ defaultValue: true,
+ description:
+ "Any gesture from the watch turns the glasses display on (the ring only wakes it with a double-tap). Off: watch input is ignored while the display is off, as ring input is.",
+});
+
+export const watchMirrorAssistantSetting = new ConfigSettingBoolean({
+ id: "watch-mirror-assistant",
+ label: "Mirror assistant to watch",
+ storageKey: "watch.mirrorAssistant",
+ defaultValue: true,
+ description: "Stream assistant replies and on-glasses alerts to the watch so they can be read from the wrist.",
+});
+
export type VerticalPosition = "top" | "upper" | "middle" | "lower" | "bottom";
const VERTICAL_POSITION_LABELS: Record = {
diff --git a/app/ui/dashboard/settings-menus.ts b/app/ui/dashboard/settings-menus.ts
index 447e2494..8de6d3eb 100644
--- a/app/ui/dashboard/settings-menus.ts
+++ b/app/ui/dashboard/settings-menus.ts
@@ -27,6 +27,7 @@ import {
assistantSkipConfirmationSetting,
batteryDisplayModeSetting,
brightnessSetting,
+ displayModeSetting,
elevenLabsApiKeySetting,
mapboxApiKeySetting,
openAiApiKeySetting,
@@ -48,7 +49,12 @@ import {
voiceProviderSetting,
screenTimeoutSetting,
wakeWordActionSetting,
+ watchCanUnlockSetting,
+ watchMirrorAssistantSetting,
+ watchRemoteEnabledSetting,
+ watchWakesDisplaySetting,
} from "../dashboard-settings";
+import { wearBridge } from "../../native/wear-bridge";
import { SettingsPanelLayer, type SettingsSection } from "./settings-panel";
import { terminalFontPickerMenuItem, uiFontPickerMenuItem } from "../font-picker";
@@ -74,6 +80,8 @@ function settingsSections(): SettingsSection[] {
// Where min-height windows (and the sidebar) sit vertically on the
// screen; the dashboard controller repositions surfaces on change.
enumSettingMenuItem(verticalPositionSetting),
+ // Band / tall / full-panel; the dashboard controller reflows windows.
+ enumSettingMenuItem(displayModeSetting),
// Controls the top-bar battery indicators (icon vs percentage).
enumSettingMenuItem(batteryDisplayModeSetting),
// Controls the top-bar clock (24-hour vs 12-hour).
@@ -133,6 +141,18 @@ function settingsSections(): SettingsSection[] {
textSettingMenuItem(roamApiTokenSetting),
],
},
+ {
+ label: "Watch",
+ // Wear OS remote (wear/); the status line above the items says whether
+ // a watch running the companion app is currently reachable.
+ items: [
+ toggleSettingMenuItem(watchRemoteEnabledSetting),
+ toggleSettingMenuItem(watchWakesDisplaySetting),
+ toggleSettingMenuItem(watchCanUnlockSetting),
+ toggleSettingMenuItem(watchMirrorAssistantSetting),
+ ],
+ renderDetail: renderWatchStatus,
+ },
{
label: "Developer",
items: [
@@ -260,6 +280,25 @@ function readBundledDoc(fileName: string): string {
}
}
+function renderWatchStatus(args: { image: GrayImage; x: number; y: number; width: number }): number {
+ const { image, x, y, width } = args;
+ const font = getDefaultSmallFont();
+ let status: string;
+ if (!wearBridge.isAvailable()) {
+ status = "Google Play services is unavailable on this phone, so no watch can connect.";
+ } else {
+ const connection = wearBridge.getWatchConnection();
+ status = connection.reachable
+ ? `Connected to ${connection.watchName || "a watch"}.`
+ : "No watch connected. Install the Faceclaw watch app (wear/ in the source tree) on a Wear OS watch paired with this phone.";
+ }
+ const lines = wrapText(font, status, width);
+ for (let i = 0; i < lines.length; i++) {
+ image.drawText(font, x, y + i * font.lineHeight, lines[i]!, 170);
+ }
+ return lines.length * font.lineHeight + 10;
+}
+
function renderAbout(args: { image: GrayImage; x: number; y: number; width: number }): number {
const { image, x, y, width } = args;
const font = getDefaultSmallFont();
diff --git a/app/ui/dashboard/settings-panel.ts b/app/ui/dashboard/settings-panel.ts
index 7642ac48..b05d7ebf 100644
--- a/app/ui/dashboard/settings-panel.ts
+++ b/app/ui/dashboard/settings-panel.ts
@@ -41,6 +41,9 @@ const NO_MENU = new MenuLayer(null, []);
* column, out to the sidebar). Third-level menus open as centered modals.
*/
export class SettingsPanelLayer implements Layer {
+ // Watch swipes map onto the two columns: right goes into a section's
+ // items, left comes back out (and out to the sidebar from the left column).
+ readonly acceptsDirectional = true;
private leftIndex = 0;
private rightIndex = 0;
private focus: "left" | "right" = "left";
@@ -185,14 +188,17 @@ export class SettingsPanelLayer implements Layer {
if (this.focus === "left") {
switch (event.type) {
case "scroll-up":
+ case "swipe-up":
this.leftIndex = (this.leftIndex + this.sections.length - 1) % this.sections.length;
this.resetRight();
return;
case "scroll-down":
+ case "swipe-down":
this.leftIndex = (this.leftIndex + 1) % this.sections.length;
this.resetRight();
return;
case "click":
+ case "swipe-right":
// Only enter sections that have something interactive on the right.
if (this.section().items.length) {
this.focus = "right";
@@ -200,6 +206,7 @@ export class SettingsPanelLayer implements Layer {
}
return;
case "double-click":
+ case "swipe-left":
shell.yieldFocusToSidebar();
return;
default:
@@ -210,18 +217,22 @@ export class SettingsPanelLayer implements Layer {
const items = this.section().items;
switch (event.type) {
case "scroll-up":
+ case "swipe-up":
if (items.length) this.rightIndex = (this.rightIndex + items.length - 1) % items.length;
return;
case "scroll-down":
+ case "swipe-down":
if (items.length) this.rightIndex = (this.rightIndex + 1) % items.length;
return;
case "click":
+ case "swipe-right":
if (items.length) {
const item = items[clamp(this.rightIndex, 0, items.length - 1)]!;
if (!isMenuItemDisabled(item)) await item.onSelect(ctx, NO_MENU);
}
return;
case "double-click":
+ case "swipe-left":
this.focus = "left";
return;
default:
@@ -242,6 +253,8 @@ export class SettingsPanelLayer implements Layer {
* layers (modal menus, the text editor) stack above it as before.
*/
export class SettingsDescriptionOverlayLayer implements Layer {
+ readonly acceptsDirectional = true;
+
constructor(private readonly panel: SettingsPanelLayer) {}
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
diff --git a/app/ui/layers.ts b/app/ui/layers.ts
index 7dc658a1..f36076cc 100644
--- a/app/ui/layers.ts
+++ b/app/ui/layers.ts
@@ -3,13 +3,35 @@ import { type Plane } from "../graphics/plane";
import { spanCurrent } from "../native/frame-timings";
import { type ConfigSettingString } from "./dashboard-settings";
+/**
+ * Where an input came from. The ring and the glasses' arms are the stock
+ * sources; "watch" is the Wear OS remote, which components may treat with a
+ * richer scheme (see isWatchInput) — the ring's semantics are never changed
+ * by it.
+ */
+export type InputSource = "ring" | "left-arm" | "right-arm" | "watch";
+
export type DashboardInputEvent =
- | { type: "click"; source: "ring" | "left-arm" | "right-arm" }
- | { type: "double-click"; source: "ring" | "left-arm" | "right-arm" }
- | { type: "scroll-up" }
- | { type: "scroll-down" }
- | { type: "long-press"; source: "ring" | "left-arm" | "right-arm" }
- | { type: "long-press-release"; source: "ring" | "left-arm" | "right-arm" }
+ | { type: "click"; source: InputSource }
+ | { type: "double-click"; source: InputSource }
+ /** Ring scroll (or a watch crown turn, then tagged source "watch"). */
+ | { type: "scroll-up"; source?: InputSource }
+ | { type: "scroll-down"; source?: InputSource }
+ | { type: "long-press"; source: InputSource }
+ | { type: "long-press-release"; source: InputSource }
+ /**
+ * Spatial (four-way) input, which only a watch can produce: the ring's
+ * scroll is a one-dimensional cursor, these are directions. Components with
+ * a spatial meaning for them opt in with Layer.acceptsDirectional /
+ * ShellWindow.acceptsDirectional and must then handle all four; for the
+ * rest, directionalFallback turns up/down into scroll, right into "select"
+ * (click) and left into "back" (double-click), so a swipe always does
+ * something sensible.
+ */
+ | { type: "swipe-up"; source: "watch" }
+ | { type: "swipe-down"; source: "watch" }
+ | { type: "swipe-left"; source: "watch" }
+ | { type: "swipe-right"; source: "watch" }
/**
* The stock display lifecycle woke while no EvenHub page was running. This
* is wake-only, unlike a normal double-click (which turns an on screen off).
@@ -24,6 +46,44 @@ export type DashboardInputEvent =
| { type: "wakeword" }
| { type: "unknown"; kind: string; eventSource: number; eventType: number };
+/** True for input from the Wear OS remote (any type that carries a source). */
+export function isWatchInput(event: DashboardInputEvent): boolean {
+ return "source" in event && event.source === "watch";
+}
+
+export type DirectionalInputEvent = Extract<
+ DashboardInputEvent,
+ { type: "swipe-up" | "swipe-down" | "swipe-left" | "swipe-right" }
+>;
+
+export function isDirectionalInput(event: DashboardInputEvent): event is DirectionalInputEvent {
+ return (
+ event.type === "swipe-up" ||
+ event.type === "swipe-down" ||
+ event.type === "swipe-left" ||
+ event.type === "swipe-right"
+ );
+}
+
+/**
+ * The ring-vocabulary equivalent of a directional swipe: up/down scroll,
+ * right selects, left backs out.
+ */
+export function directionalFallback(event: DashboardInputEvent): DashboardInputEvent {
+ switch (event.type) {
+ case "swipe-up":
+ return { type: "scroll-up" };
+ case "swipe-down":
+ return { type: "scroll-down" };
+ case "swipe-right":
+ return { type: "click", source: "ring" };
+ case "swipe-left":
+ return { type: "double-click", source: "ring" };
+ default:
+ return event;
+ }
+}
+
export type LayerActions = {
/** Ask for a dashboard repaint+transmit, e.g. when async data arrives. */
requestRender: () => void;
@@ -96,6 +156,17 @@ export interface Layer {
readonly paintOverBase?: boolean;
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage;
handleInput(event: DashboardInputEvent, ctx: LayerContext): Promise | void;
+ /**
+ * True when handleInput gives swipe-left / swipe-right a meaning of its own.
+ * Otherwise the stack hands the layer directionalFallback(event) instead.
+ */
+ readonly acceptsDirectional?: boolean;
+ /**
+ * A touch at (x, y) in this layer's own canvas coordinates, from the phone's
+ * mirror view. Return true if the layer acted on it (selected / opened what
+ * is there); false sends a plain select (click) instead.
+ */
+ hitTest?(x: number, y: number, ctx: LayerContext): Promise | boolean;
/** Called when the layer leaves the stack by any path (pop or clearToBase). */
onRemoved?(): void;
/**
@@ -195,7 +266,17 @@ export class LayerStack {
}
async handleInput(event: DashboardInputEvent): Promise {
- await this.layers[this.layers.length - 1]!.handleInput(event, this.ctx);
+ const top = this.layers[this.layers.length - 1]!;
+ const delivered = isDirectionalInput(event) && !top.acceptsDirectional ? directionalFallback(event) : event;
+ await top.handleInput(delivered, this.ctx);
+ }
+
+ /** Pass a mirror touch to the base layer when nothing is stacked on it. */
+ async hitTest(x: number, y: number): Promise {
+ if (this.layers.length !== 1) return false;
+ const base = this.layers[0]!;
+ if (!base.hitTest) return false;
+ return await base.hitTest(x, y, this.ctx);
}
/** Hand text to the top layer; false if it doesn't take text input. */
diff --git a/app/ui/shell/chrome-layer.ts b/app/ui/shell/chrome-layer.ts
index e29ad966..f5b1eaa7 100644
--- a/app/ui/shell/chrome-layer.ts
+++ b/app/ui/shell/chrome-layer.ts
@@ -13,6 +13,7 @@ import {
minWindowTop,
SHELL_OPAQUE_BLACK,
SIDEBAR_WIDTH,
+ sidebarWidth,
TOP_BAR_HEIGHT,
windowTop,
type WindowHeightMode,
@@ -166,7 +167,11 @@ export class ShellChromeLayer implements Layer {
paint(): GrayImage {
const image = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0);
const state = this.getState();
- this.drawSidebar(image, state);
+ // Full-panel mode: the strip is an overlay, present only while the user
+ // is in it (the window underneath keeps its full width the rest of the time).
+ if (sidebarWidth() > 0 || state.focus === "sidebar") {
+ this.drawSidebar(image, state);
+ }
this.drawTopBar(image, state);
return image;
}
@@ -176,6 +181,30 @@ export class ShellChromeLayer implements Layer {
// layer stack; the chrome itself never consumes events.
}
+ /**
+ * Which window's sidebar icon is under (x, y) on screen, if any — the same
+ * slot geometry drawSidebar uses, so a touch on the phone's mirror lands on
+ * the icon the mirror showed.
+ */
+ windowIndexAt(x: number, y: number, windowCount: number): number | null {
+ if (x < 0 || x >= SIDEBAR_WIDTH || windowCount === 0) return null;
+ const variant = sidebarVariant(windowCount);
+ const rows = rowsPerColumn(variant);
+ const listTop = minWindowTop() + TOP_BAR_HEIGHT + LIST_MARGIN;
+ const itemStride = variant.iconSize + ICON_SPACING;
+ const lastVisible = Math.min(windowCount, this.scrollRow + rows * variant.columns);
+ for (let index = this.scrollRow; index < lastVisible; index++) {
+ const position = index - this.scrollRow;
+ const column = variant.columns - 1 - ((position / rows) | 0);
+ const slotY = listTop + (position % rows) * itemStride;
+ const left = columnLeft(variant, column);
+ if (x >= left && x < left + variant.columnWidth && y >= slotY - 2 && y < slotY + variant.iconSize + 2) {
+ return index;
+ }
+ }
+ return null;
+ }
+
private drawSidebar(image: GrayImage, state: ShellChromeState): void {
// The sidebar always occupies the min-height window band at the preferred
// vertical position: it never moves when the foreground window's height
@@ -266,13 +295,16 @@ export class ShellChromeLayer implements Layer {
// its height mode puts that (screen top for max height). It moves when
// the foreground switches to a window of a different height.
const barTop = windowTop(state.foregroundHeightMode);
- image.fillRect(SIDEBAR_WIDTH, barTop, G2_LENS_WIDTH - SIDEBAR_WIDTH, TOP_BAR_HEIGHT, SHELL_OPAQUE_BLACK);
- image.drawLine(SIDEBAR_WIDTH, barTop + TOP_BAR_HEIGHT - 1, G2_LENS_WIDTH - 1, barTop + TOP_BAR_HEIGHT - 1, BORDER_VALUE);
+ // The bar spans the app viewport; with the sidebar overlaid (full-panel
+ // mode, sidebar focused) it still starts past the strip.
+ const barLeft = sidebarWidth() > 0 || state.focus === "sidebar" ? SIDEBAR_WIDTH : 0;
+ image.fillRect(barLeft, barTop, G2_LENS_WIDTH - barLeft, TOP_BAR_HEIGHT, SHELL_OPAQUE_BLACK);
+ image.drawLine(barLeft, barTop + TOP_BAR_HEIGHT - 1, G2_LENS_WIDTH - 1, barTop + TOP_BAR_HEIGHT - 1, BORDER_VALUE);
const now = new Date();
const clock = `${WEEKDAYS[now.getDay()]} ${now.getDate()} ${MONTHS[now.getMonth()]} ` +
formatClockTime(now);
- const clockX = SIDEBAR_WIDTH + 10;
+ const clockX = barLeft + 10;
const textY = barTop + Math.max(0, ((TOP_BAR_HEIGHT - font.lineHeight) / 2) | 0);
image.drawText(font, clockX, textY, clock, 210);
diff --git a/app/ui/shell/geometry.ts b/app/ui/shell/geometry.ts
index 0417312c..528c9058 100644
--- a/app/ui/shell/geometry.ts
+++ b/app/ui/shell/geometry.ts
@@ -1,15 +1,39 @@
import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../../graphics/image";
-import { verticalPositionSetting } from "../dashboard-settings";
+import { displayModeSetting, type DisplayModeSetting, verticalPositionSetting } from "../dashboard-settings";
/** Top bar: 24px notification icons plus a little padding. */
export const TOP_BAR_HEIGHT = 28;
/**
- * Sidebar width. Leaves the app viewport exactly 576px wide — the surface
- * width EvenHub apps expect. Icon column layout within the strip (one wide
- * column vs. two narrow ones) is the chrome layer's business.
+ * Width of the sidebar strip as painted. Leaves the app viewport exactly
+ * 576px wide — the surface width EvenHub apps expect — except in the
+ * full-panel display mode, where the strip overlays the app (see
+ * sidebarWidth). Icon column layout within the strip (one wide column vs.
+ * two narrow ones) is the chrome layer's business.
*/
export const SIDEBAR_WIDTH = 64;
+/** The Display > Display mode setting (see dashboard-settings.ts). */
+export function displayMode(): DisplayModeSetting {
+ return displayModeSetting.get();
+}
+
+/**
+ * How much of the screen's width the sidebar takes away from app windows:
+ * the strip, or nothing in the full-panel mode (where the chrome paints the
+ * strip over the window while the sidebar has focus).
+ */
+export function sidebarWidth(): number {
+ return displayMode() === "640x480" ? 0 : SIDEBAR_WIDTH;
+}
+
+/**
+ * The height an app's requested mode actually gets: the band mode honours
+ * it, the taller modes give every window the whole screen.
+ */
+export function effectiveHeightMode(mode: WindowHeightMode): WindowHeightMode {
+ return displayMode() === "576x288" ? mode : "max";
+}
+
/**
* X of the display's true horizontal centre, in app-viewport coordinates. The
* sidebar pushes the viewport to the right, so UI the wearer physically aims
@@ -17,7 +41,7 @@ export const SIDEBAR_WIDTH = 64;
* than use the viewport's own centre.
*/
export function screenCenterInViewportX(): number {
- return Math.round(G2_LENS_WIDTH / 2) - SIDEBAR_WIDTH;
+ return Math.round(G2_LENS_WIDTH / 2) - sidebarWidth();
}
/**
@@ -43,7 +67,7 @@ export const MIN_WINDOW_MAX_TOP = G2_LENS_HEIGHT - MIN_WINDOW_HEIGHT;
/** Total height (top bar + content) of a window's band in the given mode. */
export function windowBandHeight(mode: WindowHeightMode): number {
- switch (mode) {
+ switch (effectiveHeightMode(mode)) {
case "max":
return G2_LENS_HEIGHT;
case "medium":
@@ -89,7 +113,7 @@ export function windowTop(mode: WindowHeightMode): number {
/** App-content viewport size for a height mode (independent of vertical position). */
export function appViewportSize(mode: WindowHeightMode): { width: number; height: number } {
return {
- width: G2_LENS_WIDTH - SIDEBAR_WIDTH,
+ width: G2_LENS_WIDTH - sidebarWidth(),
height: windowBandHeight(mode) - TOP_BAR_HEIGHT,
};
}
@@ -102,7 +126,7 @@ export function appViewportRect(mode: WindowHeightMode): {
height: number;
} {
return {
- x: SIDEBAR_WIDTH,
+ x: sidebarWidth(),
y: windowTop(mode) + TOP_BAR_HEIGHT,
...appViewportSize(mode),
};
diff --git a/app/ui/shell/in-process-window.ts b/app/ui/shell/in-process-window.ts
index ddb8ede1..38e88a12 100644
--- a/app/ui/shell/in-process-window.ts
+++ b/app/ui/shell/in-process-window.ts
@@ -168,6 +168,9 @@ export function createInProcessWindow(options: InProcessWindowOptions): InProces
title: options.title,
surfaceId: `window:${options.windowId}`,
closeable: options.closeable,
+ // The window's own LayerStack decides per layer whether a swipe is
+ // directional or falls back to click / double-click.
+ acceptsDirectional: true,
heightMode,
close: () => {
closed = true;
@@ -195,6 +198,16 @@ export function createInProcessWindow(options: InProcessWindowOptions): InProces
await render(frameId);
},
requestRender,
+ relayout: () => {
+ stack.setBaseSize(appViewportSize(heightMode));
+ options.reconfigureSurface?.(heightMode);
+ requestRender();
+ },
+ hitTest: async (x, y) => {
+ const handled = await stack.hitTest(x, y);
+ if (handled) requestRender();
+ return handled;
+ },
receiveTextInput: options.receiveTextInput,
setForeground: (foreground) => {
options.setSurfaceVisible(foreground);
@@ -223,6 +236,15 @@ export class YieldAtRootLayer implements Layer {
return this.inner.paintOverBase;
}
+ /** Directional swipes reach the inner layer only if it understands them. */
+ get acceptsDirectional(): boolean | undefined {
+ return this.inner.acceptsDirectional;
+ }
+
+ hitTest(x: number, y: number, ctx: LayerContext): Promise | boolean {
+ return this.inner.hitTest ? this.inner.hitTest(x, y, ctx) : false;
+ }
+
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
return this.inner.paint(ctx, paintBelow);
}
diff --git a/app/ui/shell/shell.ts b/app/ui/shell/shell.ts
index b5409a55..9fefb73f 100644
--- a/app/ui/shell/shell.ts
+++ b/app/ui/shell/shell.ts
@@ -1,9 +1,20 @@
import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage } from "../../graphics/image";
import { singlePlane, type Plane } from "../../graphics/plane";
import { getDefaultSmallFont } from "../../graphics/ui-fonts";
-import { EvenAIStatus, EventSourceType, OsEventTypeList } from "../../g2/events";
+import { EvenAIStatus, EventSourceType, OsEventTypeList, WatchGestureType } from "../../g2/events";
import type { RawInputEvent } from "../../native/faceclaw-communicator";
-import { DashboardInputEvent, Layer, LayerActions, LayerContext, LayerStack, noopLayerActions } from "../layers";
+import {
+ DashboardInputEvent,
+ directionalFallback,
+ type InputSource,
+ isDirectionalInput,
+ isWatchInput,
+ Layer,
+ LayerActions,
+ LayerContext,
+ LayerStack,
+ noopLayerActions,
+} from "../layers";
import { MenuLayer, type MenuItem } from "../menu";
import { VoiceInputLayer, type VoiceSendTarget } from "./voice-input";
import { voiceActivity } from "./voice-activity";
@@ -62,6 +73,11 @@ export type ShellWindow = {
surfaceId: string;
/** Whether close menu entries (app menu default, shell escape menu) apply (the launcher is pinned). */
closeable: boolean;
+ /**
+ * True when the window gives swipe-left / swipe-right (watch directional
+ * input) a meaning; otherwise the shell forwards directionalFallback(event).
+ */
+ acceptsDirectional?: boolean;
/**
* Window height: the standard 288px band ("min") or the full screen
* ("max", terminal views). Decides the surface rect and where the shell
@@ -79,6 +95,17 @@ export type ShellWindow = {
handleInput: (event: DashboardInputEvent, frameId: number) => Promise | void;
/** Repaint and resubmit this window's surface. */
requestRender: () => void;
+ /**
+ * Re-measure against the current display mode (viewport size / band) and
+ * repaint. Windows without it (workers, whose canvas is fixed at open) are
+ * closed and relaunched by the controller instead.
+ */
+ relayout?: () => void;
+ /**
+ * A touch from the phone's mirror at (x, y) in app-viewport coordinates.
+ * True if the window acted on it; otherwise the controller sends a select.
+ */
+ hitTest?: (x: number, y: number) => Promise | boolean;
/**
* Deliver a text string to the window (e.g. finalized voice input). Optional:
* only windows that consume typed text (the terminal) implement it.
@@ -104,7 +131,18 @@ export type ShellConfig = {
/** Which surfaces need re-rendering after an input event. */
export type ShellInputOutcome = { shell: boolean; window: boolean };
-type FocusKind = "sidebar" | "window";
+/**
+ * Assistant overlay activity, for mirrors outside the glasses (the watch).
+ * "streaming" carries the reply so far (replace semantics); "done" the final
+ * reply; "error" the message; "closed" fires when the overlay leaves the
+ * stack by any path.
+ */
+export type AssistantActivityEvent = {
+ phase: "thinking" | "streaming" | "done" | "error" | "closed";
+ text: string;
+};
+
+export type FocusKind = "sidebar" | "window";
const noopActions: LayerActions = noopLayerActions;
@@ -209,6 +247,8 @@ class Shell {
private activeVoiceLayer: VoiceInputLayer | null = null;
private assistantSession: AssistantSession | null = null;
private assistantLayer: AssistantLayer | null = null;
+ private readonly assistantActivityListeners = new Set<(event: AssistantActivityEvent) => void>();
+ private readonly alertListeners = new Set<(text: string) => void>();
private escapeMenuTimer: ReturnType | null = null;
private readonly actions: LayerActions = { ...noopActions };
private config: ShellConfig = {
@@ -217,10 +257,8 @@ class Shell {
requestShellRender: () => {},
onScreenStateChanged: () => {},
};
- private readonly stack = new LayerStack(
- new ShellChromeLayer(() => this.chromeState()),
- this.actions,
- );
+ private readonly chrome = new ShellChromeLayer(() => this.chromeState());
+ private readonly stack = new LayerStack(this.chrome, this.actions);
// Top-bar settings we mirror into the chrome; a change to either repaints
// the shell surface so the top bar reflects it immediately.
@@ -379,6 +417,22 @@ class Shell {
this.lastInputAtMs = nowMs;
}
+ /** Where input currently goes: the sidebar strip or the foreground window. */
+ getFocus(): FocusKind {
+ return this.focus;
+ }
+
+ /** True while a shell overlay (menu, dialog, voice input) is above the chrome. */
+ hasOverlay(): boolean {
+ return !this.stack.isAtBase();
+ }
+
+ /** The window whose sidebar icon is at screen (x, y), for mirror touches. */
+ windowAtSidebarPoint(x: number, y: number): ShellWindow | null {
+ const index = this.chrome.windowIndexAt(x, y, this.windows.length);
+ return index === null ? null : this.windows[index] ?? null;
+ }
+
/** Turn the screen on (if off) and set focus. Returns whether it was off. */
wake(focus: FocusKind, nowMs = Date.now()): boolean {
this.lastInputAtMs = nowMs;
@@ -572,7 +626,8 @@ class Shell {
const window = this.foregroundWindow();
if (window) {
// The window owns frameId from here (render or explicit finish).
- await window.handleInput(event, frameId);
+ const delivered = isDirectionalInput(event) && !window.acceptsDirectional ? directionalFallback(event) : event;
+ await window.handleInput(delivered, frameId);
return { shell: false, window: true };
}
return { shell: false, window: false };
@@ -630,15 +685,25 @@ class Shell {
private handleSidebarInput(event: DashboardInputEvent): ShellInputOutcome {
switch (event.type) {
case "double-click":
+ // The ring's double-tap at the root turns the display off. For the
+ // watch, "back" at the root is simply the end of the road: it wakes
+ // the display on any gesture, so sleeping here would be a trap; the
+ // watch's Status screen turns the display off on purpose.
+ if (isWatchInput(event)) return { shell: false, window: false };
this.sleep();
return { shell: true, window: false };
case "scroll-up":
+ case "swipe-up":
this.moveSelection(-1);
return { shell: true, window: false };
case "scroll-down":
+ case "swipe-down":
this.moveSelection(1);
return { shell: true, window: false };
case "click":
+ case "swipe-right":
+ // Right: into the selected window (spatially, the window is to the
+ // sidebar's right). Left has nowhere further to go and is ignored.
if (this.windows.length) {
this.focus = "window";
// Repaint the window now so its selection highlight reflects focus
@@ -763,10 +828,41 @@ class Shell {
this.config.requestShellRender();
}
- private isAssistantAvailable(): boolean {
+ isAssistantAvailable(): boolean {
return this.resolveAssistantConfiguration() !== null;
}
+ /** Observe assistant turns (see AssistantActivityEvent). */
+ onAssistantActivity(listener: (event: AssistantActivityEvent) => void): () => void {
+ this.assistantActivityListeners.add(listener);
+ return () => {
+ this.assistantActivityListeners.delete(listener);
+ };
+ }
+
+ /** Observe showAlert popups (mirrored to the watch). */
+ onAlertShown(listener: (text: string) => void): () => void {
+ this.alertListeners.add(listener);
+ return () => {
+ this.alertListeners.delete(listener);
+ };
+ }
+
+ private emitAssistantActivity(event: AssistantActivityEvent): void {
+ for (const listener of Array.from(this.assistantActivityListeners)) {
+ try {
+ listener(event);
+ } catch (error) {
+ console.warn("assistant activity listener failed", error);
+ }
+ }
+ }
+
+ /** Dismiss the assistant overlay (cancelling any in-flight turn), as Done would. */
+ closeAssistant(): void {
+ this.closeAssistantLayer();
+ }
+
private ensureAssistantSession(): AssistantSession | null {
const config = this.resolveAssistantConfiguration();
if (!config) return null;
@@ -834,6 +930,7 @@ class Shell {
// stop the turn and drop the reference so a later query starts clean.
this.assistantSession?.cancel();
if (this.assistantLayer === created) this.assistantLayer = null;
+ this.emitAssistantActivity({ phase: "closed", text: "" });
},
});
layer = created;
@@ -846,11 +943,23 @@ class Shell {
private runAssistantTurn(session: AssistantSession, layer: AssistantLayer, text: string): void {
layer.startTurn();
+ let replySoFar = "";
+ this.emitAssistantActivity({ phase: "thinking", text: "" });
session.sendUtterance(text, this.buildAssistantContext(), {
- onTextDelta: (delta, textSoFar) => layer.onTextDelta(delta, textSoFar),
+ onTextDelta: (delta, textSoFar) => {
+ replySoFar = textSoFar;
+ layer.onTextDelta(delta, textSoFar);
+ this.emitAssistantActivity({ phase: "streaming", text: textSoFar });
+ },
onToolActivity: (label) => layer.onToolActivity(label),
- onTurnDone: () => layer.onTurnDone(),
- onError: (message) => layer.onError(message),
+ onTurnDone: () => {
+ layer.onTurnDone();
+ this.emitAssistantActivity({ phase: "done", text: replySoFar });
+ },
+ onError: (message) => {
+ layer.onError(message);
+ this.emitAssistantActivity({ phase: "error", text: message });
+ },
});
}
@@ -901,6 +1010,13 @@ class Shell {
/** Show a brief text popup on the lenses (assistant show_alert / notices). */
showAlert(text: string): void {
if (!this.screenOn) this.wake("sidebar");
+ for (const listener of Array.from(this.alertListeners)) {
+ try {
+ listener(text);
+ } catch (error) {
+ console.warn("alert listener failed", error);
+ }
+ }
const layer = new ShellAlertLayer(text, () => {
this.stack.popIfTop((top) => top === layer);
this.config.requestShellRender();
@@ -1024,9 +1140,9 @@ export function rawInputEventToInputEvent(event: RawInputEvent): DashboardInputE
source: eventSourceToString(event.eventSource),
};
} else if (event.eventType === OsEventTypeList.SCROLL_BOTTOM_EVENT) {
- return { type: "scroll-down" };
+ return scrollEvent("scroll-down", event.eventSource);
} else if (event.eventType === OsEventTypeList.SCROLL_TOP_EVENT) {
- return { type: "scroll-up" };
+ return scrollEvent("scroll-up", event.eventSource);
} else if (event.eventType === OsEventTypeList.RING_LONG_PRESS_EVENT) {
// CFW-forwarded long-press (replaces the firmware's force-quit dialog).
// The CFW gates this to the ring, so eventSource may be 0 (unknown);
@@ -1035,6 +1151,18 @@ export function rawInputEventToInputEvent(event: RawInputEvent): DashboardInputE
} else if (event.eventType === OsEventTypeList.RING_LONG_PRESS_RELEASE_EVENT) {
return { type: "long-press-release", source: eventSourceToString(event.eventSource) };
}
+ } else if (event.kind === "watch-gesture") {
+ // Synthetic, from the Wear OS remote (app/g2/wear-remote.ts); the glasses
+ // firmware never produces these.
+ if (event.eventType === WatchGestureType.SWIPE_LEFT) {
+ return { type: "swipe-left", source: "watch" };
+ } else if (event.eventType === WatchGestureType.SWIPE_RIGHT) {
+ return { type: "swipe-right", source: "watch" };
+ } else if (event.eventType === WatchGestureType.SWIPE_UP) {
+ return { type: "swipe-up", source: "watch" };
+ } else if (event.eventType === WatchGestureType.SWIPE_DOWN) {
+ return { type: "swipe-down", source: "watch" };
+ }
} else if (event.kind === "even-ai") {
// sid 0x07 EvenAIDataPackage; eventType carries eEvenAIStatus. Only the
// wakeword interests us -- ENTER means the user manually opened the stock
@@ -1048,9 +1176,9 @@ export function rawInputEventToInputEvent(event: RawInputEvent): DashboardInputE
return { type: "display-wake" };
} else if (event.kind === "text-click") {
if (event.eventType === OsEventTypeList.SCROLL_BOTTOM_EVENT) {
- return { type: "scroll-down" };
+ return scrollEvent("scroll-down", event.eventSource);
} else if (event.eventType === OsEventTypeList.SCROLL_TOP_EVENT) {
- return { type: "scroll-up" };
+ return scrollEvent("scroll-up", event.eventSource);
}
}
return {
@@ -1061,13 +1189,20 @@ export function rawInputEventToInputEvent(event: RawInputEvent): DashboardInputE
};
}
-function eventSourceToString(eventSource: number): "ring" | "left-arm" | "right-arm" {
+/** Scroll events only carry a source when it is the watch (the stock ones never needed one). */
+function scrollEvent(type: "scroll-up" | "scroll-down", eventSource: number): DashboardInputEvent {
+ return eventSource === EventSourceType.TOUCH_EVENT_FROM_WATCH ? { type, source: "watch" } : { type };
+}
+
+function eventSourceToString(eventSource: number): InputSource {
if (eventSource === EventSourceType.TOUCH_EVENT_FROM_RING) {
return "ring";
} else if (eventSource === EventSourceType.TOUCH_EVENT_FROM_GLASSES_L) {
return "left-arm";
} else if (eventSource === EventSourceType.TOUCH_EVENT_FROM_GLASSES_R) {
return "right-arm";
+ } else if (eventSource === EventSourceType.TOUCH_EVENT_FROM_WATCH) {
+ return "watch";
}
return "ring";
}
@@ -1086,6 +1221,14 @@ export function inputEventToString(event: DashboardInputEvent): string {
return `Long press from ${event.source}`;
case "long-press-release":
return `Long press release from ${event.source}`;
+ case "swipe-left":
+ return `Swipe left from ${event.source}`;
+ case "swipe-right":
+ return `Swipe right from ${event.source}`;
+ case "swipe-up":
+ return `Swipe up from ${event.source}`;
+ case "swipe-down":
+ return `Swipe down from ${event.source}`;
case "display-wake":
return `Display wake`;
case "wakeword":
diff --git a/wear/.gitignore b/wear/.gitignore
new file mode 100644
index 00000000..77d60bdc
--- /dev/null
+++ b/wear/.gitignore
@@ -0,0 +1,6 @@
+.gradle/
+build/
+local.properties
+.idea/
+*.iml
+.kotlin/
diff --git a/wear/PROTOCOL.md b/wear/PROTOCOL.md
new file mode 100644
index 00000000..b4489194
--- /dev/null
+++ b/wear/PROTOCOL.md
@@ -0,0 +1,62 @@
+# Watch ⇄ phone protocol
+
+Transport: the Wearable Data Layer (Google Play services). Both apps share the
+`com.faceclaw.app` application id and, for release builds, the signing key —
+the Data Layer routes only between matching apps. Payloads are UTF-8 JSON
+objects. Phone side: `App_Resources/.../FaceclawWearBridge.java` (transport),
+`app/native/wear-bridge.ts` (JS wrapper), `app/g2/wear-remote.ts` (meaning).
+Watch side: `app/src/main/kotlin/com/faceclaw/wear/Protocol.kt`, `PhoneLink.kt`.
+
+Capabilities (`res/values/wear.xml` on each side): the phone advertises
+`faceclaw_phone`, the watch `faceclaw_watch`. Each side finds the other with
+`CapabilityClient.getCapability(…, FILTER_REACHABLE)`.
+
+Every watch → phone message carries `seq` (monotonic per watch process) and is
+answered on `/faceclaw/ack`.
+
+## Watch → phone (MessageClient)
+
+| Path | Payload | Effect |
+| --- | --- | --- |
+| `/faceclaw/input` | `{gesture, steps?}` | A ring gesture through the same path as the phone UI's test buttons. `gesture` ∈ `click`, `double-click`, `scroll-up`, `scroll-down`, `long-press` (complete short hold), `long-press-start`, `long-press-release`, `wakeword` ("Hey Even"), `swipe-up`, `swipe-down`, `swipe-left`, `swipe-right` (spatial input only a watch can produce: delivered to the glasses UI as `swipe-*` events for components that navigate spatially — launcher grid, settings columns, sidebar, Music — with a scroll / click / double-click fallback elsewhere). `steps` (1–12) repeats a scroll. Refused while the glasses are disconnected. The lock screen is honoured exactly as for the ring (only a double-click reaches it, toggling the locked display). |
+| `/faceclaw/command` | `{command, …}` | `launch-app {appId}`, `focus-window {windowId}`, `close-window {windowId}`, `sidebar`, `wake`, `sleep`, `lock`, `unlock`, `connect`, `disconnect`, `close-assistant`. Everything but connect/disconnect needs a connection; everything but lock/unlock is refused while locked; `unlock` also needs the phone's "Watch can unlock glasses" setting. |
+| `/faceclaw/assistant` | `{text}` | Send a query to the assistant (`shell.sendToAssistant`) — the reply shows on the glasses and streams back to the watch as events. |
+| `/faceclaw/text` | `{text}` | Type text into the foreground window (`receiveTextInput`, e.g. the terminal). Refused when the window doesn't take text. |
+| `/faceclaw/state/request` | `{}` | Re-publish the state item even if unchanged. |
+
+All of the above except `state/request` are refused with `ok:false` when the
+phone's "Watch remote control" setting is off.
+
+## Phone → watch
+
+`/faceclaw/ack` (MessageClient, to the sender):
+`{seq, ok, jsReady, message}`. `jsReady:false` means Play services started the
+app process for the message but the JS dashboard isn't up (the user has not
+opened Faceclaw since boot); the watch shows "Open Faceclaw on the phone".
+
+`/faceclaw/event` (MessageClient, to every reachable watch):
+- `{type:"assistant", phase, text}` — `phase` ∈ `thinking`, `streaming` (text so
+ far, replace semantics, ≤ 4/s), `done` (final text), `error` (message),
+ `closed` (overlay dismissed).
+- `{type:"alert", text}` — a `glasses.show_alert` popup.
+Both are gated by the phone's "Mirror assistant to watch" setting.
+
+`/faceclaw/state` (DataClient item, keys `json` and `updatedAt`): the mirrored
+dashboard state, re-sent whenever it changes (and at least every 30 s):
+
+```json
+{
+ "protocol": 1, "version": "…",
+ "phase": "connected", "status": "…", "connected": true,
+ "screenOn": true, "locked": false, "worn": true, "listening": false,
+ "battery": 78, "charging": false,
+ "foreground": {"appId": "music", "title": "Music"},
+ "windows": [{"windowId": "…", "title": "…", "appId": "…", "focused": true, "closeable": true, "acceptsText": false}],
+ "apps": [{"appId": "timer", "title": "Timer"}],
+ "remoteEnabled": true, "canUnlock": true, "mirrorAssistant": true,
+ "assistantAvailable": true
+}
+```
+
+`apps` is the launcher grid plus installed EvenHub packages, i.e. exactly what
+the assistant's `apps.launch` tool accepts.
diff --git a/wear/README.md b/wear/README.md
new file mode 100644
index 00000000..e525dea4
--- /dev/null
+++ b/wear/README.md
@@ -0,0 +1,109 @@
+# Faceclaw for Wear OS
+
+A watch remote for Faceclaw: everything the Even R1 ring can do, plus the
+things it can't. Runs on a Wear OS 3+ watch (API 30) paired with the phone
+that runs Faceclaw. It is a remote, not a standalone app — without Faceclaw on
+the phone it only tells you to install it.
+
+## What it does
+
+**The pad** (the home screen; the whole display is the touch surface):
+
+| On the watch | On the glasses |
+| --- | --- |
+| tap | select |
+| double-tap, or a two-finger tap | **back**, everywhere: closes menus, leaves a settings column, leaves a folder or the launcher grid, returns to the sidebar (and from the sidebar turns the display off, as the ring does) |
+| press and hold | the app's context menu (a long press, held until you lift your finger) |
+| swipe ↑ ↓ ← → | **spatial navigation, with no mode to enter first**: the launcher highlights one app and the swipe moves it by a row or a column; the settings panel moves between its columns and down its lists; the sidebar moves up and down; Music skips to the previous / next track. Right goes *into* things (sidebar → window, section → items) and left comes back *out* (first column → sidebar). Anywhere without a spatial meaning, up/down scroll, right selects and left goes back. One step per swipe (long swipes used to repeat, which overshot lists whenever the display lagged); use repeated flicks, the crown, or a two-finger page swipe to cover distance. "Natural swipe" flips the vertical sense; left/right can be remapped in settings. |
+| rotate the crown | up / down (one step per detent-ish, sensitivity adjustable) — in the launcher that is rows, elsewhere scrolling |
+| two-finger swipe up / down | scroll a page (3 steps) |
+| **twist the wrist twice** (two brisk flicks, either direction) | back — from the gyroscope; on by default, sensitivity adjustable |
+| **tip taps** — tap your index finger against your thumb | select; two quick taps = back. From the accelerometer; **off by default** (experimental): on a wrist, ordinary hand movement produced phantom selects in testing. Turn on in Watch settings; needs ~¼ s of stillness before a tap counts, and both motion gestures are ignored while the watch is off the wrist or buzzing. |
+| **Tap zones** mode | tap the top / bottom third to scroll, the middle to select — for when swiping is awkward |
+
+The R1 ring's scheme is untouched: the ring only has up/down, tap, double-tap
+and hold, so on the glasses it still works in the stock two-step way (pick a
+launcher row, tap, pick the app). Watch input is tagged as its own source, so
+the same screens give the watch the direct scheme above without the ring
+ever seeing a difference.
+
+**Side buttons** (when the app is in front): button 1 tap = select, hold =
+long press; button 2 = back; button 3 = "Hey Even". You can also set
+the watch's button shortcut to open Faceclaw.
+
+**Bottom row buttons**: Assistant, Type into app, Apps, Status.
+
+- **Assistant** — ask the assistant using the *watch's* microphone (system
+ speech recognition) or the Wear keyboard, and read the reply on the watch as
+ it streams, mirrored from the glasses overlay. The watch buzzes when the
+ reply finishes. "Hey Even" instead opens the glasses' own voice dialog, which
+ uses the glasses mic.
+- **Type into app** — dictate or type text into the foreground app (the
+ terminal, for instance), the same path finalized voice input takes.
+- **Apps** — the sidebar's open windows (tap to switch, × to close) and the
+ full launcher, including installed EvenHub apps.
+- **Status** — connection and battery, display on/off, lock/unlock, connect /
+ disconnect, and whether Faceclaw is running on the phone; watch settings
+ (haptics, keep screen on, swipe direction, tap zones, horizontal swipe
+ actions, tip taps and their sensitivity, crown sensitivity).
+
+The pad keeps the watch display awake while it is showing (Watch settings >
+"Keep screen on", default on). Wear OS otherwise dozes within seconds of the
+wrist dropping and freezes the app, so the remote would need a wake-up tap
+before every gesture.
+
+Phone-side switches live in Faceclaw's Settings > Watch: turn watch control
+off entirely, decide whether watch input wakes a dark display (on by default —
+the ring only wakes it with a double-tap), forbid unlocking from the watch,
+or stop mirroring assistant replies.
+
+The watch buzzes differently when the phone refuses or doesn't answer a
+gesture (glasses disconnected, locked, watch control off); the pill at the
+bottom of the pad says why.
+
+## Building and installing
+
+The watch app is a separate Gradle project (Kotlin + Compose for Wear OS).
+It needs the same Android SDK the phone build uses and a JDK 17+:
+
+```bash
+cd wear && JAVA_HOME=/path/to/jdk ANDROID_HOME=~/Library/Android/sdk ./gradlew :app:assembleDebug
+```
+
+The APK lands in `app/build/outputs/apk/debug/`. Install it on the watch over
+adb (enable developer options on the watch, then ADB debugging and, for a
+watch without USB, Wireless debugging / debug over Wi-Fi):
+
+```bash
+adb connect :5555
+adb -s :5555 install -r app/build/outputs/apk/debug/app-debug.apk
+```
+
+Two things must match the phone app or the Data Layer silently won't route:
+
+1. **Application id** `com.faceclaw.app` — already set in `app/build.gradle.kts`.
+2. **Signing key.** Debug builds of both apps use the shared Android debug
+ keystore (`~/.android/debug.keystore`) on the machine that builds them, so
+ building both on the same computer just works. For release builds, sign the
+ watch APK with the same keystore as the phone APK.
+
+There's no Play Store listing; sideload.
+
+## Troubleshooting
+
+- *"No phone connected"* — the watch has no Bluetooth link to any phone.
+- *"Install Faceclaw on the phone"* — a phone is connected but no app there
+ advertises the `faceclaw_phone` capability: the phone build predates the
+ watch integration, or the app ids / signing keys differ.
+- *"Open Faceclaw on the phone"* — the phone app is installed but its
+ dashboard isn't running (Play services started the process just for our
+ message). Open Faceclaw once; it keeps running with its foreground service
+ while connected to the glasses.
+- *"The glasses are not connected"* — tap Status > Connect.
+- Nothing happens and no message: check Settings > Watch on the phone.
+
+Gestures the watch itself owns — the edge swipe-to-dismiss, the OS-level
+double-pinch / "universal" gestures on some watches — are not available to
+apps and aren't remapped here.
+
+Protocol details: [PROTOCOL.md](PROTOCOL.md).
diff --git a/wear/app/build.gradle.kts b/wear/app/build.gradle.kts
new file mode 100644
index 00000000..b75b32e9
--- /dev/null
+++ b/wear/app/build.gradle.kts
@@ -0,0 +1,67 @@
+plugins {
+ id("com.android.application")
+ id("org.jetbrains.kotlin.android")
+ id("org.jetbrains.kotlin.plugin.compose")
+}
+
+android {
+ namespace = "com.faceclaw.wear"
+ compileSdk = 35
+
+ defaultConfig {
+ // Must equal the phone app's id (nativescript.config.ts): the Wearable
+ // Data Layer only routes between apps with the same package name and
+ // signing key.
+ applicationId = "com.faceclaw.app"
+ minSdk = 30
+ targetSdk = 35
+ versionCode = 1
+ versionName = "1.0.0"
+ }
+
+ buildTypes {
+ release {
+ isMinifyEnabled = true
+ isShrinkResources = true
+ proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+ }
+ }
+
+ buildFeatures {
+ compose = true
+ buildConfig = true
+ }
+
+ compileOptions {
+ sourceCompatibility = JavaVersion.VERSION_17
+ targetCompatibility = JavaVersion.VERSION_17
+ }
+ kotlinOptions {
+ jvmTarget = "17"
+ }
+}
+
+dependencies {
+ val composeBom = platform("androidx.compose:compose-bom:2025.05.01")
+ implementation(composeBom)
+ implementation("androidx.compose.ui:ui")
+ implementation("androidx.compose.ui:ui-tooling-preview")
+ implementation("androidx.compose.foundation:foundation")
+ implementation("androidx.compose.runtime:runtime")
+ debugImplementation("androidx.compose.ui:ui-tooling")
+
+ implementation("androidx.wear.compose:compose-foundation:1.4.1")
+ implementation("androidx.wear.compose:compose-material:1.4.1")
+ implementation("androidx.wear.compose:compose-navigation:1.4.1")
+
+ implementation("androidx.activity:activity-compose:1.10.1")
+ implementation("androidx.core:core-ktx:1.16.0")
+ implementation("androidx.lifecycle:lifecycle-runtime-compose:2.9.2")
+ implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.9.2")
+ // RemoteInputIntentHelper: the system keyboard / voice / emoji text entry.
+ implementation("androidx.wear:wear-input:1.1.0")
+
+ implementation("com.google.android.gms:play-services-wearable:19.0.0")
+ implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.1")
+ implementation("org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.10.1")
+}
diff --git a/wear/app/proguard-rules.pro b/wear/app/proguard-rules.pro
new file mode 100644
index 00000000..821e0355
--- /dev/null
+++ b/wear/app/proguard-rules.pro
@@ -0,0 +1 @@
+# Nothing app-specific; Play services and Compose ship their own rules.
diff --git a/wear/app/src/main/AndroidManifest.xml b/wear/app/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..1f28264d
--- /dev/null
+++ b/wear/app/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/FingerTapDetector.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/FingerTapDetector.kt
new file mode 100644
index 00000000..5dd5bdfb
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/FingerTapDetector.kt
@@ -0,0 +1,179 @@
+package com.faceclaw.wear
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.util.Log
+import kotlin.math.max
+import kotlin.math.sqrt
+
+/** How hard a fingertip tap has to hit before it counts. */
+enum class TapSensitivity(val label: String, val threshold: Float, val maxActivity: Float) {
+ /** Only firm taps; most resistant to false positives. */
+ LOW("Low", 4.0f, 1.0f),
+ NORMAL("Normal", 2.6f, 1.4f),
+ /** Light taps; expect the odd stray click when moving about. */
+ HIGH("High", 1.7f, 1.9f);
+
+ fun next(): TapSensitivity = entries[(ordinal + 1) % entries.size]
+}
+
+/**
+ * Fingertip ("tip tap") gestures: tapping the index finger against the
+ * thumb sends a short, sharp acceleration impulse down the wrist. Wear OS
+ * keeps its own pinch gesture to itself, so this reads the linear
+ * acceleration sensor directly while the pad is showing and looks for brief
+ * spikes above a quiet baseline: an impulse that rises past the threshold
+ * and falls back within MAX_SPIKE_MS is a tap; anything longer is the arm
+ * moving. Taps are suppressed while the baseline activity is high (walking,
+ * gesturing), and a second tap inside the double-tap window makes a double.
+ *
+ * A heuristic, not a classifier: good enough for a deliberate tap with the
+ * wrist held still, tunable through TapSensitivity, and off in a toggle.
+ */
+class FingerTapDetector(
+ context: Context,
+ private val sensitivity: () -> TapSensitivity,
+ /** elapsedRealtime before which samples are ignored (the watch's own haptics). */
+ private val quietUntil: () -> Long,
+ /** False while the watch is off the wrist; taps then never fire. */
+ private val onBody: () -> Boolean,
+ private val onTap: () -> Unit,
+ private val onDoubleTap: () -> Unit,
+) : SensorEventListener {
+ private val sensorManager: SensorManager? = context.getSystemService(SensorManager::class.java)
+ private val sensor: Sensor? = sensorManager?.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)
+ ?: sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+ private val subtractGravity = sensor?.type == Sensor.TYPE_ACCELEROMETER
+ private val handler = Handler(Looper.getMainLooper())
+
+ private val gravity = floatArrayOf(0f, 0f, SensorManager.GRAVITY_EARTH)
+ /** Slow average of the magnitude outside spikes: how much the arm is moving. */
+ private var activity = 0f
+ private var inSpike = false
+ /** Last sample that counted as the arm moving; a tap needs stillness before it. */
+ private var lastMotionNs = 0L
+ private var spikeStartNs = 0L
+ private var refractoryUntilNs = 0L
+ private var lastTapNs = 0L
+ private var pendingSingle: Runnable? = null
+ private var running = false
+
+ val available: Boolean get() = sensor != null
+
+ /** Start listening; false when the watch has no usable accelerometer. */
+ fun start(): Boolean {
+ val manager = sensorManager ?: return false
+ val target = sensor ?: return false
+ if (running) return true
+ running = manager.registerListener(this, target, SAMPLING_PERIOD_US, handler)
+ Log.i(TAG, "tip-tap detector ${if (running) "started" else "failed to start"} on ${target.name}")
+ return running
+ }
+
+ fun stop() {
+ if (!running) return
+ running = false
+ sensorManager?.unregisterListener(this)
+ pendingSingle?.let { handler.removeCallbacks(it) }
+ pendingSingle = null
+ inSpike = false
+ }
+
+ override fun onSensorChanged(event: SensorEvent) {
+ var x = event.values[0]
+ var y = event.values[1]
+ var z = event.values[2]
+ if (subtractGravity) {
+ // Raw accelerometer fallback: strip a slowly tracked gravity vector.
+ gravity[0] += (x - gravity[0]) * GRAVITY_ALPHA
+ gravity[1] += (y - gravity[1]) * GRAVITY_ALPHA
+ gravity[2] += (z - gravity[2]) * GRAVITY_ALPHA
+ x -= gravity[0]
+ y -= gravity[1]
+ z -= gravity[2]
+ }
+ val magnitude = sqrt(x * x + y * y + z * z)
+ val now = event.timestamp
+ val level = sensitivity()
+
+ if (SystemClock.elapsedRealtime() < quietUntil() || !onBody()) {
+ // Our own vibration motor (or a desk being bumped): not a finger.
+ // Also forget any spike in progress so its tail can't complete it.
+ inSpike = false
+ refractoryUntilNs = now + REFRACTORY_NS
+ return
+ }
+
+ if (!inSpike) {
+ val still = activity < level.maxActivity && now - lastMotionNs > STILLNESS_BEFORE_TAP_NS
+ if (magnitude > level.threshold && still && now > refractoryUntilNs) {
+ inSpike = true
+ spikeStartNs = now
+ } else {
+ activity += (magnitude - activity) * ACTIVITY_ALPHA
+ if (magnitude > level.maxActivity) lastMotionNs = now
+ }
+ return
+ }
+
+ val durationNs = now - spikeStartNs
+ if (magnitude < level.threshold * SPIKE_END_FRACTION) {
+ inSpike = false
+ refractoryUntilNs = now + REFRACTORY_NS
+ if (durationNs <= MAX_SPIKE_NS) {
+ registerTap(now)
+ } else {
+ activity = max(activity, magnitude)
+ lastMotionNs = now
+ }
+ } else if (durationNs > MAX_SPIKE_NS) {
+ // Sustained acceleration is the arm moving, not a tap.
+ inSpike = false
+ refractoryUntilNs = now + REFRACTORY_NS
+ activity += (magnitude - activity) * MOVEMENT_ALPHA
+ lastMotionNs = now
+ }
+ }
+
+ override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit
+
+ private fun registerTap(nowNs: Long) {
+ val pending = pendingSingle
+ if (pending != null && nowNs - lastTapNs <= DOUBLE_TAP_WINDOW_NS) {
+ handler.removeCallbacks(pending)
+ pendingSingle = null
+ lastTapNs = 0L
+ onDoubleTap()
+ return
+ }
+ lastTapNs = nowNs
+ val fire = Runnable {
+ pendingSingle = null
+ onTap()
+ }
+ pendingSingle = fire
+ handler.postDelayed(fire, DOUBLE_TAP_WINDOW_MS)
+ }
+
+ private companion object {
+ const val TAG = "FaceclawWear"
+ /** 100 Hz: under the 200 Hz line that needs HIGH_SAMPLING_RATE_SENSORS. */
+ const val SAMPLING_PERIOD_US = 10_000
+ const val MAX_SPIKE_NS = 90_000_000L
+ /** The hand has to be still this long before an impulse can be a tap. */
+ const val STILLNESS_BEFORE_TAP_NS = 250_000_000L
+ const val REFRACTORY_NS = 140_000_000L
+ const val DOUBLE_TAP_WINDOW_MS = 380L
+ const val DOUBLE_TAP_WINDOW_NS = DOUBLE_TAP_WINDOW_MS * 1_000_000L
+ const val SPIKE_END_FRACTION = 0.5f
+ const val ACTIVITY_ALPHA = 0.04f
+ const val MOVEMENT_ALPHA = 0.3f
+ const val GRAVITY_ALPHA = 0.05f
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/Haptics.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/Haptics.kt
new file mode 100644
index 00000000..58343c90
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/Haptics.kt
@@ -0,0 +1,51 @@
+package com.faceclaw.wear
+
+import android.content.Context
+import android.os.SystemClock
+import android.os.VibrationEffect
+import android.os.Vibrator
+
+/** Short confirmations for sent gestures; each call is a no-op without a vibrator. */
+class Haptics(context: Context, private val enabled: () -> Boolean) {
+ private val vibrator: Vibrator? = context.getSystemService(Vibrator::class.java)
+ @Volatile private var lastVibrationAt = 0L
+
+ /**
+ * elapsedRealtime until which the motion sensors will still be feeling
+ * our own buzz. The tip-tap detector ignores that window, or a click's
+ * confirmation would read as another fingertip tap.
+ */
+ fun quietUntil(): Long = lastVibrationAt + VIBRATION_SETTLE_MS
+
+ /** A sent scroll step. */
+ fun tick() = play(VibrationEffect.EFFECT_TICK)
+
+ /** A sent click / command. */
+ fun click() = play(VibrationEffect.EFFECT_CLICK)
+
+ /** A sent double-click. */
+ fun doubleClick() = play(VibrationEffect.EFFECT_DOUBLE_CLICK)
+
+ /** The start of a hold. */
+ fun heavy() = play(VibrationEffect.EFFECT_HEAVY_CLICK)
+
+ /** The phone refused or did not answer; always plays. */
+ fun error() {
+ val v = vibrator ?: return
+ if (!v.hasVibrator()) return
+ lastVibrationAt = SystemClock.elapsedRealtime()
+ v.vibrate(VibrationEffect.createWaveform(longArrayOf(0, 40, 60, 40), -1))
+ }
+
+ private fun play(effect: Int) {
+ if (!enabled()) return
+ val v = vibrator ?: return
+ if (!v.hasVibrator()) return
+ lastVibrationAt = SystemClock.elapsedRealtime()
+ v.vibrate(VibrationEffect.createPredefined(effect))
+ }
+
+ private companion object {
+ const val VIBRATION_SETTLE_MS = 400L
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt
new file mode 100644
index 00000000..22c795ab
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt
@@ -0,0 +1,116 @@
+package com.faceclaw.wear
+
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.KeyEvent
+import android.view.WindowManager
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.launch
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import com.faceclaw.wear.ui.FaceclawWearApp
+
+class MainActivity : ComponentActivity() {
+ private lateinit var link: PhoneLink
+ private lateinit var prefs: WatchPrefs
+ private lateinit var haptics: Haptics
+
+ // Side (stem) buttons: button 1 is click / hold, 2 double-click, 3 "Hey Even".
+ private val stemHandler = Handler(Looper.getMainLooper())
+ private var stemHoldRunnable: Runnable? = null
+ private var stemHoldSent = false
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ link = PhoneLink(this)
+ prefs = WatchPrefs(this)
+ haptics = Haptics(this) { prefs.prefs.value.haptics }
+ setContent {
+ FaceclawWearApp(link = link, prefsStore = prefs, haptics = haptics)
+ }
+ // A remote that dozes mid-gesture is no remote: hold the display while
+ // the app is in front (every screen, not just the pad), unless the
+ // user turned "Keep screen on" off.
+ lifecycleScope.launch {
+ prefs.prefs.collect { current ->
+ if (current.keepScreenOn) {
+ window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+ } else {
+ window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+ }
+ }
+ }
+ }
+
+ override fun onStart() {
+ super.onStart()
+ link.start()
+ }
+
+ override fun onStop() {
+ cancelStemHold()
+ link.stop()
+ super.onStop()
+ }
+
+ override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+ when (keyCode) {
+ KeyEvent.KEYCODE_STEM_1 -> {
+ if (event.repeatCount == 0) {
+ cancelStemHold()
+ stemHoldSent = false
+ val runnable = Runnable {
+ stemHoldSent = true
+ haptics.heavy()
+ link.sendGesture(Gesture.LONG_PRESS_START)
+ }
+ stemHoldRunnable = runnable
+ stemHandler.postDelayed(runnable, STEM_HOLD_MS)
+ }
+ return true
+ }
+ KeyEvent.KEYCODE_STEM_2 -> {
+ if (event.repeatCount == 0) {
+ haptics.doubleClick()
+ link.sendGesture(Gesture.DOUBLE_CLICK)
+ }
+ return true
+ }
+ KeyEvent.KEYCODE_STEM_3 -> {
+ if (event.repeatCount == 0) {
+ haptics.click()
+ link.sendGesture(Gesture.WAKEWORD)
+ }
+ return true
+ }
+ }
+ return super.onKeyDown(keyCode, event)
+ }
+
+ override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
+ if (keyCode == KeyEvent.KEYCODE_STEM_1) {
+ cancelStemHold()
+ if (stemHoldSent) {
+ stemHoldSent = false
+ haptics.click()
+ link.sendGesture(Gesture.LONG_PRESS_RELEASE)
+ } else {
+ haptics.click()
+ link.sendGesture(Gesture.CLICK)
+ }
+ return true
+ }
+ if (keyCode == KeyEvent.KEYCODE_STEM_2 || keyCode == KeyEvent.KEYCODE_STEM_3) return true
+ return super.onKeyUp(keyCode, event)
+ }
+
+ private fun cancelStemHold() {
+ stemHoldRunnable?.let { stemHandler.removeCallbacks(it) }
+ stemHoldRunnable = null
+ }
+
+ private companion object {
+ const val STEM_HOLD_MS = 450L
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/OnBodyMonitor.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/OnBodyMonitor.kt
new file mode 100644
index 00000000..609d888b
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/OnBodyMonitor.kt
@@ -0,0 +1,55 @@
+package com.faceclaw.wear
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+
+/**
+ * Whether the watch is on a wrist, from the low-latency off-body sensor.
+ * The motion-sensor gestures (tip taps, wrist twists) only make sense on a
+ * wrist: on a desk, a buzzing phone next to the watch reads as a fingertip
+ * tap. Watches without the sensor are assumed worn.
+ */
+class OnBodyMonitor(context: Context) : SensorEventListener {
+ private val sensorManager: SensorManager? = context.getSystemService(SensorManager::class.java)
+ private val sensor: Sensor? = sensorManager?.getDefaultSensor(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT)
+ private val handler = Handler(Looper.getMainLooper())
+ private var running = false
+
+ @Volatile
+ var onBody: Boolean = true
+ private set
+
+ fun start() {
+ val manager = sensorManager ?: return
+ val target = sensor ?: return
+ if (running) return
+ running = manager.registerListener(this, target, SensorManager.SENSOR_DELAY_NORMAL, handler)
+ }
+
+ fun stop() {
+ if (!running) return
+ running = false
+ sensorManager?.unregisterListener(this)
+ onBody = true
+ }
+
+ override fun onSensorChanged(event: SensorEvent) {
+ val worn = event.values.firstOrNull()?.let { it >= 0.5f } ?: true
+ if (worn != onBody) {
+ onBody = worn
+ Log.i(TAG, if (worn) "watch on wrist: motion gestures enabled" else "watch off wrist: motion gestures paused")
+ }
+ }
+
+ override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit
+
+ private companion object {
+ const val TAG = "FaceclawWear"
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/PhoneLink.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/PhoneLink.kt
new file mode 100644
index 00000000..37a7ac25
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/PhoneLink.kt
@@ -0,0 +1,335 @@
+package com.faceclaw.wear
+
+import android.content.Context
+import android.net.Uri
+import android.util.Log
+import com.google.android.gms.common.api.ApiException
+import com.google.android.gms.wearable.CapabilityClient
+import com.google.android.gms.wearable.CapabilityInfo
+import com.google.android.gms.wearable.DataClient
+import com.google.android.gms.wearable.DataEvent
+import com.google.android.gms.wearable.DataEventBuffer
+import com.google.android.gms.wearable.DataItem
+import com.google.android.gms.wearable.DataMapItem
+import com.google.android.gms.wearable.MessageClient
+import com.google.android.gms.wearable.MessageEvent
+import com.google.android.gms.wearable.Node
+import com.google.android.gms.wearable.Wearable
+import com.google.android.gms.wearable.WearableStatusCodes
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.tasks.await
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicLong
+
+/** What we know about the phone and the Faceclaw app on it. */
+data class LinkStatus(
+ /** A phone is connected to the watch at all (any node). */
+ val phoneReachable: Boolean = false,
+ /** That phone has Faceclaw installed (advertises the capability). */
+ val phoneAppInstalled: Boolean = false,
+ val phoneNodeId: String? = null,
+ val phoneName: String = "",
+ /**
+ * Whether the phone app's dashboard (the JS side) answered our last
+ * message; null until we have heard anything. False means Faceclaw is
+ * installed but not running, so the user has to open it.
+ */
+ val appRunning: Boolean? = null,
+ val lastError: String? = null,
+)
+
+/** The assistant overlay as mirrored from the glasses. */
+data class AssistantMirror(
+ /** idle | thinking | streaming | done | error */
+ val phase: String = "idle",
+ val text: String = "",
+ val updatedAt: Long = 0,
+)
+
+/** A transient message for the UI (ack failures, confirmations). */
+data class Notice(val text: String, val isError: Boolean, val id: Long)
+
+/**
+ * The watch's end of the Wearable Data Layer conversation with the phone:
+ * sends gestures/commands/text as messages, receives acks and events, and
+ * mirrors the phone's state item. Lives for the activity's lifetime
+ * (start()/stop() from onStart/onStop).
+ */
+class PhoneLink(context: Context) :
+ MessageClient.OnMessageReceivedListener,
+ DataClient.OnDataChangedListener,
+ CapabilityClient.OnCapabilityChangedListener {
+
+ private val appContext = context.applicationContext
+ private val messageClient = Wearable.getMessageClient(appContext)
+ private val dataClient = Wearable.getDataClient(appContext)
+ private val capabilityClient = Wearable.getCapabilityClient(appContext)
+ private val nodeClient = Wearable.getNodeClient(appContext)
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+ private val nextSeq = AtomicLong(1)
+ private val pendingAcks = ConcurrentHashMap()
+ private var noticeJob: Job? = null
+ private var started = false
+
+ private val _state = MutableStateFlow(null)
+ val state: StateFlow = _state.asStateFlow()
+
+ private val _link = MutableStateFlow(LinkStatus())
+ val link: StateFlow = _link.asStateFlow()
+
+ private val _assistant = MutableStateFlow(AssistantMirror())
+ val assistant: StateFlow = _assistant.asStateFlow()
+
+ private val _events = MutableSharedFlow(extraBufferCapacity = 32)
+ val events: SharedFlow = _events.asSharedFlow()
+
+ private val _notice = MutableStateFlow(null)
+ val notice: StateFlow = _notice.asStateFlow()
+
+ fun start() {
+ if (started) return
+ started = true
+ messageClient.addListener(this)
+ dataClient.addListener(this)
+ capabilityClient.addListener(this, Protocol.CAPABILITY_PHONE)
+ refresh()
+ }
+
+ fun stop() {
+ if (!started) return
+ started = false
+ messageClient.removeListener(this)
+ dataClient.removeListener(this)
+ capabilityClient.removeListener(this, Protocol.CAPABILITY_PHONE)
+ }
+
+ /** Re-discover the phone, reload the cached state item, and ask for a fresh one. */
+ fun refresh() {
+ scope.launch {
+ findPhone()
+ loadStateItem()
+ if (_link.value.phoneAppInstalled) requestState()
+ }
+ }
+
+ // ---- outbound -----------------------------------------------------
+
+ fun sendGesture(gesture: Gesture, steps: Int = 1) {
+ send(Protocol.PATH_INPUT, JSONObject().put("gesture", gesture.wire).put("steps", steps))
+ }
+
+ fun sendCommand(command: String, vararg extras: Pair) {
+ val body = JSONObject().put("command", command)
+ for ((key, value) in extras) body.put(key, value)
+ send(Protocol.PATH_COMMAND, body)
+ }
+
+ fun sendAssistantQuery(text: String) {
+ _assistant.value = AssistantMirror(phase = "thinking", text = "", updatedAt = System.currentTimeMillis())
+ send(Protocol.PATH_ASSISTANT, JSONObject().put("text", text))
+ }
+
+ fun sendText(text: String) {
+ send(Protocol.PATH_TEXT, JSONObject().put("text", text))
+ }
+
+ fun requestState() {
+ send(Protocol.PATH_STATE_REQUEST, JSONObject(), quiet = true)
+ }
+
+ fun clearAssistant() {
+ _assistant.value = AssistantMirror()
+ }
+
+ private fun send(path: String, body: JSONObject, quiet: Boolean = false) {
+ val seq = nextSeq.getAndIncrement()
+ body.put("seq", seq)
+ Log.d(TAG, "send $path $body")
+ val payload = body.toString().toByteArray(Charsets.UTF_8)
+ scope.launch {
+ var nodeId = _link.value.phoneNodeId
+ if (nodeId == null) {
+ findPhone()
+ nodeId = _link.value.phoneNodeId
+ }
+ if (nodeId == null) {
+ if (!quiet) showNotice("No phone connected.", isError = true)
+ return@launch
+ }
+ if (!_link.value.phoneAppInstalled) {
+ if (!quiet) showNotice("Faceclaw isn't installed on the phone.", isError = true)
+ return@launch
+ }
+ try {
+ val requestId = messageClient.sendMessage(nodeId, path, payload).await()
+ Log.d(TAG, "sent seq=$seq requestId=$requestId")
+ // The phone acks every message; silence means the app
+ // process never received it (or Play services dropped it).
+ val timeout = scope.launch {
+ delay(ACK_TIMEOUT_MS)
+ if (pendingAcks.remove(seq) != null) {
+ _link.update { it.copy(appRunning = it.appRunning ?: false) }
+ if (!quiet) showNotice("No reply from the phone.", isError = true)
+ }
+ }
+ pendingAcks[seq] = timeout
+ } catch (error: ApiException) {
+ Log.w(TAG, "send $path failed: ${error.statusCode}", error)
+ val message = when (error.statusCode) {
+ WearableStatusCodes.TARGET_NODE_NOT_CONNECTED -> "The phone is out of range."
+ else -> "Couldn't reach the phone (${error.statusCode})."
+ }
+ _link.update { it.copy(lastError = message) }
+ if (!quiet) showNotice(message, isError = true)
+ scope.launch { findPhone() }
+ } catch (error: Exception) {
+ Log.w(TAG, "send $path failed", error)
+ if (!quiet) showNotice("Couldn't reach the phone.", isError = true)
+ }
+ }
+ }
+
+ // ---- inbound ------------------------------------------------------
+
+ override fun onMessageReceived(event: MessageEvent) {
+ val json = String(event.data, Charsets.UTF_8)
+ Log.d(TAG, "recv ${event.path} $json")
+ when (event.path) {
+ Protocol.PATH_ACK -> Ack.parse(json)?.let { handleAck(it) }
+ Protocol.PATH_EVENT -> PhoneEvent.parse(json)?.let { handleEvent(it) }
+ }
+ }
+
+ private fun handleAck(ack: Ack) {
+ pendingAcks.remove(ack.seq)?.cancel()
+ _link.update { it.copy(appRunning = ack.jsReady, lastError = null) }
+ if (!ack.ok) {
+ showNotice(ack.message.ifBlank { "The phone refused that." }, isError = true)
+ } else if (ack.message.isNotBlank()) {
+ showNotice(ack.message, isError = false)
+ }
+ }
+
+ private fun handleEvent(event: PhoneEvent) {
+ when (event) {
+ is PhoneEvent.Assistant -> {
+ _assistant.update { current ->
+ when (event.phase) {
+ "thinking" -> AssistantMirror("thinking", "", System.currentTimeMillis())
+ "streaming" -> AssistantMirror("streaming", event.text, System.currentTimeMillis())
+ "done" -> AssistantMirror("done", event.text.ifBlank { current.text }, System.currentTimeMillis())
+ "error" -> AssistantMirror("error", event.text, System.currentTimeMillis())
+ "closed" -> AssistantMirror("idle", current.text, System.currentTimeMillis())
+ else -> current
+ }
+ }
+ }
+ is PhoneEvent.Alert -> showNotice(event.text, isError = false)
+ }
+ _events.tryEmit(event)
+ }
+
+ override fun onDataChanged(buffer: DataEventBuffer) {
+ for (event in buffer) {
+ if (event.type != DataEvent.TYPE_CHANGED) continue
+ val item = event.dataItem
+ if (item.uri.path == Protocol.PATH_STATE) applyStateItem(item)
+ }
+ }
+
+ override fun onCapabilityChanged(info: CapabilityInfo) {
+ scope.launch { findPhone() }
+ }
+
+ private fun applyStateItem(item: DataItem) {
+ val map = DataMapItem.fromDataItem(item).dataMap
+ val json = map.getString(Protocol.STATE_KEY_JSON) ?: return
+ val updatedAt = map.getLong(Protocol.STATE_KEY_UPDATED_AT, 0)
+ PhoneState.parse(json, updatedAt)?.let { parsed ->
+ _state.value = parsed
+ // A state item is only ever written by the running dashboard.
+ _link.update { it.copy(appRunning = true) }
+ }
+ }
+
+ private suspend fun loadStateItem() {
+ try {
+ val uri = Uri.Builder().scheme("wear").path(Protocol.PATH_STATE).build()
+ val items = dataClient.getDataItems(uri).await()
+ try {
+ for (item in items) applyStateItem(item)
+ } finally {
+ items.release()
+ }
+ } catch (error: Exception) {
+ Log.w(TAG, "state item load failed", error)
+ }
+ }
+
+ private suspend fun findPhone() {
+ try {
+ val info = capabilityClient
+ .getCapability(Protocol.CAPABILITY_PHONE, CapabilityClient.FILTER_REACHABLE)
+ .await()
+ val phone = pickNode(info.nodes)
+ if (phone != null) {
+ _link.update {
+ it.copy(
+ phoneReachable = true,
+ phoneAppInstalled = true,
+ phoneNodeId = phone.id,
+ phoneName = phone.displayName,
+ lastError = null,
+ )
+ }
+ return
+ }
+ val connected = nodeClient.connectedNodes.await()
+ val any = pickNode(connected.toSet())
+ _link.update {
+ it.copy(
+ phoneReachable = any != null,
+ phoneAppInstalled = false,
+ phoneNodeId = null,
+ phoneName = any?.displayName ?: "",
+ appRunning = null,
+ )
+ }
+ } catch (error: Exception) {
+ Log.w(TAG, "phone lookup failed", error)
+ _link.update { it.copy(lastError = error.message) }
+ }
+ }
+
+ private fun pickNode(nodes: Set): Node? =
+ nodes.firstOrNull { it.isNearby } ?: nodes.firstOrNull()
+
+ private fun showNotice(text: String, isError: Boolean) {
+ noticeJob?.cancel()
+ _notice.value = Notice(text, isError, System.nanoTime())
+ noticeJob = scope.launch {
+ delay(if (isError) NOTICE_ERROR_MS else NOTICE_INFO_MS)
+ _notice.value = null
+ }
+ }
+
+ companion object {
+ private const val TAG = "FaceclawWear"
+ private const val ACK_TIMEOUT_MS = 3000L
+ private const val NOTICE_INFO_MS = 1800L
+ private const val NOTICE_ERROR_MS = 3200L
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/Protocol.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/Protocol.kt
new file mode 100644
index 00000000..1e0c0d71
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/Protocol.kt
@@ -0,0 +1,205 @@
+package com.faceclaw.wear
+
+import org.json.JSONObject
+
+/**
+ * Wire format shared with the phone app. Mirror of app/native/wear-bridge.ts
+ * (paths) and app/g2/wear-remote.ts (payloads); see ../../PROTOCOL.md.
+ */
+object Protocol {
+ const val PROTOCOL_VERSION = 1
+
+ /** Advertised by the phone app so the watch can find it. */
+ const val CAPABILITY_PHONE = "faceclaw_phone"
+
+ const val PATH_INPUT = "/faceclaw/input"
+ const val PATH_COMMAND = "/faceclaw/command"
+ const val PATH_ASSISTANT = "/faceclaw/assistant"
+ const val PATH_TEXT = "/faceclaw/text"
+ const val PATH_STATE_REQUEST = "/faceclaw/state/request"
+ const val PATH_ACK = "/faceclaw/ack"
+ const val PATH_EVENT = "/faceclaw/event"
+ const val PATH_STATE = "/faceclaw/state"
+
+ const val STATE_KEY_JSON = "json"
+ const val STATE_KEY_UPDATED_AT = "updatedAt"
+}
+
+/** Ring-style gestures, as the phone's synthetic ring input understands them. */
+enum class Gesture(val wire: String) {
+ CLICK("click"),
+ DOUBLE_CLICK("double-click"),
+ SCROLL_UP("scroll-up"),
+ SCROLL_DOWN("scroll-down"),
+ /** A complete short hold (press + release). */
+ LONG_PRESS("long-press"),
+ /** Finger down: the hold lasts until LONG_PRESS_RELEASE. */
+ LONG_PRESS_START("long-press-start"),
+ LONG_PRESS_RELEASE("long-press-release"),
+ /** The spoken "Hey Even": opens the glasses' own voice dialog. */
+ WAKEWORD("wakeword"),
+ /**
+ * Spatial (four-way) input the ring cannot produce. The glasses UI gives
+ * it a spatial meaning where one exists (grid rows and columns, panel
+ * columns, tracks) and otherwise treats up/down as scroll, right as select
+ * and left as back.
+ */
+ SWIPE_UP("swipe-up"),
+ SWIPE_DOWN("swipe-down"),
+ SWIPE_LEFT("swipe-left"),
+ SWIPE_RIGHT("swipe-right"),
+}
+
+/** Shell commands; things the ring cannot express. */
+object Command {
+ const val LAUNCH_APP = "launch-app"
+ const val FOCUS_WINDOW = "focus-window"
+ const val CLOSE_WINDOW = "close-window"
+ const val SIDEBAR = "sidebar"
+ const val WAKE = "wake"
+ const val SLEEP = "sleep"
+ const val LOCK = "lock"
+ const val UNLOCK = "unlock"
+ const val CONNECT = "connect"
+ const val DISCONNECT = "disconnect"
+ const val CLOSE_ASSISTANT = "close-assistant"
+ const val DISPLAY_MODE = "display-mode"
+}
+
+/** The glasses' display modes, mirroring the phone's Display > Display mode. */
+enum class DisplayMode(val wire: String, val label: String) {
+ BAND("576x288", "Band · 576×288"),
+ TALL("576x480", "Tall · 576×480"),
+ FULL("640x480", "Full panel · 640×480");
+
+ fun next(): DisplayMode = entries[(ordinal + 1) % entries.size]
+
+ companion object {
+ fun fromWire(value: String): DisplayMode? = entries.firstOrNull { it.wire == value }
+ }
+}
+
+data class AppEntry(val appId: String, val title: String)
+
+data class WindowEntry(
+ val windowId: String,
+ val title: String,
+ val appId: String,
+ val focused: Boolean,
+ val closeable: Boolean,
+ val acceptsText: Boolean,
+)
+
+/** The phone's mirrored dashboard state (Data Layer item /faceclaw/state). */
+data class PhoneState(
+ val protocol: Int,
+ val version: String,
+ val phase: String,
+ val status: String,
+ val connected: Boolean,
+ val screenOn: Boolean,
+ val locked: Boolean,
+ val worn: Boolean?,
+ val listening: Boolean,
+ /** Display mode wire value ("576x288" | "576x480" | "640x480"). */
+ val displayMode: String,
+ val battery: Int?,
+ val charging: Boolean,
+ val foreground: AppEntry?,
+ val windows: List,
+ val apps: List,
+ val remoteEnabled: Boolean,
+ val canUnlock: Boolean,
+ val mirrorAssistant: Boolean,
+ val assistantAvailable: Boolean,
+ val updatedAt: Long,
+) {
+ companion object {
+ fun parse(json: String, updatedAt: Long): PhoneState? {
+ return try {
+ val o = JSONObject(json)
+ val foreground = o.optJSONObject("foreground")
+ PhoneState(
+ protocol = o.optInt("protocol", 1),
+ version = o.optString("version", ""),
+ phase = o.optString("phase", "disconnected"),
+ status = o.optString("status", ""),
+ connected = o.optBoolean("connected", false),
+ screenOn = o.optBoolean("screenOn", false),
+ locked = o.optBoolean("locked", false),
+ worn = if (o.isNull("worn")) null else o.optBoolean("worn"),
+ listening = o.optBoolean("listening", false),
+ displayMode = o.optString("displayMode", "576x288"),
+ battery = if (o.isNull("battery")) null else o.optInt("battery").takeIf { it >= 0 },
+ charging = o.optBoolean("charging", false),
+ foreground = foreground?.let {
+ AppEntry(it.optString("appId", ""), it.optString("title", ""))
+ },
+ windows = o.optJSONArray("windows")?.let { array ->
+ (0 until array.length()).mapNotNull { index ->
+ val w = array.optJSONObject(index) ?: return@mapNotNull null
+ WindowEntry(
+ windowId = w.optString("windowId", ""),
+ title = w.optString("title", ""),
+ appId = w.optString("appId", ""),
+ focused = w.optBoolean("focused", false),
+ closeable = w.optBoolean("closeable", true),
+ acceptsText = w.optBoolean("acceptsText", false),
+ )
+ }
+ } ?: emptyList(),
+ apps = o.optJSONArray("apps")?.let { array ->
+ (0 until array.length()).mapNotNull { index ->
+ val a = array.optJSONObject(index) ?: return@mapNotNull null
+ AppEntry(a.optString("appId", ""), a.optString("title", ""))
+ }
+ } ?: emptyList(),
+ remoteEnabled = o.optBoolean("remoteEnabled", true),
+ canUnlock = o.optBoolean("canUnlock", true),
+ mirrorAssistant = o.optBoolean("mirrorAssistant", true),
+ assistantAvailable = o.optBoolean("assistantAvailable", false),
+ updatedAt = updatedAt,
+ )
+ } catch (error: Exception) {
+ null
+ }
+ }
+ }
+}
+
+/** The phone's reply to one of our messages. */
+data class Ack(val seq: Long, val ok: Boolean, val jsReady: Boolean, val message: String) {
+ companion object {
+ fun parse(json: String): Ack? = try {
+ val o = JSONObject(json)
+ Ack(
+ seq = o.optLong("seq", 0),
+ ok = o.optBoolean("ok", false),
+ jsReady = o.optBoolean("jsReady", true),
+ message = o.optString("message", ""),
+ )
+ } catch (error: Exception) {
+ null
+ }
+ }
+}
+
+/** Phone -> watch events (/faceclaw/event). */
+sealed class PhoneEvent {
+ /** phase: thinking | streaming | done | error | closed; text is the reply so far. */
+ data class Assistant(val phase: String, val text: String) : PhoneEvent()
+ data class Alert(val text: String) : PhoneEvent()
+
+ companion object {
+ fun parse(json: String): PhoneEvent? = try {
+ val o = JSONObject(json)
+ when (o.optString("type")) {
+ "assistant" -> Assistant(o.optString("phase", ""), o.optString("text", ""))
+ "alert" -> Alert(o.optString("text", ""))
+ else -> null
+ }
+ } catch (error: Exception) {
+ null
+ }
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/WatchPrefs.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/WatchPrefs.kt
new file mode 100644
index 00000000..734efb13
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/WatchPrefs.kt
@@ -0,0 +1,119 @@
+package com.faceclaw.wear
+
+import android.content.Context
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+enum class CrownSensitivity(val label: String, val pixelsPerStep: Float) {
+ LOW("Low", 110f),
+ NORMAL("Normal", 60f),
+ HIGH("High", 30f);
+
+ fun next(): CrownSensitivity = entries[(ordinal + 1) % entries.size]
+}
+
+/** What a horizontal swipe on the pad does. */
+enum class SwipeAction(val label: String) {
+ /** Sent as directional input; the glasses UI decides (see Gesture.SWIPE_LEFT). */
+ NAVIGATE("Navigate"),
+ SIDEBAR("Sidebar"),
+ DOUBLE_CLICK("Double-click"),
+ CLICK("Click"),
+ LONG_PRESS("Long press"),
+ WAKEWORD("“Hey Even”"),
+ NONE("Nothing");
+
+ fun next(): SwipeAction = entries[(ordinal + 1) % entries.size]
+}
+
+/** Watch-local preferences (nothing here is synced to the phone). */
+data class Prefs(
+ /** Buzz on every gesture sent. */
+ val haptics: Boolean = true,
+ /**
+ * Keep the display awake while the pad is showing. Wear otherwise dozes
+ * within seconds of the wrist dropping and freezes the app, which is
+ * exactly when a remote wants to stay ready.
+ */
+ val keepScreenOn: Boolean = true,
+ /** Swipe/crown direction follows the content (touch-scroll style) instead of the ring. */
+ val naturalScroll: Boolean = false,
+ /** Tap the top/bottom of the pad to scroll instead of swiping. */
+ val tapZones: Boolean = false,
+ val crownSensitivity: CrownSensitivity = CrownSensitivity.NORMAL,
+ val swipeLeft: SwipeAction = SwipeAction.NAVIGATE,
+ val swipeRight: SwipeAction = SwipeAction.NAVIGATE,
+ /**
+ * Fingertip (pinch) taps from the motion sensors; see FingerTapDetector.
+ * Off by default: on a wrist, ordinary hand movement produced phantom
+ * clicks in testing, and a phantom click opens things.
+ */
+ val fingerTaps: Boolean = false,
+ val tapSensitivity: TapSensitivity = TapSensitivity.NORMAL,
+ /** Two quick wrist twists = back (double-click); see WristTwistDetector. */
+ val wristTwist: Boolean = true,
+ val twistSensitivity: TwistSensitivity = TwistSensitivity.NORMAL,
+)
+
+class WatchPrefs(context: Context) {
+ private val store = context.applicationContext.getSharedPreferences("faceclaw_wear", Context.MODE_PRIVATE)
+ private val _prefs = MutableStateFlow(load())
+ val prefs: StateFlow = _prefs.asStateFlow()
+
+ private fun load(): Prefs = Prefs(
+ haptics = store.getBoolean(KEY_HAPTICS, true),
+ keepScreenOn = store.getBoolean(KEY_KEEP_SCREEN_ON, true),
+ naturalScroll = store.getBoolean(KEY_NATURAL_SCROLL, false),
+ tapZones = store.getBoolean(KEY_TAP_ZONES, false),
+ crownSensitivity = store.getString(KEY_CROWN, null)
+ ?.let { stored -> CrownSensitivity.entries.firstOrNull { it.name == stored } }
+ ?: CrownSensitivity.NORMAL,
+ swipeLeft = store.getString(KEY_SWIPE_LEFT, null)
+ ?.let { stored -> SwipeAction.entries.firstOrNull { it.name == stored } }
+ ?: SwipeAction.NAVIGATE,
+ swipeRight = store.getString(KEY_SWIPE_RIGHT, null)
+ ?.let { stored -> SwipeAction.entries.firstOrNull { it.name == stored } }
+ ?: SwipeAction.NAVIGATE,
+ fingerTaps = store.getBoolean(KEY_FINGER_TAPS, false),
+ tapSensitivity = store.getString(KEY_TAP_SENSITIVITY, null)
+ ?.let { stored -> TapSensitivity.entries.firstOrNull { it.name == stored } }
+ ?: TapSensitivity.NORMAL,
+ wristTwist = store.getBoolean(KEY_WRIST_TWIST, true),
+ twistSensitivity = store.getString(KEY_TWIST_SENSITIVITY, null)
+ ?.let { stored -> TwistSensitivity.entries.firstOrNull { it.name == stored } }
+ ?: TwistSensitivity.NORMAL,
+ )
+
+ fun update(transform: (Prefs) -> Prefs) {
+ val next = transform(_prefs.value)
+ _prefs.value = next
+ store.edit()
+ .putBoolean(KEY_HAPTICS, next.haptics)
+ .putBoolean(KEY_KEEP_SCREEN_ON, next.keepScreenOn)
+ .putBoolean(KEY_NATURAL_SCROLL, next.naturalScroll)
+ .putBoolean(KEY_TAP_ZONES, next.tapZones)
+ .putString(KEY_CROWN, next.crownSensitivity.name)
+ .putString(KEY_SWIPE_LEFT, next.swipeLeft.name)
+ .putString(KEY_SWIPE_RIGHT, next.swipeRight.name)
+ .putBoolean(KEY_FINGER_TAPS, next.fingerTaps)
+ .putString(KEY_TAP_SENSITIVITY, next.tapSensitivity.name)
+ .putBoolean(KEY_WRIST_TWIST, next.wristTwist)
+ .putString(KEY_TWIST_SENSITIVITY, next.twistSensitivity.name)
+ .apply()
+ }
+
+ private companion object {
+ const val KEY_HAPTICS = "haptics"
+ const val KEY_KEEP_SCREEN_ON = "keepScreenOn"
+ const val KEY_NATURAL_SCROLL = "naturalScroll"
+ const val KEY_TAP_ZONES = "tapZones"
+ const val KEY_CROWN = "crownSensitivity"
+ const val KEY_SWIPE_LEFT = "swipeLeft"
+ const val KEY_SWIPE_RIGHT = "swipeRight"
+ const val KEY_FINGER_TAPS = "fingerTaps"
+ const val KEY_TAP_SENSITIVITY = "tapSensitivity"
+ const val KEY_WRIST_TWIST = "wristTwist"
+ const val KEY_TWIST_SENSITIVITY = "twistSensitivity"
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/WristTwistDetector.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/WristTwistDetector.kt
new file mode 100644
index 00000000..82d134df
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/WristTwistDetector.kt
@@ -0,0 +1,137 @@
+package com.faceclaw.wear
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.util.Log
+import kotlin.math.abs
+
+/** How fast the wrist has to turn before a twist counts. */
+enum class TwistSensitivity(val label: String, val threshold: Float) {
+ /** Only a brisk flick; rad/s about the forearm. */
+ LOW("Low", 5.0f),
+ NORMAL("Normal", 3.6f),
+ HIGH("High", 2.6f);
+
+ fun next(): TwistSensitivity = entries[(ordinal + 1) % entries.size]
+}
+
+/**
+ * "Twist the wrist twice" = back. The gyroscope's x axis runs along the
+ * forearm on a watch, so a wrist twist (pronation / supination) is a burst of
+ * angular velocity about x. Two brisk twists in the same direction, each
+ * short and separated by 120–900 ms, fire the gesture; the wrist coming back
+ * between them spins the other way and is ignored. The direction is not
+ * fixed (away or toward), so it works on either wrist, and the twists must be
+ * quick: a slow arm rotation never crosses the rate threshold.
+ *
+ * Same status as FingerTapDetector: a heuristic with a toggle, not a
+ * classifier.
+ */
+class WristTwistDetector(
+ context: Context,
+ private val sensitivity: () -> TwistSensitivity,
+ /** elapsedRealtime before which samples are ignored (the watch's own haptics). */
+ private val quietUntil: () -> Long,
+ /** False while the watch is off the wrist; twists then never fire. */
+ private val onBody: () -> Boolean,
+ private val onDoubleTwist: () -> Unit,
+) : SensorEventListener {
+ private val sensorManager: SensorManager? = context.getSystemService(SensorManager::class.java)
+ private val sensor: Sensor? = sensorManager?.getDefaultSensor(Sensor.TYPE_GYROSCOPE)
+ private val handler = Handler(Looper.getMainLooper())
+
+ private var inBurst = false
+ /** Slow average of |rate| outside bursts: how much the arm is rotating anyway. */
+ private var activity = 0f
+ private var lastMotionNs = 0L
+ private var burstStartNs = 0L
+ private var burstSign = 0
+ private var firstTwistNs = 0L
+ private var firstTwistSign = 0
+ private var running = false
+
+ val available: Boolean get() = sensor != null
+
+ fun start(): Boolean {
+ val manager = sensorManager ?: return false
+ val target = sensor ?: return false
+ if (running) return true
+ running = manager.registerListener(this, target, SAMPLING_PERIOD_US, handler)
+ Log.i(TAG, "wrist-twist detector ${if (running) "started" else "failed to start"}")
+ return running
+ }
+
+ fun stop() {
+ if (!running) return
+ running = false
+ sensorManager?.unregisterListener(this)
+ inBurst = false
+ firstTwistNs = 0L
+ }
+
+ override fun onSensorChanged(event: SensorEvent) {
+ val rate = event.values[0]
+ val now = event.timestamp
+ if (SystemClock.elapsedRealtime() < quietUntil() || !onBody()) {
+ inBurst = false
+ firstTwistNs = 0L
+ return
+ }
+ val threshold = sensitivity().threshold
+
+ if (!inBurst) {
+ val magnitude = abs(rate)
+ // A twist pair only starts from a still-ish wrist: general arm
+ // rotation (reaching, gesturing) produced same-sign burst pairs
+ // that read as the gesture.
+ val still = activity < threshold * ACTIVITY_FRACTION && now - lastMotionNs > STILLNESS_BEFORE_TWIST_NS
+ if (magnitude > threshold && (still || firstTwistNs != 0L)) {
+ inBurst = true
+ burstStartNs = now
+ burstSign = if (rate > 0) 1 else -1
+ } else {
+ activity += (magnitude - activity) * ACTIVITY_ALPHA
+ if (magnitude > threshold * ACTIVITY_FRACTION) lastMotionNs = now
+ }
+ return
+ }
+ // In a burst: wait for the rate to drop back under the threshold.
+ if (abs(rate) > threshold * BURST_END_FRACTION && (if (rate > 0) 1 else -1) == burstSign) return
+ inBurst = false
+ val duration = now - burstStartNs
+ if (duration > MAX_BURST_NS) return // a slow sweep, not a flick
+
+ val sinceFirst = now - firstTwistNs
+ if (firstTwistNs != 0L && burstSign == firstTwistSign && sinceFirst in MIN_GAP_NS..MAX_GAP_NS) {
+ firstTwistNs = 0L
+ onDoubleTwist()
+ } else if (firstTwistNs == 0L || sinceFirst > MAX_GAP_NS || burstSign != firstTwistSign) {
+ // The return twist (opposite sign) does not start a new pair; a
+ // fresh same-direction twist does.
+ if (firstTwistNs == 0L || sinceFirst > MAX_GAP_NS) {
+ firstTwistNs = now
+ firstTwistSign = burstSign
+ }
+ }
+ }
+
+ override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit
+
+ private companion object {
+ const val TAG = "FaceclawWear"
+ const val SAMPLING_PERIOD_US = 10_000
+ const val MAX_BURST_NS = 350_000_000L
+ const val MIN_GAP_NS = 120_000_000L
+ const val MAX_GAP_NS = 900_000_000L
+ const val BURST_END_FRACTION = 0.5f
+ const val ACTIVITY_ALPHA = 0.04f
+ const val ACTIVITY_FRACTION = 0.35f
+ const val STILLNESS_BEFORE_TWIST_NS = 300_000_000L
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AppsScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AppsScreen.kt
new file mode 100644
index 00000000..449b41ab
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AppsScreen.kt
@@ -0,0 +1,128 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
+import androidx.wear.compose.foundation.lazy.items
+import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
+import androidx.wear.compose.material.Button
+import androidx.wear.compose.material.ButtonDefaults
+import androidx.wear.compose.material.Chip
+import androidx.wear.compose.material.ChipDefaults
+import androidx.wear.compose.material.Icon
+import androidx.wear.compose.material.ListHeader
+import androidx.wear.compose.material.PositionIndicator
+import androidx.wear.compose.material.Scaffold
+import androidx.wear.compose.material.Text
+import androidx.wear.compose.material.TimeText
+import com.faceclaw.wear.Command
+import com.faceclaw.wear.Haptics
+import com.faceclaw.wear.PhoneLink
+import com.faceclaw.wear.R
+import com.faceclaw.wear.WindowEntry
+
+/**
+ * The glasses' sidebar and launcher, on the wrist: open windows first (tap to
+ * bring one to the front, × to close it), then every launchable app.
+ */
+@Composable
+fun AppsScreen(link: PhoneLink, haptics: Haptics, onDone: () -> Unit) {
+ val state by link.state.collectAsStateWithLifecycle()
+ val notice by link.notice.collectAsStateWithLifecycle()
+ val listState = rememberScalingLazyListState()
+ val windows = state?.windows ?: emptyList()
+ val apps = state?.apps ?: emptyList()
+
+ Scaffold(
+ timeText = { TimeText() },
+ positionIndicator = { PositionIndicator(scalingLazyListState = listState) },
+ ) {
+ ScalingLazyColumn(
+ state = listState,
+ modifier = Modifier.fillMaxSize(),
+ ) {
+ val onScreen = windows.filter { it.focused }
+ val others = windows.filter { !it.focused }
+ if (onScreen.isNotEmpty()) {
+ item { ListHeader { Text("On screen") } }
+ items(onScreen, key = { "w:" + it.windowId }) { window -> WindowRow(window, link, haptics, onDone) }
+ }
+ if (others.isNotEmpty()) {
+ item { ListHeader { Text("Also open") } }
+ items(others, key = { "w:" + it.windowId }) { window -> WindowRow(window, link, haptics, onDone) }
+ }
+ item { ListHeader { Text(if (apps.isEmpty()) "No app list yet" else "Launch") } }
+ items(apps, key = { "a:" + it.appId }) { app ->
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendCommand(Command.LAUNCH_APP, "appId" to app.appId)
+ onDone()
+ },
+ label = { Text(app.title, maxLines = 1, overflow = TextOverflow.Ellipsis) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ if (apps.isEmpty()) {
+ item {
+ Text(
+ "Open Faceclaw on the phone and connect the glasses.",
+ textAlign = androidx.compose.ui.text.style.TextAlign.Center,
+ style = androidx.wear.compose.material.MaterialTheme.typography.caption2,
+ )
+ }
+ }
+ }
+ NoticeOverlay(notice)
+ }
+}
+
+/** One open window: tap to bring it to the front, × to close it. */
+@Composable
+private fun WindowRow(window: WindowEntry, link: PhoneLink, haptics: Haptics, onDone: () -> Unit) {
+ Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendCommand(Command.FOCUS_WINDOW, "windowId" to window.windowId)
+ onDone()
+ },
+ // The launcher's window is titled "Apps" on the glasses; here that
+ // would read as this very screen.
+ label = { Text(if (window.appId == "launcher") "Launcher" else window.title, maxLines = 1, overflow = TextOverflow.Ellipsis) },
+ secondaryLabel = if (window.acceptsText) ({ Text("takes typed text") }) else null,
+ colors = if (window.focused) ChipDefaults.primaryChipColors() else ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.weight(1f),
+ )
+ if (window.closeable) {
+ Spacer(modifier = Modifier.width(4.dp))
+ Button(
+ onClick = {
+ haptics.click()
+ link.sendCommand(Command.CLOSE_WINDOW, "windowId" to window.windowId)
+ },
+ modifier = Modifier.size(32.dp),
+ colors = ButtonDefaults.secondaryButtonColors(),
+ ) {
+ Icon(
+ painter = painterResource(R.drawable.ic_close),
+ contentDescription = "Close ${window.title}",
+ modifier = Modifier.size(16.dp),
+ )
+ }
+ }
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AssistantScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AssistantScreen.kt
new file mode 100644
index 00000000..879db572
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AssistantScreen.kt
@@ -0,0 +1,144 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
+import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
+import androidx.wear.compose.material.Button
+import androidx.wear.compose.material.ButtonDefaults
+import androidx.wear.compose.material.Chip
+import androidx.wear.compose.material.ChipDefaults
+import androidx.wear.compose.material.Icon
+import androidx.wear.compose.material.MaterialTheme
+import androidx.wear.compose.material.PositionIndicator
+import androidx.wear.compose.material.Scaffold
+import androidx.wear.compose.material.Text
+import androidx.wear.compose.material.TimeText
+import com.faceclaw.wear.Command
+import com.faceclaw.wear.Gesture
+import com.faceclaw.wear.Haptics
+import com.faceclaw.wear.PhoneLink
+import com.faceclaw.wear.R
+
+/**
+ * Ask the assistant from the wrist (watch speech recognition or keyboard) and
+ * read its reply here as it streams, mirrored from the glasses overlay. "Hey
+ * Even" instead uses the glasses' own microphone and voice dialog.
+ */
+@Composable
+fun AssistantScreen(link: PhoneLink, haptics: Haptics) {
+ val state by link.state.collectAsStateWithLifecycle()
+ val mirror by link.assistant.collectAsStateWithLifecycle()
+ val notice by link.notice.collectAsStateWithLifecycle()
+ val listState = rememberScalingLazyListState()
+ val available = state?.assistantAvailable != false
+
+ val ask = rememberSpeechLauncher(
+ prompt = stringResource(R.string.speech_prompt_assistant),
+ onResult = { text -> haptics.click(); link.sendAssistantQuery(text) },
+ onUnavailable = { haptics.error() },
+ )
+ val type = rememberKeyboardLauncher(
+ label = stringResource(R.string.keyboard_label_assistant),
+ onResult = { text -> haptics.click(); link.sendAssistantQuery(text) },
+ onUnavailable = { haptics.error() },
+ )
+
+ // A finished reply deserves a nudge: the wrist may be down while it streams.
+ LaunchedEffect(mirror.phase, mirror.updatedAt) {
+ if (mirror.phase == "done" || mirror.phase == "error") haptics.doubleClick()
+ }
+
+ Scaffold(
+ timeText = { TimeText() },
+ positionIndicator = { PositionIndicator(scalingLazyListState = listState) },
+ ) {
+ ScalingLazyColumn(state = listState, modifier = Modifier.fillMaxSize()) {
+ item {
+ Row(
+ modifier = Modifier.fillMaxWidth().padding(top = 6.dp),
+ horizontalArrangement = Arrangement.Center,
+ ) {
+ Button(onClick = ask, modifier = Modifier.size(44.dp), enabled = available) {
+ Icon(painterResource(R.drawable.ic_mic), contentDescription = "Ask by voice", modifier = Modifier.size(22.dp))
+ }
+ Spacer(modifier = Modifier.size(10.dp))
+ Button(
+ onClick = type,
+ modifier = Modifier.size(44.dp),
+ colors = ButtonDefaults.secondaryButtonColors(),
+ enabled = available,
+ ) {
+ Icon(painterResource(R.drawable.ic_keyboard), contentDescription = "Ask by keyboard", modifier = Modifier.size(22.dp))
+ }
+ }
+ }
+ item {
+ val label = when (mirror.phase) {
+ "thinking" -> "Thinking…"
+ "streaming" -> "Replying…"
+ "error" -> "Error"
+ "done" -> "Reply"
+ else -> if (available) "Ask something" else "Set up the assistant in Faceclaw's Settings"
+ }
+ Text(
+ label,
+ style = MaterialTheme.typography.caption1,
+ color = MaterialTheme.colors.onSurfaceVariant,
+ textAlign = TextAlign.Center,
+ modifier = Modifier.fillMaxWidth().padding(top = 4.dp),
+ )
+ }
+ if (mirror.text.isNotBlank()) {
+ item {
+ Text(
+ mirror.text,
+ style = MaterialTheme.typography.body2,
+ modifier = Modifier.fillMaxWidth().padding(horizontal = 6.dp, vertical = 4.dp),
+ )
+ }
+ }
+ item {
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendGesture(Gesture.WAKEWORD)
+ },
+ label = { Text("“Hey Even” on glasses") },
+ secondaryLabel = { Text("uses the glasses mic") },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ if (mirror.phase != "idle") {
+ item {
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendCommand(Command.CLOSE_ASSISTANT)
+ link.clearAssistant()
+ },
+ label = { Text(if (mirror.phase == "thinking" || mirror.phase == "streaming") "Cancel" else "Dismiss") },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ }
+ }
+ NoticeOverlay(notice)
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/Common.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/Common.kt
new file mode 100644
index 00000000..6fb65cd1
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/Common.kt
@@ -0,0 +1,109 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.wear.compose.material.MaterialTheme
+import androidx.wear.compose.material.Text
+import com.faceclaw.wear.LinkStatus
+import com.faceclaw.wear.Notice
+import com.faceclaw.wear.PhoneState
+
+/** A transient pill at the bottom of the screen: ack failures and confirmations. */
+@Composable
+fun NoticeOverlay(notice: Notice?) {
+ Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.BottomCenter) {
+ AnimatedVisibility(visible = notice != null, enter = fadeIn(), exit = fadeOut()) {
+ val current = notice ?: return@AnimatedVisibility
+ Text(
+ text = current.text,
+ style = MaterialTheme.typography.caption2,
+ color = if (current.isError) Color(0xFFFFB4A8) else MaterialTheme.colors.onSurface,
+ textAlign = TextAlign.Center,
+ maxLines = 2,
+ overflow = TextOverflow.Ellipsis,
+ modifier = Modifier
+ .padding(horizontal = 28.dp, vertical = 18.dp)
+ .background(
+ if (current.isError) Color(0xFF4A1F1A) else Color(0xFF2A2A2A),
+ RoundedCornerShape(14.dp),
+ )
+ .padding(horizontal = 10.dp, vertical = 5.dp),
+ )
+ }
+ }
+}
+
+/** The pad's top line: how the glasses and phone are doing, in a few words. */
+data class StatusLine(val text: String, val tone: StatusTone)
+
+enum class StatusTone { GOOD, BUSY, OFF, PROBLEM }
+
+fun statusLine(state: PhoneState?, link: LinkStatus): StatusLine = when {
+ !link.phoneReachable -> StatusLine("No phone", StatusTone.PROBLEM)
+ !link.phoneAppInstalled -> StatusLine("Install Faceclaw on phone", StatusTone.PROBLEM)
+ link.appRunning == false -> StatusLine("Open Faceclaw on phone", StatusTone.PROBLEM)
+ state == null -> StatusLine("Waiting for phone", StatusTone.BUSY)
+ state.remoteEnabled == false -> StatusLine("Watch control off", StatusTone.PROBLEM)
+ state.connected -> {
+ val battery = state.battery?.let { " · $it%" + if (state.charging) "⚡" else "" } ?: ""
+ StatusLine("Connected$battery", StatusTone.GOOD)
+ }
+ state.phase == "connecting" -> StatusLine("Connecting…", StatusTone.BUSY)
+ state.phase == "disconnecting" -> StatusLine("Disconnecting…", StatusTone.BUSY)
+ else -> StatusLine("Glasses disconnected", StatusTone.OFF)
+}
+
+/** The pad's centre line: what the input will land on. */
+fun focusLine(state: PhoneState?): String = when {
+ state == null || !state.connected -> ""
+ state.locked -> "Locked"
+ !state.screenOn -> "Display off"
+ state.listening -> "Listening…"
+ else -> state.foreground?.title ?: "Launcher"
+}
+
+fun StatusTone.color(): Color = when (this) {
+ StatusTone.GOOD -> Color(0xFF7BD88F)
+ StatusTone.BUSY -> Color(0xFFF2C14E)
+ StatusTone.OFF -> Color(0xFF8A8A8A)
+ StatusTone.PROBLEM -> Color(0xFFFF8A80)
+}
+
+/** Status dot + text, e.g. "● Connected · 100%". */
+@Composable
+fun StatusRow(line: StatusLine, modifier: Modifier = Modifier) {
+ Row(modifier = modifier, verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.Center) {
+ Box(
+ modifier = Modifier
+ .size(7.dp)
+ .background(line.tone.color(), CircleShape),
+ )
+ Spacer(modifier = Modifier.width(6.dp))
+ Text(
+ text = line.text,
+ style = MaterialTheme.typography.caption2,
+ color = MaterialTheme.colors.onSurfaceVariant,
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis,
+ )
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/FaceclawWearApp.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/FaceclawWearApp.kt
new file mode 100644
index 00000000..dbeb36b0
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/FaceclawWearApp.kt
@@ -0,0 +1,65 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.graphics.Color
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.wear.compose.material.Colors
+import androidx.wear.compose.material.MaterialTheme
+import androidx.wear.compose.navigation.SwipeDismissableNavHost
+import androidx.wear.compose.navigation.composable
+import androidx.wear.compose.navigation.rememberSwipeDismissableNavController
+import com.faceclaw.wear.Haptics
+import com.faceclaw.wear.PhoneLink
+import com.faceclaw.wear.WatchPrefs
+
+object Routes {
+ const val REMOTE = "remote"
+ const val APPS = "apps"
+ const val ASSISTANT = "assistant"
+ const val STATUS = "status"
+ const val SETTINGS = "settings"
+}
+
+private val FaceclawColors = Colors(
+ primary = Color(0xFFB8D8FF),
+ primaryVariant = Color(0xFF7FB0F0),
+ secondary = Color(0xFFC9C9C9),
+ secondaryVariant = Color(0xFF8A8A8A),
+ onPrimary = Color(0xFF0B1A2E),
+ onSecondary = Color(0xFF101010),
+)
+
+/** Root: the remote pad, with every other screen a swipe-back away. */
+@Composable
+fun FaceclawWearApp(link: PhoneLink, prefsStore: WatchPrefs, haptics: Haptics) {
+ val prefs by prefsStore.prefs.collectAsStateWithLifecycle()
+ val navController = rememberSwipeDismissableNavController()
+
+ MaterialTheme(colors = FaceclawColors) {
+ SwipeDismissableNavHost(navController = navController, startDestination = Routes.REMOTE) {
+ composable(Routes.REMOTE) {
+ RemoteScreen(
+ link = link,
+ prefs = prefs,
+ haptics = haptics,
+ onOpenApps = { navController.navigate(Routes.APPS) },
+ onOpenAssistant = { navController.navigate(Routes.ASSISTANT) },
+ onOpenStatus = { navController.navigate(Routes.STATUS) },
+ )
+ }
+ composable(Routes.APPS) {
+ AppsScreen(link = link, haptics = haptics, onDone = { navController.popBackStack() })
+ }
+ composable(Routes.ASSISTANT) {
+ AssistantScreen(link = link, haptics = haptics)
+ }
+ composable(Routes.STATUS) {
+ StatusScreen(link = link, haptics = haptics, onOpenSettings = { navController.navigate(Routes.SETTINGS) })
+ }
+ composable(Routes.SETTINGS) {
+ SettingsScreen(prefs = prefs, store = prefsStore)
+ }
+ }
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt
new file mode 100644
index 00000000..275f656e
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt
@@ -0,0 +1,384 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.focusable
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.input.rotary.onRotaryScrollEvent
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.wear.compose.material.Button
+import androidx.wear.compose.material.ButtonDefaults
+import androidx.wear.compose.material.Icon
+import androidx.wear.compose.material.MaterialTheme
+import androidx.wear.compose.material.Text
+import androidx.wear.compose.material.TimeText
+import com.faceclaw.wear.Command
+import com.faceclaw.wear.FingerTapDetector
+import com.faceclaw.wear.Gesture
+import com.faceclaw.wear.Haptics
+import com.faceclaw.wear.OnBodyMonitor
+import com.faceclaw.wear.PhoneLink
+import com.faceclaw.wear.Prefs
+import com.faceclaw.wear.R
+import com.faceclaw.wear.SwipeAction
+import com.faceclaw.wear.WristTwistDetector
+import kotlinx.coroutines.delay
+import kotlin.math.abs
+
+private const val MAX_SWIPE_STEPS = 4
+/** A two-finger swipe scrolls this many steps: a "page". */
+private const val TWO_FINGER_SWIPE_STEPS = 3
+private const val FLASH_MS = 160L
+private const val ARROW_LIT_MS = 220L
+private const val RING_RADIUS_FRACTION = 0.33f
+private const val RING_CENTER_Y_FRACTION = 0.47f
+private val ARROW_INSET = 6.dp
+private val ARROW_SIZE = 18.dp
+
+/** The d-pad directions, for lighting the arrow that was just swiped. */
+enum class Arrow { UP, DOWN, LEFT, RIGHT }
+
+/**
+ * The touchpad. The whole screen is the pad: tap = select, double-tap =
+ * back, hold = long press (released when the finger lifts), two-finger tap =
+ * the hold menu ("right click"), swipes in four directions = spatial
+ * navigation (crown and two-finger vertical swipes = plain scrolling, a page
+ * at a time for the latter). Fingertip pinch-taps from the motion sensors
+ * select / go back, and two quick wrist twists go back. The small buttons at
+ * the bottom reach the rest.
+ */
+@Composable
+fun RemoteScreen(
+ link: PhoneLink,
+ prefs: Prefs,
+ haptics: Haptics,
+ onOpenApps: () -> Unit,
+ onOpenAssistant: () -> Unit,
+ onOpenStatus: () -> Unit,
+) {
+ val state by link.state.collectAsStateWithLifecycle()
+ val linkStatus by link.link.collectAsStateWithLifecycle()
+ val notice by link.notice.collectAsStateWithLifecycle()
+ val currentPrefs by rememberUpdatedState(prefs)
+ val view = LocalView.current
+ var holding by remember { mutableStateOf(false) }
+ // Brief ring highlight acknowledging a sensor (tip-tap) gesture.
+ var flashUntil by remember { mutableStateOf(0L) }
+ var flashing by remember { mutableStateOf(false) }
+ // Which d-pad arrow lights up for the swipe just sent.
+ var litArrow by remember { mutableStateOf(null) }
+ var litTick by remember { mutableStateOf(0L) }
+ val focusRequester = remember { FocusRequester() }
+ var crownAccumulator by remember { mutableStateOf(0f) }
+ // Pad height in px, for the tap zones; written by onSizeChanged, read by
+ // the gesture callbacks (plain holder: the callbacks are remembered once).
+ val padHeight = remember { floatArrayOf(1f) }
+
+ val keyboardToApp = rememberKeyboardLauncher(
+ label = stringResource(R.string.keyboard_label_app),
+ onResult = { text -> haptics.click(); link.sendText(text) },
+ onUnavailable = { haptics.error() },
+ )
+
+ fun scroll(gesture: Gesture, steps: Int) {
+ haptics.tick()
+ link.sendGesture(gesture, steps)
+ }
+
+ fun light(arrow: Arrow) {
+ litArrow = arrow
+ litTick = System.currentTimeMillis()
+ }
+
+ fun click() {
+ haptics.click()
+ link.sendGesture(Gesture.CLICK)
+ }
+
+ fun doubleClick() {
+ haptics.doubleClick()
+ link.sendGesture(Gesture.DOUBLE_CLICK)
+ }
+
+ /** Run a horizontal-swipe action; `left` says which way the finger went. */
+ fun perform(action: SwipeAction, left: Boolean) {
+ when (action) {
+ SwipeAction.NAVIGATE -> { haptics.click(); link.sendGesture(if (left) Gesture.SWIPE_LEFT else Gesture.SWIPE_RIGHT) }
+ SwipeAction.SIDEBAR -> { haptics.click(); link.sendCommand(Command.SIDEBAR) }
+ SwipeAction.DOUBLE_CLICK -> doubleClick()
+ SwipeAction.CLICK -> click()
+ SwipeAction.LONG_PRESS -> { haptics.heavy(); link.sendGesture(Gesture.LONG_PRESS) }
+ SwipeAction.WAKEWORD -> { haptics.click(); link.sendGesture(Gesture.WAKEWORD) }
+ SwipeAction.NONE -> Unit
+ }
+ }
+
+ /** Whether a vertical swipe means "up", honouring the natural-scroll preference. */
+ fun swipeIsUp(dy: Float): Boolean {
+ // Ring convention: swiping up means up. "Natural" flips it so the
+ // content follows the finger like a touch screen.
+ return if (currentPrefs.naturalScroll) dy > 0 else dy < 0
+ }
+
+ val callbacks = remember(link, haptics) {
+ TouchpadCallbacks(
+ onTap = { position ->
+ if (currentPrefs.tapZones) {
+ // Top third scrolls up, bottom third down, the middle clicks.
+ val zone = position.y / padHeight[0].coerceAtLeast(1f)
+ when {
+ zone < 1f / 3f -> scroll(Gesture.SCROLL_UP, 1)
+ zone > 2f / 3f -> scroll(Gesture.SCROLL_DOWN, 1)
+ else -> click()
+ }
+ } else {
+ click()
+ }
+ },
+ onDoubleTap = { _ -> doubleClick() },
+ // Two fingers = back as well: easier than timing a double-tap.
+ onTwoFingerTap = { doubleClick() },
+ onTwoFingerSwipe = { dx, dy ->
+ if (abs(dy) >= abs(dx)) {
+ scroll(if (swipeIsUp(dy)) Gesture.SCROLL_UP else Gesture.SCROLL_DOWN, TWO_FINGER_SWIPE_STEPS)
+ } else {
+ perform(if (dx < 0) currentPrefs.swipeLeft else currentPrefs.swipeRight, left = dx < 0)
+ }
+ },
+ onLongPressStart = {
+ holding = true
+ haptics.heavy()
+ link.sendGesture(Gesture.LONG_PRESS_START)
+ },
+ onLongPressEnd = {
+ holding = false
+ haptics.click()
+ link.sendGesture(Gesture.LONG_PRESS_RELEASE)
+ },
+ onSwipe = { dx, dy, _ ->
+ if (abs(dy) >= abs(dx)) {
+ // One step per swipe, regardless of length: the glasses
+ // repaint per step, and multi-step swipes overshot lists
+ // whenever the display lagged the finger. Fast repeated
+ // swiping, the crown, or a two-finger page swipe cover
+ // long distances instead.
+ val up = swipeIsUp(dy)
+ light(if (up) Arrow.UP else Arrow.DOWN)
+ scroll(if (up) Gesture.SWIPE_UP else Gesture.SWIPE_DOWN, 1)
+ } else {
+ light(if (dx < 0) Arrow.LEFT else Arrow.RIGHT)
+ perform(if (dx < 0) currentPrefs.swipeLeft else currentPrefs.swipeRight, left = dx < 0)
+ }
+ },
+ )
+ }
+
+ // Motion-sensor gestures only count on a wrist (see OnBodyMonitor).
+ val onBody = remember { OnBodyMonitor(view.context) }
+ DisposableEffect(onBody) {
+ onBody.start()
+ onDispose { onBody.stop() }
+ }
+
+ // Fingertip (pinch) taps from the motion sensors, only while the pad is up.
+ val fingerTapsEnabled = prefs.fingerTaps
+ DisposableEffect(fingerTapsEnabled, link, haptics) {
+ if (!fingerTapsEnabled) return@DisposableEffect onDispose { }
+ val detector = FingerTapDetector(
+ context = view.context,
+ sensitivity = { currentPrefs.tapSensitivity },
+ quietUntil = { haptics.quietUntil() },
+ onBody = { onBody.onBody },
+ onTap = { flashUntil = System.currentTimeMillis() + FLASH_MS; click() },
+ onDoubleTap = { flashUntil = System.currentTimeMillis() + FLASH_MS; doubleClick() },
+ )
+ detector.start()
+ onDispose { detector.stop() }
+ }
+ // Two quick wrist twists = back, from the gyroscope, only while the pad is up.
+ val wristTwistEnabled = prefs.wristTwist
+ DisposableEffect(wristTwistEnabled, link, haptics) {
+ if (!wristTwistEnabled) return@DisposableEffect onDispose { }
+ val detector = WristTwistDetector(
+ context = view.context,
+ sensitivity = { currentPrefs.twistSensitivity },
+ quietUntil = { haptics.quietUntil() },
+ onBody = { onBody.onBody },
+ onDoubleTwist = { flashUntil = System.currentTimeMillis() + FLASH_MS; doubleClick() },
+ )
+ detector.start()
+ onDispose { detector.stop() }
+ }
+ LaunchedEffect(litTick) {
+ if (litTick == 0L) return@LaunchedEffect
+ delay(ARROW_LIT_MS)
+ litArrow = null
+ }
+ LaunchedEffect(flashUntil) {
+ if (flashUntil == 0L) return@LaunchedEffect
+ flashing = true
+ delay((flashUntil - System.currentTimeMillis()).coerceAtLeast(1L))
+ flashing = false
+ }
+
+ LaunchedEffect(Unit) { focusRequester.requestFocus() }
+
+ // A refused or unanswered gesture gets a distinct buzz, so the wrist knows
+ // without looking (the notice pill says why).
+ LaunchedEffect(notice?.id) {
+ if (notice?.isError == true) haptics.error()
+ }
+
+
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ .onRotaryScrollEvent { event ->
+ // Clockwise (positive) scrolls down, as in every Wear list.
+ crownAccumulator += event.verticalScrollPixels
+ val threshold = currentPrefs.crownSensitivity.pixelsPerStep
+ var steps = 0
+ while (crownAccumulator >= threshold) { crownAccumulator -= threshold; steps++ }
+ while (crownAccumulator <= -threshold) { crownAccumulator += threshold; steps-- }
+ // Capped low: a fast twirl otherwise outruns the display.
+ if (steps > 0) { light(Arrow.DOWN); scroll(Gesture.SCROLL_DOWN, steps.coerceAtMost(2)) }
+ if (steps < 0) { light(Arrow.UP); scroll(Gesture.SCROLL_UP, (-steps).coerceAtMost(2)) }
+ true
+ }
+ .focusRequester(focusRequester)
+ .focusable()
+ .onSizeChanged { padHeight[0] = it.height.toFloat() }
+ .pointerInput(callbacks) { detectTouchpadGestures(callbacks) },
+ ) {
+ // The pad: a ring with a d-pad arrow at each compass point (the one
+ // you swiped lights up), the current glasses app in the middle, and
+ // the tap legend under it. Brightens while a hold is in progress.
+ BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
+ val ringRadius = minOf(maxWidth, maxHeight) * RING_RADIUS_FRACTION
+ val ringCenterY = maxHeight * RING_CENTER_Y_FRACTION
+ val ringColor = if (holding || flashing) MaterialTheme.colors.primary else Color(0xFF2E2E2E)
+ Canvas(modifier = Modifier.fillMaxSize()) {
+ drawCircle(
+ color = ringColor,
+ radius = ringRadius.toPx(),
+ center = Offset(size.width / 2f, ringCenterY.toPx()),
+ style = Stroke(width = if (holding || flashing) 4f else 2f),
+ )
+ }
+
+ TimeText()
+ StatusRow(
+ statusLine(state, linkStatus),
+ modifier = Modifier.align(Alignment.TopCenter).padding(top = 28.dp, start = 36.dp, end = 36.dp),
+ )
+
+ ArrowGlyph("▲", litArrow == Arrow.UP, Modifier.align(Alignment.TopCenter).padding(top = ringCenterY - ringRadius + ARROW_INSET))
+ ArrowGlyph("▼", litArrow == Arrow.DOWN, Modifier.align(Alignment.TopCenter).padding(top = ringCenterY + ringRadius - ARROW_INSET - ARROW_SIZE))
+ ArrowGlyph("◀", litArrow == Arrow.LEFT, Modifier.align(Alignment.TopStart).padding(start = maxWidth / 2 - ringRadius + ARROW_INSET, top = ringCenterY - ARROW_SIZE / 2))
+ ArrowGlyph("▶", litArrow == Arrow.RIGHT, Modifier.align(Alignment.TopEnd).padding(end = maxWidth / 2 - ringRadius + ARROW_INSET, top = ringCenterY - ARROW_SIZE / 2))
+
+ // What the next gesture lands on (the app on the glasses, or the
+ // state in the way of it) above the centre line; the tap legend
+ // below it, clear of the side arrows.
+ val focus = if (holding) "holding" else focusLine(state).ifEmpty { "—" }
+ Text(
+ text = focus,
+ style = MaterialTheme.typography.title3,
+ color = if (holding) MaterialTheme.colors.primary else MaterialTheme.colors.onSurface,
+ textAlign = TextAlign.Center,
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis,
+ modifier = Modifier
+ .align(Alignment.TopCenter)
+ .padding(top = ringCenterY - 44.dp, start = 60.dp, end = 60.dp),
+ )
+ Text(
+ text = if (prefs.tapZones) "▲▼ tap zones · ● select" else "● select ●● back ‒ menu",
+ style = MaterialTheme.typography.caption3,
+ color = MaterialTheme.colors.onSurfaceVariant,
+ textAlign = TextAlign.Center,
+ maxLines = 1,
+ modifier = Modifier
+ .align(Alignment.TopCenter)
+ .padding(top = ringCenterY + 18.dp, start = 56.dp, end = 56.dp),
+ )
+
+ Row(
+ // Four 36dp buttons need 144dp; at this height the round
+ // display's chord is ~186dp wide, so 36dp margins keep every
+ // button inside the glass.
+ modifier = Modifier
+ .align(Alignment.BottomCenter)
+ .fillMaxWidth()
+ .padding(horizontal = 36.dp, vertical = 26.dp),
+ horizontalArrangement = Arrangement.SpaceBetween,
+ verticalAlignment = Alignment.CenterVertically,
+ ) {
+ PadButton(icon = R.drawable.ic_assistant, description = "Assistant", onClick = onOpenAssistant)
+ PadButton(icon = R.drawable.ic_keyboard, description = "Type into app", onClick = keyboardToApp)
+ PadButton(icon = R.drawable.ic_apps, description = "Apps", onClick = onOpenApps)
+ PadButton(icon = R.drawable.ic_more, description = "Status and settings", onClick = onOpenStatus)
+ }
+ }
+
+ NoticeOverlay(notice)
+ }
+}
+
+@Composable
+private fun ArrowGlyph(glyph: String, lit: Boolean, modifier: Modifier) {
+ Text(
+ text = glyph,
+ style = MaterialTheme.typography.caption1,
+ color = if (lit) MaterialTheme.colors.primary else Color(0xFF6E6E6E),
+ textAlign = TextAlign.Center,
+ modifier = modifier.size(ARROW_SIZE),
+ )
+}
+
+@Composable
+private fun PadButton(icon: Int, description: String, onClick: () -> Unit) {
+ Button(
+ onClick = onClick,
+ modifier = Modifier.size(36.dp),
+ colors = ButtonDefaults.secondaryButtonColors(),
+ ) {
+ Icon(
+ painter = painterResource(icon),
+ contentDescription = description,
+ modifier = Modifier.size(20.dp),
+ )
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/SettingsScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/SettingsScreen.kt
new file mode 100644
index 00000000..60a9283d
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/SettingsScreen.kt
@@ -0,0 +1,170 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
+import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
+import androidx.wear.compose.material.Chip
+import androidx.wear.compose.material.ChipDefaults
+import androidx.wear.compose.material.ListHeader
+import androidx.wear.compose.material.MaterialTheme
+import androidx.wear.compose.material.PositionIndicator
+import androidx.wear.compose.material.Scaffold
+import androidx.wear.compose.material.Switch
+import androidx.wear.compose.material.Text
+import androidx.wear.compose.material.TimeText
+import androidx.wear.compose.material.ToggleChip
+import com.faceclaw.wear.BuildConfig
+import com.faceclaw.wear.Prefs
+import com.faceclaw.wear.WatchPrefs
+
+/** Watch-local preferences: feel of the pad and crown. */
+@Composable
+fun SettingsScreen(prefs: Prefs, store: WatchPrefs) {
+ val listState = rememberScalingLazyListState()
+ Scaffold(
+ timeText = { TimeText() },
+ positionIndicator = { PositionIndicator(scalingLazyListState = listState) },
+ ) {
+ ScalingLazyColumn(state = listState, modifier = Modifier.fillMaxSize()) {
+ item { ListHeader { Text("Touchpad") } }
+ item {
+ ToggleChip(
+ checked = prefs.haptics,
+ onCheckedChange = { on -> store.update { it.copy(haptics = on) } },
+ label = { Text("Vibrate on input") },
+ toggleControl = { Switch(checked = prefs.haptics) },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item {
+ ToggleChip(
+ checked = prefs.keepScreenOn,
+ onCheckedChange = { on -> store.update { it.copy(keepScreenOn = on) } },
+ label = { Text("Keep screen on") },
+ secondaryLabel = { Text("while Faceclaw is in front") },
+ toggleControl = { Switch(checked = prefs.keepScreenOn) },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item {
+ ToggleChip(
+ checked = prefs.naturalScroll,
+ onCheckedChange = { on -> store.update { it.copy(naturalScroll = on) } },
+ label = { Text("Natural swipe") },
+ secondaryLabel = { Text(if (prefs.naturalScroll) "content follows finger" else "swipe up = scroll up (ring)") },
+ toggleControl = { Switch(checked = prefs.naturalScroll) },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item {
+ ToggleChip(
+ checked = prefs.tapZones,
+ onCheckedChange = { on -> store.update { it.copy(tapZones = on) } },
+ label = { Text("Tap zones") },
+ secondaryLabel = { Text("tap top/bottom to scroll") },
+ toggleControl = { Switch(checked = prefs.tapZones) },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item {
+ Chip(
+ onClick = { store.update { it.copy(swipeLeft = it.swipeLeft.next()) } },
+ label = { Text("Swipe left") },
+ secondaryLabel = { Text(prefs.swipeLeft.label) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item {
+ Chip(
+ onClick = { store.update { it.copy(swipeRight = it.swipeRight.next()) } },
+ label = { Text("Swipe right") },
+ secondaryLabel = { Text(prefs.swipeRight.label) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item { ListHeader { Text("Tip taps") } }
+ item {
+ ToggleChip(
+ checked = prefs.fingerTaps,
+ onCheckedChange = { on -> store.update { it.copy(fingerTaps = on) } },
+ label = { Text("Fingertip taps (experimental)") },
+ secondaryLabel = { Text("finger to thumb: select / double = back") },
+ toggleControl = { Switch(checked = prefs.fingerTaps) },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item {
+ Chip(
+ onClick = { store.update { it.copy(tapSensitivity = it.tapSensitivity.next()) } },
+ label = { Text("Tap sensitivity") },
+ secondaryLabel = { Text(prefs.tapSensitivity.label) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ enabled = prefs.fingerTaps,
+ )
+ }
+ item {
+ Text(
+ "Experimental: taps are read from the motion sensors while the pad is open, and ignored while the arm is moving.",
+ style = MaterialTheme.typography.caption3,
+ color = MaterialTheme.colors.onSurfaceVariant,
+ textAlign = TextAlign.Center,
+ )
+ }
+ item { ListHeader { Text("Wrist twist") } }
+ item {
+ ToggleChip(
+ checked = prefs.wristTwist,
+ onCheckedChange = { on -> store.update { it.copy(wristTwist = on) } },
+ label = { Text("Twist twice = back") },
+ secondaryLabel = { Text("two quick wrist flicks") },
+ toggleControl = { Switch(checked = prefs.wristTwist) },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item {
+ Chip(
+ onClick = { store.update { it.copy(twistSensitivity = it.twistSensitivity.next()) } },
+ label = { Text("Twist sensitivity") },
+ secondaryLabel = { Text(prefs.twistSensitivity.label) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ enabled = prefs.wristTwist,
+ )
+ }
+ item { ListHeader { Text("Crown") } }
+ item {
+ Chip(
+ onClick = { store.update { it.copy(crownSensitivity = it.crownSensitivity.next()) } },
+ label = { Text("Sensitivity") },
+ secondaryLabel = { Text(prefs.crownSensitivity.label) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ item { ListHeader { Text("Buttons") } }
+ item {
+ Text(
+ "Side button 1: tap = select, hold = long press.\nButton 2: back.\nButton 3: “Hey Even”.",
+ style = MaterialTheme.typography.caption2,
+ color = MaterialTheme.colors.onSurfaceVariant,
+ textAlign = TextAlign.Center,
+ )
+ }
+ item {
+ Text(
+ "Faceclaw watch v${BuildConfig.VERSION_NAME}",
+ style = MaterialTheme.typography.caption3,
+ color = MaterialTheme.colors.onSurfaceVariant,
+ textAlign = TextAlign.Center,
+ )
+ }
+ }
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/StatusScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/StatusScreen.kt
new file mode 100644
index 00000000..62144725
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/StatusScreen.kt
@@ -0,0 +1,171 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
+import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
+import androidx.wear.compose.material.Chip
+import androidx.wear.compose.material.ChipDefaults
+import androidx.wear.compose.material.Icon
+import androidx.wear.compose.material.ListHeader
+import androidx.wear.compose.material.PositionIndicator
+import androidx.wear.compose.material.Scaffold
+import androidx.wear.compose.material.Text
+import androidx.wear.compose.material.TimeText
+import com.faceclaw.wear.Command
+import com.faceclaw.wear.DisplayMode
+import com.faceclaw.wear.Haptics
+import com.faceclaw.wear.PhoneLink
+import com.faceclaw.wear.R
+
+/** Glasses and phone status, with the connection / display / lock switches. */
+@Composable
+fun StatusScreen(link: PhoneLink, haptics: Haptics, onOpenSettings: () -> Unit) {
+ val state by link.state.collectAsStateWithLifecycle()
+ val linkStatus by link.link.collectAsStateWithLifecycle()
+ val notice by link.notice.collectAsStateWithLifecycle()
+ val listState = rememberScalingLazyListState()
+ val connected = state?.connected == true
+
+ Scaffold(
+ timeText = { TimeText() },
+ positionIndicator = { PositionIndicator(scalingLazyListState = listState) },
+ ) {
+ ScalingLazyColumn(state = listState, modifier = Modifier.fillMaxSize()) {
+ item { ListHeader { Text("Glasses") } }
+ item {
+ val phaseLabel = when {
+ state == null -> "No status yet"
+ connected -> "Connected" + (state?.battery?.let { " · $it%" } ?: "") + if (state?.charging == true) " charging" else ""
+ state?.phase == "connecting" -> "Connecting…"
+ state?.phase == "disconnecting" -> "Disconnecting…"
+ else -> "Disconnected"
+ }
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendCommand(if (connected) Command.DISCONNECT else Command.CONNECT)
+ },
+ label = { Text(phaseLabel, maxLines = 1, overflow = TextOverflow.Ellipsis) },
+ secondaryLabel = { Text(if (connected) "tap to disconnect" else "tap to connect") },
+ colors = if (connected) ChipDefaults.primaryChipColors() else ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ enabled = linkStatus.appRunning != false,
+ )
+ }
+ item {
+ val on = state?.screenOn == true
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendCommand(if (on) Command.SLEEP else Command.WAKE)
+ },
+ label = { Text(if (on) "Display on" else "Display off") },
+ secondaryLabel = { Text(if (on) "tap to turn off" else "tap to wake") },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ enabled = connected && state?.locked != true,
+ )
+ }
+ item {
+ val locked = state?.locked == true
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendCommand(if (locked) Command.UNLOCK else Command.LOCK)
+ },
+ label = { Text(if (locked) "Locked" else "Unlocked") },
+ secondaryLabel = {
+ Text(
+ when {
+ locked && state?.canUnlock == false -> "unlock from the phone"
+ locked -> "tap to unlock"
+ else -> "tap to lock"
+ },
+ )
+ },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ enabled = connected && !(locked && state?.canUnlock == false),
+ )
+ }
+ item {
+ val mode = DisplayMode.fromWire(state?.displayMode ?: "") ?: DisplayMode.BAND
+ Chip(
+ onClick = {
+ haptics.click()
+ link.sendCommand(Command.DISPLAY_MODE, "value" to mode.next().wire)
+ },
+ label = { Text("Display mode") },
+ secondaryLabel = { Text(mode.label) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ enabled = connected,
+ )
+ }
+ state?.foreground?.let { foreground ->
+ item {
+ Chip(
+ onClick = { haptics.click(); link.sendCommand(Command.SIDEBAR) },
+ label = { Text("On screen: ${foreground.title}", maxLines = 1, overflow = TextOverflow.Ellipsis) },
+ secondaryLabel = { Text("tap to open the sidebar") },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ enabled = connected,
+ )
+ }
+ }
+
+ item { ListHeader { Text("Phone") } }
+ item {
+ val phoneLabel = when {
+ !linkStatus.phoneReachable -> "No phone connected"
+ !linkStatus.phoneAppInstalled -> "Faceclaw not installed"
+ linkStatus.appRunning == false -> "Faceclaw not running"
+ else -> linkStatus.phoneName.ifBlank { "Phone" }
+ }
+ val detail = when {
+ !linkStatus.phoneReachable -> "check Bluetooth"
+ !linkStatus.phoneAppInstalled -> "install it on the phone"
+ linkStatus.appRunning == false -> "open it on the phone"
+ state?.version?.isNotBlank() == true -> "Faceclaw v${state?.version}"
+ else -> "tap to refresh"
+ }
+ Chip(
+ onClick = { haptics.click(); link.refresh() },
+ label = { Text(phoneLabel, maxLines = 1, overflow = TextOverflow.Ellipsis) },
+ secondaryLabel = { Text(detail) },
+ icon = { Icon(painterResource(R.drawable.ic_refresh), contentDescription = null, modifier = Modifier.size(20.dp)) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ if (state?.remoteEnabled == false) {
+ item {
+ Text(
+ "Watch control is turned off in Faceclaw's Settings > Watch.",
+ style = androidx.wear.compose.material.MaterialTheme.typography.caption2,
+ )
+ }
+ }
+ item {
+ Chip(
+ onClick = onOpenSettings,
+ label = { Text("Watch settings") },
+ icon = { Icon(painterResource(R.drawable.ic_settings), contentDescription = null, modifier = Modifier.size(20.dp)) },
+ colors = ChipDefaults.secondaryChipColors(),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ }
+ NoticeOverlay(notice)
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TextEntry.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TextEntry.kt
new file mode 100644
index 00000000..ad25d47d
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TextEntry.kt
@@ -0,0 +1,82 @@
+package com.faceclaw.wear.ui
+
+import android.app.Activity
+import android.app.RemoteInput
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.speech.RecognizerIntent
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.wear.input.RemoteInputIntentHelper
+
+private const val REMOTE_INPUT_KEY = "faceclaw_text"
+
+/**
+ * The watch's own speech recognizer (the system's, so it works with the
+ * wrist raised and no glasses mic involved). Returns a launcher; the
+ * recognized text arrives in onResult.
+ */
+@Composable
+fun rememberSpeechLauncher(
+ prompt: String,
+ onResult: (String) -> Unit,
+ onUnavailable: () -> Unit,
+): () -> Unit {
+ val currentOnResult = rememberUpdatedState(onResult)
+ val launcher = rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+ if (result.resultCode != Activity.RESULT_OK) return@rememberLauncherForActivityResult
+ val text = result.data
+ ?.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS)
+ ?.firstOrNull()
+ ?.trim()
+ if (!text.isNullOrEmpty()) currentOnResult.value(text)
+ }
+ return {
+ val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH)
+ .putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
+ .putExtra(RecognizerIntent.EXTRA_PROMPT, prompt)
+ try {
+ launcher.launch(intent)
+ } catch (error: ActivityNotFoundException) {
+ onUnavailable()
+ }
+ }
+}
+
+/**
+ * The Wear OS text entry sheet (keyboard / voice / handwriting, whatever the
+ * watch offers). Returns a launcher; the entered text arrives in onResult.
+ */
+@Composable
+fun rememberKeyboardLauncher(
+ label: String,
+ onResult: (String) -> Unit,
+ onUnavailable: () -> Unit,
+): () -> Unit {
+ val currentOnResult = rememberUpdatedState(onResult)
+ val launcher = rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+ if (result.resultCode != Activity.RESULT_OK) return@rememberLauncherForActivityResult
+ val data = result.data ?: return@rememberLauncherForActivityResult
+ val text = RemoteInput.getResultsFromIntent(data)
+ ?.getCharSequence(REMOTE_INPUT_KEY)
+ ?.toString()
+ ?.trim()
+ if (!text.isNullOrEmpty()) currentOnResult.value(text)
+ }
+ return {
+ val remoteInput = RemoteInput.Builder(REMOTE_INPUT_KEY)
+ .setLabel(label)
+ .setAllowFreeFormInput(true)
+ .build()
+ val intent = RemoteInputIntentHelper.createActionRemoteInputIntent()
+ RemoteInputIntentHelper.putRemoteInputsExtra(intent, listOf(remoteInput))
+ RemoteInputIntentHelper.putTitleExtra(intent, label)
+ try {
+ launcher.launch(intent)
+ } catch (error: ActivityNotFoundException) {
+ onUnavailable()
+ }
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt
new file mode 100644
index 00000000..a63bd8cb
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt
@@ -0,0 +1,105 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.waitForUpOrCancellation
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.PointerInputScope
+import androidx.compose.ui.input.pointer.positionChanged
+
+/** What the remote's touch surface can report. */
+class TouchpadCallbacks(
+ val onTap: (position: Offset) -> Unit,
+ val onDoubleTap: (position: Offset) -> Unit,
+ val onTwoFingerTap: () -> Unit,
+ /** Two fingers travelled past touch slop; dx/dy are the primary finger's displacement. */
+ val onTwoFingerSwipe: (dx: Float, dy: Float) -> Unit,
+ val onLongPressStart: () -> Unit,
+ val onLongPressEnd: () -> Unit,
+ /** Finger travelled past touch slop; dx/dy are the total displacement. */
+ val onSwipe: (dx: Float, dy: Float, durationMs: Long) -> Unit,
+)
+
+/**
+ * One detector for everything the pad does, so a gesture is reported exactly
+ * once: tap, double-tap (a second tap inside the double-tap timeout), a hold
+ * (reported at the long-press timeout and again on release), a swipe, and a
+ * two-finger tap or swipe. Written as a single awaitEachGesture loop because the
+ * stock detectors would each claim the same finger.
+ */
+suspend fun PointerInputScope.detectTouchpadGestures(callbacks: TouchpadCallbacks) {
+ val longPressTimeout = viewConfiguration.longPressTimeoutMillis
+ val doubleTapTimeout = viewConfiguration.doubleTapTimeoutMillis
+ val slop = viewConfiguration.touchSlop
+
+ awaitEachGesture {
+ val down = awaitFirstDown()
+ down.consume()
+ val downTime = down.uptimeMillis
+ var maxPointers = 1
+ var moved = false
+ var longPressed = false
+ var displacement = Offset.Zero
+ var releaseTime = downTime
+
+ while (true) {
+ val remaining = if (longPressed || moved || maxPointers > 1) {
+ HOLD_POLL_MS
+ } else {
+ longPressTimeout - (System.currentTimeMillis() - wallClockAt(downTime))
+ }
+ val event = withTimeoutOrNull(remaining.coerceAtLeast(1L)) { awaitPointerEvent() }
+ if (event == null) {
+ if (!longPressed && !moved && maxPointers == 1) {
+ longPressed = true
+ callbacks.onLongPressStart()
+ }
+ continue
+ }
+ // Something above us (the system, a parent) took the gesture:
+ // Compose reports that as already-consumed changes. Drop it rather
+ // than mistaking the cancellation for a tap.
+ if (event.changes.any { it.isConsumed }) break
+ val pressedCount = event.changes.count { it.pressed }
+ if (pressedCount > maxPointers) maxPointers = pressedCount
+ val primary = event.changes.firstOrNull { it.id == down.id } ?: event.changes.first()
+ if (primary.positionChanged()) {
+ displacement = primary.position - down.position
+ if (!moved && !longPressed && displacement.getDistance() > slop) moved = true
+ }
+ for (change in event.changes) change.consume()
+ if (pressedCount > 0) continue
+
+ releaseTime = event.changes.maxOf { it.uptimeMillis }
+ val duration = releaseTime - downTime
+ when {
+ longPressed -> callbacks.onLongPressEnd()
+ maxPointers >= 2 -> if (moved) callbacks.onTwoFingerSwipe(displacement.x, displacement.y) else callbacks.onTwoFingerTap()
+ moved -> callbacks.onSwipe(displacement.x, displacement.y, duration)
+ else -> {
+ // A plain tap; give a second tap a chance to make it a double.
+ val second = withTimeoutOrNull(doubleTapTimeout) { awaitFirstDown() }
+ if (second == null) {
+ callbacks.onTap(down.position)
+ } else {
+ second.consume()
+ val up = waitForUpOrCancellation()
+ if (up != null) up.consume()
+ callbacks.onDoubleTap(down.position)
+ }
+ }
+ }
+ break
+ }
+ }
+}
+
+/** Poll interval while a hold or drag is in progress (no timeout semantics needed). */
+private const val HOLD_POLL_MS = 60_000L
+
+/**
+ * Pointer timestamps are SystemClock.uptimeMillis; map one to wall-clock so the
+ * remaining long-press time can be computed without a second clock.
+ */
+private fun wallClockAt(uptimeMillis: Long): Long =
+ System.currentTimeMillis() - (android.os.SystemClock.uptimeMillis() - uptimeMillis)
diff --git a/wear/app/src/main/res/drawable/ic_apps.xml b/wear/app/src/main/res/drawable/ic_apps.xml
new file mode 100644
index 00000000..fa883d1e
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_apps.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_assistant.xml b/wear/app/src/main/res/drawable/ic_assistant.xml
new file mode 100644
index 00000000..30c58883
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_assistant.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_close.xml b/wear/app/src/main/res/drawable/ic_close.xml
new file mode 100644
index 00000000..6f6c8767
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_close.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_keyboard.xml b/wear/app/src/main/res/drawable/ic_keyboard.xml
new file mode 100644
index 00000000..26e8e6c1
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_keyboard.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_launcher_foreground.xml b/wear/app/src/main/res/drawable/ic_launcher_foreground.xml
new file mode 100644
index 00000000..fd826a31
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_launcher_foreground.xml
@@ -0,0 +1,15 @@
+
+
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_mic.xml b/wear/app/src/main/res/drawable/ic_mic.xml
new file mode 100644
index 00000000..7259e5a1
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_mic.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_more.xml b/wear/app/src/main/res/drawable/ic_more.xml
new file mode 100644
index 00000000..2250cf91
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_more.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_refresh.xml b/wear/app/src/main/res/drawable/ic_refresh.xml
new file mode 100644
index 00000000..311594ea
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_refresh.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/drawable/ic_settings.xml b/wear/app/src/main/res/drawable/ic_settings.xml
new file mode 100644
index 00000000..64356d15
--- /dev/null
+++ b/wear/app/src/main/res/drawable/ic_settings.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/wear/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/wear/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
new file mode 100644
index 00000000..036d09bc
--- /dev/null
+++ b/wear/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/wear/app/src/main/res/mipmap-hdpi/ic_launcher.png b/wear/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..00e4cf14
Binary files /dev/null and b/wear/app/src/main/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/wear/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png b/wear/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png
new file mode 100644
index 00000000..5325cbf4
Binary files /dev/null and b/wear/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png differ
diff --git a/wear/app/src/main/res/mipmap-mdpi/ic_launcher.png b/wear/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..df6b391a
Binary files /dev/null and b/wear/app/src/main/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/wear/app/src/main/res/mipmap-mdpi/ic_launcher_foreground.png b/wear/app/src/main/res/mipmap-mdpi/ic_launcher_foreground.png
new file mode 100644
index 00000000..20755afc
Binary files /dev/null and b/wear/app/src/main/res/mipmap-mdpi/ic_launcher_foreground.png differ
diff --git a/wear/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/wear/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..8f8ff7f8
Binary files /dev/null and b/wear/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/wear/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png b/wear/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png
new file mode 100644
index 00000000..d3a9ee62
Binary files /dev/null and b/wear/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png differ
diff --git a/wear/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/wear/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..711cec40
Binary files /dev/null and b/wear/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/wear/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png b/wear/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png
new file mode 100644
index 00000000..4e5790ab
Binary files /dev/null and b/wear/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png differ
diff --git a/wear/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/wear/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..1bf449d1
Binary files /dev/null and b/wear/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/wear/app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png b/wear/app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png
new file mode 100644
index 00000000..a5aedb7e
Binary files /dev/null and b/wear/app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png differ
diff --git a/wear/app/src/main/res/values/ic_launcher_background.xml b/wear/app/src/main/res/values/ic_launcher_background.xml
new file mode 100644
index 00000000..a30f9a7e
--- /dev/null
+++ b/wear/app/src/main/res/values/ic_launcher_background.xml
@@ -0,0 +1,4 @@
+
+
+ #00000000
+
\ No newline at end of file
diff --git a/wear/app/src/main/res/values/strings.xml b/wear/app/src/main/res/values/strings.xml
new file mode 100644
index 00000000..56c642c9
--- /dev/null
+++ b/wear/app/src/main/res/values/strings.xml
@@ -0,0 +1,8 @@
+
+
+ Faceclaw
+ Ask the assistant
+ Say what to type
+ Ask the assistant
+ Type into the app
+
diff --git a/wear/app/src/main/res/values/themes.xml b/wear/app/src/main/res/values/themes.xml
new file mode 100644
index 00000000..86ac8fd4
--- /dev/null
+++ b/wear/app/src/main/res/values/themes.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
diff --git a/wear/app/src/main/res/values/wear.xml b/wear/app/src/main/res/values/wear.xml
new file mode 100644
index 00000000..ebb4878f
--- /dev/null
+++ b/wear/app/src/main/res/values/wear.xml
@@ -0,0 +1,8 @@
+
+
+
+
+ - faceclaw_watch
+
+
diff --git a/wear/build.gradle.kts b/wear/build.gradle.kts
new file mode 100644
index 00000000..0fdc2bca
--- /dev/null
+++ b/wear/build.gradle.kts
@@ -0,0 +1,9 @@
+// Faceclaw watch app (Wear OS companion). A standalone Gradle project: it
+// shares nothing with the NativeScript build except the applicationId and
+// (for release builds) the signing key, both of which the Wearable Data
+// Layer requires to match the phone app.
+plugins {
+ id("com.android.application") version "8.7.3" apply false
+ id("org.jetbrains.kotlin.android") version "2.1.10" apply false
+ id("org.jetbrains.kotlin.plugin.compose") version "2.1.10" apply false
+}
diff --git a/wear/gradle.properties b/wear/gradle.properties
new file mode 100644
index 00000000..5f4cff37
--- /dev/null
+++ b/wear/gradle.properties
@@ -0,0 +1,4 @@
+org.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8
+android.useAndroidX=true
+android.nonTransitiveRClass=true
+kotlin.code.style=official
diff --git a/wear/gradle/wrapper/gradle-wrapper.jar b/wear/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 00000000..249e5832
Binary files /dev/null and b/wear/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/wear/gradle/wrapper/gradle-wrapper.properties b/wear/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 00000000..d4081da4
--- /dev/null
+++ b/wear/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/wear/gradlew b/wear/gradlew
new file mode 100755
index 00000000..a69d9cb6
--- /dev/null
+++ b/wear/gradlew
@@ -0,0 +1,240 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+# Gradle start up script for POSIX generated by Gradle.
+#
+# Important for running:
+#
+# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+# noncompliant, but you have some other compliant shell such as ksh or
+# bash, then to run this script, type that shell name before the whole
+# command line, like:
+#
+# ksh Gradle
+#
+# Busybox and similar reduced shells will NOT work, because this script
+# requires all of these POSIX shell features:
+# * functions;
+# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+# * compound commands having a testable exit status, especially «case»;
+# * various built-in commands including «command», «set», and «ulimit».
+#
+# Important for patching:
+#
+# (2) This script targets any POSIX shell, so it avoids extensions provided
+# by Bash, Ksh, etc; in particular arrays are avoided.
+#
+# The "traditional" practice of packing multiple parameters into a
+# space-separated string is a well documented source of bugs and security
+# problems, so this is (mostly) avoided, by progressively accumulating
+# options in "$@", and eventually passing that to Java.
+#
+# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+# see the in-line comments for details.
+#
+# There are tweaks for specific operating systems such as AIX, CygWin,
+# Darwin, MinGW, and NonStop.
+#
+# (3) This script is generated from the Groovy template
+# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+# within the Gradle project.
+#
+# You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+ APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
+ [ -h "$app_path" ]
+do
+ ls=$( ls -ld "$app_path" )
+ link=${ls#*' -> '}
+ case $link in #(
+ /*) app_path=$link ;; #(
+ *) app_path=$APP_HOME$link ;;
+ esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+ echo "$*"
+} >&2
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in #(
+ CYGWIN* ) cygwin=true ;; #(
+ Darwin* ) darwin=true ;; #(
+ MSYS* | MINGW* ) msys=true ;; #(
+ NONSTOP* ) nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD=$JAVA_HOME/jre/sh/java
+ else
+ JAVACMD=$JAVA_HOME/bin/java
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD=java
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+ case $MAX_FD in #(
+ max*)
+ MAX_FD=$( ulimit -H -n ) ||
+ warn "Could not query maximum file descriptor limit"
+ esac
+ case $MAX_FD in #(
+ '' | soft) :;; #(
+ *)
+ ulimit -n "$MAX_FD" ||
+ warn "Could not set maximum file descriptor limit to $MAX_FD"
+ esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+# * args from the command line
+# * the main class name
+# * -classpath
+# * -D...appname settings
+# * --module-path (only if needed)
+# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+ APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+ CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+ JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ for arg do
+ if
+ case $arg in #(
+ -*) false ;; # don't mess with options #(
+ /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
+ [ -e "$t" ] ;; #(
+ *) false ;;
+ esac
+ then
+ arg=$( cygpath --path --ignore --mixed "$arg" )
+ fi
+ # Roll the args list around exactly as many times as the number of
+ # args, so each arg winds up back in the position where it started, but
+ # possibly modified.
+ #
+ # NB: a `for` loop captures its iteration list before it begins, so
+ # changing the positional parameters here affects neither the number of
+ # iterations, nor the values presented in `arg`.
+ shift # remove old arg
+ set -- "$@" "$arg" # push replacement arg
+ done
+fi
+
+# Collect all arguments for the java command;
+# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+# shell script including quotes and variable substitutions, so put them in
+# double quotes to make sure that they get re-expanded; and
+# * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+ "-Dorg.gradle.appname=$APP_BASE_NAME" \
+ -classpath "$CLASSPATH" \
+ org.gradle.wrapper.GradleWrapperMain \
+ "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+ die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+# set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+ printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+ xargs -n1 |
+ sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+ tr '\n' ' '
+ )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/wear/gradlew.bat b/wear/gradlew.bat
new file mode 100644
index 00000000..f127cfd4
--- /dev/null
+++ b/wear/gradlew.bat
@@ -0,0 +1,91 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/wear/settings.gradle.kts b/wear/settings.gradle.kts
new file mode 100644
index 00000000..b273625d
--- /dev/null
+++ b/wear/settings.gradle.kts
@@ -0,0 +1,16 @@
+pluginManagement {
+ repositories {
+ google()
+ mavenCentral()
+ gradlePluginPortal()
+ }
+}
+dependencyResolutionManagement {
+ repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+ repositories {
+ google()
+ mavenCentral()
+ }
+}
+rootProject.name = "faceclaw-wear"
+include(":app")