@capgo/capacitor-health 8.2.17 → 8.3.0

package/ios/Sources/HealthPlugin/Health.swift

@@ -27,6 +27,19 @@ enum HealthManagerError: LocalizedError {
     }
 }
 
+/// WorkoutType enum that maps TypeScript workout types to iOS HealthKit HKWorkoutActivityType values.
+///
+/// This enum provides bidirectional mapping between the plugin's TypeScript workout types and
+/// native iOS HealthKit workout activity types. The mapping is designed to provide maximum
+/// compatibility across all iOS versions.
+///
+/// iOS Version Compatibility:
+/// - Most workout types are available on all supported iOS versions
+/// - cardioDance and socialDance require iOS 14.0+ and fallback to .dance on older versions
+/// - transition requires iOS 16.0+ and falls back to .other on older versions
+/// - underwaterDiving requires iOS 17.0+ and falls back to .swimming on older versions
+///
+/// Note: The enum case names match the TypeScript WorkoutType union type for consistency.
 enum WorkoutType: String, CaseIterable {
     case running
     case cycling
@@ -49,6 +62,66 @@ enum WorkoutType: String, CaseIterable {
     case waterPolo
     case waterSports
     case wrestling
+    case archery
+    case australianFootball
+    case badminton
+    case barre
+    case bowling
+    case boxing
+    case climbing
+    case cooldown
+    case coreTraining
+    case cricket
+    case crossCountrySkiing
+    case curling
+    case dance
+    case discSports
+    case downhillSkiing
+    case equestrianSports
+    case fencing
+    case fishing
+    case fitnessGaming
+    case flexibility
+    case functionalStrengthTraining
+    case golf
+    case gymnastics
+    case handball
+    case handCycling
+    case highIntensityIntervalTraining
+    case hockey
+    case hunting
+    case jumpRope
+    case kickboxing
+    case lacrosse
+    case martialArts
+    case mindAndBody
+    case mixedCardio
+    case paddleSports
+    case pickleball
+    case pilates
+    case play
+    case preparationAndRecovery
+    case racquetball
+    case rugby
+    case sailing
+    case skatingSports
+    case snowboarding
+    case snowSports
+    case softball
+    case squash
+    case stairs
+    case stepTraining
+    case surfingSports
+    case tableTennis
+    case taiChi
+    case trackAndField
+    case transition
+    case underwaterDiving
+    case volleyball
+    case wheelchairRunPace
+    case wheelchairWalkPace
+    case cardioDance
+    case socialDance
     case other
 
     func hkWorkoutActivityType() -> HKWorkoutActivityType {
@@ -95,6 +168,142 @@ enum WorkoutType: String, CaseIterable {
             return .waterSports
         case .wrestling:
             return .wrestling
+        case .archery:
+            return .archery
+        case .australianFootball:
+            return .australianFootball
+        case .badminton:
+            return .badminton
+        case .barre:
+            return .barre
+        case .bowling:
+            return .bowling
+        case .boxing:
+            return .boxing
+        case .climbing:
+            return .climbing
+        case .cooldown:
+            return .cooldown
+        case .coreTraining:
+            return .coreTraining
+        case .cricket:
+            return .cricket
+        case .crossCountrySkiing:
+            return .crossCountrySkiing
+        case .curling:
+            return .curling
+        case .dance:
+            return .dance
+        case .discSports:
+            return .discSports
+        case .downhillSkiing:
+            return .downhillSkiing
+        case .equestrianSports:
+            return .equestrianSports
+        case .fencing:
+            return .fencing
+        case .fishing:
+            return .fishing
+        case .fitnessGaming:
+            return .fitnessGaming
+        case .flexibility:
+            return .flexibility
+        case .functionalStrengthTraining:
+            return .functionalStrengthTraining
+        case .golf:
+            return .golf
+        case .gymnastics:
+            return .gymnastics
+        case .handball:
+            return .handball
+        case .handCycling:
+            return .handCycling
+        case .highIntensityIntervalTraining:
+            return .highIntensityIntervalTraining
+        case .hockey:
+            return .hockey
+        case .hunting:
+            return .hunting
+        case .jumpRope:
+            return .jumpRope
+        case .kickboxing:
+            return .kickboxing
+        case .lacrosse:
+            return .lacrosse
+        case .martialArts:
+            return .martialArts
+        case .mindAndBody:
+            return .mindAndBody
+        case .mixedCardio:
+            return .mixedCardio
+        case .paddleSports:
+            return .paddleSports
+        case .pickleball:
+            return .pickleball
+        case .pilates:
+            return .pilates
+        case .play:
+            return .play
+        case .preparationAndRecovery:
+            return .preparationAndRecovery
+        case .racquetball:
+            return .racquetball
+        case .rugby:
+            return .rugby
+        case .sailing:
+            return .sailing
+        case .skatingSports:
+            return .skatingSports
+        case .snowboarding:
+            return .snowboarding
+        case .snowSports:
+            return .snowSports
+        case .softball:
+            return .softball
+        case .squash:
+            return .squash
+        case .stairs:
+            return .stairs
+        case .stepTraining:
+            return .stepTraining
+        case .surfingSports:
+            return .surfingSports
+        case .tableTennis:
+            return .tableTennis
+        case .taiChi:
+            return .taiChi
+        case .trackAndField:
+            return .trackAndField
+        case .transition:
+            // transition requires iOS 16.0+, fallback to other for older versions
+            if #available(iOS 16.0, *) {
+                return .transition
+            }
+            return .other
+        case .underwaterDiving:
+            // underwaterDiving requires iOS 17.0+, fallback to swimming for older versions
+            if #available(iOS 17.0, *) {
+                return .underwaterDiving
+            }
+            return .swimming
+        case .volleyball:
+            return .volleyball
+        case .wheelchairRunPace:
+            return .wheelchairRunPace
+        case .wheelchairWalkPace:
+            return .wheelchairWalkPace
+        case .cardioDance:
+            // cardioDance requires iOS 14.0+, fallback to dance for older versions
+            if #available(iOS 14.0, *) {
+                return .cardioDance
+            }
+            return .dance
+        case .socialDance:
+            // socialDance requires iOS 14.0+, fallback to dance for older versions
+            if #available(iOS 14.0, *) {
+                return .socialDance
+            }
+            return .dance
         case .other:
             return .other
         }
