Files
faceclaw/apple-watch/Faceclaw/PadGestureRecognizer.swift
T

144 lines
4.7 KiB
Swift

import CoreGraphics
import Foundation
/** What the remote's touch surface can report. */
enum PadEvent: Equatable {
/** A finger landed (the second tap of a pair included), before it's known what the touch will become. */
case press
case tap
case doubleTap
/** A tap whose immediate second press was held: the G2 tap-then-hold gesture. */
case shortThenLongPress
case longPressStart
case longPressEnd
/** The finger travelled past touch slop; dx/dy are the total displacement. */
case swipe(start: CGPoint, dx: CGFloat, dy: CGFloat)
}
/**
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) and a swipe. The same state
machine as wear/.../TouchpadGestures.kt, without its two-finger gestures:
SwiftUI on watchOS only ever sees one finger.
It has no clock of its own. The owner passes the time with each event and calls
`advance(to:)` once `deadline` passes, which is what makes it testable.
Every longPressStart is paired with a longPressEnd, whatever ends the touch:
the phone treats a start without a release as a hold still in progress.
*/
final class PadGestureRecognizer {
struct Timing {
var longPress: TimeInterval = 0.4
var doubleTap: TimeInterval = 0.3
var slop: CGFloat = 8
}
private enum Phase {
case idle
case firstTouch(start: CGPoint, moved: Bool)
case holding
case awaitingSecondTouch
case secondTouch(held: Bool)
}
private var phase = Phase.idle
private let timing: Timing
/** When `advance(to:)` next has something to do; nil when only a touch event can move things on. */
private(set) var deadline: TimeInterval?
var onEvent: (PadEvent) -> Void = { _ in }
init(timing: Timing = Timing()) {
self.timing = timing
}
/** A finger is on the pad, as far as this recognizer knows. */
var isTouching: Bool {
switch phase {
case .firstTouch, .holding, .secondTouch: return true
case .idle, .awaitingSecondTouch: return false
}
}
func touchDown(at location: CGPoint, time: TimeInterval) {
if isTouching { cancel() }
onEvent(.press)
if case .awaitingSecondTouch = phase {
phase = .secondTouch(held: false)
} else {
phase = .firstTouch(start: location, moved: false)
}
deadline = time + timing.longPress
}
func touchMoved(to location: CGPoint) {
guard case let .firstTouch(start, moved) = phase, !moved else { return }
if hypot(location.x - start.x, location.y - start.y) > timing.slop {
phase = .firstTouch(start: start, moved: true)
deadline = nil
}
}
func touchUp(at location: CGPoint, time: TimeInterval) {
switch phase {
case let .firstTouch(start, moved):
if moved {
reset()
onEvent(.swipe(start: start, dx: location.x - start.x, dy: location.y - start.y))
} else {
// A plain tap; give a second tap a chance to make it a double.
phase = .awaitingSecondTouch
deadline = time + timing.doubleTap
}
case .holding:
reset()
onEvent(.longPressEnd)
case let .secondTouch(held):
reset()
if !held { onEvent(.doubleTap) }
case .idle, .awaitingSecondTouch:
break
}
}
func advance(to time: TimeInterval) {
guard let deadline, time >= deadline else { return }
self.deadline = nil
switch phase {
case .firstTouch:
phase = .holding
onEvent(.longPressStart)
case .secondTouch:
phase = .secondTouch(held: true)
onEvent(.shortThenLongPress)
case .awaitingSecondTouch:
reset()
onEvent(.tap)
case .idle, .holding:
break
}
}
/**
The touch is over but no touch-up will come: the system took the gesture or
the wrist dropped. A touch in progress is dropped rather than mistaken for a
tap; a tap already completed and a hold already reported are both honoured.
*/
func cancel() {
let cancelled = phase
reset()
switch cancelled {
case .holding: onEvent(.longPressEnd)
case .awaitingSecondTouch: onEvent(.tap)
case .idle, .firstTouch, .secondTouch: break
}
}
private func reset() {
phase = .idle
deadline = nil
}
}