잠긴 폰으로 받는 회전 안내

public enum TurnAlertPolicy {
  /// Walks only: a driver should not be reading. Only the prepare and imminent
  /// stages (the early one is too far ahead to act on). Never while the phone
  /// app is on screen (Dad is looking at it), and never while the watch's own
  /// navigation session is live (the open watch app taps by itself; two taps
  /// for one turn is noise).
  public static func shouldAlert(
    stage: AnnouncementStage, isArrival: Bool, mode: TravelMode, appActive: Bool, watchLive: Bool, enabled: Bool
  ) -> Bool {
    guard enabled, mode == .walking, !appActive, !watchLive else { return false }
    return isArrival || stage >= .prepare
  }

  /// The turn ahead: its words as the title, how far as the body.
  func post(_ announcement: Announcement, distance: String) {
    guard let center else { return }
    let content = UNMutableNotificationContent()
    content.title =
      announcement.isArrival ? "Arriving" : InstructionChunker.readable(announcement.instruction)
    content.body = distance
    content.sound = .default
    content.threadIdentifier = Self.thread
    content.interruptionLevel = .active
    let id = "pathfinder.turn.\(announcement.stepIndex).\(announcement.stage.rawValue)"
    center.add(UNNotificationRequest(identifier: id, content: content, trigger: nil))
    // Only the turn ahead stays on the lock screen.
    let earlier = posted.filter { $0 != id }
    if !earlier.isEmpty { center.removeDeliveredNotifications(withIdentifiers: earlier) }
    posted = [id]
  }

import Foundation

// A minimal sketch: TurnAlertPolicy's two questions, copied from PathfinderKit,
// replayed against the kit's own test table.
enum Stage: Int, Comparable { case early, prepare, imminent
  static func < (a: Stage, b: Stage) -> Bool { a.rawValue < b.rawValue } }
enum Mode { case driving, walking }

let watchingTrust: TimeInterval = 75  // the watch says "live" every 30 s

func shouldAlert(stage: Stage, isArrival: Bool, mode: Mode, appActive: Bool, watchLive: Bool, enabled: Bool) -> Bool {
  guard enabled, mode == .walking, !appActive, !watchLive else { return false }
  return isArrival || stage >= .prepare
}

func watchLive(lastWatching: Date?, live: Bool, now: Date) -> Bool {
  guard live, let lastWatching else { return false }
  return now.timeIntervalSince(lastWatching) <= watchingTrust
}

func alert(_ stage: Stage, mode: Mode = .walking, active: Bool = false, watch: Bool = false, enabled: Bool = true) -> Bool {
  shouldAlert(stage: stage, isArrival: false, mode: mode, appActive: active, watchLive: watch, enabled: enabled)
}

let now = Date()
let rows: [(String, Bool)] = [
  ("prepare, app not on screen", alert(.prepare)),
  ("imminent", alert(.imminent)),
  ("early (too far ahead to act on)", alert(.early)),
  ("prepare, but driving", alert(.prepare, mode: .driving)),
  ("prepare, app on screen", alert(.prepare, active: true)),
  ("prepare, watch's own session live", alert(.prepare, watch: true)),
  ("prepare, switched off in Settings", alert(.prepare, enabled: false)),
  ("arrival on a walk", shouldAlert(stage: .early, isArrival: true, mode: .walking, appActive: false, watchLive: false, enabled: true)),
  ("watch said live 40 s ago", watchLive(lastWatching: now.addingTimeInterval(-40), live: true, now: now)),
  ("watch said live 90 s ago", watchLive(lastWatching: now.addingTimeInterval(-90), live: true, now: now)),
]
for (name, value) in rows { print(value ? "yes" : "no ", name) }

// Output:
// yes prepare, app not on screen
// yes imminent
// no  early (too far ahead to act on)
// no  prepare, but driving
// no  prepare, app on screen
// no  prepare, watch's own session live
// no  prepare, switched off in Settings
// yes arrival on a walk
// yes watch said live 40 s ago
// no  watch said live 90 s ago