vitality 0.1.1 indexed Offers unified access to health data, supporting over 66 health metrics, real-time monitoring, workout management, and FHIR medical records compliance with cross-platform API for seamless integration.
Bring this to kpkg
This library is indexed from the KMP ecosystem and already resolves through kpkg.dev's Maven Central proxy. Maintainers can verify the namespace and publish future versions to kpkg for free hosting, real download stats, and signed-provenance pages.
Metadata
Owner crowded-libs
Stars 18
Used by —
Health —
License Apache License 2.0
Latest 0.1.1
Repository github.com/crowded-libs/vitality
Updated 2025-09-16 Readme Changelog Vitality
A Kotlin Multiplatform library providing unified health data access across Apple HealthKit (iOS) and Health Connect (Android). Vitality offers comprehensive health metrics, real-time monitoring via Kotlin flows, workout management, and medical records support through FHIR standards.
Features
Installation
Gradle (Kotlin DSL)
dependencies {
implementation("io.crowded-libs:vitality:0.1.1" )
}
Platform Requirements
iOS : iOS 13.0+, HealthKit capability enabledAndroid : API 26+ (Health Connect support), API 34+ (full features)
Quick Start
1. Platform Setup
Android
Add to your Application class:
class MyApplication : Application () {
override fun onCreate () super .onCreate()
HealthConnectorContextProvider.initialize(applicationContext)
}
}
Add to AndroidManifest.xml:
<uses-permission android:name ="android.permission.health.READ_HEART_RATE" />
<uses-permission android:name ="android.permission.health.WRITE_HEART_RATE" />
iOS
Enable HealthKit capability in Xcode and add to Info.plist:
<key > NSHealthShareUsageDescription</key >
<string > This app reads your health data to provide insights</string >
<key > NSHealthUpdateUsageDescription</key >
<string > This app updates your health data from workouts</string >
2. Basic Usage
HealthConnector Interface
The HealthConnector interface is the main entry point for all health data operations:
Platform Implementations
iOS - HealthKitConnector
Direct integration with Apple HealthKit:
val connector = createHealthConnector()
Android - HealthConnectConnector
Integration with Android Health Connect:
val connector = createHealthConnector()
Data Types Mapping Matrix
Below is a comprehensive mapping of all Vitality data types to their platform equivalents:
Fitness Data
Vital Signs
Body Measurements
Nutrition
Sleep
Mobility & Movement
Advanced Fitness Metrics
Environmental & Audio
Clinical Data
Reproductive Health
Other
Vitality Type HealthKit (iOS) Health Connect (Android) Notes MindfulnessHKCategoryTypeIdentifierMindfulSessionSupported via sessions
Clinical Records (FHIR)
Platform-Specific Notes
iOS-Only Features
Mobility Metrics : Walking asymmetry, double support, stair speeds (iOS 14+)Advanced Running Metrics : Stride length, vertical oscillation, ground contact time (iOS 16+)Cycling Metrics : Cadence, power, functional threshold (iOS 17+)Environmental Sensing : Audio exposure, UV exposure, time in daylightClinical Features : ECG, irregular rhythm notifications
Android-Only Features
Reproductive Health : Comprehensive menstruation and fertility trackingNutrition Details : Granular macronutrient tracking via NutritionRecordActivity Metrics : Speed and power recordsSession-Based Data : Rich metadata for exercise sessionsMedical Records (Android 16+) : Full FHIR R4 support via MedicalResource API
Workout Types
Both platforms support these workout types:
enum class WorkoutType {
RUNNING, WALKING, CYCLING, SWIMMING, STRENGTH_TRAINING,
YOGA, PILATES, DANCE, MARTIAL_ARTS, ROWING, ELLIPTICAL,
STAIR_CLIMBING, HIGH_INTENSITY_INTERVAL_TRAINING,
FUNCTIONAL_TRAINING, CORE_TRAINING, CROSS_TRAINING,
FLEXIBILITY, MIXED_CARDIO, SOCCER, BASKETBALL, TENNIS,
GOLF, HIKING, SKIING, SNOWBOARDING, SKATING,
SURFING, CLIMBING, EQUESTRIAN, FISHING, HUNTING,
PLAY, MEDITATION, COOLDOWN, OTHER
}
Workout Session Example
Medical Records (FHIR)
Vitality provides comprehensive FHIR R4 support for medical records:
Supported FHIR Resource Types
Advanced Features
Statistical Queries
Platform-Specific Configuration
iOS Background Delivery
val connector = createHealthConnector()
val capabilities = connector.getPlatformCapabilities()
if (capabilities.supportsBackgroundDelivery) {
🏥 66 Health Data Types - Comprehensive coverage of fitness, vitals, body measurements, nutrition, sleep, and more
📱 Cross-Platform - Single API for both iOS HealthKit and Android Health Connect
🔄 Real-time Monitoring - Flow-based reactive streams for continuous health data updates
🏃 Workout Sessions - Live workout tracking with pause/resume, segments, laps, and route support
📊 Statistical Queries - Aggregate data with time-bucketed statistics
🏥 FHIR Medical Records - Standard-compliant medical data modeling
🔐 Granular Permissions - Fine-grained control over health data access <uses-permission android:name ="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name ="android.permission.FOREGROUND_SERVICE_HEALTH" />
import vitality.*
import vitality.models.*
import kotlinx.coroutines.*
val healthConnector = createHealthConnector()
suspend fun setupHealthAccess () val result = healthConnector.initialize()
result.fold(
onSuccess = {
println("Health connector initialized successfully" )
val availableTypes = healthConnector.getAvailableDataTypes()
println("Available data types: ${availableTypes.size} " )
val capabilities = healthConnector.getPlatformCapabilities()
println("Platform: ${capabilities.platformName} " )
},
onFailure = { exception ->
println("Initialization failed: $exception " )
}
)
}
suspend fun requestPermissions () val permissions = setOf(
HealthPermission(HealthDataType.HeartRate, HealthPermission.AccessType.READ),
HealthPermission(HealthDataType.Steps, HealthPermission.AccessType.READ),
HealthPermission(HealthDataType.Calories, HealthPermission.AccessType.WRITE)
)
val result = healthConnector.requestPermissions(permissions)
result.fold(
onSuccess = { permissionResult ->
permissionResult.granted.forEach {
println("Granted: ${it.dataType} - ${it.accessType} " )
}
permissionResult.denied.forEach {
println("Denied: ${it.dataType} - ${it.accessType} " )
}
},
onFailure = { exception ->
println("Permission request failed: $exception " )
}
)
}
suspend fun readTodaysData () val stepsResult = healthConnector.readStepsToday()
stepsResult.fold(
onSuccess = { steps ->
println("Steps today: ${steps.count} " )
},
onFailure = { exception ->
println("Failed to read steps: $exception " )
}
)
val heartRateResult = healthConnector.readLatestHeartRate()
heartRateResult.fold(
onSuccess = { heartRate ->
heartRate?.let {
println("Latest heart rate: ${it.bpm} bpm" )
} ?: println("No heart rate data available" )
},
onFailure = { exception ->
println("Failed to read heart rate: $exception " )
}
)
}
suspend fun readHistoricalData () val endTime = Clock.System.now()
val startTime = endTime.minus(7. days)
val result = healthConnector.readHealthData(
dataType = HealthDataType.HeartRate,
startDate = startTime,
endDate = endTime
)
result.fold(
onSuccess = { dataPoints ->
dataPoints.forEach { dataPoint ->
println("Health data: ${dataPoint.value} ${dataPoint.unit} at ${dataPoint.timestamp} " )
}
},
onFailure = { exception ->
println("Failed to read health data: $exception " )
}
)
}
fun monitorHealthData () val stepsFlow: Flow<StepsData> = healthConnector.observe(HealthDataType.Steps)
stepsFlow
.onEach { steps ->
println("Steps updated: ${steps.count} " )
}
.launchIn(GlobalScope)
val heartRateFlow: Flow<HeartRateData> = healthConnector.observe(
HealthDataType.HeartRate,
samplingInterval = 5. seconds
)
heartRateFlow
.onEach { heartRate ->
println("Heart rate: ${heartRate.bpm} bpm" )
}
.launchIn(GlobalScope)
}
interface HealthConnector {
suspend fun initialize () Unit >
suspend fun getAvailableDataTypes () suspend fun getPlatformCapabilities () suspend fun requestPermissions (permissions: Set <HealthPermission >) suspend fun checkPermissions (permissions: Set <HealthPermission >) suspend fun readLatestHeartRate () suspend fun readStepsToday () suspend fun readCaloriesToday () suspend fun readLatestWeight () suspend fun readWorkouts (startDate: Instant , endDate: Instant ) suspend fun readHealthData (
dataType: HealthDataType ,
startDate: Instant ,
endDate: Instant
) fun <T> observe (
dataType: HealthDataType ,
samplingInterval: Duration = 30. seconds
) fun observeActiveWorkout () suspend fun startWorkoutSession (
workoutType: WorkoutType ,
title: String ? = null ,
metadata: Map <String , Any> = emptyMap() suspend fun startWorkoutSession (
configuration: WorkoutConfiguration ,
title: String ? = null
) suspend fun pauseWorkoutSession (sessionId: String ) Unit >
suspend fun resumeWorkoutSession (sessionId: String ) Unit >
suspend fun endWorkoutSession (sessionId: String ) Unit >
suspend fun discardWorkoutSession (sessionId: String ) Unit >
suspend fun writeWeight (weight: Double , unit: WeightUnit , timestamp: Instant = Clock.System.now() Unit >
suspend fun writeWorkout (workoutData: WorkoutData ) Unit >
suspend fun writeHealthData (dataPoint: HealthDataPoint ) Unit >
suspend fun readStatistics (
dataType: HealthDataType ,
startDate: Instant ,
endDate: Instant ,
statisticOptions: Set <StatisticOption > = setOf(StatisticOption.AVERAGE) null
): Result<HealthStatistics>
suspend fun readImmunizations (
startDate: Instant ? = null ,
endDate: Instant ? = null
) suspend fun readMedications (
startDate: Instant ? = null ,
endDate: Instant ? = null
) suspend fun readAllergies (
includeInactive: Boolean = false
) suspend fun readConditions (
includeResolved: Boolean = false
) suspend fun readLabResults (
startDate: Instant ? = null ,
endDate: Instant ? = null ,
category: String ? = null
) suspend fun readProcedures (
startDate: Instant ? = null ,
endDate: Instant ? = null
) suspend fun areClinicalRecordsAvailable () Boolean
}
val
"Running on: ${capabilities.platformName} "
"Version: ${capabilities.platformVersion} "
"Supports background delivery: ${capabilities.supportsBackgroundDelivery} "
"Supports workout routes: ${capabilities.supportsWorkoutRoutes} "
val
"Background HR update: ${heartRate.bpm} "
if
"Apple Watch connected"
val
"Health Connect version: ${capabilities.platformVersion} "
val
"Steps update: ${steps.count} "
"Workout distance: ${workout.totalDistance} meters"
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
StepsHKQuantityTypeIdentifierStepCountStepsRecordCount of steps DistanceHKQuantityTypeIdentifierDistanceWalkingRunningDistanceRecordDistance in meters CaloriesHKQuantityTypeIdentifierActiveEnergyBurnedTotalCaloriesBurnedRecordTotal calories ActiveCaloriesHKQuantityTypeIdentifierActiveEnergyBurnedActiveCaloriesBurnedRecordActive calories only BasalCaloriesHKQuantityTypeIdentifierBasalEnergyBurnedBasalMetabolicRateRecordResting calories FloorsHKQuantityTypeIdentifierFlightsClimbed❌ Not supported iOS only Elevation❌ Not supported ElevationGainedRecordAndroid only WorkoutHKWorkoutTypeExerciseSessionRecordWorkout sessions VO2MaxHKQuantityTypeIdentifierVO2MaxVo2MaxRecordAerobic fitness WheelchairPushes❌ Not supported WheelchairPushesRecordAndroid only
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
HeartRateHKQuantityTypeIdentifierHeartRateHeartRateRecordBeats per minute HeartRateVariabilityHKQuantityTypeIdentifierHeartRateVariabilitySDNNHeartRateVariabilityRmssdRecordSDNN on iOS, RMSSD on Android RestingHeartRateHKQuantityTypeIdentifierRestingHeartRateRestingHeartRateRecordiOS 11+ BloodPressureHKCorrelationTypeIdentifierBloodPressureBloodPressureRecordSystolic/Diastolic RespiratoryRateHKQuantityTypeIdentifierRespiratoryRateRespiratoryRateRecordBreaths per minute OxygenSaturationHKQuantityTypeIdentifierOxygenSaturationOxygenSaturationRecordSpO2 percentage BodyTemperatureHKQuantityTypeIdentifierBodyTemperatureBodyTemperatureRecordCore temperature BloodGlucoseHKQuantityTypeIdentifierBloodGlucoseBloodGlucoseRecordmg/dL or mmol/L
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
WeightHKQuantityTypeIdentifierBodyMassWeightRecordKilograms HeightHKQuantityTypeIdentifierHeightHeightRecordMeters BMIHKQuantityTypeIdentifierBodyMassIndex❌ Calculate from height/weight kg/m² BodyFatHKQuantityTypeIdentifierBodyFatPercentageBodyFatRecordPercentage LeanBodyMassHKQuantityTypeIdentifierLeanBodyMassLeanBodyMassRecordKilograms
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
WaterHKQuantityTypeIdentifierDietaryWaterHydrationRecordMilliliters ProteinHKQuantityTypeIdentifierDietaryProteinNutritionRecord.proteinGrams CarbohydratesHKQuantityTypeIdentifierDietaryCarbohydratesNutritionRecord.totalCarbohydrateGrams FatHKQuantityTypeIdentifierDietaryFatTotalNutritionRecord.totalFatGrams FiberHKQuantityTypeIdentifierDietaryFiberNutritionRecord.dietaryFiberGrams SugarHKQuantityTypeIdentifierDietarySugarNutritionRecord.sugarGrams CaffeineHKQuantityTypeIdentifierDietaryCaffeineNutritionRecord.caffeineMilligrams
SleepHKCategoryTypeIdentifierSleepAnalysisSleepSessionRecordSleep sessions SleepStagesWithin sleep analysis SleepSessionRecord.StageREM, Deep, Light, Awake
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
WalkingAsymmetryHKQuantityTypeIdentifierWalkingAsymmetryPercentage❌ Not supported iOS 14+ only WalkingDoubleSupportPercentageHKQuantityTypeIdentifierWalkingDoubleSupportPercentage❌ Not supported iOS 14+ only WalkingSpeedHKQuantityTypeIdentifierWalkingSpeed❌ Not supported iOS only WalkingStepLengthHKQuantityTypeIdentifierWalkingStepLength❌ Not supported iOS only StairAscentSpeedHKQuantityTypeIdentifierStairAscentSpeed❌ Not supported iOS 14+ only StairDescentSpeedHKQuantityTypeIdentifierStairDescentSpeed❌ Not supported iOS 14+ only SixMinuteWalkTestDistanceHKQuantityTypeIdentifierSixMinuteWalkTestDistance❌ Not supported iOS only NumberOfTimesFallenHKQuantityTypeIdentifierNumberOfTimesFallen❌ Not supported iOS only StandHoursHKCategoryTypeIdentifierAppleStandHour❌ Not supported iOS only
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
Speed❌ Not supported SpeedRecordAndroid only Power❌ Not supported PowerRecordAndroid only RunningStrideLengthHKQuantityTypeIdentifierRunningStrideLength❌ Not supported iOS 16+ only RunningVerticalOscillationHKQuantityTypeIdentifierRunningVerticalOscillation❌ Not supported iOS 16+ only RunningGroundContactTimeHKQuantityTypeIdentifierRunningGroundContactTime❌ Not supported iOS 16+ only CyclingCadenceHKQuantityTypeIdentifierCyclingCadence❌ Not supported iOS 17+ only CyclingPowerHKQuantityTypeIdentifierCyclingPowerPowerRecordiOS 17+ / Android CyclingPedalingCadence❌ Not supported CyclingPedalingCadenceRecordAndroid only CyclingFunctionalThresholdPowerHKQuantityTypeIdentifierCyclingFunctionalThresholdPower❌ Not supported iOS 17+ only SwimmingStrokeStyleStored as workout metadata ❌ Not supported Stroke type
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
EnvironmentalAudioExposureHKQuantityTypeIdentifierEnvironmentalAudioExposure❌ Not supported iOS only HeadphoneAudioExposureHKQuantityTypeIdentifierHeadphoneAudioExposure❌ Not supported iOS only UVExposureHKQuantityTypeIdentifierUVExposure❌ Not supported iOS only TimeInDaylightHKQuantityTypeIdentifierTimeInDaylight❌ Not supported iOS 17+ only
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
ElectrocardiogramHKElectrocardiogramType❌ Not supported iOS 14+ only IrregularHeartRhythmEventHKCategoryTypeIdentifierIrregularHeartRhythmEvent❌ Not supported iOS only PeripheralPerfusionIndexHKQuantityTypeIdentifierPeripheralPerfusionIndex❌ Not supported iOS only
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
MenstruationFlowHKCategoryTypeIdentifierMenstrualFlowMenstruationFlowRecordiOS 9+ MenstruationPeriod❌ Not supported MenstruationPeriodRecordAndroid only IntermenstrualBleedingHKCategoryTypeIdentifierIntermenstrualBleedingIntermenstrualBleedingRecordiOS 9+ CervicalMucusHKCategoryTypeIdentifierCervicalMucusQualityCervicalMucusRecordiOS 9+ OvulationTestHKCategoryTypeIdentifierOvulationTestResultOvulationTestRecordiOS 9+ SexualActivityHKCategoryTypeIdentifierSexualActivitySexualActivityRecordiOS 9+
Vitality Type HealthKit (iOS) Health Connect (Android) Notes
ClinicalAllergiesHKClinicalTypeIdentifierAllergyRecordMedicalResource (AllergyIntolerance)FHIR AllergyIntolerance ClinicalConditionsHKClinicalTypeIdentifierConditionRecordMedicalResource (Condition)FHIR Condition ClinicalImmunizationsHKClinicalTypeIdentifierImmunizationRecordMedicalResource (Immunization)FHIR Immunization ClinicalLabResultsHKClinicalTypeIdentifierLabResultRecordMedicalResource (Observation)FHIR Observation ClinicalMedicationsHKClinicalTypeIdentifierMedicationRecordMedicalResource (MedicationStatement)FHIR MedicationStatement ClinicalProceduresHKClinicalTypeIdentifierProcedureRecordMedicalResource (Procedure)FHIR Procedure ClinicalVitalSignsHKClinicalTypeIdentifierVitalSignRecordMedicalResource (Observation)FHIR Observation
Apple Watch Integration : Seamless data from paired devices
suspend fun startRunningWorkout () val sessionResult = healthConnector.startWorkoutSession(
workoutType = WorkoutType.RUNNING,
title = "Morning Run" ,
metadata = mapOf("surface" to "outdoor" , "weather" to "sunny" )
)
val config = WorkoutConfiguration(
type = WorkoutType.RUNNING,
isIndoor = false ,
enableGpsTracking = true ,
metadata = mapOf("surface" to "track" )
)
val result = healthConnector.startWorkoutSession(config)
val session = result.getOrElse {
println("Failed to start workout: $it " )
return
}
val sessionId = session.id
val sessionStartTime = Clock.System.now()
launch {
healthConnector.observeActiveWorkout()
.collect { workoutData ->
println("Distance: ${workoutData.totalDistance} m" )
println("Calories: ${workoutData.totalCalories} kcal" )
println("Duration: ${workoutData.duration} " )
}
}
launch {
val heartRateFlow: Flow<HeartRateData> = healthConnector.observe(
HealthDataType.HeartRate,
samplingInterval = 5. seconds
)
heartRateFlow.collect { heartRate ->
println("Current heart rate: ${heartRate.beatsPerMinute} bpm" )
}
}
delay(5. minutes)
healthConnector.pauseWorkoutSession(sessionId)
println("Workout paused" )
delay(30. seconds)
healthConnector.resumeWorkoutSession(sessionId)
println("Workout resumed" )
delay(10. minutes)
val endResult = healthConnector.endWorkoutSession(sessionId)
endResult.fold(
onSuccess = {
println("Workout completed!" )
val workoutResult = healthConnector.readWorkouts(
startDate = sessionStartTime,
endDate = Clock.System.now()
)
workoutResult.getOrNull()?.firstOrNull()?.let { workout ->
println("Duration: ${workout.duration} " )
println("Total calories: ${workout.totalCalories} kcal" )
println("Total distance: ${workout.totalDistance} meters" )
}
},
onFailure = { exception ->
println("Failed to end workout: $exception " )
healthConnector.discardWorkoutSession(sessionId)
}
)
}
suspend fun checkClinicalRecordsSupport () if (healthConnector.areClinicalRecordsAvailable()) {
println("Clinical records are supported on this device" )
} else {
println("Clinical records not available" )
}
}
suspend fun getVaccinationHistory () val result = healthConnector.readImmunizations()
result.fold(
onSuccess = { immunizations ->
immunizations.forEach { immunization ->
println("Vaccine: ${immunization.vaccineCode.text} " )
println("Date: ${immunization.occurrenceDateTime} " )
println("Status: ${immunization.status} " )
println("Dose: ${immunization.doseQuantity?.value} ${immunization.doseQuantity?.unit} " )
}
},
onFailure = { exception ->
println("Failed to read immunizations: $exception " )
}
)
}
suspend fun getCurrentMedications () val oneYearAgo = Clock.System.now().minus(365. days)
val result = healthConnector.readMedications(startDate = oneYearAgo)
result.fold(
onSuccess = { medications ->
medications.forEach { resource ->
when (resource) {
is FHIRMedicationStatement -> {
println("Medication: ${resource.medicationCodeableConcept?.text} " )
println("Status: ${resource.status} " )
println("Dosage: ${resource.dosage.firstOrNull()?.text} " )
}
is FHIRMedicationRequest -> {
println("Prescription: ${resource.medicationCodeableConcept?.text} " )
println("Status: ${resource.status} " )
println("Requester: ${resource.requester?.display} " )
}
}
}
},
onFailure = { exception ->
println("Failed to read medications: $exception " )
}
)
}
suspend fun getActiveAllergies () val result = healthConnector.readAllergies(includeInactive = false )
result.fold(
onSuccess = { allergies ->
allergies.forEach { allergy ->
println("Allergen: ${allergy.code?.text} " )
println("Type: ${allergy.type} " )
println("Category: ${allergy.category.joinToString()} " )
println("Criticality: ${allergy.criticality} " )
println("Reactions: ${allergy.reaction.joinToString { it.description ?: "Unknown" } }" )
}
},
onFailure = { exception ->
println("Failed to read allergies: $exception " )
}
)
}
suspend fun getMedicalConditions () val result = healthConnector.readConditions(includeResolved = false )
result.fold(
onSuccess = { conditions ->
conditions.forEach { condition ->
println("Condition: ${condition.code.text} " )
println("Clinical Status: ${condition.clinicalStatus?.text} " )
println("Verification: ${condition.verificationStatus?.text} " )
println("Onset: ${condition.onsetDateTime} " )
println("Severity: ${condition.severity?.text} " )
}
},
onFailure = { exception ->
println("Failed to read conditions: $exception " )
}
)
}
suspend fun getLabResults () val result = healthConnector.readLabResults(category = "laboratory" )
result.fold(
onSuccess = { observations ->
observations.forEach { observation ->
println("Test: ${observation.code.text} " )
println("Value: ${observation.valueQuantity?.value} ${observation.valueQuantity?.unit} " )
println("Status: ${observation.status} " )
println("Date: ${observation.effectiveDateTime} " )
println("Reference Range: ${observation.referenceRange.firstOrNull()?.text} " )
}
},
onFailure = { exception ->
println("Failed to read lab results: $exception " )
}
)
}
suspend fun getRecentProcedures () val sixMonthsAgo = Clock.System.now().minus(180. days)
val result = healthConnector.readProcedures(startDate = sixMonthsAgo)
result.fold(
onSuccess = { procedures ->
procedures.forEach { procedure ->
println("Procedure: ${procedure.code?.text} " )
println("Status: ${procedure.status} " )
println("Date: ${procedure.performedDateTime} " )
println("Outcome: ${procedure.outcome?.text} " )
println("Performer: ${procedure.performer.firstOrNull()?.actor?.display} " )
}
},
onFailure = { exception ->
println("Failed to read procedures: $exception " )
}
)
}
ALLERGY_INTOLERANCE - Allergies and intolerances
CONDITION - Medical conditions and diagnoses
IMMUNIZATION - Vaccination records
MEDICATION - Current medications
MEDICATION_REQUEST - Prescriptions
MEDICATION_STATEMENT - Medication usage history
OBSERVATION - Lab results and vital signs
PROCEDURE - Medical procedures
DIAGNOSTIC_REPORT - Lab and imaging reports
DOCUMENT_REFERENCE - Clinical documents
suspend fun getWeeklyHeartRateStats () val endTime = Clock.System.now()
val startTime = endTime.minus(7. days)
val result = healthConnector.readStatistics(
dataType = HealthDataType.HeartRate,
startDate = startTime,
endDate = endTime,
statisticOptions = setOf(
StatisticOption.AVERAGE,
StatisticOption.MIN,
StatisticOption.MAX
),
bucketDuration = 1. days
)
result.fold(
onSuccess = { stats ->
stats.dataPoints.forEach { dataPoint ->
println("Date: ${dataPoint.startTime} - ${dataPoint.endTime} " )
println("Average HR: ${dataPoint.average} bpm" )
println("Min HR: ${dataPoint.min} bpm" )
println("Max HR: ${dataPoint.max} bpm" )
}
},
onFailure = { exception ->
println("Failed to get statistics: $exception " )
}
)
}
suspend fun getDailyFitnessStats () val today = Clock.System.now()
val yesterday = today.minus(1. days)
val dataTypes = setOf(
HealthDataType.Steps,
HealthDataType.Calories,
HealthDataType.Distance,
HealthDataType.HeartRate
)
dataTypes.forEach { dataType ->
val result = healthConnector.readStatistics(
dataType = dataType,
startDate = yesterday,
endDate = today,
statisticOptions = when (dataType) {
HealthDataType.HeartRate -> setOf(StatisticOption.AVERAGE)
else -> setOf(StatisticOption.TOTAL)
}
)
result.fold(
onSuccess = { stats ->
println("\n$dataType statistics:" )
when (dataType) {
HealthDataType.Steps, HealthDataType.Calories, HealthDataType.Distance -> {
println("Total: ${stats.total} " )
}
HealthDataType.HeartRate -> {
println("Average: ${stats.average} " )
}
else -> {
println("Data: $stats " )
}
}
},
onFailure = { exception ->
println("Failed to get $dataType stats: $exception " )
}
)
}
}
val
if
100
50
"Abnormal heart rate: ${heartRate.beatsPerMinute} bpm"
val
Related libraries Surfaced from shared tags and platforms — no rankings paid for.
kaluga ★ 397
splendo Offers modular tools for cross-platform mobile app development, including features like MVVM architecture, location services, permissions management, Bluetooth communication, and more, using coroutines and `Flow` for efficient design. Shared: kotlin-flow, apple konnection ★ 170
TM-Apps Library emits network connection status, offers immediate connection state checks, IP info retrieval, and network state observation. Supports customizable instance creation and includes default IP resolvers. Shared: kotlin-flow, apple kmp-app-review ★ 89
SergeiMikhailovskii Enables launching in-app or market reviews from shared code, supporting multiple app stores with implementations for Amazon, App Gallery, Galaxy Store, Google Play, and RuStore. Shared: kotlin-flow, apple core-crypto ★ 47
wireapp Abstracts MLS and Proteus into a unified API, provides FFI bindings for various platforms, and includes an encrypted keystore using SQLCipher or AES256-GCM. Offers comprehensive build instructions and versioning guidelines. Shared: apple, api libphonenumber-kotlin ★ 46
luca992 Enhances phone number handling by addressing performance issues and reducing method count in Android applications. Offers a repackaged API and custom instantiation methods for streamlined usage. Shared: apple, api bipak ★ 35
nicolashaan Aims to simplify paging and data flow management across various UI patterns, supporting network or database data sources. Provides integration with Android RecyclerView, Jetpack Compose, SwiftUI, and UIKit. Shared: kotlin-flow, apple 
