Health, Motion and Accessories

<!-- FieldNotes/FieldNotes.entitlements (excerpt) -->
<key>com.apple.developer.healthkit</key>
<true/>
<key>com.apple.developer.healthkit.access</key>
<array/>

<!-- FieldNotes/Info.plist (excerpt) -->
<key>NSHealthShareUsageDescription</key>
<string>FieldNotes reads your distance and heart rate to summarize field trips in your notes.</string>
<key>NSHealthUpdateUsageDescription</key>
<string>FieldNotes saves the hikes you record as workouts in Health.</string>

// FieldNotes/Health/FieldTripWorkoutSession+Authorization.swift
#if os(iOS) || os(watchOS)
import HealthKit

extension FieldTripWorkoutSession {
    static let shareTypes: Set<HKSampleType> = [
        HKObjectType.workoutType(),
        HKQuantityType(.distanceWalkingRunning),
        HKQuantityType(.activeEnergyBurned),
    ]
    static let readTypes: Set<HKObjectType> = [
        HKQuantityType(.distanceWalkingRunning),
        HKQuantityType(.activeEnergyBurned),
        HKQuantityType(.heartRate),
        HKQuantityType(.stepCount),
    ]

    /// Returns false on devices without Health data (for example, an iPad with iPadOS 16 or a Mac).
    func requestAuthorization() async throws -> Bool {
        guard HKHealthStore.isHealthDataAvailable() else { return false }
        try await healthStore.requestAuthorization(toShare: Self.shareTypes, read: Self.readTypes)
        return healthStore.authorizationStatus(for: HKObjectType.workoutType()) == .sharingAuthorized
    }
}
#endif

// FieldNotes/Health/HealthAccessRow.swift
#if os(iOS) || os(watchOS)
import SwiftUI
import HealthKit
import HealthKitUI

struct HealthAccessRow: View {
    let healthStore: HKHealthStore
    @State private var requestTrigger = false
    @State private var isRequested = false

    var body: some View {
        Button(isRequested ? "Health Access Requested" : "Connect to Health", systemImage: "heart.text.square") {
            requestTrigger.toggle()
        }
        .disabled(isRequested || !HKHealthStore.isHealthDataAvailable())
        .healthDataAccessRequest(store: healthStore,
                                 shareTypes: FieldTripWorkoutSession.shareTypes,
                                 readTypes: FieldTripWorkoutSession.readTypes,
                                 trigger: requestTrigger) { result in
            Task { @MainActor in isRequested = (try? result.get()) ?? false }
        }
    }
}
#endif

// FieldNotes/Health/HealthSummaries.swift
#if os(iOS) || os(watchOS) || os(visionOS)
import HealthKit

enum HealthSummaries {
    static func stepsToday(in store: HKHealthStore) async throws -> Int {
        let startOfDay = Calendar.current.startOfDay(for: .now)
        let today = HKQuery.predicateForSamples(withStart: startOfDay, end: .now)
        let descriptor = HKStatisticsQueryDescriptor(
            predicate: .quantitySample(type: HKQuantityType(.stepCount), predicate: today),
            options: .cumulativeSum)
        let statistics = try await descriptor.result(for: store)
        return Int(statistics?.sumQuantity()?.doubleValue(for: .count()) ?? 0)
    }
}
#endif

// FieldNotes/Health/FieldTripWorkoutSession.swift
#if os(iOS) || os(watchOS)
import HealthKit
import Observation

@Observable
@MainActor
final class FieldTripWorkoutSession: NSObject {
    enum State: Equatable { case idle, running, paused, ended }

    private(set) var state: State = .idle
    private(set) var distanceMeters: Double = 0
    private(set) var activeKilocalories: Double = 0
    private(set) var heartRate: Double?
    private(set) var heartRateZone: Int?   // set on 27 and later

    @ObservationIgnored let healthStore = HKHealthStore()
    @ObservationIgnored private var session: HKWorkoutSession?
    @ObservationIgnored private var builder: HKLiveWorkoutBuilder?

    var startDate: Date? { builder?.startDate }

    func start() async throws {
        let configuration = HKWorkoutConfiguration()
        configuration.activityType = .hiking
        configuration.locationType = .outdoor

        let session = try HKWorkoutSession(healthStore: healthStore, configuration: configuration)
        let builder = session.associatedWorkoutBuilder()
        builder.dataSource = HKLiveWorkoutDataSource(healthStore: healthStore,
                                                     workoutConfiguration: configuration)
        session.delegate = self
        builder.delegate = self
        self.session = session
        self.builder = builder

        let startDate = Date.now
        session.startActivity(with: startDate)
        try await builder.beginCollection(at: startDate)
    }

    func pause() { session?.pause() }
    func resume() { session?.resume() }

    /// Stops collecting, saves the workout to Health and returns it.
    func finish() async throws -> HKWorkout? {
        guard let session, let builder else { return nil }
        let endDate = Date.now
        session.stopActivity(with: endDate)
        try await builder.endCollection(at: endDate)
        let workout = try await builder.finishWorkout()
        session.end()
        return workout
    }
}