@@ -112,8 +321,11 @@ enum WorkoutType: String, CaseIterable {
             return .swimming
         case .yoga:
             return .yoga
+        // Note: Both plugin workout types "strengthTraining" and "traditionalStrengthTraining"
+        // are written to HealthKit as HKWorkoutActivityType.traditionalStrengthTraining.
+        // When reading from HealthKit we always normalize back to .strengthTraining to keep
+        // a single canonical plugin type and maintain backward compatibility.
         case .traditionalStrengthTraining:
-            // Map back to strengthTraining for consistency (both map to the same HK type)
             return .strengthTraining
         case .hiking:
             return .hiking
@@ -143,7 +355,140 @@ enum WorkoutType: String, CaseIterable {
             return .waterSports
         case .wrestling:
             return .wrestling
+        case .archery:
+            return .archery
+        case .australianFootball:
+            return .australianFootball
+        case .badminton:
+            return .badminton
+        case .barre:
+            return .barre
+        case .bowling:
+            return .bowling
+        case .boxing:
+            return .boxing
+        case .climbing:
+            return .climbing
+        case .cooldown:
+            return .cooldown
+        case .coreTraining:
+            return .coreTraining
+        case .cricket:
+            return .cricket
+        case .crossCountrySkiing:
+            return .crossCountrySkiing
+        case .curling:
+            return .curling
+        case .dance:
+            return .dance
+        case .discSports:
+            return .discSports
+        case .downhillSkiing:
+            return .downhillSkiing
+        case .equestrianSports:
+            return .equestrianSports
+        case .fencing:
+            return .fencing
+        case .fishing:
+            return .fishing
+        case .fitnessGaming:
+            return .fitnessGaming
+        case .flexibility:
+            return .flexibility
+        case .functionalStrengthTraining:
+            return .functionalStrengthTraining
+        case .golf:
+            return .golf
+        case .gymnastics:
+            return .gymnastics
+        case .handball:
+            return .handball
+        case .handCycling:
+            return .handCycling
+        case .highIntensityIntervalTraining:
+            return .highIntensityIntervalTraining
+        case .hockey:
+            return .hockey
+        case .hunting:
+            return .hunting
+        case .jumpRope:
+            return .jumpRope
+        case .kickboxing:
+            return .kickboxing
+        case .lacrosse:
+            return .lacrosse
+        case .martialArts:
+            return .martialArts
+        case .mindAndBody:
+            return .mindAndBody
+        case .mixedCardio:
+            return .mixedCardio
+        case .paddleSports:
+            return .paddleSports
+        case .pickleball:
+            return .pickleball
+        case .pilates:
+            return .pilates
+        case .play:
+            return .play
+        case .preparationAndRecovery:
+            return .preparationAndRecovery
+        case .racquetball:
+            return .racquetball
+        case .rugby:
+            return .rugby
+        case .sailing:
+            return .sailing
+        case .skatingSports:
+            return .skatingSports
+        case .snowboarding:
+            return .snowboarding
+        case .snowSports:
+            return .snowSports
+        case .softball:
+            return .softball
+        case .squash:
+            return .squash
+        case .stairs:
+            return .stairs
+        case .stepTraining:
+            return .stepTraining
+        case .surfingSports:
+            return .surfingSports
+        case .tableTennis:
+            return .tableTennis
+        case .taiChi:
+            return .taiChi
+        case .trackAndField:
+            return .trackAndField
+        case .volleyball:
+            return .volleyball
+        case .wheelchairRunPace:
+            return .wheelchairRunPace
+        case .wheelchairWalkPace:
+            return .wheelchairWalkPace
         default:
+            // Handle iOS 14+ types
+            if #available(iOS 14.0, *) {
+                if hkType == .cardioDance {
+                    return .cardioDance
+                }
+                if hkType == .socialDance {
+                    return .socialDance
+                }
+            }
+            // Handle iOS 16+ types
+            if #available(iOS 16.0, *) {
+                if hkType == .transition {
+                    return .transition
+                }
+            }
+            // Handle iOS 17+ types
+            if #available(iOS 17.0, *) {
+                if hkType == .underwaterDiving {
+                    return .underwaterDiving
+                }
+            }
             return .other
         }
     }
