🎯 왜 지금 헬스케어 앱인가?

📱 HealthKit이 뭐길래?

HealthKit의 정체

HealthKit이 다루는 데이터 종류

🔐 HealthKit의 프라이버시와 보안

💻 HealthKit 개발 시작하기

개발 환경 설정

프로젝트에 HealthKit 추가하기

<key>NSHealthShareUsageDescription</key>
<string>건강 데이터를 읽어서 맞춤형 운동 계획을 제공합니다.</string>

<key>NSHealthUpdateUsageDescription</key>
<string>운동 기록을 건강 앱에 저장합니다.</string>

HKHealthStore 초기화

import HealthKit

class HealthKitManager {
    let healthStore = HKHealthStore()
    
    // HealthKit 사용 가능 여부 확인
    func isHealthKitAvailable() -> Bool {
        return HKHealthStore.isHealthDataAvailable()
    }
}

권한 요청하기

func requestAuthorization(completion: @escaping (Bool, Error?) -> Void) {
    // 읽고 싶은 데이터 타입들
    let readTypes: Set<HKObjectType> = [
        HKObjectType.quantityType(forIdentifier: .stepCount)!,
        HKObjectType.quantityType(forIdentifier: .heartRate)!,
        HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)!,
        HKObjectType.categoryType(forIdentifier: .sleepAnalysis)!
    ]
    
    // 쓰고 싶은 데이터 타입들
    let writeTypes: Set<HKSampleType> = [
        HKObjectType.quantityType(forIdentifier: .stepCount)!,
        HKObjectType.workoutType()
    ]
    
    // 권한 요청
    healthStore.requestAuthorization(toShare: writeTypes, read: readTypes) { success, error in
        completion(success, error)
    }
}

📖 HealthKit 데이터 읽기

걸음 수 가져오기

func getTodaySteps(completion: @escaping (Double?, Error?) -> Void) {
    guard let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount) else {
        completion(nil, nil)
        return
    }
    
    // 오늘 자정부터 지금까지
    let now = Date()
    let startOfDay = Calendar.current.startOfDay(for: now)
    let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: now, options: .strictStartDate)
    
    // 통계 쿼리 생성
    let query = HKStatisticsQuery(quantityType: stepType, quantitySamplePredicate: predicate, options: .cumulativeSum) { _, result, error in
        
        guard let result = result, let sum = result.sumQuantity() else {
            completion(nil, error)
            return
        }
        
        let steps = sum.doubleValue(for: HKUnit.count())
        completion(steps, nil)
    }
    
    healthStore.execute(query)
}

심박수 데이터 가져오기

func getRecentHeartRates(completion: @escaping ([HKQuantitySample]?, Error?) -> Void) {
    guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate) else {
        completion(nil, nil)
        return
    }
    
    // 최신 데이터부터 정렬
    let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
    
    // 샘플 쿼리 생성 (최대 10개)
    let query = HKSampleQuery(sampleType: heartRateType, predicate: nil, limit: 10, sortDescriptors: [sortDescriptor]) { _, samples, error in
        
        guard let samples = samples as? [HKQuantitySample] else {
            completion(nil, error)
            return
        }
        
        completion(samples, nil)
    }
    
    healthStore.execute(query)
}

수면 데이터 분석하기

func getWeeklySleepData(completion: @escaping ([HKCategorySample]?, Error?) -> Void) {
    guard let sleepType = HKCategoryType.categoryType(forIdentifier: .sleepAnalysis) else {
        completion(nil, nil)
        return
    }
    
    // 7일 전부터 지금까지
    let endDate = Date()
    let startDate = Calendar.current.date(byAdding: .day, value: -7, to: endDate)!
    let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: .strictStartDate)
    
    let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
    
    let query = HKSampleQuery(sampleType: sleepType, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: [sortDescriptor]) { _, samples, error in
        
        guard let samples = samples as? [HKCategorySample] else {
            completion(nil, error)
            return
        }
        
        completion(samples, nil)
    }
    
    healthStore.execute(query)
}

✍️ HealthKit 데이터 쓰기

운동 세션 기록하기

