diff --git a/CHANGELOG b/CHANGELOG
index cabb3ecf..82d04f75 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -13,6 +13,11 @@ Compass app:
Files app:
* Viewing image files gamma-corrects and dithers them
+Watch app:
+* Ambient mode: the watch no longer blurs when idle
+* Fix flicker on waking the watch
+* Tapping the idle watch to wake it counts as a tap on the pad
+
## 0.6.3 - 2026-09-01
* Update custom firmware base version from 2.2.6 to 2.2.9
* Add support for the short-then-long-press gesture
diff --git a/wear/README.md b/wear/README.md
index 04697424..c8c594a8 100644
--- a/wear/README.md
+++ b/wear/README.md
@@ -51,8 +51,23 @@ down beginning in the button tray to hide them.
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.
+wrist dropping, so the remote would need a wake-up tap before every gesture.
+
+When the watch does doze (wrist down, or "Keep screen on" off), the app stays
+in front as an always-on face: the pad's clock and status line on black,
+redrawn once a minute. Wear OS would otherwise blur a snapshot of the app
+under the system clock and, after its app timeout, drop back to the watch
+face; being ambient-aware avoids both. Motion and crown input pause in ambient.
+
+**Waking with a tap.** The system consumes the touch that wakes the watch, so
+the pad treats each wake as a first tap it never saw:
+
+- With the Wear OS "Always-on screen" setting on, the dozing pad is the same
+ screen, so a tap on it is a tap: one tap wakes the watch and sends *select*
+ to the glasses; a double-tap wakes it and sends *back*.
+- With "Always-on screen" off the display was dark, so a lone tap just turns
+ it on; a double-tap turns it on and sends *back*.
+- A wrist raise (the wrist-tilt gesture sensor) or a crown turn is not a tap.
Phone-side switches live in Faceclaw's Settings > Watch: turn watch control
off entirely, reverse the crown direction, forbid unlocking from the watch,
diff --git a/wear/app/build.gradle.kts b/wear/app/build.gradle.kts
index 71cd6049..963e22cf 100644
--- a/wear/app/build.gradle.kts
+++ b/wear/app/build.gradle.kts
@@ -68,6 +68,8 @@ dependencies {
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")
+ // AmbientLifecycleObserver: the always-on (ambient) display callbacks.
+ implementation("androidx.wear:wear:1.3.0")
implementation("com.google.android.gms:play-services-wearable:19.0.0")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.1")
diff --git a/wear/app/src/main/AndroidManifest.xml b/wear/app/src/main/AndroidManifest.xml
index 1f28264d..1a700075 100644
--- a/wear/app/src/main/AndroidManifest.xml
+++ b/wear/app/src/main/AndroidManifest.xml
@@ -4,6 +4,8 @@
+
+
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/AmbientMode.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/AmbientMode.kt
new file mode 100644
index 00000000..bb1fefef
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/AmbientMode.kt
@@ -0,0 +1,20 @@
+package com.faceclaw.wear
+
+/**
+ * The watch's ambient (always-on, low-power) display state, as reported by
+ * the system through [androidx.wear.ambient.AmbientLifecycleObserver].
+ */
+data class AmbientMode(
+ /** The display is in ambient: draw black, still, and as few pixels as possible. */
+ val active: Boolean = false,
+ /** The panel burns in: nudge the content between redraws. */
+ val burnInProtectionRequired: Boolean = false,
+ /** The panel is 1-bit in ambient: no greys, no anti-aliasing worth relying on. */
+ val lowBit: Boolean = false,
+ /**
+ * Bumped on entering ambient and on every ambient update (about once a
+ * minute), so the clock redraws: the CPU may be suspended in between, so
+ * no timer can be relied on for that.
+ */
+ val tick: Long = 0,
+)
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt
index b5c1e6b9..41274bd9 100644
--- a/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/MainActivity.kt
@@ -3,18 +3,56 @@ package com.faceclaw.wear
import android.os.Bundle
import android.os.Handler
import android.os.Looper
+import android.os.PowerManager
+import android.util.Log
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 androidx.wear.ambient.AmbientLifecycleObserver
import com.faceclaw.wear.ui.FaceclawWearApp
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.update
class MainActivity : ComponentActivity() {
private lateinit var link: PhoneLink
private lateinit var prefs: WatchPrefs
private lateinit var haptics: Haptics
+ private lateinit var wakeTracker: WakeTracker
+ private val ambient = MutableStateFlow(AmbientMode())
+ /** The last stop was the display turning off (not the user leaving). */
+ private var stoppedForScreenOff = false
+
+ // Always-on support: with these callbacks Wear OS keeps the activity in
+ // front in ambient (we draw the clock) instead of blurring a snapshot of
+ // it under the system clock and, after a timeout, dropping back to the
+ // watch face.
+ private val ambientCallback = object : AmbientLifecycleObserver.AmbientLifecycleCallback {
+ override fun onEnterAmbient(ambientDetails: AmbientLifecycleObserver.AmbientDetails) {
+ Log.d(TAG, "enter ambient (burnIn=${ambientDetails.burnInProtectionRequired} lowBit=${ambientDetails.deviceHasLowBitAmbient})")
+ ambient.update {
+ AmbientMode(
+ active = true,
+ burnInProtectionRequired = ambientDetails.burnInProtectionRequired,
+ lowBit = ambientDetails.deviceHasLowBitAmbient,
+ tick = it.tick + 1,
+ )
+ }
+ }
+
+ override fun onUpdateAmbient() {
+ Log.d(TAG, "update ambient")
+ ambient.update { it.copy(tick = it.tick + 1) }
+ }
+
+ override fun onExitAmbient() {
+ Log.d(TAG, "exit ambient")
+ ambient.update { it.copy(active = false) }
+ wakeTracker.onWake(fromScreenOff = false)
+ }
+ }
// Side (stem) buttons: button 1 is click / hold, 2 double-click, 3 "Hey Even".
private val stemHandler = Handler(Looper.getMainLooper())
@@ -27,8 +65,17 @@ class MainActivity : ComponentActivity() {
link = PhoneLink(this)
prefs = WatchPrefs(this)
haptics = Haptics(this) { prefs.prefs.value.haptics }
+ wakeTracker = WakeTracker(this)
+ wakeTracker.start()
+ lifecycle.addObserver(AmbientLifecycleObserver(this, ambientCallback))
setContent {
- FaceclawWearApp(link = link, prefsStore = prefs, haptics = haptics)
+ FaceclawWearApp(
+ link = link,
+ prefsStore = prefs,
+ haptics = haptics,
+ ambient = ambient,
+ wakes = wakeTracker.wakes,
+ )
}
// 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
@@ -46,10 +93,29 @@ class MainActivity : ComponentActivity() {
override fun onStart() {
super.onStart()
+ Log.d(TAG, "onStart")
link.start()
}
+ override fun onResume() {
+ super.onResume()
+ Log.d(TAG, "onResume")
+ if (stoppedForScreenOff) {
+ stoppedForScreenOff = false
+ wakeTracker.onWake(fromScreenOff = true)
+ }
+ }
+
+ override fun onPause() {
+ Log.d(TAG, "onPause")
+ super.onPause()
+ }
+
override fun onStop() {
+ // With always-on off the display going dark stops the activity; the
+ // next resume is then a wake, and its tap deserves the wake treatment.
+ stoppedForScreenOff = getSystemService(PowerManager::class.java)?.isInteractive == false
+ Log.d(TAG, "onStop (screenOff=$stoppedForScreenOff)")
cancelStemHold()
// A stopped activity never sees the key-up, and the phone keeps the
// hold (and its escape-menu countdown) running until it hears the
@@ -62,6 +128,11 @@ class MainActivity : ComponentActivity() {
super.onStop()
}
+ override fun onDestroy() {
+ wakeTracker.stop()
+ super.onDestroy()
+ }
+
override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
when (keyCode) {
KeyEvent.KEYCODE_STEM_1 -> {
@@ -132,6 +203,7 @@ class MainActivity : ComponentActivity() {
link.state.value?.let { it.connected && !it.screenOn } == true
private companion object {
+ const val TAG = "FaceclawWear"
const val STEM_HOLD_MS = 450L
}
}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/WakeTracker.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/WakeTracker.kt
new file mode 100644
index 00000000..2a7ffac6
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/WakeTracker.kt
@@ -0,0 +1,98 @@
+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 kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/** A wake of the watch display that a tap on the pad may have caused. */
+data class Wake(
+ val id: Long,
+ /** SystemClock.uptimeMillis when the app learned of the wake. */
+ val uptimeMillis: Long,
+ /**
+ * The display was fully off (always-on disabled), so the activity was
+ * stopped and the tap's job was to turn the screen on; a lone tap should
+ * not also reach the glasses. False for an exit from ambient, where the
+ * pad was already showing and a tap on it means a tap.
+ */
+ val fromScreenOff: Boolean,
+)
+
+/**
+ * Which display wakes were taps. The system consumes the touch that wakes
+ * the watch (from ambient or from off), so the pad never sees it; this
+ * reports each wake so the pad can treat it as a virtual first tap. Wakes by
+ * wrist raise are filtered out with the wrist-tilt gesture sensor, the same
+ * signal tilt-to-wake uses. Rotary and button wakes are left to the pad to
+ * cancel (a crown event follows straight away; a button wake leaves the app).
+ * Lives for the activity's lifetime (start()/stop() from onCreate/onDestroy):
+ * the sensor is a wake-up one, so a tilt is seen even while the activity sits
+ * stopped behind an off display.
+ */
+class WakeTracker(context: Context) : SensorEventListener {
+ private val sensorManager: SensorManager? = context.getSystemService(SensorManager::class.java)
+ private val sensor: Sensor? = sensorManager?.getDefaultSensor(TYPE_WRIST_TILT_GESTURE, true)
+ ?: sensorManager?.getDefaultSensor(TYPE_WRIST_TILT_GESTURE)
+ private val handler = Handler(Looper.getMainLooper())
+ private var running = false
+ private var lastTiltAt = Long.MIN_VALUE / 2
+ private var nextId = 1L
+
+ private val _wakes = MutableStateFlow(null)
+ /** The latest wake, or null once it was attributed to a wrist raise. */
+ val wakes: StateFlow = _wakes.asStateFlow()
+
+ fun start() {
+ val manager = sensorManager ?: return
+ val target = sensor ?: run { Log.i(TAG, "no wrist-tilt sensor: wakes are all taken for taps"); return }
+ if (running) return
+ running = manager.registerListener(this, target, SensorManager.SENSOR_DELAY_NORMAL, handler)
+ }
+
+ fun stop() {
+ if (!running) return
+ running = false
+ sensorManager?.unregisterListener(this)
+ }
+
+ /** The display just woke with the app in front. Main thread. */
+ fun onWake(fromScreenOff: Boolean) {
+ val now = SystemClock.uptimeMillis()
+ if (now - lastTiltAt <= TILT_GRACE_MS) {
+ Log.d(TAG, "wake (fromScreenOff=$fromScreenOff): wrist raise, ignored")
+ return
+ }
+ Log.d(TAG, "wake (fromScreenOff=$fromScreenOff): possible tap")
+ _wakes.value = Wake(id = nextId++, uptimeMillis = now, fromScreenOff = fromScreenOff)
+ }
+
+ override fun onSensorChanged(event: SensorEvent) {
+ lastTiltAt = SystemClock.uptimeMillis()
+ val pending = _wakes.value
+ if (pending != null && lastTiltAt - pending.uptimeMillis <= TILT_GRACE_MS) {
+ Log.d(TAG, "wrist tilt: wake ${pending.id} was a wrist raise")
+ _wakes.value = null
+ } else {
+ Log.d(TAG, "wrist tilt")
+ }
+ }
+
+ override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit
+
+ private companion object {
+ const val TAG = "FaceclawWear"
+ /** Sensor.TYPE_WRIST_TILT_GESTURE ("android.sensor.wrist_tilt_gesture"): hidden in the SDK. */
+ const val TYPE_WRIST_TILT_GESTURE = 26
+ /** A tilt this close to a wake (either side) means the tilt caused it. */
+ const val TILT_GRACE_MS = 500L
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AmbientScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AmbientScreen.kt
new file mode 100644
index 00000000..7e3cc278
--- /dev/null
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/AmbientScreen.kt
@@ -0,0 +1,80 @@
+package com.faceclaw.wear.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+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.IntOffset
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.wear.compose.material.MaterialTheme
+import androidx.wear.compose.material.Text
+import com.faceclaw.wear.AmbientMode
+import com.faceclaw.wear.PhoneLink
+import java.util.Date
+import kotlin.random.Random
+
+/** Burn-in protection shifts the content by up to this many pixels each way. */
+private const val BURN_IN_SHIFT_PX = 8
+
+/**
+ * The always-on face: the pad's clock and its status line on black, nothing
+ * else and nothing moving. Redraws when [AmbientMode.tick] changes (the
+ * system's once-a-minute ambient update) and when the phone's state does.
+ */
+@Composable
+fun AmbientScreen(link: PhoneLink, ambient: AmbientMode) {
+ val state by link.state.collectAsStateWithLifecycle()
+ val linkStatus by link.link.collectAsStateWithLifecycle()
+ val formatter = rememberClockFormatter()
+ val time = remember(ambient.tick, formatter) { formatter.format(Date()) }
+ val shift = remember(ambient.tick, ambient.burnInProtectionRequired) {
+ if (!ambient.burnInProtectionRequired) IntOffset.Zero else {
+ val random = Random(ambient.tick)
+ IntOffset(
+ random.nextInt(-BURN_IN_SHIFT_PX, BURN_IN_SHIFT_PX + 1),
+ random.nextInt(-BURN_IN_SHIFT_PX, BURN_IN_SHIFT_PX + 1),
+ )
+ }
+ }
+ // A 1-bit panel renders grey as noise: everything white there.
+ val statusColor = if (ambient.lowBit) Color.White else Color(0xFF8A8A8A)
+
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ .background(Color.Black)
+ .offset { shift },
+ ) {
+ Text(
+ text = time,
+ color = Color.White,
+ fontSize = 42.sp,
+ textAlign = TextAlign.Center,
+ maxLines = 1,
+ modifier = Modifier.align(Alignment.Center),
+ )
+ Text(
+ text = padLine(state, linkStatus).text,
+ style = MaterialTheme.typography.title3,
+ color = statusColor,
+ textAlign = TextAlign.Center,
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis,
+ modifier = Modifier
+ .align(Alignment.Center)
+ .offset(y = 46.dp)
+ .padding(horizontal = 42.dp),
+ )
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/Common.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/Common.kt
index e571e861..92b027fb 100644
--- a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/Common.kt
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/Common.kt
@@ -3,15 +3,18 @@ package com.faceclaw.wear.ui
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
+import android.text.format.DateFormat
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
@@ -20,6 +23,16 @@ import androidx.wear.compose.material.Text
import com.faceclaw.wear.LinkStatus
import com.faceclaw.wear.Notice
import com.faceclaw.wear.PhoneState
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+/** Hours and minutes in the watch's 12/24-hour preference, for the pad's clock. */
+@Composable
+fun rememberClockFormatter(): SimpleDateFormat {
+ val context = LocalContext.current
+ val pattern = remember(context) { if (DateFormat.is24HourFormat(context)) "HH:mm" else "h:mm" }
+ return remember(pattern) { SimpleDateFormat(pattern, Locale.getDefault()) }
+}
/** A transient pill at the bottom of the screen: ack failures and confirmations. */
@Composable
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/FaceclawWearApp.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/FaceclawWearApp.kt
index dbeb36b0..a244554b 100644
--- a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/FaceclawWearApp.kt
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/FaceclawWearApp.kt
@@ -1,17 +1,27 @@
package com.faceclaw.wear.ui
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavHostController
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.AmbientMode
import com.faceclaw.wear.Haptics
import com.faceclaw.wear.PhoneLink
+import com.faceclaw.wear.Prefs
+import com.faceclaw.wear.Wake
import com.faceclaw.wear.WatchPrefs
+import kotlinx.coroutines.flow.StateFlow
object Routes {
const val REMOTE = "remote"
@@ -30,36 +40,70 @@ private val FaceclawColors = Colors(
onSecondary = Color(0xFF101010),
)
-/** Root: the remote pad, with every other screen a swipe-back away. */
+/** The watch's ambient state, for screens that pause work while it is on. */
+val LocalAmbientMode = compositionLocalOf { AmbientMode() }
+
+/**
+ * Root: the remote pad, with every other screen a swipe-back away. In ambient
+ * [AmbientScreen] is laid over the lot. The screens stay composed underneath
+ * (the nav host animates any destination it composes, which on every wake
+ * was a visible flicker between two identical frames) and read
+ * [LocalAmbientMode] to pause their sensors.
+ */
@Composable
-fun FaceclawWearApp(link: PhoneLink, prefsStore: WatchPrefs, haptics: Haptics) {
+fun FaceclawWearApp(
+ link: PhoneLink,
+ prefsStore: WatchPrefs,
+ haptics: Haptics,
+ ambient: StateFlow,
+ wakes: StateFlow,
+) {
val prefs by prefsStore.prefs.collectAsStateWithLifecycle()
+ val ambientMode by ambient.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)
+ CompositionLocalProvider(LocalAmbientMode provides ambientMode) {
+ Box(modifier = Modifier.fillMaxSize()) {
+ Screens(navController, link, prefs, prefsStore, haptics, wakes)
+ if (ambientMode.active) AmbientScreen(link = link, ambient = ambientMode)
}
}
}
}
+
+@Composable
+private fun Screens(
+ navController: NavHostController,
+ link: PhoneLink,
+ prefs: Prefs,
+ prefsStore: WatchPrefs,
+ haptics: Haptics,
+ wakes: StateFlow,
+) {
+ SwipeDismissableNavHost(navController = navController, startDestination = Routes.REMOTE) {
+ composable(Routes.REMOTE) {
+ RemoteScreen(
+ link = link,
+ prefs = prefs,
+ haptics = haptics,
+ wakes = wakes,
+ onOpenApps = { navController.navigate(Routes.APPS) },
+ onOpenAssistant = { navController.navigate(Routes.ASSISTANT) },
+ onOpenStatus = { navController.navigate(Routes.STATUS) },
+ )
+ }
+ composable(Routes.APPS) {
+ AppsScreen(link = link, haptics = haptics, onDone = { navController.popBackStack() })
+ }
+ composable(Routes.ASSISTANT) {
+ AssistantScreen(link = link, haptics = haptics)
+ }
+ composable(Routes.STATUS) {
+ StatusScreen(link = link, haptics = haptics, onOpenSettings = { navController.navigate(Routes.SETTINGS) })
+ }
+ composable(Routes.SETTINGS) {
+ SettingsScreen(prefs = prefs, store = prefsStore)
+ }
+ }
+}
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt
index d26400e2..b6d72bff 100644
--- a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/RemoteScreen.kt
@@ -1,6 +1,6 @@
package com.faceclaw.wear.ui
-import android.text.format.DateFormat
+import android.os.SystemClock
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
@@ -30,9 +30,9 @@ import androidx.compose.ui.focus.focusRequester
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.LocalContext
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.platform.LocalViewConfiguration
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
@@ -59,17 +59,24 @@ import com.faceclaw.wear.PhoneLink
import com.faceclaw.wear.Prefs
import com.faceclaw.wear.R
import com.faceclaw.wear.SwipeAction
+import com.faceclaw.wear.Wake
import com.faceclaw.wear.WristTwistDetector
import kotlinx.coroutines.delay
-import java.text.SimpleDateFormat
+import kotlinx.coroutines.flow.StateFlow
import java.util.Date
-import java.util.Locale
import kotlin.math.abs
/** A two-finger swipe scrolls this many steps: a "page". */
private const val TWO_FINGER_SWIPE_STEPS = 3
private val EDGE_REVEAL_ZONE = 24.dp
private val BUTTON_TRAY_HEIGHT = 62.dp
+/**
+ * After a wake from an off display, how long a press still counts as the
+ * second tap of the double-tap that woke it. Longer than the double-tap
+ * timeout because the window only gets input focus ~300 ms into such a wake
+ * and the press queues behind that.
+ */
+private const val SCREEN_ON_SECOND_TAP_WINDOW_MS = 600L
/**
* The touchpad. The whole screen is the pad: tap = select, double-tap =
@@ -79,6 +86,12 @@ private val BUTTON_TRAY_HEIGHT = 62.dp
* at a time for the latter). Fingertip pinch-taps from the motion sensors
* select / go back, and two quick wrist twists go back. An upward swipe that
* begins at the bottom edge reveals the otherwise-hidden action buttons.
+ *
+ * A tap that wakes the display never reaches the pad (the system eats it),
+ * so each wake in [wakes] stands in for a first tap: a press inside the
+ * double-tap window makes the pair a double-tap, and a lone wake from ambient
+ * (where the pad was already showing) becomes a tap once the window closes.
+ * A lone wake from an off display just turned the screen on.
*/
// rememberActiveFocusRequester (rotary focus) is still experimental in Wear Compose 1.4.
@OptIn(ExperimentalWearFoundationApi::class)
@@ -87,6 +100,7 @@ fun RemoteScreen(
link: PhoneLink,
prefs: Prefs,
haptics: Haptics,
+ wakes: StateFlow,
onOpenApps: () -> Unit,
onOpenAssistant: () -> Unit,
onOpenStatus: () -> Unit,
@@ -94,6 +108,10 @@ fun RemoteScreen(
val state by link.state.collectAsStateWithLifecycle()
val linkStatus by link.link.collectAsStateWithLifecycle()
val notice by link.notice.collectAsStateWithLifecycle()
+ val wake by wakes.collectAsStateWithLifecycle()
+ val ambientActive = LocalAmbientMode.current.active
+ val doubleTapTimeout = LocalViewConfiguration.current.doubleTapTimeoutMillis
+ val pendingTap = remember { PendingTap() }
val currentPrefs by rememberUpdatedState(prefs)
val currentState by rememberUpdatedState(state)
val view = LocalView.current
@@ -243,9 +261,25 @@ fun RemoteScreen(
)
}
- // Motion-sensor gestures only count on a wrist (see OnBodyMonitor).
+ // The wake-tap: arm the detector for a second press, and when none comes
+ // decide what the lone tap meant. A wake the tracker re-attributes to a
+ // wrist raise arrives as null and cancels all of it.
+ LaunchedEffect(wake) {
+ val current = wake
+ if (current == null) {
+ pendingTap.disarm()
+ return@LaunchedEffect
+ }
+ val window = if (current.fromScreenOff) SCREEN_ON_SECOND_TAP_WINDOW_MS else doubleTapTimeout
+ pendingTap.arm(current.uptimeMillis, window)
+ delay((current.uptimeMillis + window - SystemClock.uptimeMillis()).coerceAtLeast(0L))
+ if (pendingTap.expire() && !current.fromScreenOff) click()
+ }
+
+ // Motion-sensor gestures only count on a wrist (see OnBodyMonitor); none
+ // of the sensors run in ambient.
val onBody = remember { OnBodyMonitor(view.context) }
- WhileStartedEffect(onBody, start = onBody::start, stop = onBody::stop)
+ WhileStartedEffect(onBody, enabled = !ambientActive, start = onBody::start, stop = onBody::stop)
// Fingertip (pinch) taps from the motion sensors, only while the pad is up.
val fingerTapsEnabled = prefs.fingerTaps
@@ -259,7 +293,7 @@ fun RemoteScreen(
onDoubleTap = { doubleClick() },
)
}
- WhileStartedEffect(fingerTapDetector, start = { fingerTapDetector?.start() }, stop = { fingerTapDetector?.stop() })
+ WhileStartedEffect(fingerTapDetector, enabled = !ambientActive, start = { fingerTapDetector?.start() }, stop = { fingerTapDetector?.stop() })
// Two quick wrist twists = back, from the gyroscope, only while the pad is up.
val wristTwistEnabled = prefs.wristTwist
val wristTwistDetector = remember(wristTwistEnabled, link, haptics) {
@@ -271,7 +305,7 @@ fun RemoteScreen(
onDoubleTwist = { doubleClick() },
)
}
- WhileStartedEffect(wristTwistDetector, start = { wristTwistDetector?.start() }, stop = { wristTwistDetector?.stop() })
+ WhileStartedEffect(wristTwistDetector, enabled = !ambientActive, start = { wristTwistDetector?.start() }, stop = { wristTwistDetector?.stop() })
// A refused or unanswered gesture gets a distinct buzz, so the wrist knows
// without looking (the notice pill says why).
@@ -284,6 +318,8 @@ fun RemoteScreen(
modifier = Modifier
.fillMaxSize()
.onRotaryScrollEvent { event ->
+ // A crown turn can be what woke the display: not a tap, then.
+ pendingTap.disarm()
crownAccumulator += event.verticalScrollPixels
val threshold = currentPrefs.crownSensitivity.pixelsPerStep
var steps = 0
@@ -299,7 +335,7 @@ fun RemoteScreen(
.focusRequester(focusRequester)
.focusable()
.onSizeChanged { padHeight[0] = it.height.toFloat() }
- .pointerInput(callbacks) { detectTouchpadGestures(callbacks) },
+ .pointerInput(callbacks) { detectTouchpadGestures(callbacks, pendingTap) },
) {
StraightTime(modifier = Modifier.align(Alignment.Center))
@@ -362,11 +398,14 @@ fun RemoteScreen(
* leaving the composition. A plain DisposableEffect keeps sensors registered
* while the activity sits stopped-but-cached (palmed screen, back on the watch
* face), which at gyroscope/accelerometer rates is a real battery drain.
+ * [enabled] false holds it stopped regardless (ambient, where the activity
+ * stays started for the clock).
*/
@Composable
-private fun WhileStartedEffect(key: Any?, start: () -> Unit, stop: () -> Unit) {
+private fun WhileStartedEffect(key: Any?, enabled: Boolean = true, start: () -> Unit, stop: () -> Unit) {
val lifecycleOwner = LocalLifecycleOwner.current
- DisposableEffect(lifecycleOwner, key) {
+ DisposableEffect(lifecycleOwner, key, enabled) {
+ if (!enabled) return@DisposableEffect onDispose { }
val observer = LifecycleEventObserver { _, event ->
when (event) {
Lifecycle.Event.ON_START -> start()
@@ -382,14 +421,18 @@ private fun WhileStartedEffect(key: Any?, start: () -> Unit, stop: () -> Unit) {
}
}
-/** A large, straight clock fixed on the vertical centre of the touchpad. */
+/**
+ * A large, straight clock fixed on the vertical centre of the touchpad. The
+ * minute timer cannot run while the watch dozes, so the clock also resyncs
+ * on every ambient tick and on the way out of ambient: the first frame after
+ * a wake would otherwise show the minute the watch dozed off at.
+ */
@Composable
private fun StraightTime(modifier: Modifier = Modifier) {
- val context = LocalContext.current
var now by remember { mutableStateOf(System.currentTimeMillis()) }
- val pattern = remember(context) { if (DateFormat.is24HourFormat(context)) "HH:mm" else "h:mm" }
- val formatter = remember(pattern) { SimpleDateFormat(pattern, Locale.getDefault()) }
- LaunchedEffect(Unit) {
+ val formatter = rememberClockFormatter()
+ val ambient = LocalAmbientMode.current
+ LaunchedEffect(ambient.tick, ambient.active) {
while (true) {
val current = System.currentTimeMillis()
now = current
diff --git a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt
index a2fd515f..7cf837e4 100644
--- a/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt
+++ b/wear/app/src/main/kotlin/com/faceclaw/wear/ui/TouchpadGestures.kt
@@ -2,9 +2,10 @@ 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.AwaitPointerEventScope
import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerInputChange
import androidx.compose.ui.input.pointer.PointerInputScope
import androidx.compose.ui.input.pointer.positionChanged
import kotlin.math.abs
@@ -24,15 +25,51 @@ class TouchpadCallbacks(
val onSwipe: (start: Offset, dx: Float, dy: Float, durationMs: Long) -> Unit,
)
+/**
+ * A first tap the pad never saw: the touch that woke the display, which the
+ * system consumes. Armed by the pad on a wake; the next press inside the
+ * window is then the second tap of a pair (a double-tap, or tap-then-hold),
+ * and if no press comes the pad decides what a lone wake-tap meant. Main
+ * thread only.
+ */
+class PendingTap {
+ private var armedAt = -1L
+ private var windowMs = 0L
+
+ fun arm(uptimeMillis: Long, windowMs: Long) {
+ armedAt = uptimeMillis
+ this.windowMs = windowMs
+ }
+
+ fun disarm() {
+ armedAt = -1L
+ }
+
+ /** A press just landed: whether it pairs with the pending tap (which is spent either way). */
+ fun claim(downUptimeMillis: Long): Boolean {
+ val at = armedAt
+ armedAt = -1L
+ return at >= 0 && downUptimeMillis - at in 0..windowMs
+ }
+
+ /** The window closed: whether the tap was still pending (it is spent now). */
+ fun expire(): Boolean {
+ val pending = armedAt >= 0
+ armedAt = -1L
+ return pending
+ }
+}
+
/**
* 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), tap-then-hold (a
* second tap held past the long-press timeout), 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.
+ * detectors would each claim the same finger. A press that pairs with
+ * [pendingTap] skips straight to the second-tap handling.
*/
-suspend fun PointerInputScope.detectTouchpadGestures(callbacks: TouchpadCallbacks) {
+suspend fun PointerInputScope.detectTouchpadGestures(callbacks: TouchpadCallbacks, pendingTap: PendingTap) {
val longPressTimeout = viewConfiguration.longPressTimeoutMillis
val doubleTapTimeout = viewConfiguration.doubleTapTimeoutMillis
val slop = viewConfiguration.touchSlop
@@ -41,6 +78,10 @@ suspend fun PointerInputScope.detectTouchpadGestures(callbacks: TouchpadCallback
val down = awaitFirstDown()
down.consume()
val downTime = down.uptimeMillis
+ if (pendingTap.claim(downTime)) {
+ secondTap(callbacks, longPressTimeout, down.position, down)
+ return@awaitEachGesture
+ }
var maxPointers = 1
var moved = false
var longPressed = false
@@ -98,33 +139,7 @@ suspend fun PointerInputScope.detectTouchpadGestures(callbacks: TouchpadCallback
if (second == null) {
callbacks.onTap(down.position)
} else {
- second.consume()
- // Released within the long-press timeout it's a
- // double-tap; held past it, the G2 tap-then-hold
- // gesture (reported once at the timeout, movement
- // tolerated, the rest of the hold swallowed).
- var held = false
- while (true) {
- val remaining2 = if (held) {
- HOLD_POLL_MS
- } else {
- longPressTimeout - (System.currentTimeMillis() - wallClockAt(second.uptimeMillis))
- }
- val event2 = withTimeoutOrNull(remaining2.coerceAtLeast(1L)) { awaitPointerEvent() }
- if (event2 == null) {
- if (!held) {
- held = true
- callbacks.onShortThenLongPress()
- }
- continue
- }
- if (event2.changes.any { it.isConsumed }) break
- for (change in event2.changes) change.consume()
- if (event2.changes.none { it.pressed }) {
- if (!held) callbacks.onDoubleTap(down.position)
- break
- }
- }
+ secondTap(callbacks, longPressTimeout, down.position, second)
}
}
}
@@ -136,6 +151,42 @@ suspend fun PointerInputScope.detectTouchpadGestures(callbacks: TouchpadCallback
}
}
+/**
+ * The second press of a pair. Released within the long-press timeout it's a
+ * double-tap; held past it, the G2 tap-then-hold gesture (reported once at
+ * the timeout, movement tolerated, the rest of the hold swallowed).
+ */
+private suspend fun AwaitPointerEventScope.secondTap(
+ callbacks: TouchpadCallbacks,
+ longPressTimeout: Long,
+ first: Offset,
+ second: PointerInputChange,
+) {
+ second.consume()
+ var held = false
+ while (true) {
+ val remaining = if (held) {
+ HOLD_POLL_MS
+ } else {
+ longPressTimeout - (System.currentTimeMillis() - wallClockAt(second.uptimeMillis))
+ }
+ val event = withTimeoutOrNull(remaining.coerceAtLeast(1L)) { awaitPointerEvent() }
+ if (event == null) {
+ if (!held) {
+ held = true
+ callbacks.onShortThenLongPress()
+ }
+ continue
+ }
+ if (event.changes.any { it.isConsumed }) break
+ for (change in event.changes) change.consume()
+ if (event.changes.none { it.pressed }) {
+ if (!held) callbacks.onDoubleTap(first)
+ break
+ }
+ }
+}
+
/**
* Observe the button tray before its child buttons consume a pointer. A
* downward drag claims the gesture and dismisses the tray; a tap remains