One Press, One Turn

// clients/apple/PippaMobile/Wrist/WristVoiceTurn.swift:60-98 (cwkPippa)
    mutating func begin() -> Int? {
        guard launch == nil, phase == .off || isStopped else { return nil }
        generation += 1
        launch = generation
        return generation
    }

    /// Whether this start is still the one under way (not stopped meanwhile).
    func stillStarting(_ token: Int) -> Bool {
        launch == token && token == generation
    }

    /// The start's audio is up: the microphone opens for this turn. False
    /// when the turn was stopped meanwhile; the start then opens nothing.
    mutating func audioUp(_ token: Int) -> Bool {
        guard stillStarting(token) else { return false }
        launch = nil
        pending = nil
        phoneReading = false
        phase = .listening
        return true
    }

    /// The start could not open the microphone (permission, audio session).
    mutating func startFailed(_ token: Int, _ reason: String) {
        guard stillStarting(token) else { return }
        launch = nil
        phase = .stopped(reason)
    }

    /// The utterance left for the phone: the microphone is closed for good
    /// in this turn, and the turn waits for her.
    @discardableResult
    mutating func sent(_ id: String) -> Bool {
        guard phase == .listening else { return false }
        pending = id
        phase = .thinking
        return true
    }

// clients/apple/PippaMobile/Wrist/WristVoiceTurn.swift:191-229 (cwkPippa)
    enum Tap: Equatable {
        /// He is talking: his turn goes now, without waiting for silence.
        case sendNow
        /// She is speaking on the watch: cut her off, and the turn is over.
        case cutOff
        /// The turn ended early: start the next one.
        case start
        case nothing
    }

    /// What a tap on the ring does now. Never "listen again": while the turn
    /// waits for her the ring does nothing, and Stop ends the turn.
    var tap: Tap {
        switch phase {
        case .listening: return .sendNow
        case .speaking: return .cutOff
        case .stopped: return .start
        case .off, .thinking: return .nothing
        }
    }

    /// Stop, Close, or leaving the app.
    mutating func stop() {
        end()
    }

    /// The turn ends early, with its reason on the screen.
    mutating func halt(_ reason: String) {
        end()
        phase = .stopped(reason)
    }

    private mutating func end() {
        generation += 1
        launch = nil
        pending = nil
        phoneReading = false
        phase = .off
    }

// A minimal sketch: the watch's old loop beside the one-press turn that replaced it.
enum Phase: Equatable { case off, listening, thinking, speaking }

enum Event: String { case press, sent, replyRead, voiceNearby, stop }

/// The loop: the end of every reply was a way back to the microphone.
func loop(_ phase: Phase, _ event: Event) -> (Phase, String) {
  switch (phase, event) {
  case (.off, .press): return (.listening, "mic open")
  case (.listening, .sent): return (.thinking, "sent; mic closed")
  case (.thinking, .replyRead): return (.listening, "listens again by itself")
  case (.listening, .voiceNearby): return (.thinking, "SENT someone else's words")
  case (_, .stop): return (.off, "off")
  default: return (phase, "nothing")
  }
}

/// The turn: only a press opens the microphone, and every end is off.
struct Turn {
  private(set) var phase: Phase = .off
  private var generation = 0
  private var launch: Int?

  /// A press asks for the mic; nil while a turn is already up or starting.
  mutating func begin() -> Int? {
    guard launch == nil, phase == .off else { return nil }
    generation += 1
    launch = generation
    return generation
  }

  /// The audio came up: open the mic only if this start still stands.
  mutating func audioUp(_ token: Int) -> Bool {
    guard launch == token, token == generation else { return false }
    launch = nil
    phase = .listening
    return true
  }

  mutating func handle(_ event: Event) -> String {
    switch (phase, event) {
    case (.listening, .sent): phase = .thinking; return "sent; mic closed"
    case (.thinking, .replyRead): end(); return "reply read; off, mic closed"
    case (.off, .voiceNearby): return "mic closed: nothing heard"
    case (_, .stop): end(); return "off"
    default: return "nothing"
    }
  }

  private mutating func end() {
    generation += 1  // voids any start still on its way
    launch = nil
    phase = .off
  }
}

func pad(_ s: String) -> String { s + String(repeating: " ", count: max(0, 12 - s.count)) }

var old = Phase.off
print("-- the loop")
for event in [Event.press, .sent, .replyRead, .voiceNearby] {
  let (next, said) = loop(old, event)
  old = next
  print("  \(pad(event.rawValue)) -> \(next)  (\(said))")
}

var turn = Turn()
print("-- the turn")
if let token = turn.begin(), turn.audioUp(token) { print("  press        -> \(turn.phase)  (mic open)") }
for event in [Event.sent, .replyRead, .voiceNearby] {
  let said = turn.handle(event)
  print("  \(pad(event.rawValue)) -> \(turn.phase)  (\(said))")
}

print("-- a press, then Stop before the audio came up")
if let token = turn.begin() {
  _ = turn.handle(.stop)
  print("  audio up after Stop opens the mic? \(turn.audioUp(token)) -> \(turn.phase)")
}

// Output:
// -- the loop
//   press        -> listening  (mic open)
//   sent         -> thinking  (sent; mic closed)
//   replyRead    -> listening  (listens again by itself)
//   voiceNearby  -> thinking  (SENT someone else's words)
// -- the turn
//   press        -> listening  (mic open)
//   sent         -> thinking  (sent; mic closed)
//   replyRead    -> off  (reply read; off, mic closed)
//   voiceNearby  -> off  (mic closed: nothing heard)
// -- a press, then Stop before the audio came up
//   audio up after Stop opens the mic? false -> off