func saveWorkout(completion: @escaping (Bool, Error?) -> Void) {
    // 운동 시작/종료 시간
    let endDate = Date()
    let startDate = endDate.addingTimeInterval(-30 * 60) // 30분 전
    
    // 소모한 칼로리 (예: 250kcal)
    let energyBurned = HKQuantity(unit: HKUnit.kilocalorie(), doubleValue: 250)
    
    // 이동 거리 (예: 5km)
    let distance = HKQuantity(unit: HKUnit.meter(), doubleValue: 5000)
    
    // 운동 객체 생성
    let workout = HKWorkout(activityType: .running,
                           start: startDate,
                           end: endDate,
                           duration: 30 * 60,
                           totalEnergyBurned: energyBurned,
                           totalDistance: distance,
                           metadata: nil)
    
    // HealthKit에 저장
    healthStore.save(workout) { success, error in
        completion(success, error)
    }
}

심박수 데이터 저장하기

func saveHeartRate(value: Double, date: Date, completion: @escaping (Bool, Error?) -> Void) {
    guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate) else {
        completion(false, nil)
        return
    }
    
    // 심박수 단위는 분당 횟수 (bpm)
    let heartRateQuantity = HKQuantity(unit: HKUnit.count().unitDivided(by: HKUnit.minute()), doubleValue: value)
    
    // 샘플 생성
    let heartRateSample = HKQuantitySample(type: heartRateType,
                                          quantity: heartRateQuantity,
                                          start: date,
                                          end: date)
    
    // 저장
    healthStore.save(heartRateSample) { success, error in
        completion(success, error)
    }
}

배치로 여러 데이터 저장하기

func saveBatchSamples(samples: [HKSample], completion: @escaping (Bool, Error?) -> Void) {
    healthStore.save(samples) { success, error in
        completion(success, error)
    }
}

🔔 실시간 데이터 모니터링

Observer Query로 변화 감지하기

func setupStepCountObserver() {
    guard let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount) else {
        return
    }
    
    let query = HKObserverQuery(sampleType: stepType, predicate: nil) { query, completionHandler, error in
        if error != nil {
            print("Observer query failed: \(error!.localizedDescription)")
            return
        }
        
        // 걸음 수가 업데이트되었을 때 실행될 코드
        self.getTodaySteps { steps, error in
            if let steps = steps {
                print("새로운 걸음 수: \(steps)")
                // UI 업데이트 등
            }
        }
        
        // 반드시 completion handler를 호출해야 함!
        completionHandler()
    }
    
    healthStore.execute(query)
    
    // 백그라운드에서도 동작하도록 설정
    healthStore.enableBackgroundDelivery(for: stepType, frequency: .immediate) { success, error in
        if success {
            print("백그라운드 업데이트 활성화됨")
        }
    }
}

Anchored Object Query로 증분 업데이트

var anchor: HKQueryAnchor?

func fetchNewHeartRateData() {
    guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate) else {
        return
    }
    
    let query = HKAnchoredObjectQuery(type: heartRateType,
                                     predicate: nil,
                                     anchor: anchor,
                                     limit: HKObjectQueryNoLimit) { query, newSamples, deletedSamples, newAnchor, error in
        
        // 새로운 앵커 저장 (다음 쿼리에서 사용)
        self.anchor = newAnchor
        
        // 새로 추가된 샘플들 처리
        if let samples = newSamples as? [HKQuantitySample] {
            for sample in samples {
                let heartRate = sample.quantity.doubleValue(for: HKUnit.count().unitDivided(by: .minute()))
                print("새로운 심박수: \(heartRate) bpm")
            }
        }
        
        // 삭제된 샘플들 처리
        if let deleted = deletedSamples {
            print("\(deleted.count)개의 샘플이 삭제됨")
        }
    }
    
    // 업데이트 핸들러 설정 (데이터 변경 시 자동 호출)
    query.updateHandler = { query, newSamples, deletedSamples, newAnchor, error in
        self.anchor = newAnchor
        // 새로운 데이터 처리...
    }
    
    healthStore.execute(query)
}

🏥 CareKit 소개

CareKit의 4가지 핵심 모듈

💻 CareKit 시작하기

프로젝트 설정

CareStore 초기화

import CareKit
import CareKitStore

class CareKitManager {
    // 앱 그룹을 사용하면 여러 앱/확장 프로그램 간 데이터 공유 가능
    let storeManager: OCKSynchronizedStoreManager = {
        let store = OCKStore(name: "myHealthApp", type: .onDisk)
        let manager = OCKSynchronizedStoreManager(wrapping: store)
        return manager
    }()
    
    var store: OCKStore {
        return storeManager.store
    }
}

📋 치료 계획 만들기

Task 생성하기

