rzen/workouts
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Rework the Apple Watch progress flow

Browse Source 
Watch root lists every in-progress workout; picking an exercise runs a paged Ready -> work/rest -> Finish flow (One More + auto-firing Done), with a phase-dot row and brand-tinted count-up/down timers. Includes the configurable rest and auto-finish settings synced over WatchConnectivity and the wrist-down timer fix.
This commit is contained in:
Rouslan Zenetl
2026-06-20 14:15:31 -04:00
parent f2da47a70a
commit f06c4e996e
9 changed files with 373 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Workouts Watch App/Views/ExerciseProgressView.swift
+256 -87
View File
@@ -8,16 +8,22 @@
import SwiftUI
import WatchKit
/// Runs a single exercise as a horizontally-paged HIIT cycle:
/// Runs a single exercise as a horizontally-paged flow:
///
/// Work₁ → Rest₁ → Work₂ → Rest₂ → … → Rest₍ₙ₋₁₎ → Workₙ
/// [Ready] → Work₁ → Rest₁ → Work₂ → … → Workₙ → Finish
///
/// The **work** phase counts *up* (a stopwatch for the current set); the user swipes
/// left when they're done. The **rest** phase counts *down* from the configurable rest
/// time, beeps once per second in the final three seconds, and then auto-advances to
/// the next work phase. The final work phase has no rest after it — instead it offers
/// **One More** (append a bonus set and keep going) and **Done** (mark the exercise
/// complete and return to the list).
/// A **Ready?** page leads in *only* when the exercise hasn't been started yet (a
/// resumed exercise jumps straight to its first unfinished set). The **work** phase
/// counts *up* (a stopwatch for the current set, tinted with the brand purple); the
/// user swipes left when they're done. The **rest** phase counts *down* from the
/// configurable rest time (light teal), beeps once per second in the final three
/// seconds, then auto-advances to the next work phase. Every work phase — including
/// the last — looks the same; sliding past the final set reaches a **Finish** page
/// offering **One More** (append a bonus set and keep going) and **Done** (which also
/// auto-fires after a configurable countdown, completing the exercise).
///
/// A row of phase dots tracks progress: purple for work, teal for rest, with the
/// current phase drawn as a wider dash.
struct ExerciseProgressView: View {
@Environment(\.dismiss) private var dismiss
@@ -35,8 +41,13 @@ struct ExerciseProgressView: View {
@State private var showingCancelConfirm = false
@State private var didRestorePage = false
/// Forces the starting page (used only by the DEBUG screenshot host to land on a
/// rest page). Always nil in normal use.
/// True when this run opens on the lead-in **Ready?** page (the exercise hadn't
/// been started). A resumed exercise — or the screenshot host — skips it. Constant
/// for the lifetime of the view, so all the page-index math below is stable.
private let showsReady: Bool
/// Forces the starting page (used only by the DEBUG screenshot host). When set it
/// also suppresses the Ready page so the index is a plain work/rest cycle offset.
private let debugInitialPage: Int?
init(doc: Binding<WorkoutDocument>, logID: String, onChange: @escaping () -> Void, debugInitialPage: Int? = nil) {
@@ -48,23 +59,45 @@ struct ExerciseProgressView: View {
let log = doc.wrappedValue.logs.first { $0.id == logID }
let sets = max(1, log?.sets ?? 1)
_setCount = State(initialValue: sets)
let notStarted = (log?.status ?? WorkoutStatus.notStarted.rawValue) == WorkoutStatus.notStarted.rawValue
let ready = debugInitialPage == nil && notStarted
self.showsReady = ready
let base = ready ? 1 : 0
// Resume on the first unfinished set's work page (clamped to the last set).
let completed = min(max(0, log?.currentStateIndex ?? 0), sets - 1)
_currentPage = State(initialValue: debugInitialPage ?? (completed * 2))
let resume = ready ? 0 : base + completed * 2
_currentPage = State(initialValue: debugInitialPage ?? resume)
}
private var log: WorkoutLogDocument? {
doc.logs.first { $0.id == logID }
}
/// Work₁, Rest₁, …, Workₙ ⇒ N sets + (N−1) rests = 2N − 1 pages.
private var totalPages: Int { setCount * 2 - 1 }
/// Offset of the work/rest cycle: `1` when a Ready page leads, else `0`.
private var base: Int { showsReady ? 1 : 0 }
/// The first unfinished set's work page (clamped to the last set). Resuming an
/// exercise opens here, skipping any completed work/rest pairs.
/// Work/rest pages: Work₁, Rest₁, …, Workₙ ⇒ N sets + (N−1) rests = 2N − 1.
private var cycleCount: Int { setCount * 2 - 1 }
/// Ready (`base`) + cycle (`2N − 1`) + Finish (`1`).
private var totalPages: Int { base + cycleCount + 1 }
/// The single Finish page sits just past the last work page.
private var finishIndex: Int { base + cycleCount }
/// The first unfinished set's work page (only used when resuming, so `base == 0`).
private var resumePage: Int {
let completed = min(max(0, log?.currentStateIndex ?? 0), setCount - 1)
return completed * 2
return base + completed * 2
}
/// Position within the work/rest cycle for the current page — `nil` on the Ready
/// and Finish pages (which show no dots).
private var currentCycleIndex: Int? {
let c = currentPage - base
return (0..<cycleCount).contains(c) ? c : nil
}
private var detail: String {
@@ -75,6 +108,12 @@ struct ExerciseProgressView: View {
return "\(log.reps) reps"
}
/// One-line plan summary for the Ready page, e.g. "4 sets × 8 reps".
private var readySummary: String {
let setsText = "\(setCount) set\(setCount == 1 ? "" : "s")"
return detail.isEmpty ? setsText : "\(setsText) × \(detail)"
}
var body: some View {
TabView(selection: $currentPage) {
ForEach(0..<totalPages, id: \.self) { index in
@@ -82,7 +121,13 @@ struct ExerciseProgressView: View {
.tag(index)
}
}
.tabViewStyle(.page)
.tabViewStyle(.page(indexDisplayMode: .never))
.overlay(alignment: .bottom) {
if let cycleIndex = currentCycleIndex {
PhaseProgressDots(count: cycleCount, currentIndex: cycleIndex)
.padding(.bottom, 2)
}
}
.toolbar {
ToolbarItem(placement: .cancellationAction) {
Button {
@@ -101,11 +146,11 @@ struct ExerciseProgressView: View {
}
.onAppear {
// Jump to the first unfinished set. A paged TabView can settle on page 0 on
// first layout, so re-assert once more after this run loop. (The screenshot
// host pins an explicit page, so skip the resume jump there.)
// first layout, so re-assert once more after this run loop. (The Ready page
// and the screenshot host both pin an explicit page, so skip the jump there.)
guard !didRestorePage else { return }
didRestorePage = true
if debugInitialPage == nil {
if !showsReady && debugInitialPage == nil {
jumpToResumePage()
Task { @MainActor in jumpToResumePage() }
}
@@ -125,27 +170,42 @@ struct ExerciseProgressView: View {
@ViewBuilder
private func page(for index: Int) -> some View {
let isActive = index == currentPage
if index.isMultiple(of: 2) {
// Work phase. The last page (set N) finishes the exercise.
WorkPhaseView(
setNumber: index / 2 + 1,
totalSets: setCount,
detail: detail,
isLast: index == totalPages - 1,
isActive: isActive,
onOneMore: addSet,
onDone: { completeExercise(); dismiss() }
)
if showsReady && index == 0 {
ReadyPhaseView(summary: readySummary, onStart: start)
} else {
// Rest phase. Auto-advances to the next work page when the timer hits zero.
RestPhaseView(isActive: isActive) {
withAnimation { advance(from: index) }
let cycleIndex = index - base
if cycleIndex == cycleCount {
// Finish page — confirm Done (auto-fires) or add One More.
FinishPhaseView(
isActive: isActive,
onDone: { completeExercise(); dismiss() },
onOneMore: addSet
)
} else if cycleIndex.isMultiple(of: 2) {
// Work phase.
WorkPhaseView(
setNumber: cycleIndex / 2 + 1,
totalSets: setCount,
detail: detail,
isActive: isActive
)
} else {
// Rest phase. Auto-advances to the next work page when the timer hits zero.
RestPhaseView(isActive: isActive) {
withAnimation { advance(from: index) }
}
}
}
}
// MARK: - Mutations
/// Leave the Ready page for the first work phase, marking the exercise started.
private func start() {
beginExercise()
withAnimation { currentPage = base }
}
/// Programmatically move one page right (used by the rest auto-advance), guarding
/// against overrun if the user swiped away in the meantime.
private func advance(from index: Int) {
@@ -153,15 +213,30 @@ struct ExerciseProgressView: View {
currentPage = index + 1
}
/// Append a bonus set: grow the plan, record the just-finished set as done, and
/// slide into the rest period that now follows the previously-final work page.
/// Flip a not-yet-started exercise to in-progress the moment the user taps Start.
private func beginExercise() {
guard let i = doc.logs.firstIndex(where: { $0.id == logID }) else { return }
guard doc.logs[i].status == WorkoutStatus.notStarted.rawValue else { return }
doc.logs[i].status = WorkoutStatus.inProgress.rawValue
recomputeWorkoutStatus()
doc.updatedAt = Date()
onChange()
}
/// Append a bonus set from the Finish page: mark every prior set done, grow the
/// plan, and slide forward into the bonus set's work phase.
///
/// Growing `setCount` and advancing `currentPage` in one animated transaction makes
/// the new work phase slide in from the right. (We land on work, not a rest, because
/// the Finish page's own auto-finish countdown already served as the between-set
/// breather — and the rest page would otherwise sit at the very index the Finish
/// page occupied, which a paged TabView can't animate to.)
private func addSet() {
let restPage = currentPage + 1 // the rest page that becomes valid after the bump
setCount += 1
let newCount = setCount + 1
if let i = doc.logs.firstIndex(where: { $0.id == logID }) {
doc.logs[i].sets = setCount
doc.logs[i].currentStateIndex = setCount - 1 // the old final set is complete
doc.logs[i].sets = newCount
doc.logs[i].currentStateIndex = newCount - 1 // every prior set is now complete
doc.logs[i].status = WorkoutStatus.inProgress.rawValue
doc.logs[i].completed = false
recomputeWorkoutStatus()
@@ -169,29 +244,29 @@ struct ExerciseProgressView: View {
onChange()
}
withAnimation { currentPage = restPage }
withAnimation {
setCount = newCount
currentPage += 1
}
}
/// Page index → completed-set count: Work₁(0)→0, Rest₁(1)→1, Work₂(2)→1, … —
/// i.e. `(pageIndex + 1) / 2`. Reaching set N as *completed* only happens via Done.
/// Map a page to completed-set count and record forward progress.
///
/// Progress is **monotonic**: completing a work phase advances the count (and
/// forwards it to the phone), but swiping back — or a transient TabView snap to
/// page 0 — never un-counts a finished set.
/// Paging tops out at `setCount − 1` completed sets — the final set is marked done
/// only by an explicit **Done** (`completeExercise`). Progress is **monotonic**:
/// completing a work phase advances the count (and forwards it to the phone), but
/// swiping back — or a transient TabView snap to page 0 — never un-counts a set.
private func recordProgress(for pageIndex: Int) {
let reached = min((pageIndex + 1) / 2, setCount)
if showsReady && pageIndex == 0 { return } // Ready page records nothing
let cycleIndex = pageIndex - base
let reached = min(max(0, (cycleIndex + 1) / 2), setCount - 1)
guard let i = doc.logs.firstIndex(where: { $0.id == logID }) else { return }
guard reached > doc.logs[i].currentStateIndex else { return }
doc.logs[i].currentStateIndex = reached
if reached >= setCount {
doc.logs[i].status = WorkoutStatus.completed.rawValue
doc.logs[i].completed = true
} else {
doc.logs[i].status = WorkoutStatus.inProgress.rawValue
doc.logs[i].completed = false
}
doc.logs[i].status = WorkoutStatus.inProgress.rawValue
doc.logs[i].completed = false
recomputeWorkoutStatus()
doc.updatedAt = Date()
@@ -238,16 +313,66 @@ struct ExerciseProgressView: View {
}
}
// MARK: - Phase Progress Dots
/// Compact progress row for the work/rest cycle: purple dots for work, teal for rest,
/// with the active phase drawn as a wider dash. Dots are deliberately a touch thick so
/// the count of remaining sets reads at a glance.
private struct PhaseProgressDots: View {
let count: Int
let currentIndex: Int
var body: some View {
HStack(spacing: 4) {
ForEach(0..<count, id: \.self) { i in
let isWork = i.isMultiple(of: 2)
let isCurrent = i == currentIndex
Capsule()
.fill(isWork ? Color.workTint : Color.restTint)
.frame(width: isCurrent ? 12 : 6, height: 6)
.opacity(isCurrent ? 1 : 0.45)
}
}
}
}
// MARK: - Ready Phase
private struct ReadyPhaseView: View {
let summary: String
let onStart: () -> Void
var body: some View {
VStack(spacing: 10) {
Text("Ready?")
.font(.system(size: 30, weight: .bold, design: .rounded))
if !summary.isEmpty {
Text(summary)
.font(.subheadline)
.foregroundStyle(.secondary)
}
Button(action: onStart) {
Label("Start", systemImage: "play.fill")
.frame(maxWidth: .infinity)
}
.buttonStyle(.borderedProminent)
.tint(.workTint)
.padding(.top, 4)
}
.padding(.horizontal)
.frame(maxWidth: .infinity, maxHeight: .infinity)
}
}
// MARK: - Work Phase
private struct WorkPhaseView: View {
let setNumber: Int
let totalSets: Int
let detail: String
let isLast: Bool
let isActive: Bool
let onOneMore: () -> Void
let onDone: () -> Void
/// Wall-clock anchor for the count-up stopwatch. Driving the display from a fixed
/// start date (rendered by SwiftUI's timer text) instead of incrementing a counter
@@ -257,38 +382,18 @@ private struct WorkPhaseView: View {
var body: some View {
VStack(spacing: 6) {
Text("Set \(setNumber) of \(totalSets)")
Text("\(setNumber) of \(totalSets)")
.font(.headline)
.foregroundStyle(.secondary)
Text(startDate, style: .timer)
.font(.system(size: 48, weight: .bold, design: .rounded))
.monospacedDigit()
.foregroundStyle(.green)
.foregroundStyle(Color.workTint)
Text(detail)
.font(.subheadline)
.foregroundStyle(.secondary)
if isLast {
VStack(spacing: 6) {
Button(action: onOneMore) {
Label("One More", systemImage: "plus")
.frame(maxWidth: .infinity)
}
.tint(.blue)
Button(action: onDone) {
Label("Done", systemImage: "checkmark")
.frame(maxWidth: .infinity)
}
.tint(.green)
}
.buttonStyle(.borderedProminent)
.padding(.top, 4)
} else {
Label("Swipe to rest", systemImage: "chevron.right")
.font(.caption2)
if !detail.isEmpty {
Text(detail)
.font(.subheadline)
.foregroundStyle(.secondary)
}
}
@@ -335,11 +440,7 @@ private struct RestPhaseView: View {
Text(timerInterval: startDate...endDate, countsDown: true)
.font(.system(size: 54, weight: .bold, design: .rounded))
.monospacedDigit()
.foregroundStyle(.orange)
Label("Swipe to skip", systemImage: "chevron.right")
.font(.caption2)
.foregroundStyle(.secondary)
.foregroundStyle(Color.restTint)
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
.onAppear { if isActive { start() } }
@@ -374,3 +475,71 @@ private struct RestPhaseView: View {
}
}
}
// MARK: - Finish Phase
/// Terminal page after the last set. **Done** completes the exercise and dismisses —
/// and fires automatically after a configurable countdown so the user doesn't have to
/// tap with sweaty hands. **One More** appends a bonus set instead.
private struct FinishPhaseView: View {
let isActive: Bool
let onDone: () -> Void
let onOneMore: () -> Void
@AppStorage("doneCountdownSeconds") private var doneCountdownSeconds: Int = 5
/// Wall-clock deadline for the auto-Done (same Always-On rationale as the rest
/// timer). `remaining` is what the Done button shows.
@State private var endDate = Date()
@State private var remaining = 0
/// Fires the auto-Done exactly once, and latches off while the page isn't active.
@State private var didFire = false
private let ticker = Timer.publish(every: 0.25, on: .main, in: .common).autoconnect()
var body: some View {
VStack(spacing: 8) {
Text("Finished!")
.font(.headline)
.foregroundStyle(.secondary)
Button(action: fire) {
Label(remaining > 0 ? "Done · \(remaining)" : "Done", systemImage: "checkmark")
.frame(maxWidth: .infinity)
}
.buttonStyle(.borderedProminent)
.tint(Color.workTint)
Button(action: onOneMore) {
Label("One More", systemImage: "plus")
.frame(maxWidth: .infinity)
}
.buttonStyle(.bordered)
}
.padding(.horizontal)
.frame(maxWidth: .infinity, maxHeight: .infinity)
.onAppear { if isActive { start() } }
.onChange(of: isActive) { _, active in active ? start() : (didFire = true) }
.onReceive(ticker) { _ in tick() }
}
private func start() {
let total = max(1, doneCountdownSeconds)
endDate = Date().addingTimeInterval(Double(total))
remaining = total
didFire = false
}
private func tick() {
guard isActive, !didFire else { return }
let r = Int(ceil(endDate.timeIntervalSinceNow))
remaining = max(0, r)
if r <= 0 { fire() }
}
private func fire() {
guard !didFire else { return }
didFire = true
WKInterfaceDevice.current().play(.success)
onDone()
}
}