mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
Watch app uses ambient mode, looks correct when idle, doesn't lose taps when woken
This commit is contained in:
1 parent
fddb6ea886
commit
984c65a90e
12 files changed
+518
-73
No files matched your search
@@ -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
|
||||
|
||||
+17
-2
@@ -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,
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
<uses-feature android:name="android.hardware.type.watch" />
|
||||
|
||||
<uses-permission android:name="android.permission.VIBRATE" />
|
||||
<!-- Required by AmbientLifecycleObserver (always-on display support). -->
|
||||
<uses-permission android:name="android.permission.WAKE_LOCK" />
|
||||
|
||||
<!-- Not standalone: the watch app is a remote for Faceclaw on the phone
|
||||
and does nothing useful without it. -->
|
||||
|
||||
@@ -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,
|
||||
)
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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<Wake?>(null)
|
||||
/** The latest wake, or null once it was attributed to a wrist raise. */
|
||||
val wakes: StateFlow<Wake?> = _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
|
||||
}
|
||||
}
|
||||
@@ -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),
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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<AmbientMode>,
|
||||
wakes: StateFlow<Wake?>,
|
||||
) {
|
||||
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<Wake?>,
|
||||
) {
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<Wake?>,
|
||||
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
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in new issue
Block a user