extension FieldTripWorkoutSession: HKWorkoutSessionDelegate {
    nonisolated func workoutSession(_ workoutSession: HKWorkoutSession, didChangeTo toState: HKWorkoutSessionState,
                                    from fromState: HKWorkoutSessionState, date: Date) {
        let newState: State? = switch toState {
        case .running: .running
        case .paused: .paused
        case .ended: .ended
        default: nil
        }
        guard let newState else { return }
        Task { @MainActor in self.state = newState }
    }

    nonisolated func workoutSession(_ workoutSession: HKWorkoutSession, didFailWithError error: any Error) {
        Task { @MainActor in self.state = .idle }
    }
}

extension FieldTripWorkoutSession: HKLiveWorkoutBuilderDelegate {
    nonisolated func workoutBuilderDidCollectEvent(_ workoutBuilder: HKLiveWorkoutBuilder) {}

    // New in 27: called when the user moves into another zone (see Workout Zones below).
    @available(iOS 27, watchOS 27, *)
    nonisolated func workoutBuilder(_ workoutBuilder: HKLiveWorkoutBuilder,
                                    didUpdateWorkoutZone zoneUpdate: HKLiveWorkoutZoneUpdate) {
        let zoneIndex = zoneUpdate.currentZoneDuration?.zone.index
        Task { @MainActor in self.heartRateZone = zoneIndex }
    }

    nonisolated func workoutBuilder(_ workoutBuilder: HKLiveWorkoutBuilder,
                                    didCollectDataOf collectedTypes: Set<HKSampleType>) {
        // Read the statistics here, on HealthKit's queue, and send only Doubles to the main actor.
        let distance = workoutBuilder.statistics(for: HKQuantityType(.distanceWalkingRunning))?
            .sumQuantity()?.doubleValue(for: .meter())
        let energy = workoutBuilder.statistics(for: HKQuantityType(.activeEnergyBurned))?
            .sumQuantity()?.doubleValue(for: .kilocalorie())
        let bpm = workoutBuilder.statistics(for: HKQuantityType(.heartRate))?
            .mostRecentQuantity()?.doubleValue(for: .count().unitDivided(by: .minute()))
        Task { @MainActor in
            if let distance { self.distanceMeters = distance }
            if let energy { self.activeKilocalories = energy }
            self.heartRate = bpm
        }
    }
}
#endif

// FieldNotes/Health/FieldTripView.swift
#if os(iOS) || os(watchOS)
import SwiftUI
import FieldNotesModel
import FieldNotesServices

struct FieldTripView: View {
    @Environment(NoteStore.self) private var store
    @State private var workout = FieldTripWorkoutSession()
    @State private var errorMessage: String?

    var body: some View {
        Form {
            LabeledContent("Distance",
                           value: Measurement(value: workout.distanceMeters, unit: UnitLength.meters),
                           format: .measurement(width: .abbreviated, usage: .road))
            LabeledContent("Energy", value: workout.activeKilocalories, format: .number.precision(.fractionLength(0)))
            if let heartRate = workout.heartRate {
                LabeledContent("Heart Rate", value: "\(Int(heartRate)) BPM")
            }
            if let zone = workout.heartRateZone {
                LabeledContent("Zone", value: zone + 1, format: .number)
            }
            switch workout.state {
            case .idle, .ended:
                Button("Start Field Trip", systemImage: "figure.hiking") { Task { await start() } }
            case .running:
                Button("Pause", systemImage: "pause.fill") { workout.pause() }
                Button("Finish", systemImage: "stop.fill", role: .destructive) { Task { await finish() } }
            case .paused:
                Button("Resume", systemImage: "play.fill") { workout.resume() }
            }
        }
        .alert("Health Unavailable", isPresented: Binding(get: { errorMessage != nil },
                                                          set: { if !$0 { errorMessage = nil } })) {
            Button("OK") {}
        } message: {
            Text(errorMessage ?? "")
        }
    }

    private func start() async {
        do {
            guard try await workout.requestAuthorization() else {
                errorMessage = "Allow FieldNotes to save workouts in Settings > Health."
                return
            }
            try await workout.start()
        } catch {
            errorMessage = error.localizedDescription
        }
    }

    private func finish() async {
        guard let hike = try? await workout.finish() else { return }
        let kilometers = (hike.totalDistance?.doubleValue(for: .meterUnit(with: .kilo)) ?? 0)
        store.add(Note(title: "Field trip",
                       body: "Hiked \(kilometers.formatted(.number.precision(.fractionLength(1)))) km " +
                             "in \(Duration.seconds(hike.duration).formatted(.time(pattern: .hourMinute))).",
                       tags: ["field-trip"]))
    }
}

#Preview {
    FieldTripView()
        .environment(NoteStore())
}
#endif