func createMedicationTask() async throws {
    // 약 복용 스케줄 생성 (매일 아침 8시, 저녁 8시)
    let schedule = OCKSchedule.dailyAtTimes(
        hour: [8, 20],
        minutes: [0, 0],
        start: Date(),
        end: nil,
        text: "아침과 저녁 식후"
    )
    
    // Task 생성
    var task = OCKTask(
        id: "medication-aspirin",
        title: "아스피린 복용",
        carePlanUUID: nil,
        schedule: schedule
    )
    
    task.instructions = "물과 함께 1정을 복용하세요."
    task.impactsAdherence = true // 준수율 계산에 포함
    
    // 저장
    try await store.addTask(task)
    print("약 복용 Task가 생성되었습니다!")
}

다양한 스케줄 패턴

// 1. 매일 특정 시간에
let dailySchedule = OCKSchedule.dailyAtTime(
    hour: 9,
    minutes: 0,
    start: Date(),
    end: nil,
    text: "매일 아침 9시"
)

// 2. 주 3회 (월, 수, 금)
let weeklySchedule = OCKSchedule.weeklyAtTime(
    weekday: [.monday, .wednesday, .friday],
    hours: 14,
    minutes: 0,
    start: Date(),
    end: nil
)

// 3. 4시간마다
let intervalSchedule = OCKSchedule(
    composing: [
        OCKScheduleElement(
            start: Date(),
            end: nil,
            interval: DateComponents(hour: 4),
            text: "4시간마다"
        )
    ]
)

// 4. 필요할 때만 (횟수 제한 없음)
let asNeededSchedule = OCKSchedule(
    composing: [
        OCKScheduleElement(
            start: Date(),
            end: nil,
            interval: DateComponents(day: 1),
            text: "필요시",
            targetValues: [],
            duration: .allDay
        )
    ]
)

Outcome 기록하기

func completeTask(taskID: String, date: Date) async throws {
    // 해당 날짜의 Task 이벤트 가져오기
    let query = OCKEventQuery(for: date)
    let events = try await store.fetchEvents(taskID: taskID, query: query)
    
    guard let event = events.first else {
        print("이벤트를 찾을 수 없습니다")
        return
    }
    
    // Outcome 생성
    let outcome = OCKOutcome(
        taskUUID: event.task.uuid,
        taskOccurrenceIndex: event.scheduleEvent.occurrence,
        values: [OCKOutcomeValue(true)]
    )
    
    // 저장
    try await store.addOutcome(outcome)
    print("Task 완료!")
}

🎨 CareKit UI 컴포넌트

Task View Controller

import CareKit
import CareKitUI
import UIKit

class DailyTasksViewController: OCKDailyTasksPageViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 스토어 연결
        storeManager = careKitManager.storeManager
        
        // 네비게이션 바 설정
        title = "오늘의 할 일"
        navigationController?.navigationBar.prefersLargeTitles = true
    }
    
    // Task 카드 커스터마이징
    override func taskView(for task: OCKAnyTask, on date: Date) -> UIView? {
        let card = OCKSimpleTaskViewController(task: task, eventQuery: .init(for: date), storeManager: storeManager)
        
        // 카드 스타일 커스터마이징
        card.view.layer.cornerRadius = 12
        card.view.layer.shadowColor = UIColor.black.cgColor
        card.view.layer.shadowOpacity = 0.1
        card.view.layer.shadowOffset = CGSize(width: 0, height: 2)
        card.view.layer.shadowRadius = 4
        
        return card.view
    }
}

Chart View

func createHeartRateChart() -> UIViewController {
    // 차트 데이터 설정
    let dataSeriesConfig = OCKDataSeriesConfiguration(
        taskID: "heart-rate",
        legendTitle: "심박수",
        gradientStartColor: .systemRed,
        gradientEndColor: .systemOrange,
        markerSize: 8,
        eventAggregator: .countOutcomeValues
    )
    
    // 차트 뷰 컨트롤러 생성
    let chartViewController = OCKCartesianChartViewController(
        plotType: .line,
        selectedDate: Date(),
        configurations: [dataSeriesConfig],
        storeManager: storeManager
    )
    
    chartViewController.chartView.headerView.titleLabel.text = "심박수 추이"
    chartViewController.chartView.headerView.detailLabel.text = "최근 7일"
    
    return chartViewController
}

Contact View

