@capgo/capacitor-health 7.0.0

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst Health = registerPlugin('Health', {\n    web: () => import('./web').then((m) => new m.HealthWeb()),\n});\nexport * from './definitions';\nexport { Health };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class HealthWeb extends WebPlugin {\n    async isAvailable() {\n        return {\n            available: false,\n            platform: 'web',\n            reason: 'Native health APIs are not accessible in a browser environment.',\n        };\n    }\n    async requestAuthorization(_options) {\n        throw this.unimplemented('Health permissions are only available on native platforms.');\n    }\n    async checkAuthorization(_options) {\n        throw this.unimplemented('Health permissions are only available on native platforms.');\n    }\n    async readSamples(_options) {\n        throw this.unimplemented('Reading health data is only available on native platforms.');\n    }\n    async saveSample(_options) {\n        throw this.unimplemented('Writing health data is only available on native platforms.');\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;AACK,UAAC,MAAM,GAAGA,mBAAc,CAAC,QAAQ,EAAE;IACxC,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;IAC7D,CAAC;;ICFM,MAAM,SAAS,SAASC,cAAS,CAAC;IACzC,IAAI,MAAM,WAAW,GAAG;IACxB,QAAQ,OAAO;IACf,YAAY,SAAS,EAAE,KAAK;IAC5B,YAAY,QAAQ,EAAE,KAAK;IAC3B,YAAY,MAAM,EAAE,iEAAiE;IACrF,SAAS;IACT,IAAI;IACJ,IAAI,MAAM,oBAAoB,CAAC,QAAQ,EAAE;IACzC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,4DAA4D,CAAC;IAC9F,IAAI;IACJ,IAAI,MAAM,kBAAkB,CAAC,QAAQ,EAAE;IACvC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,4DAA4D,CAAC;IAC9F,IAAI;IACJ,IAAI,MAAM,WAAW,CAAC,QAAQ,EAAE;IAChC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,4DAA4D,CAAC;IAC9F,IAAI;IACJ,IAAI,MAAM,UAAU,CAAC,QAAQ,EAAE;IAC/B,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,4DAA4D,CAAC;IAC9F,IAAI;IACJ;;;;;;;;;;;;;;;"}

package/ios/Sources/HealthPlugin/Health.swift

@@ -0,0 +1,420 @@
+import Foundation
+import HealthKit
+
+enum HealthManagerError: LocalizedError {
+    case healthDataUnavailable
+    case invalidDataType(String)
+    case invalidDate(String)
+    case dataTypeUnavailable(String)
+    case invalidDateRange
+    case operationFailed(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .healthDataUnavailable:
+            return "Health data is not available on this device."
+        case let .invalidDataType(identifier):
+            return "Unsupported health data type: \(identifier)."
+        case let .invalidDate(dateString):
+            return "Invalid ISO 8601 date value: \(dateString)."
+        case let .dataTypeUnavailable(identifier):
+            return "The health data type \(identifier) is not available on this device."
+        case .invalidDateRange:
+            return "endDate must be greater than or equal to startDate."
+        case let .operationFailed(message):
+            return message
+        }
+    }
+}
+
+enum HealthDataType: String, CaseIterable {
+    case steps
+    case distance
+    case calories
+    case heartRate
+    case weight
+
+    func sampleType() throws -> HKQuantityType {
+        let identifier: HKQuantityTypeIdentifier
+        switch self {
+        case .steps:
+            identifier = .stepCount
+        case .distance:
+            identifier = .distanceWalkingRunning
+        case .calories:
+            identifier = .activeEnergyBurned
+        case .heartRate:
+            identifier = .heartRate
+        case .weight:
+            identifier = .bodyMass
+        }
+
+        guard let type = HKObjectType.quantityType(forIdentifier: identifier) else {
+            throw HealthManagerError.dataTypeUnavailable(rawValue)
+        }
+        return type
+    }
+
+    var defaultUnit: HKUnit {
+        switch self {
+        case .steps:
+            return HKUnit.count()
+        case .distance:
+            return HKUnit.meter()
+        case .calories:
+            return HKUnit.kilocalorie()
+        case .heartRate:
+            return HKUnit.count().unitDivided(by: HKUnit.minute())
+        case .weight:
+            return HKUnit.gramUnit(with: .kilo)
+        }
+    }
+
+    var unitIdentifier: String {
+        switch self {
+        case .steps:
+            return "count"
+        case .distance:
+            return "meter"
+        case .calories:
+            return "kilocalorie"
+        case .heartRate:
+            return "bpm"
+        case .weight:
+            return "kilogram"
+        }
+    }
+
+    static func parseMany(_ identifiers: [String]) throws -> [HealthDataType] {
+        try identifiers.map { identifier in
+            guard let type = HealthDataType(rawValue: identifier) else {
+                throw HealthManagerError.invalidDataType(identifier)
+            }
+            return type
+        }
+    }
+}
+
+struct AuthorizationStatusPayload {
+    let readAuthorized: [HealthDataType]
+    let readDenied: [HealthDataType]
+    let writeAuthorized: [HealthDataType]
+    let writeDenied: [HealthDataType]
+
+    func toDictionary() -> [String: Any] {
+        return [
+            "readAuthorized": readAuthorized.map { $0.rawValue },
+            "readDenied": readDenied.map { $0.rawValue },
+            "writeAuthorized": writeAuthorized.map { $0.rawValue },
+            "writeDenied": writeDenied.map { $0.rawValue }
+        ]
+    }
+}
+
+final class Health {
+    private let healthStore = HKHealthStore()
+    private let isoFormatter: ISO8601DateFormatter
+
+    init() {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        isoFormatter = formatter
+    }
+
+    func availabilityPayload() -> [String: Any] {
+        let available = HKHealthStore.isHealthDataAvailable()
+        if available {
+            return [
+                "available": true,
+                "platform": "ios"
+            ]
+        }
+
+        return [
+            "available": false,
+            "platform": "ios",
+            "reason": "Health data is not available on this device."
+        ]
+    }
+
+    func requestAuthorization(readIdentifiers: [String], writeIdentifiers: [String], completion: @escaping (Result<AuthorizationStatusPayload, Error>) -> Void) {
+        guard HKHealthStore.isHealthDataAvailable() else {
+            completion(.failure(HealthManagerError.healthDataUnavailable))
+            return
+        }
+
+        do {
+            let readTypes = try HealthDataType.parseMany(readIdentifiers)
+            let writeTypes = try HealthDataType.parseMany(writeIdentifiers)
+
+            let readObjectTypes = try objectTypes(for: readTypes)
+            let writeSampleTypes = try sampleTypes(for: writeTypes)
+
+            healthStore.requestAuthorization(toShare: writeSampleTypes, read: readObjectTypes) { [weak self] success, error in
+                guard let self = self else { return }
+
+                if let error = error {
+                    completion(.failure(error))
+                    return
+                }
+
+                if success {
+                    self.evaluateAuthorizationStatus(readTypes: readTypes, writeTypes: writeTypes) { result in
+                        completion(.success(result))
+                    }
+                } else {
+                    completion(.failure(HealthManagerError.operationFailed("Authorization request was not granted.")))
+                }
+            }
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
+    func checkAuthorization(readIdentifiers: [String], writeIdentifiers: [String], completion: @escaping (Result<AuthorizationStatusPayload, Error>) -> Void) {
+        do {
+            let readTypes = try HealthDataType.parseMany(readIdentifiers)
+            let writeTypes = try HealthDataType.parseMany(writeIdentifiers)
+
+            evaluateAuthorizationStatus(readTypes: readTypes, writeTypes: writeTypes) { payload in
+                completion(.success(payload))
+            }
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
+    func readSamples(dataTypeIdentifier: String, startDateString: String?, endDateString: String?, limit: Int?, ascending: Bool, completion: @escaping (Result<[[String: Any]], Error>) -> Void) throws {
+        let dataType = try parseDataType(identifier: dataTypeIdentifier)
+        let sampleType = try dataType.sampleType()
+
+        let startDate = try parseDate(startDateString, defaultValue: Date().addingTimeInterval(-86400))
+        let endDate = try parseDate(endDateString, defaultValue: Date())
+
+        guard endDate >= startDate else {
+            throw HealthManagerError.invalidDateRange
+        }
+
+        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: [])
+        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: ascending)
+        let queryLimit = limit ?? 100
+
+        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 quantitySamples = samples as? [HKQuantitySample] else {
+                completion(.success([]))
+                return
+            }
+
+            let results = quantitySamples.map { sample -> [String: Any] in
+                let value = sample.quantity.doubleValue(for: dataType.defaultUnit)
+                var payload: [String: Any] = [
+                    "dataType": dataType.rawValue,
+                    "value": value,
+                    "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)
+    }
+
+    func saveSample(dataTypeIdentifier: String, value: Double, unitIdentifier: String?, startDateString: String?, endDateString: String?, metadata: [String: String]?, completion: @escaping (Result<Void, Error>) -> Void) throws {
+        guard HKHealthStore.isHealthDataAvailable() else {
+            throw HealthManagerError.healthDataUnavailable
+        }
+
+        let dataType = try parseDataType(identifier: dataTypeIdentifier)
+        let sampleType = try dataType.sampleType()
+
+        let startDate = try parseDate(startDateString, defaultValue: Date())
+        let endDate = try parseDate(endDateString, defaultValue: startDate)
+
+        guard endDate >= startDate else {
+            throw HealthManagerError.invalidDateRange
+        }
+
+        let unit = unit(for: unitIdentifier, dataType: dataType)
+        let quantity = HKQuantity(unit: unit, doubleValue: value)
+
+        var metadataDictionary: [String: Any]?
+        if let metadata = metadata, !metadata.isEmpty {
+            metadataDictionary = metadata.reduce(into: [String: Any]()) { result, entry in
+                result[entry.key] = entry.value
+            }
+        }
+
+        let sample = HKQuantitySample(type: sampleType, quantity: quantity, 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.")))
+            }
+        }
+    }
+
+    private func evaluateAuthorizationStatus(readTypes: [HealthDataType], writeTypes: [HealthDataType], completion: @escaping (AuthorizationStatusPayload) -> Void) {
+        let writeStatus = writeAuthorizationStatus(for: writeTypes)
+
+        readAuthorizationStatus(for: readTypes) { readAuthorized, readDenied in
+            let payload = AuthorizationStatusPayload(
+                readAuthorized: readAuthorized,
+                readDenied: readDenied,
+                writeAuthorized: writeStatus.authorized,
+                writeDenied: writeStatus.denied
+            )
+            completion(payload)
+        }
+    }
+
+    private func writeAuthorizationStatus(for types: [HealthDataType]) -> (authorized: [HealthDataType], denied: [HealthDataType]) {
+        var authorized: [HealthDataType] = []
+        var denied: [HealthDataType] = []
+
+        for type in types {
+            guard let sampleType = try? type.sampleType() else {
+                denied.append(type)
+                continue
+            }
+
+            switch healthStore.authorizationStatus(for: sampleType) {
+            case .sharingAuthorized:
+                authorized.append(type)
+            case .sharingDenied, .notDetermined:
+                denied.append(type)
+            @unknown default:
+                denied.append(type)
+            }
+        }
+
+        return (authorized, denied)
+    }
+
+    private func readAuthorizationStatus(for types: [HealthDataType], completion: @escaping ([HealthDataType], [HealthDataType]) -> Void) {
+        guard !types.isEmpty else {
+            completion([], [])
+            return
+        }
+
+        if #available(iOS 12.0, *) {
+            let group = DispatchGroup()
+            let lock = NSLock()
+            var authorized: [HealthDataType] = []
+            var denied: [HealthDataType] = []
+
+            for type in types {
+                guard let objectType = try? type.sampleType() else {
+                    denied.append(type)
+                    continue
+                }
+
+                group.enter()
+                let readSet = Set<HKObjectType>([objectType])
+                healthStore.getRequestStatusForAuthorization(toShare: Set<HKSampleType>(), read: readSet) { status, error in
+                    defer { group.leave() }
+
+                    if error != nil {
+                        lock.lock(); denied.append(type); lock.unlock()
+                        return
+                    }
+
+                    switch status {
+                    case .unnecessary:
+                        lock.lock(); authorized.append(type); lock.unlock()
+                    case .shouldRequest, .unknown:
+                        lock.lock(); denied.append(type); lock.unlock()
+                    @unknown default:
+                        lock.lock(); denied.append(type); lock.unlock()
+                    }
+                }
+            }
+
+            group.notify(queue: .main) {
+                completion(authorized, denied)
+            }
+        } else {
+            completion(types, [])
+        }
+    }
+
+    private func parseDataType(identifier: String) throws -> HealthDataType {
+        guard let type = HealthDataType(rawValue: identifier) else {
+            throw HealthManagerError.invalidDataType(identifier)
+        }
+        return type
+    }
+
+    private func parseDate(_ string: String?, defaultValue: Date) throws -> Date {
+        guard let value = string else {
+            return defaultValue
+        }
+
+        if let date = isoFormatter.date(from: value) {
+            return date
+        }
+
+        throw HealthManagerError.invalidDate(value)
+    }
+
+    private func unit(for identifier: String?, dataType: HealthDataType) -> HKUnit {
+        guard let identifier = identifier else {
+            return dataType.defaultUnit
+        }
+
+        switch identifier {
+        case "count":
+            return HKUnit.count()
+        case "meter":
+            return HKUnit.meter()
+        case "kilocalorie":
+            return HKUnit.kilocalorie()
+        case "bpm":
+            return HKUnit.count().unitDivided(by: HKUnit.minute())
+        case "kilogram":
+            return HKUnit.gramUnit(with: .kilo)
+        default:
+            return dataType.defaultUnit
+        }
+    }
+
+    private func objectTypes(for dataTypes: [HealthDataType]) throws -> Set<HKObjectType> {
+        var set = Set<HKObjectType>()
+        for dataType in dataTypes {
+            let type = try dataType.sampleType()
+            set.insert(type)
+        }
+        return set
+    }
+
+    private func sampleTypes(for dataTypes: [HealthDataType]) throws -> Set<HKSampleType> {
+        var set = Set<HKSampleType>()
+        for dataType in dataTypes {
+            let type = try dataType.sampleType() as HKSampleType
+            set.insert(type)
+        }
+        return set
+    }
+}

package/ios/Sources/HealthPlugin/HealthPlugin.swift

@@ -0,0 +1,130 @@
+import Foundation
+import Capacitor
+
+@objc(HealthPlugin)
+public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "HealthPlugin"
+    public let jsName = "Health"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "isAvailable", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestAuthorization", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkAuthorization", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "readSamples", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "saveSample", returnType: CAPPluginReturnPromise)
+    ]
+
+    private let implementation = Health()
+
+    @objc func isAvailable(_ call: CAPPluginCall) {
+        call.resolve(implementation.availabilityPayload())
+    }
+
+    @objc func requestAuthorization(_ call: CAPPluginCall) {
+        let read = (call.getArray("read") as? [String]) ?? []
+        let write = (call.getArray("write") as? [String]) ?? []
+
+        implementation.requestAuthorization(readIdentifiers: read, writeIdentifiers: write) { result in
+            DispatchQueue.main.async {
+                switch result {
+                case let .success(payload):
+                    call.resolve(payload.toDictionary())
+                case let .failure(error):
+                    call.reject(error.localizedDescription, nil, error)
+                }
+            }
+        }
+    }
+
+    @objc func checkAuthorization(_ call: CAPPluginCall) {
+        let read = (call.getArray("read") as? [String]) ?? []
+        let write = (call.getArray("write") as? [String]) ?? []
+
+        implementation.checkAuthorization(readIdentifiers: read, writeIdentifiers: write) { result in
+            DispatchQueue.main.async {
+                switch result {
+                case let .success(payload):
+                    call.resolve(payload.toDictionary())
+                case let .failure(error):
+                    call.reject(error.localizedDescription, nil, error)
+                }
+            }
+        }
+    }
+
+    @objc func readSamples(_ call: CAPPluginCall) {
+        guard let dataType = call.getString("dataType") else {
+            call.reject("dataType is required")
+            return
+        }
+
+        let startDate = call.getString("startDate")
+        let endDate = call.getString("endDate")
+        let limit = call.getInt("limit")
+        let ascending = call.getBool("ascending") ?? false
+
+        do {
+            try implementation.readSamples(
+                dataTypeIdentifier: dataType,
+                startDateString: startDate,
+                endDateString: endDate,
+                limit: limit,
+                ascending: ascending
+            ) { result in
+                DispatchQueue.main.async {
+                    switch result {
+                    case let .success(samples):
+                        call.resolve(["samples": samples])
+                    case let .failure(error):
+                        call.reject(error.localizedDescription, nil, error)
+                    }
+                }
+            }
+        } catch {
+            call.reject(error.localizedDescription, nil, error)
+        }
+    }
+
+    @objc func saveSample(_ call: CAPPluginCall) {
+        guard let dataType = call.getString("dataType") else {
+            call.reject("dataType is required")
+            return
+        }
+
+        guard let value = call.getDouble("value") else {
+            call.reject("value is required")
+            return
+        }
+
+        let unit = call.getString("unit")
+        let startDate = call.getString("startDate")
+        let endDate = call.getString("endDate")
+        let metadataAny = call.getObject("metadata") as? [String: Any]
+        let metadata = metadataAny?.reduce(into: [String: String]()) { result, entry in
+            if let stringValue = entry.value as? String {
+                result[entry.key] = stringValue
+            }
+        }
+
+        do {
+            try implementation.saveSample(
+                dataTypeIdentifier: dataType,
+                value: value,
+                unitIdentifier: unit,
+                startDateString: startDate,
+                endDateString: endDate,
+                metadata: metadata
+            ) { result in
+                DispatchQueue.main.async {
+                    switch result {
+                    case .success:
+                        call.resolve()
+                    case let .failure(error):
+                        call.reject(error.localizedDescription, nil, error)
+                    }
+                }
+            }
+        } catch {
+            call.reject(error.localizedDescription, nil, error)
+        }
+    }
+}

package/ios/Tests/HealthPluginTests/HealthPluginTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import HealthPlugin
+
+class HealthTests: XCTestCase {
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let implementation = Health()
+        let value = "Hello, World!"
+        let result = implementation.echo(value)
+
+        XCTAssertEqual(value, result)
+    }
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@capgo/capacitor-health",
+  "version": "7.0.0",
+  "description": "Capacitor plugin to interact with data from Apple HealthKit and Health Connect",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapgoCapacitorHealth.podspec"
+  ],
+  "author": "Martin Donadieu <martin@capgo.app>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cap-go/capacitor-health.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Cap-go/capacitor-health/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapgoCapacitorHealth -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api HealthPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^7.0.0",
+    "@capacitor/core": "^7.0.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^7.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.4.2",
+    "prettier-plugin-java": "^2.6.6",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.30.1",
+    "swiftlint": "^2.0.0",
+    "typescript": "~4.1.5"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}