// FieldNotes/Health/FieldTripWorkoutSession+Zones.swift
#if os(iOS) || os(watchOS)
import HealthKit

// The live zone callback, workoutBuilder(_:didUpdateWorkoutZone:), is in the HKLiveWorkoutBuilderDelegate
// extension above, next to the other delegate methods, so the Objective-C optional requirement is matched.
extension FieldTripWorkoutSession {
    /// The user's heart-rate zones from Health settings, lowest first.
    @available(iOS 27, watchOS 27, *)
    func preferredHeartRateZones() async throws -> [HKWorkoutZone] {
        let configuration = try await healthStore.preferredWorkoutZoneConfiguration(for: HKQuantityType(.heartRate))
        return configuration?.zones ?? []
    }

    /// Minutes spent in each heart-rate zone of a finished hike, for the note's summary.
    @available(iOS 27, watchOS 27, *)
    static func minutesInZones(of workout: HKWorkout) -> [(zone: Int, minutes: Double)] {
        guard let group = workout.zoneGroup(for: HKQuantityType(.heartRate)) else { return [] }
        return group.zoneDurations.map { (zone: $0.zone.index + 1, minutes: $0.duration / 60) }
    }
}
#endif

// FieldNotes/Motion/StepCounter.swift
#if os(iOS) || os(watchOS)
import CoreMotion
import Observation

@Observable
@MainActor
final class StepCounter {
    private(set) var steps = 0
    private(set) var meters: Double?
    let isAvailable = CMPedometer.isStepCountingAvailable()
    @ObservationIgnored private let pedometer = CMPedometer()

    func start(from startDate: Date) {
        guard isAvailable, CMPedometer.authorizationStatus() != .denied else { return }
        pedometer.startUpdates(from: startDate) { @Sendable data, error in
            guard let data, error == nil else { return }
            let steps = data.numberOfSteps.intValue
            let meters = data.distance?.doubleValue
            Task { @MainActor in
                self.steps = steps
                self.meters = meters
            }
        }
    }

    func stop() {
        pedometer.stopUpdates()
    }

    /// Steps in a past range, from the coprocessor's history (about seven days).
    func steps(from start: Date, to end: Date) async throws -> Int {
        try await withCheckedThrowingContinuation { continuation in
            pedometer.queryPedometerData(from: start, to: end) { @Sendable data, error in
                if let error {
                    continuation.resume(throwing: error)
                } else {
                    continuation.resume(returning: data?.numberOfSteps.intValue ?? 0)
                }
            }
        }
    }
}
#endif

// FieldNotes/Views/NoteEditor.swift (excerpt)
#if os(iOS) || os(watchOS)
@State private var stepCounter = StepCounter()

var stepsRow: some View {
    LabeledContent("Steps Since Opening", value: stepCounter.steps, format: .number)
        .opacity(stepCounter.isAvailable ? 1 : 0)
        .onAppear { stepCounter.start(from: .now) }
        .onDisappear { stepCounter.stop() }
}
#endif

// FieldNotes/Motion/DeviceLevel.swift
#if os(iOS) || os(watchOS) || os(visionOS)
import CoreMotion
import Observation

@Observable
@MainActor
final class DeviceLevel {
    static let shared = DeviceLevel()
    private(set) var pitchDegrees: Double = 0
    private(set) var rollDegrees: Double = 0
    @ObservationIgnored private let manager = CMMotionManager()

    var isLevel: Bool { abs(pitchDegrees) < 2 && abs(rollDegrees) < 2 }

    func start() {
        guard manager.isDeviceMotionAvailable, !manager.isDeviceMotionActive else { return }
        manager.deviceMotionUpdateInterval = 1.0 / 30.0
        // Deliver on the main queue, which is the main actor, so the handler can update state directly.
        manager.startDeviceMotionUpdates(to: .main) { motion, _ in
            guard let attitude = motion?.attitude else { return }
            self.pitchDegrees = attitude.pitch * 180 / .pi
            self.rollDegrees = attitude.roll * 180 / .pi
        }
    }

    func stop() {
        manager.stopDeviceMotionUpdates()
    }
}
#endif

// FieldNotes/Motion/HeadphoneNodDetector.swift
#if os(iOS) || os(macOS) || os(watchOS)
import CoreMotion
import Observation

@Observable
@MainActor
final class HeadphoneNodDetector {
    private(set) var nodCount = 0
    @ObservationIgnored private let manager = CMHeadphoneMotionManager()
    @ObservationIgnored private var wasLookingDown = false

    func start() {
        guard manager.isDeviceMotionAvailable else { return }
        manager.startDeviceMotionUpdates(to: .main) { motion, _ in
            guard let pitch = motion?.attitude.pitch else { return }
            let isLookingDown = pitch < -0.35          // about 20 degrees down
            if self.wasLookingDown && !isLookingDown { self.nodCount += 1 }
            self.wasLookingDown = isLookingDown
        }
    }

    func stop() {
        manager.stopDeviceMotionUpdates()
    }
}
#endif