func createContactCard() -> UIView {
    var contact = OCKContact(
        id: "doctor-kim",
        givenName: "김",
        familyName: "철수",
        carePlanUUID: nil
    )
    
    contact.title = "담당 의사"
    contact.role = "내과 전문의"
    contact.emailAddresses = [OCKLabeledValue(label: "이메일", value: "doctor.kim@hospital.com")]
    contact.phoneNumbers = [OCKLabeledValue(label: "진료실", value: "02-1234-5678")]
    contact.messagingNumbers = [OCKLabeledValue(label: "카카오톡", value: "doctorkim")]
    contact.address = {
        let address = OCKPostalAddress()
        address.street = "서울시 강남구 테헤란로 123"
        address.city = "서울"
        address.state = "서울"
        address.postalCode = "06234"
        return address
    }()
    
    let contactViewController = OCKDetailedContactViewController(contact: contact, storeManager: storeManager)
    return contactViewController.view
}

🔗 HealthKit과 CareKit 연동하기

HealthKit 데이터를 CareKit Task로 변환

class HealthCareIntegration {
    let healthStore = HKHealthStore()
    let careStore: OCKStore
    
    init(careStore: OCKStore) {
        self.careStore = careStore
    }
    
    // HealthKit 운동 데이터를 CareKit Outcome으로 변환
    func syncWorkoutData() async throws {
        // 오늘의 운동 데이터 가져오기
        let workouts = try await fetchTodayWorkouts()
        
        // CareKit의 운동 Task 가져오기
        let query = OCKTaskQuery(for: Date())
        let tasks = try await careStore.fetchTasks(query: query)
        
        guard let exerciseTask = tasks.first(where: { $0.id == "daily-exercise" }) else {
            return
        }
        
        // 운동을 했다면 Outcome 생성
        if !workouts.isEmpty {
            let totalDuration = workouts.reduce(0) { $0 + $1.duration }
            let totalCalories = workouts.compactMap { $0.totalEnergyBurned?.doubleValue(for: .kilocalorie()) }.reduce(0, +)
            
            let outcome = OCKOutcome(
                taskUUID: exerciseTask.uuid,
                taskOccurrenceIndex: 0,
                values: [
                    OCKOutcomeValue(totalDuration, units: "분"),
                    OCKOutcomeValue(totalCalories, units: "kcal")
                ]
            )
            
            try await careStore.addOutcome(outcome)
            print("운동 데이터 동기화 완료!")
        }
    }
    
    private func fetchTodayWorkouts() async throws -> [HKWorkout] {
        let workoutType = HKObjectType.workoutType()
        let today = Calendar.current.startOfDay(for: Date())
        let predicate = HKQuery.predicateForSamples(withStart: today, end: Date(), options: .strictStartDate)
        
        return try await withCheckedThrowingContinuation { continuation in
            let query = HKSampleQuery(sampleType: workoutType, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: nil) { _, samples, error in
                if let error = error {
                    continuation.resume(throwing: error)
                } else {
                    continuation.resume(returning: samples as? [HKWorkout] ?? [])
                }
            }
            healthStore.execute(query)
        }
    }
}

CareKit 데이터를 HealthKit에 저장

func saveBloodPressureToHealthKit(systolic: Double, diastolic: Double, date: Date) async throws {
    guard let systolicType = HKQuantityType.quantityType(forIdentifier: .bloodPressureSystolic),
          let diastolicType = HKQuantityType.quantityType(forIdentifier: .bloodPressureDiastolic) else {
        return
    }
    
    // 수축기 혈압
    let systolicQuantity = HKQuantity(unit: HKUnit.millimeterOfMercury(), doubleValue: systolic)
    let systolicSample = HKQuantitySample(type: systolicType, quantity: systolicQuantity, start: date, end: date)
    
    // 이완기 혈압
    let diastolicQuantity = HKQuantity(unit: HKUnit.millimeterOfMercury(), doubleValue: diastolic)
    let diastolicSample = HKQuantitySample(type: diastolicType, quantity: diastolicQuantity, start: date, end: date)
    
    // 혈압은 상관관계가 있는 데이터이므로 함께 저장
    let correlation = HKCorrelation(type: HKCorrelationType.correlationType(forIdentifier: .bloodPressure)!,
                                   start: date,
                                   end: date,
                                   objects: [systolicSample, diastolicSample])
    
    try await healthStore.save(correlation)
    print("혈압 데이터가 HealthKit에 저장되었습니다!")
}

🚀 실전 프로젝트: 당뇨병 관리 앱

1단계: 데이터 모델 설계

enum DiabetesTaskID {
    static let bloodGlucose = "blood-glucose-measurement"
    static let insulin = "insulin-injection"
    static let breakfast = "meal-breakfast"
    static let lunch = "meal-lunch"
    static let dinner = "meal-dinner"
    static let exercise = "daily-exercise"
}

