HealthKit ile Sağlık ve Fitness Uygulamaları Geliştirme

1import HealthKit
2 
3class HealthKitManager {
4    let healthStore = HKHealthStore()
5 
6    // Okuma ve yazma izinleri
7    func requestAuthorization() async throws {
8        guard HKHealthStore.isHealthDataAvailable() else {
9            throw HealthError.notAvailable
10        }
11 
12        let readTypes: Set<HKObjectType> = [
13            HKQuantityType(.stepCount),
14            HKQuantityType(.heartRate),
15            HKQuantityType(.activeEnergyBurned),
16            HKQuantityType(.distanceWalkingRunning),
17            HKCategoryType(.sleepAnalysis),
18            HKQuantityType(.bodyMass),
19        ]
20 
21        let writeTypes: Set<HKSampleType> = [
22            HKQuantityType(.stepCount),
23            HKQuantityType(.activeEnergyBurned),
24            HKQuantityType(.bodyMass),
25        ]
26 
27        try await healthStore.requestAuthorization(toShare: writeTypes, read: readTypes)
28    }
29}

1// Bugünün adım sayısı
2func getTodaySteps() async throws -> Double {
3    let stepType = HKQuantityType(.stepCount)
4    let now = Date()
5    let startOfDay = Calendar.current.startOfDay(for: now)
6    let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: now)
7 
8    let statistics = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<HKStatistics, Error>) in
9        let query = HKStatisticsQuery(
10            quantityType: stepType,
11            quantitySamplePredicate: predicate,
12            options: .cumulativeSum
13        ) { _, statistics, error in
14            if let error { continuation.resume(throwing: error) }
15            else if let statistics { continuation.resume(returning: statistics) }
16            else { continuation.resume(throwing: HealthError.noData) }
17        }
18        healthStore.execute(query)
19    }
20 
21    return statistics.sumQuantity()?.doubleValue(for: .count()) ?? 0
22}
23 
24// Kalp atış hızı - son 7 gün
25func getHeartRateData(days: Int = 7) async throws -> [(date: Date, bpm: Double)] {
26    let heartRateType = HKQuantityType(.heartRate)
27    let startDate = Calendar.current.date(byAdding: .day, value: -days, to: Date())!
28    let predicate = HKQuery.predicateForSamples(withStart: startDate, end: Date())
29    let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
30 
31    return try await withCheckedThrowingContinuation { continuation in
32        let query = HKSampleQuery(
33            sampleType: heartRateType,
34            predicate: predicate,
35            limit: HKObjectQueryNoLimit,
36            sortDescriptors: [sortDescriptor]
37        ) { _, samples, error in
38            if let error { continuation.resume(throwing: error); return }
39            let results = (samples as? [HKQuantitySample])?.map { sample in
40                (date: sample.startDate, bpm: sample.quantity.doubleValue(for: .init(from: "count/min")))
41            } ?? []
42            continuation.resume(returning: results)
43        }
44        healthStore.execute(query)
45    }
46}

1// Kilo kaydet
2func saveBodyMass(kg: Double, date: Date = Date()) async throws {
3    let type = HKQuantityType(.bodyMass)
4    let quantity = HKQuantity(unit: .gramUnit(with: .kilo), doubleValue: kg)
5    let sample = HKQuantitySample(type: type, quantity: quantity, start: date, end: date)
6    try await healthStore.save(sample)
7}
8 
9// Workout kaydet
10func saveWorkout(type: HKWorkoutActivityType, duration: TimeInterval, calories: Double) async throws {
11    let workout = HKWorkout(
12        activityType: type,
13        start: Date().addingTimeInterval(-duration),
14        end: Date(),
15        duration: duration,
16        totalEnergyBurned: HKQuantity(unit: .kilocalorie(), doubleValue: calories),
17        totalDistance: nil,
18        metadata: nil
19    )
20    try await healthStore.save(workout)
21}

1// watchOS Workout Session
2import HealthKit
3 
4class WorkoutManager: NSObject, HKWorkoutSessionDelegate, HKLiveWorkoutBuilderDelegate {
5    let healthStore = HKHealthStore()
6    var session: HKWorkoutSession?
7    var builder: HKLiveWorkoutBuilder?
8 
9    func startWorkout(type: HKWorkoutActivityType) async throws {
10        let config = HKWorkoutConfiguration()
11        config.activityType = type
12        config.locationType = .outdoor
13 
14        session = try HKWorkoutSession(healthStore: healthStore, configuration: config)
15        builder = session?.associatedWorkoutBuilder()
16        builder?.dataSource = HKLiveWorkoutDataSource(healthStore: healthStore, workoutConfiguration: config)
17 
18        session?.delegate = self
19        builder?.delegate = self
20 
21        let startDate = Date()
22        session?.startActivity(with: startDate)
23        try await builder?.beginCollection(at: startDate)
24    }
25 
26    func endWorkout() async throws {
27        session?.end()
28        try await builder?.endCollection(at: Date())
29        try await builder?.finishWorkout()
30    }
31 
32    func workoutSession(_ workoutSession: HKWorkoutSession, didChangeTo toState: HKWorkoutSessionState, from fromState: HKWorkoutSessionState, date: Date) {
33        // State değişikliği handle et
34    }
35 
36    func workoutBuilderDidCollectEvent(_ workoutBuilder: HKLiveWorkoutBuilder) {
37        // Yeni veri geldi
38    }
39}

1// Uygulama arka plandayken sağlık verisi güncellemesi al
2func enableBackgroundDelivery() {
3    let stepType = HKQuantityType(.stepCount)
4    healthStore.enableBackgroundDelivery(for: stepType, frequency: .hourly) { success, error in
5        if success {
6            print("Background delivery enabled for steps")
7        }
8    }
9 
10    // Observer query ile veri dinle
11    let query = HKObserverQuery(sampleType: stepType, predicate: nil) { _, completionHandler, error in
12        // Yeni adım verisi geldi - UI güncelle veya notification gönder
13        self.refreshStepCount()
14        completionHandler()
15    }
16    healthStore.execute(query)
17}

1import SwiftUI
2import Charts
3 
4struct StepChartView: View {
5    let data: [(date: Date, steps: Int)]
6 
7    var body: some View {
8        Chart(data, id: \.date) { item in
9            BarMark(
10                x: .value("Tarih", item.date, unit: .day),
11                y: .value("Adım", item.steps)
12            )
13            .foregroundStyle(item.steps >= 10000 ? .green : .blue)
14        }
15        .chartYAxis {
16            AxisMarks(position: .leading)
17        }
18        .frame(height: 200)
19    }
20}