Add Wear OS companion app and remote controls
Add a Wearable Data Layer bridge for syncing dashboard state and commands. Introduce a standalone watch app with assistant, app launcher, touchpad remote, settings, and connectivity UI.
No files matched your search
@@ -0,0 +1,6 @@
|
||||
.gradle/
|
||||
build/
|
||||
local.properties
|
||||
.idea/
|
||||
*.iml
|
||||
.kotlin/
|
||||
@@ -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.
|
||||
@@ -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 <watch-ip>:5555
|
||||
adb -s <watch-ip>: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).
|
||||
@@ -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")
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
# Nothing app-specific; Play services and Compose ship their own rules.
|
||||
@@ -0,0 +1,35 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
|
||||
|
||||
<uses-feature android:name="android.hardware.type.watch" />
|
||||
|
||||
<uses-permission android:name="android.permission.VIBRATE" />
|
||||
|
||||
<!-- Not standalone: the watch app is a remote for Faceclaw on the phone
|
||||
and does nothing useful without it. -->
|
||||
<application
|
||||
android:allowBackup="false"
|
||||
android:icon="@mipmap/ic_launcher"
|
||||
android:label="@string/app_name"
|
||||
android:theme="@style/Theme.Faceclaw">
|
||||
|
||||
<uses-library
|
||||
android:name="com.google.android.wearable"
|
||||
android:required="true" />
|
||||
|
||||
<meta-data
|
||||
android:name="com.google.android.wearable.standalone"
|
||||
android:value="false" />
|
||||
|
||||
<activity
|
||||
android:name=".MainActivity"
|
||||
android:exported="true"
|
||||
android:launchMode="singleTask"
|
||||
android:taskAffinity="">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
<category android:name="android.intent.category.LAUNCHER" />
|
||||
</intent-filter>
|
||||
</activity>
|
||||
</application>
|
||||
</manifest>
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
}
|
||||
@@ -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<Long, Job>()
|
||||
private var noticeJob: Job? = null
|
||||
private var started = false
|
||||
|
||||
private val _state = MutableStateFlow<PhoneState?>(null)
|
||||
val state: StateFlow<PhoneState?> = _state.asStateFlow()
|
||||
|
||||
private val _link = MutableStateFlow(LinkStatus())
|
||||
val link: StateFlow<LinkStatus> = _link.asStateFlow()
|
||||
|
||||
private val _assistant = MutableStateFlow(AssistantMirror())
|
||||
val assistant: StateFlow<AssistantMirror> = _assistant.asStateFlow()
|
||||
|
||||
private val _events = MutableSharedFlow<PhoneEvent>(extraBufferCapacity = 32)
|
||||
val events: SharedFlow<PhoneEvent> = _events.asSharedFlow()
|
||||
|
||||
private val _notice = MutableStateFlow<Notice?>(null)
|
||||
val notice: StateFlow<Notice?> = _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<String, String>) {
|
||||
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>): 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
|
||||
}
|
||||
}
|
||||
@@ -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<WindowEntry>,
|
||||
val apps: List<AppEntry>,
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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> = _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"
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<Arrow?>(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),
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M4,8h4L8,4L4,4v4zM10,20h4v-4h-4v4zM4,20h4v-4L4,16v4zM4,14h4v-4L4,10v4zM10,14h4v-4h-4v4zM16,4v4h4L20,4h-4zM10,8h4L14,4h-4v4zM16,14h4v-4h-4v4zM16,20h4v-4h-4v4z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M19,9l1.25,-2.75L23,5l-2.75,-1.25L19,1l-1.25,2.75L15,5l2.75,1.25L19,9zM11.5,9.5L9,4 6.5,9.5 1,12l5.5,2.5L9,20l2.5,-5.5L17,12l-5.5,-2.5zM19,15l-1.25,2.75L15,19l2.75,1.25L19,23l1.25,-2.75L23,19l-2.75,-1.25L19,15z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M19,6.41L17.59,5 12,10.59 6.41,5 5,6.41 10.59,12 5,17.59 6.41,19 12,13.41 17.59,19 19,17.59 13.41,12z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M20,5L4,5c-1.1,0 -1.99,0.9 -1.99,2L2,17c0,1.1 0.9,2 2,2h16c1.1,0 2,-0.9 2,-2L22,7c0,-1.1 -0.9,-2 -2,-2zM11,8h2v2h-2L11,8zM11,11h2v2h-2v-2zM8,8h2v2L8,10L8,8zM8,11h2v2L8,13v-2zM7,13L5,13v-2h2v2zM7,10L5,10L5,8h2v2zM16,17L8,17v-2h8v2zM16,13h-2v-2h2v2zM16,10h-2L14,8h2v2zM19,13h-2v-2h2v2zM19,10h-2L17,8h2v2z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,15 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="108dp"
|
||||
android:height="108dp"
|
||||
android:viewportWidth="108"
|
||||
android:viewportHeight="108">
|
||||
<group android:scaleX="0.07382812"
|
||||
android:scaleY="0.07382812"
|
||||
android:translateX="16.2"
|
||||
android:translateY="16.2">
|
||||
<path
|
||||
android:pathData="M843,511.86L843,512.96C843,513.22 842.8,513.43 842.55,513.46C809.18,516.58 783.07,543.69 783.07,577.86L783.07,714.8C783.07,724.37 781.06,733.6 777.43,742.03C767.08,766.1 743.59,783.6 716.27,783.6L647.07,783.6L646.59,783L377.41,445.68L377.41,783.6L307.73,783.6C270.84,783.6 240.93,753.7 240.93,716.8L240.93,577.86C240.93,543.69 214.82,516.58 181.45,513.46C181.2,513.43 181,513.22 181,512.96L181,511.86C181,511.61 181.19,511.4 181.45,511.37C214.69,508.14 240.67,480.35 240.67,446.26L240.67,307.2C240.67,297.91 242.57,289.05 246,281.01C256.18,257.14 279.87,240.39 307.47,240.39L377.13,240.39L377.41,240.74L646.59,578.07L646.59,240.39L716.53,240.39C753.42,240.39 783.33,270.3 783.33,307.2L783.33,446.26C783.33,480.35 809.31,508.14 842.55,511.37C842.81,511.4 843,511.61 843,511.86"
|
||||
android:fillColor="#65ADF1"
|
||||
android:fillType="nonZero"/>
|
||||
</group>
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M12,14c1.66,0 2.99,-1.34 2.99,-3L15,5c0,-1.66 -1.34,-3 -3,-3S9,3.34 9,5v6c0,1.66 1.34,3 3,3zM17.3,11c0,3 -2.54,5.1 -5.3,5.1S6.7,14 6.7,11L5,11c0,3.41 2.72,6.23 6,6.72L11,21h2v-3.28c3.28,-0.48 6,-3.3 6,-6.72h-1.7z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M6,10c-1.1,0 -2,0.9 -2,2s0.9,2 2,2 2,-0.9 2,-2 -0.9,-2 -2,-2zM18,10c-1.1,0 -2,0.9 -2,2s0.9,2 2,2 2,-0.9 2,-2 -0.9,-2 -2,-2zM12,10c-1.1,0 -2,0.9 -2,2s0.9,2 2,2 2,-0.9 2,-2 -0.9,-2 -2,-2z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M17.65,6.35C16.2,4.9 14.21,4 12,4c-4.42,0 -7.99,3.58 -7.99,8s3.57,8 7.99,8c3.73,0 6.84,-2.55 7.73,-6h-2.08c-0.82,2.33 -3.04,4 -5.65,4 -3.31,0 -6,-2.69 -6,-6s2.69,-6 6,-6c1.66,0 3.14,0.69 4.22,1.78L13,11h7V4l-2.35,2.35z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="@android:color/white"
|
||||
android:pathData="M19.14,12.94c0.04,-0.3 0.06,-0.61 0.06,-0.94 0,-0.32 -0.02,-0.64 -0.07,-0.94l2.03,-1.58c0.18,-0.14 0.23,-0.41 0.12,-0.61l-1.92,-3.32c-0.12,-0.22 -0.37,-0.29 -0.59,-0.22l-2.39,0.96c-0.5,-0.38 -1.03,-0.7 -1.62,-0.94L14.4,2.81c-0.04,-0.24 -0.24,-0.41 -0.48,-0.41h-3.84c-0.24,0 -0.43,0.17 -0.47,0.41L9.25,5.35C8.66,5.59 8.12,5.92 7.63,6.29L5.24,5.33c-0.22,-0.08 -0.47,0 -0.59,0.22L2.74,8.87C2.62,9.08 2.66,9.34 2.86,9.48l2.03,1.58C4.84,11.36 4.8,11.69 4.8,12s0.02,0.64 0.07,0.94l-2.03,1.58c-0.18,0.14 -0.23,0.41 -0.12,0.61l1.92,3.32c0.12,0.22 0.37,0.29 0.59,0.22l2.39,-0.96c0.5,0.38 1.03,0.7 1.62,0.94l0.36,2.54c0.05,0.24 0.24,0.41 0.48,0.41h3.84c0.24,0 0.44,-0.17 0.47,-0.41l0.36,-2.54c0.59,-0.24 1.13,-0.56 1.62,-0.94l2.39,0.96c0.22,0.08 0.47,0 0.59,-0.22l1.92,-3.32c0.12,-0.22 0.07,-0.47 -0.12,-0.61L19.14,12.94zM12,15.6c-1.98,0 -3.6,-1.62 -3.6,-3.6s1.62,-3.6 3.6,-3.6 3.6,1.62 3.6,3.6S13.98,15.6 12,15.6z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
|
||||
<background android:drawable="@color/ic_launcher_background"/>
|
||||
<foreground android:drawable="@mipmap/ic_launcher_foreground"/>
|
||||
</adaptive-icon>
|
||||
|
After Width: | Height: | Size: 9.6 KiB |
|
After Width: | Height: | Size: 21 KiB |
|
After Width: | Height: | Size: 4.8 KiB |
|
After Width: | Height: | Size: 11 KiB |
|
After Width: | Height: | Size: 16 KiB |
|
After Width: | Height: | Size: 34 KiB |
|
After Width: | Height: | Size: 32 KiB |
|
After Width: | Height: | Size: 65 KiB |
|
After Width: | Height: | Size: 53 KiB |
|
After Width: | Height: | Size: 106 KiB |
@@ -0,0 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources>
|
||||
<color name="ic_launcher_background">#00000000</color>
|
||||
</resources>
|
||||
@@ -0,0 +1,8 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources>
|
||||
<string name="app_name">Faceclaw</string>
|
||||
<string name="speech_prompt_assistant">Ask the assistant</string>
|
||||
<string name="speech_prompt_app">Say what to type</string>
|
||||
<string name="keyboard_label_assistant">Ask the assistant</string>
|
||||
<string name="keyboard_label_app">Type into the app</string>
|
||||
</resources>
|
||||
@@ -0,0 +1,9 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources>
|
||||
<!-- The pad uses rightward swipes as input, so the system's whole-window
|
||||
swipe-to-dismiss is off; the crown/home button leaves the app, and
|
||||
inner screens still swipe back through SwipeDismissableNavHost. -->
|
||||
<style name="Theme.Faceclaw" parent="@android:style/Theme.DeviceDefault">
|
||||
<item name="android:windowSwipeToDismiss">false</item>
|
||||
</style>
|
||||
</resources>
|
||||
@@ -0,0 +1,8 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Advertised over the Wearable Data Layer; the phone app targets its
|
||||
messages at nodes with this capability (FaceclawWearBridge). -->
|
||||
<resources>
|
||||
<string-array name="android_wear_capabilities">
|
||||
<item>faceclaw_watch</item>
|
||||
</string-array>
|
||||
</resources>
|
||||
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
org.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8
|
||||
android.useAndroidX=true
|
||||
android.nonTransitiveRClass=true
|
||||
kotlin.code.style=official
|
||||
@@ -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
|
||||
@@ -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" "$@"
|
||||
@@ -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
|
||||
@@ -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")
|
||||