class DiabetesCarePlan {
    let store: OCKStore
    
    init(store: OCKStore) {
        self.store = store
    }
    
    func setupInitialTasks() async throws {
        // 1. 혈당 측정 Task (하루 4회: 아침 공복, 식후 2시간씩)
        let glucoseSchedule = OCKSchedule.dailyAtTimes(
            hour: [7, 9, 13, 19],
            minutes: [0, 0, 0, 0],
            start: Date(),
            end: nil,
            text: "혈당 측정 시간"
        )
        
        var glucoseTask = OCKTask(id: DiabetesTaskID.bloodGlucose,
                                 title: "혈당 측정",
                                 carePlanUUID: nil,
                                 schedule: glucoseSchedule)
        glucoseTask.instructions = "혈당 측정기로 혈당을 측정하고 결과를 기록하세요."
        glucoseTask.impactsAdherence = true
        
        // 2. 인슐린 투여 Task (아침, 저녁 식전)
        let insulinSchedule = OCKSchedule.dailyAtTimes(
            hour: [7, 18],
            minutes: [30, 30],
            start: Date(),
            end: nil,
            text: "식사 30분 전"
        )
        
        var insulinTask = OCKTask(id: DiabetesTaskID.insulin,
                                 title: "인슐린 투여",
                                 carePlanUUID: nil,
                                 schedule: insulinSchedule)
        insulinTask.instructions = "처방된 용량의 인슐린을 투여하세요."
        insulinTask.impactsAdherence = true
        
        // 3. 식사 기록 Tasks
        let breakfastTask = createMealTask(id: DiabetesTaskID.breakfast, title: "아침 식사", hour: 8)
        let lunchTask = createMealTask(id: DiabetesTaskID.lunch, title: "점심 식사", hour: 12)
        let dinnerTask = createMealTask(id: DiabetesTaskID.dinner, title: "저녁 식사", hour: 19)
        
        // 4. 운동 Task (주 5회, 30분 이상)
        let exerciseSchedule = OCKSchedule.weeklyAtTime(
            weekday: [.monday, .tuesday, .wednesday, .thursday, .friday],
            hours: 17,
            minutes: 0,
            start: Date(),
            end: nil
        )
        
        var exerciseTask = OCKTask(id: DiabetesTaskID.exercise,
                                  title: "유산소 운동",
                                  carePlanUUID: nil,
                                  schedule: exerciseSchedule)
        exerciseTask.instructions = "30분 이상 걷기, 조깅, 자전거 등의 유산소 운동을 하세요."
        exerciseTask.impactsAdherence = true
        
        // 모든 Task 저장
        try await store.addTasks([glucoseTask, insulinTask, breakfastTask, lunchTask, dinnerTask, exerciseTask])
        print("당뇨병 관리 계획이 생성되었습니다!")
    }
    
    private func createMealTask(id: String, title: String, hour: Int) -> OCKTask {
        let schedule = OCKSchedule.dailyAtTime(hour: hour, minutes: 0, start: Date(), end: nil, text: nil)
        var task = OCKTask(id: id, title: title, carePlanUUID: nil, schedule: schedule)
        task.instructions = "식사 내용과 탄수화물 섭취량을 기록하세요."
        return task
    }
}

2단계: 혈당 측정 화면 구현

import UIKit
import CareKit
import HealthKit

class BloodGlucoseViewController: UIViewController {
    let healthStore = HKHealthStore()
    let careStore: OCKStore
    var currentEvent: OCKAnyEvent?
    
    let valueTextField: UITextField = {
        let tf = UITextField()
        tf.placeholder = "혈당 수치 (mg/dL)"
        tf.keyboardType = .numberPad
        tf.borderStyle = .roundedRect
        tf.font = .systemFont(ofSize: 18)
        return tf
    }()
    
    let saveButton: UIButton = {
        let btn = UIButton(type: .system)
        btn.setTitle("저장", for: .normal)
        btn.titleLabel?.font = .boldSystemFont(ofSize: 18)
        btn.backgroundColor = .systemBlue
        btn.setTitleColor(.white, for: .normal)
        btn.layer.cornerRadius = 12
        return btn
    }()
    
