Build a Complete Fitness Tracker with Rork Max — HealthKit, Apple Watch, and Widget Integration

Create a fitness tracker app.
 
[iPhone App Screens]
1. Dashboard (Tab 1)
   - Today's steps (large number + circular progress ring)
   - Calories burned (ring display)
   - Heart rate (latest value + small line chart)
   - Sleep score (bar chart + rating text)
 
2. History (Tab 2)
   - Weekly/monthly step trend graph
   - Daily detail data list
 
3. Settings (Tab 3)
   - Change step goal
   - Toggle notifications
   - HealthKit connection status
 
[Design Requirements]
- Dark mode fitness UI
- Circular progress similar to Apple's Activity Rings
- SF Symbols for icons
- SwiftUI Charts framework for graphs

Integrate HealthKit into the app.
 
[Data to Read]
- Steps (HKQuantityType.stepCount) — today's total
- Calories (HKQuantityType.activeEnergyBurned) — today's total
- Heart rate (HKQuantityType.heartRate) — latest + last 24h samples
- Sleep (HKCategoryType.sleepAnalysis) — last night's duration
 
[Requirements]
- Create a HealthKitManager class to centralize data fetching
- Show HealthKit authorization request on first launch
- Use background delivery for step count updates
- Show placeholders when data is unavailable
- Set appropriate NSHealthShareUsageDescription

// HealthKitManager.swift — Core data fetching class
import HealthKit
 
class HealthKitManager: ObservableObject {
    let healthStore = HKHealthStore()
 
    @Published var todaySteps: Int = 0
    @Published var todayCalories: Double = 0
    @Published var latestHeartRate: Double = 0
    @Published var sleepHours: Double = 0
 
    // Request HealthKit authorization
    func requestAuthorization() async throws {
        let readTypes: Set<HKObjectType> = [
            HKQuantityType(.stepCount),
            HKQuantityType(.activeEnergyBurned),
            HKQuantityType(.heartRate),
            HKCategoryType(.sleepAnalysis)
        ]
        try await healthStore.requestAuthorization(
            toShare: [], read: readTypes
        )
    }
 
    // Fetch today's step count
    func fetchTodaySteps() async {
        let stepsType = HKQuantityType(.stepCount)
        let today = Calendar.current.startOfDay(for: Date())
        let predicate = HKQuery.predicateForSamples(
            withStart: today, end: Date()
        )
 
        let query = HKStatisticsQuery(
            quantityType: stepsType,
            quantitySamplePredicate: predicate,
            options: .cumulativeSum
        ) { _, result, _ in
            DispatchQueue.main.async {
                self.todaySteps = Int(
                    result?.sumQuantity()?
                        .doubleValue(for: .count()) ?? 0
                )
            }
        }
        healthStore.execute(query)
    }
}
 
// Expected output:
// todaySteps = 8432 (actual step count from HealthKit)
// todayCalories = 342.5 (active energy burned)

Add an Apple Watch companion app.
 
[Watch App Features]
1. Workout recording screen
   - Workout type selection (Running/Walking/Cycling)
   - Start/Pause/Stop buttons
   - Real-time heart rate, calories, and elapsed time
   - Use HKWorkoutSession for accurate workout data
 
2. Today's activity screen
   - Steps + calories circular progress
   - Same goal values as the iPhone app
 
3. Complication
   - CircularGauge style showing current step count
 
[Technical Requirements]
- WatchConnectivity for bidirectional iPhone sync
- Extended Runtime Session for background workouts
- Digital Crown to scroll through workout types

// WorkoutManager.swift — Workout session management
import HealthKit
import WatchKit
 
class WorkoutManager: NSObject, ObservableObject {
    let healthStore = HKHealthStore()
    var workoutSession: HKWorkoutSession?
    var workoutBuilder: HKLiveWorkoutBuilder?
 
    @Published var heartRate: Double = 0
    @Published var calories: Double = 0
    @Published var elapsedTime: TimeInterval = 0
    @Published var isActive = false
 
    func startWorkout(type: HKWorkoutActivityType) async throws {
        let config = HKWorkoutConfiguration()
        config.activityType = type
        config.locationType = .outdoor
 
        workoutSession = try HKWorkoutSession(
            healthStore: healthStore,
            configuration: config
        )
        workoutBuilder = workoutSession?.associatedWorkoutBuilder()
        workoutBuilder?.dataSource = HKLiveWorkoutDataSource(
            healthStore: healthStore,
            workoutConfiguration: config
        )
 
        workoutSession?.delegate = self
        workoutBuilder?.delegate = self
 
        let start = Date()
        workoutSession?.startActivity(with: start)
        try await workoutBuilder?.beginCollection(at: start)
        isActive = true
    }
 
    func endWorkout() async throws {
        workoutSession?.end()
        try await workoutBuilder?.endCollection(at: Date())
        try await workoutBuilder?.finishWorkout()
        isActive = false
    }
}
 
// Expected output:
// After starting a workout, heart rate and calories update in real time
// heartRate = 142.0 (bpm)
// calories = 87.3 (kcal)
// elapsedTime = 1200.0 (seconds = 20 minutes)

Add Home Screen widgets.
 
[Widget Specs]
- Sizes: Small (2x2) and Medium (4x2)
- Small: Today's steps + circular progress ring
- Medium: Steps + calories + heart rate side by side
 
[Technical Requirements]
- App Group for sharing data with the iPhone app
- TimelineProvider that refreshes every 15 minutes
- Fitness-themed accent color (green tones)
- Widget tap opens iPhone app dashboard via DeepLink

// FitnessWidget.swift — Widget timeline provider
import WidgetKit
import SwiftUI
 
struct FitnessEntry: TimelineEntry {
    let date: Date
    let steps: Int
    let stepGoal: Int
    let calories: Double
    let heartRate: Double
}
 
struct FitnessTimelineProvider: TimelineProvider {
    let defaults = UserDefaults(
        suiteName: "group.com.yourapp.fitness"
    )
 
    func getTimeline(
        in context: Context,
        completion: @escaping (Timeline<FitnessEntry>) -> Void
    ) {
        let steps = defaults?.integer(forKey: "todaySteps") ?? 0
        let goal = defaults?.integer(forKey: "stepGoal") ?? 10000
        let cal = defaults?.double(forKey: "todayCalories") ?? 0
        let hr = defaults?.double(forKey: "latestHeartRate") ?? 0
 
        let entry = FitnessEntry(
            date: Date(), steps: steps,
            stepGoal: goal, calories: cal, heartRate: hr
        )
 
        let next = Calendar.current.date(
            byAdding: .minute, value: 15, to: Date()
        )!
        let timeline = Timeline(
            entries: [entry], policy: .after(next)
        )
        completion(timeline)
    }
 
    // ... placeholder, snapshot omitted
}
 
// Expected output:
// Home Screen shows activity ring with current steps
// Updates every 15 minutes with latest data
// Tapping opens the iPhone app

Use CMMotionActivityManager to detect when the user starts running
and send a notification asking "Start a workout?"

Every Monday at 9 AM, send a local notification with last week's
exercise summary (total steps, average heart rate, workout count).

Add an "Export Data" button in Settings that exports the last 30 days
of steps, calories, and sleep data as a CSV file via the share sheet.