Remove some prototype/unfinished features from the Watch app

Double twist gesture: I wasn't able to get this to trigger, and it
conflicted with a Wear OS builtin gesture.

Swipe left/right remapping: Some parts of the glasses UI are written to
assume that if you're using watch inputs, you have access to left/right
navigation, so letting these be remapped effectively broke them.

Tap zones: An interesting idea, but turned out to be bad UX in practice.
Swipe works much better because you're looking at the glasses screen,
not the watch, while using it.

Natural swipe toggle: Inverted swipe makes sense for touch scrolling,
but didn't make sense in this context.
This commit is contained in:
James Babcock committed 2026-09-01 23:18:38 -07:00
1 parent 984c65a90e
commit c7d4e7a630
8 files changed
+23 -314

No files matched your search

+1
View File
@@ -17,6 +17,7 @@ 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
* Remove a number of unfinished prototype features
## 0.6.3 - 2026-09-01
* Update custom firmware base version from 2.2.6 to 2.2.9
+3 -6
View File
@@ -14,12 +14,10 @@ the phone it only tells you to install it.
| 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. |
| 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. |
| rotate the crown | previous / next (one step per detent-ish, sensitivity adjustable) — clockwise is previous by default; reverse it in the on-glasses Settings > Watch section |
| 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 |
| **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 taps are ignored while the watch is off the wrist or buzzing. |
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
@@ -46,8 +44,7 @@ down beginning in the button tray to hide them.
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).
(haptics, keep screen on, 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
@@ -11,7 +11,7 @@ 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
* The motion-sensor gestures (tip taps) 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.
*/
@@ -13,20 +13,6 @@ enum class CrownSensitivity(val label: String, val pixelsPerStep: Float) {
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. */
@@ -37,13 +23,7 @@ data class Prefs(
* exactly when a remote wants to stay ready.
*/
val keepScreenOn: Boolean = true,
/** Swipe 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
@@ -51,9 +31,6 @@ data class Prefs(
*/
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) {
@@ -64,25 +41,13 @@ class WatchPrefs(context: Context) {
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) {
@@ -91,29 +56,17 @@ class WatchPrefs(context: Context) {
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"
}
}
@@ -1,137 +0,0 @@
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
}
}
@@ -18,7 +18,6 @@ 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
@@ -58,14 +57,13 @@ fun FaceclawWearApp(
ambient: StateFlow<AmbientMode>,
wakes: StateFlow<Wake?>,
) {
val prefs by prefsStore.prefs.collectAsStateWithLifecycle()
val ambientMode by ambient.collectAsStateWithLifecycle()
val navController = rememberSwipeDismissableNavController()
MaterialTheme(colors = FaceclawColors) {
CompositionLocalProvider(LocalAmbientMode provides ambientMode) {
Box(modifier = Modifier.fillMaxSize()) {
Screens(navController, link, prefs, prefsStore, haptics, wakes)
Screens(navController, link, prefsStore, haptics, wakes)
if (ambientMode.active) AmbientScreen(link = link, ambient = ambientMode)
}
}
@@ -76,13 +74,16 @@ fun FaceclawWearApp(
private fun Screens(
navController: NavHostController,
link: PhoneLink,
prefs: Prefs,
prefsStore: WatchPrefs,
haptics: Haptics,
wakes: StateFlow<Wake?>,
) {
// Prefs are collected inside each destination rather than passed in as a
// value: the nav host keeps the content lambda it composed, so a value
// captured by the builder would stay stale until the screen is re-entered.
SwipeDismissableNavHost(navController = navController, startDestination = Routes.REMOTE) {
composable(Routes.REMOTE) {
val prefs by prefsStore.prefs.collectAsStateWithLifecycle()
RemoteScreen(
link = link,
prefs = prefs,
@@ -103,6 +104,7 @@ private fun Screens(
StatusScreen(link = link, haptics = haptics, onOpenSettings = { navController.navigate(Routes.SETTINGS) })
}
composable(Routes.SETTINGS) {
val prefs by prefsStore.prefs.collectAsStateWithLifecycle()
SettingsScreen(prefs = prefs, store = prefsStore)
}
}
@@ -50,7 +50,6 @@ 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 com.faceclaw.wear.Command
import com.faceclaw.wear.FingerTapDetector
import com.faceclaw.wear.Gesture
import com.faceclaw.wear.Haptics
@@ -58,9 +57,7 @@ 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.Wake
import com.faceclaw.wear.WristTwistDetector
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.StateFlow
import java.util.Date
@@ -81,10 +78,10 @@ private const val SCREEN_ON_SECOND_TAP_WINDOW_MS = 600L
/**
* 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
* back as well, 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. An upward swipe that
* select / 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),
@@ -134,7 +131,7 @@ fun RemoteScreen(
onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
}
var crownAccumulator by remember { mutableStateOf(0f) }
// Pad height in px, for the tap zones; written by onSizeChanged, read by
// Pad height in px, for the edge-reveal zone; written by onSizeChanged, read by
// the gesture callbacks (plain holder: the callbacks are remembered once).
val padHeight = remember { floatArrayOf(1f) }
@@ -166,47 +163,15 @@ fun RemoteScreen(
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 -> {
val gesture = if (left) Gesture.SWIPE_LEFT else Gesture.SWIPE_RIGHT
if (gestureAllowed(gesture)) { haptics.click(); link.sendGesture(gesture) }
}
SwipeAction.SIDEBAR -> if (!glassesScreenIsOff()) {
haptics.click()
link.sendCommand(Command.SIDEBAR, "source" to "gesture")
}
SwipeAction.DOUBLE_CLICK -> doubleClick()
SwipeAction.CLICK -> click()
SwipeAction.LONG_PRESS -> if (!glassesScreenIsOff()) { haptics.heavy(); link.sendGesture(Gesture.LONG_PRESS) }
SwipeAction.WAKEWORD -> if (!glassesScreenIsOff()) { 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
/** A horizontal swipe is spatial input; the glasses UI decides what it means. */
fun navigate(left: Boolean) {
val gesture = if (left) Gesture.SWIPE_LEFT else Gesture.SWIPE_RIGHT
if (gestureAllowed(gesture)) { haptics.click(); link.sendGesture(gesture) }
}
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()
}
},
onTap = { _ -> click() },
onDoubleTap = { _ -> doubleClick() },
onShortThenLongPress = {
if (!glassesScreenIsOff()) { haptics.heavy(); link.sendGesture(Gesture.SHORT_THEN_LONG_PRESS) }
@@ -215,9 +180,9 @@ fun RemoteScreen(
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)
scroll(if (dy < 0) Gesture.SCROLL_UP else Gesture.SCROLL_DOWN, TWO_FINGER_SWIPE_STEPS)
} else {
perform(if (dx < 0) currentPrefs.swipeLeft else currentPrefs.swipeRight, left = dx < 0)
navigate(left = dx < 0)
}
},
onLongPressStart = {
@@ -252,10 +217,9 @@ fun RemoteScreen(
// 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)
scroll(if (up) Gesture.SWIPE_UP else Gesture.SWIPE_DOWN, 1)
scroll(if (dy < 0) Gesture.SWIPE_UP else Gesture.SWIPE_DOWN, 1)
}
else -> perform(if (dx < 0) currentPrefs.swipeLeft else currentPrefs.swipeRight, left = dx < 0)
else -> navigate(left = dx < 0)
}
},
)
@@ -294,18 +258,6 @@ fun RemoteScreen(
)
}
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) {
if (!wristTwistEnabled) null else WristTwistDetector(
context = view.context,
sensitivity = { currentPrefs.twistSensitivity },
quietUntil = { haptics.quietUntil() },
onBody = { onBody.onBody },
onDoubleTwist = { doubleClick() },
)
}
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).
@@ -50,44 +50,6 @@ fun SettingsScreen(prefs: Prefs, store: WatchPrefs) {
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(
@@ -117,27 +79,6 @@ fun SettingsScreen(prefs: Prefs, store: WatchPrefs) {
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(