    init(careStore: OCKStore, event: OCKAnyEvent) {
        self.careStore = careStore
        self.currentEvent = event
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        saveButton.addTarget(self, action: #selector(saveButtonTapped), for: .touchUpInside)
    }
    
    private func setupUI() {
        view.backgroundColor = .systemBackground
        title = "혈당 측정"
        
        view.addSubview(valueTextField)
        view.addSubview(saveButton)
        
        valueTextField.translatesAutoresizingMaskIntoConstraints = false
        saveButton.translatesAutoresizingMaskIntoConstraints = false
        
        NSLayoutConstraint.activate([
            valueTextField.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            valueTextField.centerYAnchor.constraint(equalTo: view.centerYAnchor, constant: -50),
            valueTextField.widthAnchor.constraint(equalToConstant: 250),
            valueTextField.heightAnchor.constraint(equalToConstant: 50),
            
            saveButton.topAnchor.constraint(equalTo: valueTextField.bottomAnchor, constant: 20),
            saveButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            saveButton.widthAnchor.constraint(equalToConstant: 250),
            saveButton.heightAnchor.constraint(equalToConstant: 50)
        ])
    }
    
    @objc private func saveButtonTapped() {
        guard let valueText = valueTextField.text,
              let glucoseValue = Double(valueText),
              let event = currentEvent else {
            showAlert(message: "올바른 혈당 수치를 입력하세요.")
            return
        }
        
        Task {
            do {
                // CareKit에 저장
                try await saveToCareKit(value: glucoseValue, event: event)
                
                // HealthKit에도 저장
                try await saveToHealthKit(value: glucoseValue)
                
                showAlert(message: "혈당 수치가 저장되었습니다!") {
                    self.dismiss(animated: true)
                }
            } catch {
                showAlert(message: "저장 중 오류가 발생했습니다: \(error.localizedDescription)")
            }
        }
    }
    
    private func saveToCareKit(value: Double, event: OCKAnyEvent) async throws {
        let outcome = OCKOutcome(
            taskUUID: event.task.uuid,
            taskOccurrenceIndex: event.scheduleEvent.occurrence,
            values: [OCKOutcomeValue(value, units: "mg/dL")]
        )
        try await careStore.addOutcome(outcome)
    }
    
    private func saveToHealthKit(value: Double) async throws {
        guard let glucoseType = HKQuantityType.quantityType(forIdentifier: .bloodGlucose) else {
            return
        }
        
        let quantity = HKQuantity(unit: HKUnit.gramUnit(with: .milli).unitDivided(by: .literUnit(with: .deci)), doubleValue: value)
        let sample = HKQuantitySample(type: glucoseType, quantity: quantity, start: Date(), end: Date())
        
        try await healthStore.save(sample)
    }
    
    private func showAlert(message: String, completion: (() -> Void)? = nil) {
        let alert = UIAlertController(title: nil, message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "확인", style: .default) { _ in
            completion?()
        })
        present(alert, animated: true)
    }
}

3단계: 혈당 추이 그래프

class BloodGlucoseChartViewController: OCKCartesianChartViewController {
    
    init(storeManager: OCKSynchronizedStoreManager) {
        // 혈당 데이터 시리즈 설정
        let dataConfig = OCKDataSeriesConfiguration(
            taskID: DiabetesTaskID.bloodGlucose,
            legendTitle: "혈당 (mg/dL)",
            gradientStartColor: .systemRed,
            gradientEndColor: .systemOrange,
            markerSize: 6,
            eventAggregator: .custom { events in
                // 하루 평균 혈당 계산
                let values = events.compactMap { event -> Double? in
                    guard let value = event.outcome?.values.first?.doubleValue else { return nil }
                    return value
                }
                return values.isEmpty ? 0 : values.reduce(0, +) / Double(values.count)
            }
        )
        
        super.init(plotType: .line, selectedDate: Date(), configurations: [dataConfig], storeManager: storeManager)
        
        setupChart()
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    private func setupChart() {
        // 차트 헤더 설정
        chartView.headerView.titleLabel.text = "혈당 추이"
        chartView.headerView.detailLabel.text = "최근 30일 평균"
        
        // 정상 범위 표시 (70-140 mg/dL)
        chartView.graphView.horizontalAxisMarkers = [70, 100, 140, 180]
        
        // 위험 구간 색상 표시
        let normalRange = OCKCartesianGraphView.PlotRange(min: 70, max: 140)
        chartView.graphView.selectedRangeColor = .systemGreen.withAlphaComponent(0.2)
    }
}

🔒 보안과 프라이버시 고려사항

HIPAA 준수 (미국 의료정보보호법)

데이터 익명화

struct AnonymizedHealthData {
    let patientID: String  // 실제 ID가 아닌 해시값
    let age: Int
    let gender: String
    let measurements: [Double]
    
