600 lines
19 KiB
Swift
600 lines
19 KiB
Swift
import Foundation
|
|
import SwiftUI
|
|
import HealthKit
|
|
import WatchKit
|
|
import WatchConnectivity
|
|
|
|
class WorkoutManager: NSObject, ObservableObject, HKLiveWorkoutBuilderDelegate {
|
|
@Published var isWorkoutActive = false
|
|
@Published var savedWorkouts: [StoredWorkout] = []
|
|
@Published var completedWorkouts: [StoredWorkout] = []
|
|
@Published var selectedWorkout: StoredWorkout?
|
|
@Published var currentSetIndex = 0
|
|
@Published var currentRep = 0
|
|
@Published var currentRepDistanceSwum: Int = 0
|
|
@Published var elapsedSeconds: TimeInterval = 0
|
|
@Published var heartRate: Double = 0
|
|
@Published var activeCalories: Double = 0
|
|
@Published var isResting = false
|
|
@Published var restTimeRemaining: TimeInterval = 0
|
|
@Published var workoutSummary: WorkoutSummary?
|
|
|
|
private var workoutTimer: Timer?
|
|
private var restTimer: Timer?
|
|
private var healthStore: HKHealthStore?
|
|
private var activeWorkout: HKWorkoutSession?
|
|
private var builder: HKWorkoutBuilder?
|
|
private var lapStartTime: Date?
|
|
private var completedLaps: [CompletedLap] = []
|
|
|
|
// Heart rate & calorie queries
|
|
private var heartRateQuery: HKObserverQuery?
|
|
private var calorieQuery: HKObserverQuery?
|
|
|
|
// Lap detection
|
|
@Published var lapDetected = false
|
|
@Published var healthKitAuthorized = false
|
|
@Published var isPaused = false
|
|
@Published var isWaterLockEnabled = false
|
|
|
|
// HealthKit lap tracking
|
|
private var currentStrokeCount: Double = 0
|
|
private var healthKitLapCount: Int = 0
|
|
|
|
private var waterLockCheckTimer: Timer?
|
|
|
|
override init() {
|
|
super.init()
|
|
healthStore = HKHealthStore()
|
|
requestHealthKitAuthorization()
|
|
}
|
|
|
|
private func requestHealthKitAuthorization() {
|
|
guard let healthStore = healthStore else { return }
|
|
let typesToRead: Set<HKObjectType> = [
|
|
HKQuantityType.quantityType(forIdentifier: .heartRate)!,
|
|
HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)!,
|
|
HKQuantityType.quantityType(forIdentifier: .swimmingStrokeCount)!,
|
|
HKQuantityType.quantityType(forIdentifier: .distanceSwimming)!,
|
|
HKObjectType.workoutType()
|
|
]
|
|
let typesToWrite: Set<HKSampleType> = [
|
|
HKObjectType.workoutType()
|
|
]
|
|
|
|
if healthStore.authorizationStatus(for: .workoutType()) == .sharingAuthorized {
|
|
DispatchQueue.main.async {
|
|
self.healthKitAuthorized = true
|
|
}
|
|
return
|
|
}
|
|
|
|
healthStore.requestAuthorization(toShare: typesToWrite, read: typesToRead) { [weak self] success, error in
|
|
if let error = error {
|
|
print("HealthKit authorization failed: \(error)")
|
|
}
|
|
DispatchQueue.main.async {
|
|
self?.healthKitAuthorized = success
|
|
print("HealthKit authorization: \(success)")
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Data Persistence
|
|
|
|
func loadSavedWorkouts() {
|
|
let defaults = UserDefaults.standard
|
|
|
|
if let data = defaults.data(forKey: "savedWorkouts"),
|
|
let workouts = try? JSONDecoder().decode([StoredWorkout].self, from: data) {
|
|
savedWorkouts = workouts
|
|
}
|
|
|
|
if let data = defaults.data(forKey: "completedWorkouts"),
|
|
let workouts = try? JSONDecoder().decode([StoredWorkout].self, from: data) {
|
|
completedWorkouts = workouts
|
|
}
|
|
}
|
|
|
|
func saveWorkoutsToStorage() {
|
|
let defaults = UserDefaults.standard
|
|
if let data = try? JSONEncoder().encode(savedWorkouts) {
|
|
defaults.set(data, forKey: "savedWorkouts")
|
|
}
|
|
if let data = try? JSONEncoder().encode(completedWorkouts) {
|
|
defaults.set(data, forKey: "completedWorkouts")
|
|
}
|
|
}
|
|
|
|
func addWorkoutFromPhone(_ plan: StoredWorkout) {
|
|
savedWorkouts.append(plan)
|
|
saveWorkoutsToStorage()
|
|
}
|
|
|
|
func deleteSavedWorkouts(at offsets: IndexSet) {
|
|
savedWorkouts.remove(atOffsets: offsets)
|
|
saveWorkoutsToStorage()
|
|
}
|
|
|
|
func deleteCompletedWorkouts(at offsets: IndexSet) {
|
|
let limited = Array(completedWorkouts.prefix(3))
|
|
for i in offsets {
|
|
if i < limited.count {
|
|
let id = limited[i].id
|
|
completedWorkouts.removeAll { $0.id == id }
|
|
}
|
|
}
|
|
saveWorkoutsToStorage()
|
|
}
|
|
|
|
// MARK: - Workout Selection
|
|
|
|
func selectWorkout(_ workout: StoredWorkout) {
|
|
selectedWorkout = workout
|
|
}
|
|
|
|
func dismissSummary() {
|
|
workoutSummary = nil
|
|
}
|
|
|
|
// MARK: - Workout Control
|
|
|
|
func startWorkout() {
|
|
guard selectedWorkout != nil else { return }
|
|
|
|
if !healthKitAuthorized {
|
|
print("HealthKit not authorized, requesting...")
|
|
requestHealthKitAuthorization()
|
|
return
|
|
}
|
|
|
|
isWorkoutActive = true
|
|
currentSetIndex = 0
|
|
currentRep = 0
|
|
elapsedSeconds = 0
|
|
activeCalories = 0
|
|
heartRate = 0
|
|
completedLaps = []
|
|
healthKitLapCount = 0
|
|
currentStrokeCount = 0
|
|
currentRepDistanceSwum = 0
|
|
|
|
startHealthKitWorkout(poolLength: selectedWorkout?.poolLength ?? 25)
|
|
startHeartRateQuery()
|
|
startCalorieQuery()
|
|
startTimer()
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
|
|
WKInterfaceDevice.current().enableWaterLock()
|
|
}
|
|
startWaterLockCheck()
|
|
WKInterfaceDevice.current().play(.start)
|
|
}
|
|
|
|
func pauseWorkout() {
|
|
workoutTimer?.invalidate()
|
|
stopHeartRateQuery()
|
|
stopCalorieQuery()
|
|
isPaused = true
|
|
WKInterfaceDevice.current().play(.notification)
|
|
}
|
|
|
|
func resumeWorkout() {
|
|
startTimer()
|
|
startHeartRateQuery()
|
|
startCalorieQuery()
|
|
isPaused = false
|
|
WKInterfaceDevice.current().play(.start)
|
|
}
|
|
|
|
func endWorkout() {
|
|
workoutTimer?.invalidate()
|
|
restTimer?.invalidate()
|
|
isWorkoutActive = false
|
|
|
|
stopWaterLockCheck()
|
|
stopHeartRateQuery()
|
|
stopCalorieQuery()
|
|
endHealthKitWorkout()
|
|
|
|
createWorkoutSummary()
|
|
syncCompletedWorkout()
|
|
WKInterfaceDevice.current().play(.success)
|
|
}
|
|
|
|
// MARK: - Water Lock Check
|
|
|
|
private func startWaterLockCheck() {
|
|
isWaterLockEnabled = WKInterfaceDevice.current().isWaterLockEnabled
|
|
waterLockCheckTimer = Timer.scheduledTimer(withTimeInterval: 1.5, repeats: true) { [weak self] _ in
|
|
DispatchQueue.main.async {
|
|
self?.isWaterLockEnabled = WKInterfaceDevice.current().isWaterLockEnabled
|
|
}
|
|
}
|
|
}
|
|
|
|
private func stopWaterLockCheck() {
|
|
waterLockCheckTimer?.invalidate()
|
|
waterLockCheckTimer = nil
|
|
isWaterLockEnabled = false
|
|
}
|
|
|
|
// MARK: - Workout Summary
|
|
|
|
private func createWorkoutSummary() {
|
|
let summary = WorkoutSummary(
|
|
duration: elapsedSeconds,
|
|
totalDistance: Int(totalDistanceSwum),
|
|
calories: Int(activeCalories),
|
|
laps: completedLaps
|
|
)
|
|
workoutSummary = summary
|
|
}
|
|
|
|
// MARK: - Lap Tracking
|
|
|
|
private func advanceToNextRep() {
|
|
guard let workout = selectedWorkout else { return }
|
|
let currentSet = workout.sets[currentSetIndex]
|
|
|
|
currentRepDistanceSwum = 0
|
|
|
|
if currentRep + 1 < currentSet.repCount {
|
|
currentRep += 1
|
|
lapStartTime = Date()
|
|
} else if currentSetIndex + 1 < workout.sets.count {
|
|
startRestPeriod()
|
|
} else {
|
|
endWorkout()
|
|
}
|
|
}
|
|
|
|
// MARK: - Rest Period
|
|
|
|
private func startRestPeriod() {
|
|
guard let workout = selectedWorkout else { return }
|
|
let currentSet = workout.sets[currentSetIndex]
|
|
|
|
guard currentSet.restType != "none", currentSet.restDuration > 0 else {
|
|
moveToNextSet()
|
|
return
|
|
}
|
|
|
|
isResting = true
|
|
restTimeRemaining = currentSet.restDuration
|
|
|
|
WKInterfaceDevice.current().play(.notification)
|
|
|
|
restTimer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
|
|
guard let self = self else { return }
|
|
self.restTimeRemaining -= 1
|
|
|
|
if self.restTimeRemaining <= 0 {
|
|
self.restTimer?.invalidate()
|
|
self.moveToNextSet()
|
|
}
|
|
}
|
|
}
|
|
|
|
private func moveToNextSet() {
|
|
isResting = false
|
|
currentSetIndex += 1
|
|
currentRep = 0
|
|
lapStartTime = Date()
|
|
|
|
if currentSetIndex >= (selectedWorkout?.sets.count ?? 0) {
|
|
endWorkout()
|
|
} else {
|
|
WKInterfaceDevice.current().play(.start)
|
|
}
|
|
}
|
|
|
|
// MARK: - Computed Stats
|
|
|
|
var totalDistanceSwum: Double {
|
|
var distance: Double = 0
|
|
for lap in completedLaps {
|
|
distance += Double(lap.distance)
|
|
}
|
|
return distance
|
|
}
|
|
|
|
var currentSetDistanceSwum: Double {
|
|
completedLaps
|
|
.filter { $0.setPosition == currentSetIndex + 1 }
|
|
.reduce(0) { $0 + Double($1.distance) }
|
|
}
|
|
|
|
var currentSetTotalDistance: Double {
|
|
guard let workout = selectedWorkout, currentSetIndex < workout.sets.count else { return 0 }
|
|
let set = workout.sets[currentSetIndex]
|
|
return Double(set.distancePerRep) * Double(set.repCount)
|
|
}
|
|
|
|
// MARK: - Heart Rate Query
|
|
|
|
private func startHeartRateQuery() {
|
|
guard let healthStore = healthStore else { return }
|
|
let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)!
|
|
|
|
heartRateQuery = HKObserverQuery(sampleType: heartRateType, predicate: nil) { [weak self] _, completionHandler, _ in
|
|
self?.fetchLatestHeartRate()
|
|
completionHandler()
|
|
}
|
|
|
|
if let query = heartRateQuery {
|
|
healthStore.execute(query)
|
|
healthStore.enableBackgroundDelivery(for: heartRateType, frequency: .immediate) { _, _ in }
|
|
}
|
|
}
|
|
|
|
private func stopHeartRateQuery() {
|
|
if let query = heartRateQuery {
|
|
healthStore?.stop(query)
|
|
heartRateQuery = nil
|
|
}
|
|
}
|
|
|
|
private func fetchLatestHeartRate() {
|
|
guard let healthStore = healthStore else { return }
|
|
let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)!
|
|
let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
|
|
|
|
let query = HKSampleQuery(sampleType: heartRateType, predicate: nil, limit: 1, sortDescriptors: [sortDescriptor]) { [weak self] _, samples, _ in
|
|
guard let sample = samples?.first as? HKQuantitySample else { return }
|
|
let heartRateUnit = HKUnit.count().unitDivided(by: .minute())
|
|
let value = sample.quantity.doubleValue(for: heartRateUnit)
|
|
|
|
DispatchQueue.main.async {
|
|
self?.heartRate = value
|
|
}
|
|
}
|
|
healthStore.execute(query)
|
|
}
|
|
|
|
// MARK: - Calorie Query
|
|
|
|
private func startCalorieQuery() {
|
|
guard let healthStore = healthStore else { return }
|
|
let calorieType = HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)!
|
|
|
|
calorieQuery = HKObserverQuery(sampleType: calorieType, predicate: nil) { [weak self] _, completionHandler, _ in
|
|
self?.fetchActiveCalories()
|
|
completionHandler()
|
|
}
|
|
|
|
if let query = calorieQuery {
|
|
healthStore.execute(query)
|
|
healthStore.enableBackgroundDelivery(for: calorieType, frequency: .immediate) { _, _ in }
|
|
}
|
|
}
|
|
|
|
private func stopCalorieQuery() {
|
|
if let query = calorieQuery {
|
|
healthStore?.stop(query)
|
|
calorieQuery = nil
|
|
}
|
|
}
|
|
|
|
private func fetchActiveCalories() {
|
|
guard let healthStore = healthStore else { return }
|
|
let calorieType = HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)!
|
|
let now = Date()
|
|
|
|
let predicate = HKQuery.predicateForSamples(withStart: now.addingTimeInterval(-elapsedSeconds), end: now, options: .strictStartDate)
|
|
|
|
let query = HKStatisticsQuery(quantityType: calorieType, quantitySamplePredicate: predicate, options: .cumulativeSum) { [weak self] _, result, _ in
|
|
guard let sum = result?.sumQuantity() else { return }
|
|
let calories = sum.doubleValue(for: HKUnit.kilocalorie())
|
|
|
|
DispatchQueue.main.async {
|
|
self?.activeCalories = calories
|
|
}
|
|
}
|
|
healthStore.execute(query)
|
|
}
|
|
|
|
// MARK: - Lap Detection (HealthKit-based)
|
|
|
|
// Lap detection is now handled by HKLiveWorkoutBuilderDelegate
|
|
// which processes HKWorkoutEvent.lap events from HealthKit's
|
|
// built-in swimming lap detection algorithm.
|
|
|
|
// MARK: - Timer
|
|
|
|
private func startTimer() {
|
|
lapStartTime = Date()
|
|
workoutTimer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
|
|
self?.elapsedSeconds += 1
|
|
}
|
|
}
|
|
|
|
// MARK: - HealthKit
|
|
|
|
private func startHealthKitWorkout(poolLength: Double) {
|
|
guard let healthStore = healthStore else { return }
|
|
|
|
let config = HKWorkoutConfiguration()
|
|
config.activityType = .swimming
|
|
config.locationType = .indoor
|
|
config.swimmingLocationType = .pool
|
|
config.lapLength = HKQuantity(unit: .meter(), doubleValue: poolLength)
|
|
|
|
do {
|
|
activeWorkout = try HKWorkoutSession(healthStore: healthStore, configuration: config)
|
|
let workoutBuilder = activeWorkout!.associatedWorkoutBuilder()
|
|
workoutBuilder.delegate = self
|
|
self.builder = workoutBuilder
|
|
activeWorkout?.startActivity(with: Date())
|
|
workoutBuilder.beginCollection(withStart: Date()) { success, error in
|
|
if let error = error {
|
|
print("Failed to begin collection: \(error)")
|
|
}
|
|
}
|
|
} catch {
|
|
print("Failed to start HealthKit workout: \(error)")
|
|
}
|
|
}
|
|
|
|
private func endHealthKitWorkout() {
|
|
activeWorkout?.end()
|
|
builder?.endCollection(withEnd: Date()) { [weak self] success, error in
|
|
if let error = error {
|
|
print("Failed to end collection: \(error)")
|
|
}
|
|
self?.builder?.finishWorkout { _, _ in }
|
|
}
|
|
}
|
|
|
|
// MARK: - HKLiveWorkoutBuilderDelegate
|
|
|
|
func workoutBuilder(_ workoutBuilder: HKLiveWorkoutBuilder, didCollectDataOf collectedTypes: Set<HKSampleType>) {
|
|
for type in collectedTypes {
|
|
guard let quantityType = type as? HKQuantityType else { continue }
|
|
|
|
if let statistics = workoutBuilder.statistics(for: quantityType) {
|
|
DispatchQueue.main.async {
|
|
switch quantityType {
|
|
case HKQuantityType.quantityType(forIdentifier: .heartRate):
|
|
let heartRateUnit = HKUnit.count().unitDivided(by: .minute())
|
|
self.heartRate = statistics.mostRecentQuantity()?.doubleValue(for: heartRateUnit) ?? 0
|
|
case HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned):
|
|
self.activeCalories = statistics.sumQuantity()?.doubleValue(for: .kilocalorie()) ?? 0
|
|
case HKQuantityType.quantityType(forIdentifier: .swimmingStrokeCount):
|
|
self.currentStrokeCount = statistics.sumQuantity()?.doubleValue(for: .count()) ?? 0
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func workoutBuilderDidCollectEvent(_ workoutBuilder: HKLiveWorkoutBuilder) {
|
|
guard let events = workoutBuilder.workoutEvents as? [HKWorkoutEvent] else { return }
|
|
|
|
let lapEvents = events.filter { $0.type == .lap }
|
|
let newLapCount = lapEvents.count
|
|
|
|
if newLapCount > healthKitLapCount {
|
|
let lapsDelta = newLapCount - healthKitLapCount
|
|
healthKitLapCount = newLapCount
|
|
|
|
for _ in 0..<lapsDelta {
|
|
DispatchQueue.main.async {
|
|
self.completeLapFromHealthKit()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func completeLapFromHealthKit() {
|
|
guard let workout = selectedWorkout else { return }
|
|
|
|
let now = Date()
|
|
let duration = lapStartTime.map { now.timeIntervalSince($0) } ?? 0
|
|
let lapDistance = Int(workout.poolLength)
|
|
|
|
let lap = CompletedLap(
|
|
setPosition: currentSetIndex + 1,
|
|
repNumber: currentRep + 1,
|
|
distance: lapDistance,
|
|
duration: duration,
|
|
heartRate: Int(heartRate),
|
|
strokeType: workout.sets[currentSetIndex].stroke,
|
|
strokeCount: Int(currentStrokeCount)
|
|
)
|
|
completedLaps.append(lap)
|
|
currentStrokeCount = 0
|
|
|
|
currentRepDistanceSwum += lapDistance
|
|
|
|
WKInterfaceDevice.current().play(.click)
|
|
|
|
DispatchQueue.main.async {
|
|
self.lapDetected = true
|
|
}
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
|
|
self.lapDetected = false
|
|
}
|
|
|
|
if currentRepDistanceSwum >= workout.sets[currentSetIndex].distancePerRep {
|
|
advanceToNextRep()
|
|
}
|
|
lapStartTime = Date()
|
|
}
|
|
|
|
// MARK: - Sync to Phone
|
|
|
|
private func syncCompletedWorkout() {
|
|
let workoutSummary: [String: Any] = [
|
|
"type": "workoutCompleted",
|
|
"workoutId": selectedWorkout?.id ?? "",
|
|
"name": selectedWorkout?.name ?? "Workout",
|
|
"poolLength": selectedWorkout?.poolLength ?? 0,
|
|
"laps": completedLaps.map { lap in
|
|
[
|
|
"setPosition": lap.setPosition,
|
|
"repNumber": lap.repNumber,
|
|
"distance": lap.distance,
|
|
"duration": lap.duration,
|
|
"heartRate": lap.heartRate ?? 0,
|
|
"strokeType": lap.strokeType ?? "",
|
|
"strokeCount": lap.strokeCount ?? 0,
|
|
] as [String: Any]
|
|
},
|
|
"duration": elapsedSeconds,
|
|
"totalDistance": Int(totalDistanceSwum),
|
|
"calories": Int(activeCalories),
|
|
]
|
|
|
|
var completed = completedWorkouts
|
|
var summary = selectedWorkout
|
|
summary?.completedAt = ISO8601DateFormatter().string(from: Date())
|
|
if let s = summary {
|
|
completed.insert(s, at: 0)
|
|
}
|
|
if let data = try? JSONEncoder().encode(completed) {
|
|
UserDefaults.standard.set(data, forKey: "completedWorkouts")
|
|
}
|
|
|
|
// Always use transferUserInfo for reliable delivery
|
|
WCSession.default.transferUserInfo(workoutSummary)
|
|
print("[WorkoutManager] Synced completed workout to phone")
|
|
}
|
|
}
|
|
|
|
// MARK: - Models
|
|
|
|
struct StoredWorkout: Codable, Identifiable {
|
|
let id: String
|
|
let name: String?
|
|
let poolLength: Double
|
|
let sets: [StoredSet]
|
|
var completedAt: String?
|
|
}
|
|
|
|
struct StoredSet: Codable {
|
|
let stroke: String
|
|
let distancePerRep: Int
|
|
let repCount: Int
|
|
let restType: String
|
|
let restDuration: TimeInterval
|
|
}
|
|
|
|
struct CompletedLap {
|
|
let setPosition: Int
|
|
let repNumber: Int
|
|
let distance: Int
|
|
let duration: TimeInterval
|
|
let heartRate: Int?
|
|
let strokeType: String?
|
|
let strokeCount: Int?
|
|
}
|
|
|
|
struct WorkoutSummary {
|
|
let duration: TimeInterval
|
|
let totalDistance: Int
|
|
let calories: Int
|
|
let laps: [CompletedLap]
|
|
}
|