@@ -160,6 +505,18 @@ enum HealthDataType: String, CaseIterable {
     case oxygenSaturation
     case restingHeartRate
     case heartRateVariability
+    case bloodPressure
+    case bloodGlucose
+    case bodyTemperature
+    case height
+    case flightsClimbed
+    case exerciseTime
+    case distanceCycling
+    case bodyFat
+    case basalBodyTemperature
+    case basalCalories
+    case totalCalories
+    case mindfulness
 
     func sampleType() throws -> HKSampleType {
         switch self {
@@ -168,6 +525,16 @@ enum HealthDataType: String, CaseIterable {
                 throw HealthManagerError.dataTypeUnavailable(rawValue)
             }
             return type
+        case .bloodPressure:
+            guard let type = HKObjectType.correlationType(forIdentifier: .bloodPressure) else {
+                throw HealthManagerError.dataTypeUnavailable(rawValue)
+            }
+            return type
+        case .mindfulness:
+            guard let type = HKObjectType.categoryType(forIdentifier: .mindfulSession) else {
+                throw HealthManagerError.dataTypeUnavailable(rawValue)
+            }
+            return type
         default:
             return try quantityType()
         }
@@ -194,8 +561,32 @@ enum HealthDataType: String, CaseIterable {
             identifier = .restingHeartRate
         case .heartRateVariability:
             identifier = .heartRateVariabilitySDNN
+        case .bloodGlucose:
+            identifier = .bloodGlucose
+        case .bodyTemperature:
+            identifier = .bodyTemperature
+        case .height:
+            identifier = .height
+        case .flightsClimbed:
+            identifier = .flightsClimbed
+        case .exerciseTime:
+            identifier = .appleExerciseTime
+        case .distanceCycling:
+            identifier = .distanceCycling
+        case .bodyFat:
+            identifier = .bodyFatPercentage
+        case .basalBodyTemperature:
+            identifier = .basalBodyTemperature
+        case .basalCalories:
+            identifier = .basalEnergyBurned
+        case .totalCalories:
+            identifier = .activeEnergyBurned
         case .sleep:
             throw HealthManagerError.invalidDataType("Sleep is a category type, not a quantity type")
+        case .bloodPressure:
+            throw HealthManagerError.invalidDataType("Blood pressure is a correlation type, not a quantity type")
+        case .mindfulness:
+            throw HealthManagerError.invalidDataType("Mindfulness is a category type, not a quantity type")
         }
 
         guard let type = HKObjectType.quantityType(forIdentifier: identifier) else {
@@ -224,6 +615,28 @@ enum HealthDataType: String, CaseIterable {
             return HKUnit.secondUnit(with: .milli)
         case .sleep:
             return HKUnit.minute()
+        case .bloodPressure:
+            return HKUnit.millimeterOfMercury()
+        case .bloodGlucose:
+            return HKUnit.gramUnit(with: .milli).unitDivided(by: HKUnit.literUnit(with: .deci))
+        case .bodyTemperature, .basalBodyTemperature:
+            return HKUnit.degreeCelsius()
+        case .height:
+            return HKUnit.meterUnit(with: .centi)
+        case .flightsClimbed:
+            return HKUnit.count()
+        case .exerciseTime:
+            return HKUnit.minute()
+        case .distanceCycling:
+            return HKUnit.meter()
+        case .bodyFat:
+            return HKUnit.percent()
+        case .basalCalories:
+            return HKUnit.kilocalorie()
+        case .totalCalories:
+            return HKUnit.kilocalorie()
+        case .mindfulness:
+            return HKUnit.minute()
         }
     }
 
@@ -245,6 +658,28 @@ enum HealthDataType: String, CaseIterable {
             return "millisecond"
         case .sleep:
             return "minute"
+        case .bloodPressure:
+            return "mmHg"
+        case .bloodGlucose:
+            return "mg/dL"
+        case .bodyTemperature, .basalBodyTemperature:
+            return "celsius"
+        case .height:
+            return "centimeter"
+        case .flightsClimbed:
+            return "count"
+        case .exerciseTime:
+            return "minute"
+        case .distanceCycling:
+            return "meter"
+        case .bodyFat:
+            return "percent"
+        case .basalCalories:
+            return "kilocalorie"
+        case .totalCalories:
+            return "kilocalorie"
+        case .mindfulness:
+            return "minute"
         }
     }
 
@@ -415,6 +850,94 @@ final class Health {
             healthStore.execute(query)
             return
         }
+        
+        // Handle mindfulness as a category sample
+        if dataType == .mindfulness {
+            let query = HKSampleQuery(sampleType: sampleType, predicate: predicate, limit: queryLimit, sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
+                guard let self = self else { return }
+
+                if let error = error {
+                    completion(.failure(error))
+                    return
+                }
+
+                guard let categorySamples = samples as? [HKCategorySample] else {
+                    completion(.success([]))
+                    return
+                }
+
+                let results = categorySamples.map { sample -> [String: Any] in
+                    let durationMinutes = sample.endDate.timeIntervalSince(sample.startDate) / 60.0
+                    
+                    var payload: [String: Any] = [
+                        "dataType": dataType.rawValue,
+                        "value": durationMinutes,
+                        "unit": dataType.unitIdentifier,
+                        "startDate": self.isoFormatter.string(from: sample.startDate),
+                        "endDate": self.isoFormatter.string(from: sample.endDate)
+                    ]
+
+                    let source = sample.sourceRevision.source
+                    payload["sourceName"] = source.name
+                    payload["sourceId"] = source.bundleIdentifier
+
+                    return payload
+                }
+
+                completion(.success(results))
+            }
+            healthStore.execute(query)
+            return
+        }
+        
+        // Handle blood pressure as a correlation sample
+        if dataType == .bloodPressure {
+            let query = HKSampleQuery(sampleType: sampleType, predicate: predicate, limit: queryLimit, sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
+                guard let self = self else { return }
+
+                if let error = error {
+                    completion(.failure(error))
+                    return
+                }
+
+                guard let correlations = samples as? [HKCorrelation] else {
+                    completion(.success([]))
+                    return
+                }
+
+                let results = correlations.compactMap { correlation -> [String: Any]? in
+                    guard let systolicType = HKObjectType.quantityType(forIdentifier: .bloodPressureSystolic),
+                          let diastolicType = HKObjectType.quantityType(forIdentifier: .bloodPressureDiastolic),
+                          let systolicSample = correlation.objects(for: systolicType).first as? HKQuantitySample,
+                          let diastolicSample = correlation.objects(for: diastolicType).first as? HKQuantitySample else {
+                        return nil
+                    }
+                    
+                    let systolicValue = systolicSample.quantity.doubleValue(for: HKUnit.millimeterOfMercury())
+                    let diastolicValue = diastolicSample.quantity.doubleValue(for: HKUnit.millimeterOfMercury())
+                    
+                    var payload: [String: Any] = [
+                        "dataType": dataType.rawValue,
+                        "value": systolicValue,
+                        "unit": dataType.unitIdentifier,
+                        "startDate": self.isoFormatter.string(from: correlation.startDate),
+                        "endDate": self.isoFormatter.string(from: correlation.endDate),
+                        "systolic": systolicValue,
+                        "diastolic": diastolicValue
+                    ]
+
+                    let source = correlation.sourceRevision.source
+                    payload["sourceName"] = source.name
+                    payload["sourceId"] = source.bundleIdentifier
+
+                    return payload
+                }
+
+                completion(.success(results))
+            }
+            healthStore.execute(query)
+            return
+        }
 
         // Handle quantity samples
         let query = HKSampleQuery(sampleType: sampleType, predicate: predicate, limit: queryLimit, sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
@@ -481,7 +1004,7 @@ final class Health {
         }
     }
 
-    func saveSample(dataTypeIdentifier: String, value: Double, unitIdentifier: String?, startDateString: String?, endDateString: String?, metadata: [String: String]?, completion: @escaping (Result<Void, Error>) -> Void) throws {
+    func saveSample(dataTypeIdentifier: String, value: Double, unitIdentifier: String?, startDateString: String?, endDateString: String?, metadata: [String: String]?, systolic: Double?, diastolic: Double?, completion: @escaping (Result<Void, Error>) -> Void) throws {
         guard HKHealthStore.isHealthDataAvailable() else {
             throw HealthManagerError.healthDataUnavailable
         }
@@ -526,6 +1049,63 @@ final class Health {
             }
             return
         }
+        
+        // Handle mindfulness as a category sample
+        if dataType == .mindfulness {
+            guard let categoryType = HKObjectType.categoryType(forIdentifier: .mindfulSession) else {
+                throw HealthManagerError.dataTypeUnavailable(dataTypeIdentifier)
+            }
+            let sample = HKCategorySample(type: categoryType, value: 0, start: startDate, end: endDate, metadata: metadataDictionary)
+            
+            healthStore.save(sample) { success, error in
+                if let error = error {
+                    completion(.failure(error))
+                    return
+                }
+                
+                if success {
+                    completion(.success(()))
+                } else {
+                    completion(.failure(HealthManagerError.operationFailed("Failed to save the sample.")))
+                }
+            }
+            return
+        }
+        
+        // Handle blood pressure as a correlation sample
+        if dataType == .bloodPressure {
+            guard let systolicValue = systolic, let diastolicValue = diastolic else {
+                throw HealthManagerError.operationFailed("Blood pressure requires both systolic and diastolic values")
+            }
+            
+            guard let systolicType = HKObjectType.quantityType(forIdentifier: .bloodPressureSystolic),
+                  let diastolicType = HKObjectType.quantityType(forIdentifier: .bloodPressureDiastolic),
+                  let correlationType = HKObjectType.correlationType(forIdentifier: .bloodPressure) else {
+                throw HealthManagerError.dataTypeUnavailable(dataTypeIdentifier)
+            }
+            
+            let systolicQuantity = HKQuantity(unit: HKUnit.millimeterOfMercury(), doubleValue: systolicValue)
+            let diastolicQuantity = HKQuantity(unit: HKUnit.millimeterOfMercury(), doubleValue: diastolicValue)
+            
+            let systolicSample = HKQuantitySample(type: systolicType, quantity: systolicQuantity, start: startDate, end: endDate)
+            let diastolicSample = HKQuantitySample(type: diastolicType, quantity: diastolicQuantity, start: startDate, end: endDate)
+            
+            let correlation = HKCorrelation(type: correlationType, start: startDate, end: endDate, objects: [systolicSample, diastolicSample], metadata: metadataDictionary)
+            
+            healthStore.save(correlation) { success, error in
+                if let error = error {
+                    completion(.failure(error))
+                    return
+                }
+                
+                if success {
+                    completion(.success(()))
+                } else {
+                    completion(.failure(HealthManagerError.operationFailed("Failed to save the sample.")))
+                }
+            }
+            return
+        }
 
         // Handle quantity samples
         let sampleType = try dataType.quantityType()

package/ios/Sources/HealthPlugin/HealthPlugin.swift

@@ -3,7 +3,7 @@ import Capacitor
 
 @objc(HealthPlugin)
 public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.2.17"
+    private let pluginVersion: String = "8.3.0"
     public let identifier = "HealthPlugin"
     public let jsName = "Health"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -110,6 +110,9 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 result[entry.key] = stringValue
             }
         }
+        
+        let systolic = call.getDouble("systolic")
+        let diastolic = call.getDouble("diastolic")
 
         do {
             try implementation.saveSample(
@@ -118,7 +121,9 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 unitIdentifier: unit,
                 startDateString: startDate,
                 endDateString: endDate,
-                metadata: metadata
+                metadata: metadata,
+                systolic: systolic,
+                diastolic: diastolic
             ) { result in
                 DispatchQueue.main.async {
                     switch result {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-health",
-  "version": "8.2.17",
+  "version": "8.3.0",
   "description": "Capacitor plugin to interact with data from Apple HealthKit and Health Connect",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",