    init(from patient: Patient) {
        // 실제 ID를 SHA-256으로 해시
        self.patientID = patient.id.sha256Hash
        self.age = patient.age
        self.gender = patient.gender
        self.measurements = patient.measurements
    }
}

extension String {
    var sha256Hash: String {
        // SHA-256 해시 구현
        // 실제로는 CryptoKit 사용 권장
        return "hashed_\(self.hashValue)"
    }
}

🧪 테스트와 디버깅

HealthKit 시뮬레이터 테스트

func generateTestData() async throws {
    let calendar = Calendar.current
    let now = Date()
    
    // 지난 30일간의 걸음 수 데이터 생성
    for day in 0..<30 {
        guard let date = calendar.date(byAdding: .day, value: -day, to: now) else { continue }
        let steps = Double.random(in: 5000...15000)
        
        let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount)!
        let quantity = HKQuantity(unit: .count(), doubleValue: steps)
        let sample = HKQuantitySample(type: stepType, quantity: quantity, start: date, end: date)
        
        try await healthStore.save(sample)
    }
    print("테스트 데이터 생성 완료!")
}

Unit Testing

import XCTest
@testable import MyHealthApp

class HealthKitManagerTests: XCTestCase {
    var sut: HealthKitManager!
    var mockHealthStore: MockHealthStore!
    
    override func setUp() {
        super.setUp()
        mockHealthStore = MockHealthStore()
        sut = HealthKitManager(healthStore: mockHealthStore)
    }
    
    func testFetchStepCount() async throws {
        // Given
        mockHealthStore.mockStepCount = 10000
        
        // When
        let steps = try await sut.getTodaySteps()
        
        // Then
        XCTAssertEqual(steps, 10000)
        XCTAssertTrue(mockHealthStore.executeQueryCalled)
    }
    
    func testSaveWorkout() async throws {
        // Given
        let workout = createTestWorkout()
        
        // When
        try await sut.saveWorkout(workout)
        
        // Then
        XCTAssertTrue(mockHealthStore.saveCalled)
        XCTAssertEqual(mockHealthStore.savedObjects.count, 1)
    }
}

class MockHealthStore: HKHealthStore {
    var mockStepCount: Double = 0
    var executeQueryCalled = false
    var saveCalled = false
    var savedObjects: [HKObject] = []
    
    override func execute(_ query: HKQuery) {
        executeQueryCalled = true
        // Mock 응답 반환
    }
    
    override func save(_ object: HKObject, withCompletion completion: @escaping (Bool, Error?) -> Void) {
        saveCalled = true
        savedObjects.append(object)
        completion(true, nil)
    }
}

🚀 배포와 앱스토어 제출

앱스토어 리뷰 가이드라인

앱 메타데이터 작성

📈 성능 최적화

배터리 효율성

class OptimizedHealthKitManager {
    let healthStore = HKHealthStore()
    private var observers: [HKObserverQuery] = []
    
    // 배치 업데이트로 효율성 향상
    func setupEfficientObserver() {
        guard let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount) else { return }
        
        // 즉시 업데이트 대신 시간별 업데이트 사용
        healthStore.enableBackgroundDelivery(for: stepType, frequency: .hourly) { success, error in
            if success {
                print("시간별 백그라운드 업데이트 활성화")
            }
        }
    }
    
    // 쿼리 결과 캐싱
    private var cachedSteps: (date: Date, value: Double)?
    
    func getTodayStepsOptimized() async throws -> Double {
        let today = Calendar.current.startOfDay(for: Date())
        
        // 캐시 확인
        if let cached = cachedSteps, Calendar.current.isDate(cached.date, inSameDayAs: today) {
            return cached.value
        }
        
        // 새로 가져오기
        let steps = try await fetchSteps()
        cachedSteps = (today, steps)
        return steps
    }
    
    private func fetchSteps() async throws -> Double {
        // 실제 HealthKit 쿼리
        return 0
    }
    
    // 앱 종료 시 리소스 정리
    func cleanup() {
        observers.forEach { healthStore.stop($0) }
        observers.removeAll()
    }
}

데이터 로딩 최적화

func fetchHealthDataPaginated(limit: Int = 100, anchor: HKQueryAnchor? = nil) async throws -> (samples: [HKSample], newAnchor: HKQueryAnchor?) {
    guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate) else {
        throw HealthKitError.typeNotAvailable
    }
    
    return try await withCheckedThrowingContinuation { continuation in
        let query = HKAnchoredObjectQuery(
            type: heartRateType,
            predicate: nil,
            anchor: anchor,
            limit: limit
        ) { _, samples, _, newAnchor, error in
            if let error = error {
                continuation.resume(throwing: error)
            } else {
                continuation.resume(returning: (samples ?? [], newAnchor))
            }
        }
        
        healthStore.execute(query)
    }
}

// 사용 예시
func loadAllData() async {
    var allSamples: [HKSample] = []
    var currentAnchor: HKQueryAnchor? = nil
    
    repeat {
        do {
            let result = try await fetchHealthDataPaginated(anchor: currentAnchor)
            allSamples.append(contentsOf: result.samples)
            currentAnchor = result.newAnchor
            
            // UI 업데이트 (점진적 로딩)
            await MainActor.run {
                updateUI(with: allSamples)
            }
            
            if result.samples.isEmpty {
                break
            }
        } catch {
            print("데이터 로딩 실패: \(error)")
            break
        }
    } while true
}

🌟 고급 기능과 팁

Apple Watch 연동

import WatchConnectivity

class WatchConnectivityManager: NSObject, WCSessionDelegate {
    static let shared = WatchConnectivityManager()
    private var session: WCSession?
    
    func setupSession() {
        if WCSession.isSupported() {
            session = WCSession.default
            session?.delegate = self
            session?.activate()
        }
    }
    
    // 아이폰 → 애플워치로 데이터 전송
    func sendToWatch(data: [String: Any]) {
        guard let session = session, session.isReachable else {
            print("워치에 연결할 수 없습니다")
            return
        }
        
        session.sendMessage(data, replyHandler: nil) { error in
            print("전송 실패: \(error.localizedDescription)")
        }
    }
    
    // 애플워치 → 아이폰으로 데이터 수신
    func session(_ session: WCSession, didReceiveMessage message: [String : Any]) {
        if let heartRate = message["heartRate"] as? Double {
            // 심박수 데이터 처리
            Task {
                try await saveHeartRateToHealthKit(heartRate)
            }
        }
    }
    
    func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: Error?) {
        if let error = error {
            print("세션 활성화 실패: \(error.localizedDescription)")
        } else {
            print("워치 연결 성공!")
        }
    }
    
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) {}
    
    private func saveHeartRateToHealthKit(_ value: Double) async throws {
        // HealthKit 저장 로직
    }
}

Siri 단축어 통합

import Intents

class HealthIntentHandler: NSObject, LogHealthDataIntentHandling {
    func handle(intent: LogHealthDataIntent, completion: @escaping (LogHealthDataIntentResponse) -> Void) {
        guard let dataType = intent.dataType,
              let value = intent.value else {
            completion(LogHealthDataIntentResponse(code: .failure, userActivity: nil))
            return
        }
        
        Task {
            do {
                // 데이터 저장
                try await saveHealthData(type: dataType, value: value.doubleValue)
                
                let response = LogHealthDataIntentResponse(code: .success, userActivity: nil)
                response.result = "\(dataType)이(가) 기록되었습니다: \(value)"
                completion(response)
            } catch {
                completion(LogHealthDataIntentResponse(code: .failure, userActivity: nil))
            }
        }
    }
    
    private func saveHealthData(type: String, value: Double) async throws {
        // HealthKit 저장 로직
    }
}

위젯 지원

import WidgetKit
import SwiftUI

struct HealthWidgetView: View {
    let entry: HealthEntry
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text("오늘의 활동")
                .font(.headline)
                .foregroundColor(.white)
            
            HStack {
                VStack(alignment: .leading) {
                    Text("\(entry.steps)")
                        .font(.title)
                        .fontWeight(.bold)
                        .foregroundColor(.white)
                    Text("걸음")
                        .font(.caption)
                        .foregroundColor(.white.opacity(0.8))
                }
                
                Spacer()
                
                VStack(alignment: .leading) {
                    Text("\(entry.calories)")
                        .font(.title)
                        .fontWeight(.bold)
                        .foregroundColor(.white)
                    Text("칼로리")
                        .font(.caption)
                        .foregroundColor(.white.opacity(0.8))
                }
            }
            
            ProgressView(value: Double(entry.steps) / 10000.0)
                .tint(.green)
        }
        .padding()
        .background(
            LinearGradient(
                colors: [Color.blue, Color.purple],
                startPoint: .topLeading,
                endPoint: .bottomTrailing
            )
        )
    }
}

struct HealthEntry: TimelineEntry {
    let date: Date
    let steps: Int
    let calories: Int
}

🎓 학습 리소스와 커뮤니티

공식 문서

온라인 커뮤니티

추천 도서

🎯 마무리하며