@asiriindatissa/capacitor-health 9.0.3 → 9.0.4

package/README.md

@@ -213,10 +213,10 @@ const { sleepSessions } = await Health.querySleep({
 * [`isAvailable()`](#isavailable)
 * [`requestAuthorization(...)`](#requestauthorization)
 * [`checkAuthorization(...)`](#checkauthorization)
-* [`readSamples(...)`](#readsamples)
 * [`getPluginVersion()`](#getpluginversion)
 * [`openHealthConnectSettings()`](#openhealthconnectsettings)
 * [`showPrivacyPolicy()`](#showprivacypolicy)
+* [`queryWorkouts(...)`](#queryworkouts)
 * [`querySleep(...)`](#querysleep)
 * [`queryHydration(...)`](#queryhydration)
 * [Interfaces](#interfaces)
@@ -274,23 +274,6 @@ Checks authorization status for the provided data types without prompting the us
 --------------------
 
 
-### readSamples(...)
-
-```typescript
-readSamples(options: QueryOptions) => Promise<ReadSamplesResult>
-```
-
-Reads samples for the given data type within the specified time frame.
-
-| Param         | Type                                                  |
-| ------------- | ----------------------------------------------------- |
-| **`options`** | <code><a href="#queryoptions">QueryOptions</a></code> |
-
-**Returns:** <code>Promise&lt;<a href="#readsamplesresult">ReadSamplesResult</a>&gt;</code>
-
---------------------
-
-
 ### getPluginVersion()
 
 ```typescript
@@ -336,6 +319,23 @@ or by placing an HTML file at www/privacypolicy.html in your assets.
 --------------------
 
 
+### queryWorkouts(...)
+
+```typescript
+queryWorkouts(options: QueryWorkoutsOptions) => Promise<QueryWorkoutsResult>
+```
+
+Queries workout sessions from the native health store on Android (Health Connect).
+
+| Param         | Type                                                                  | Description                                                                             |
+| ------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| **`options`** | <code><a href="#queryworkoutsoptions">QueryWorkoutsOptions</a></code> | Query options including optional workout type filter, date range, limit, and sort order |
+
+**Returns:** <code>Promise&lt;<a href="#queryworkoutsresult">QueryWorkoutsResult</a>&gt;</code>
+
+--------------------
+
+
 ### querySleep(...)
 
 ```typescript
@@ -399,35 +399,35 @@ Queries hydration records from the native health store on Android (Health Connec
 | **`read`** | <code>ReadAuthorizationType[]</code> | Data types that should be readable after authorization. |
 
 
-#### ReadSamplesResult
+#### QueryWorkoutsResult
 
-| Prop          | Type                        |
-| ------------- | --------------------------- |
-| **`samples`** | <code>HealthSample[]</code> |
+| Prop           | Type                   |
+| -------------- | ---------------------- |
+| **`workouts`** | <code>Workout[]</code> |
 
 
-#### HealthSample
+#### Workout
 
-| Prop             | Type                                                      |
-| ---------------- | --------------------------------------------------------- |
-| **`dataType`**   | <code><a href="#healthdatatype">HealthDataType</a></code> |
-| **`value`**      | <code>number</code>                                       |
-| **`unit`**       | <code><a href="#healthunit">HealthUnit</a></code>         |
-| **`startDate`**  | <code>string</code>                                       |
-| **`endDate`**    | <code>string</code>                                       |
-| **`sourceName`** | <code>string</code>                                       |
-| **`sourceId`**   | <code>string</code>                                       |
+| Prop              | Type                                                            | Description                            |
+| ----------------- | --------------------------------------------------------------- | -------------------------------------- |
+| **`workoutType`** | <code><a href="#workouttype">WorkoutType</a></code>             | The type of workout.                   |
+| **`duration`**    | <code>number</code>                                             | Duration of the workout in seconds.    |
+| **`startDate`**   | <code>string</code>                                             | ISO 8601 start date of the workout.    |
+| **`endDate`**     | <code>string</code>                                             | ISO 8601 end date of the workout.      |
+| **`sourceName`**  | <code>string</code>                                             | Source name that recorded the workout. |
+| **`sourceId`**    | <code>string</code>                                             | Source bundle identifier.              |
+| **`metadata`**    | <code><a href="#record">Record</a>&lt;string, string&gt;</code> | Additional metadata (if available).    |
 
 
-#### QueryOptions
+#### QueryWorkoutsOptions
 
-| Prop            | Type                                                      | Description                                                        |
-| --------------- | --------------------------------------------------------- | ------------------------------------------------------------------ |
-| **`dataType`**  | <code><a href="#healthdatatype">HealthDataType</a></code> | The type of data to retrieve from the health store.                |
-| **`startDate`** | <code>string</code>                                       | Inclusive ISO 8601 start date (defaults to now - 1 day).           |
-| **`endDate`**   | <code>string</code>                                       | Exclusive ISO 8601 end date (defaults to now).                     |
-| **`limit`**     | <code>number</code>                                       | Maximum number of samples to return (defaults to 100).             |
-| **`ascending`** | <code>boolean</code>                                      | Return results sorted ascending by start date (defaults to false). |
+| Prop              | Type                                                | Description                                                               |
+| ----------------- | --------------------------------------------------- | ------------------------------------------------------------------------- |
+| **`workoutType`** | <code><a href="#workouttype">WorkoutType</a></code> | Optional workout type filter. If omitted, all workout types are returned. |
+| **`startDate`**   | <code>string</code>                                 | Inclusive ISO 8601 start date (defaults to now - 1 day).                  |
+| **`endDate`**     | <code>string</code>                                 | Exclusive ISO 8601 end date (defaults to now).                            |
+| **`limit`**       | <code>number</code>                                 | Maximum number of workouts to return (defaults to 100).                   |
+| **`ascending`**   | <code>boolean</code>                                | Return results sorted ascending by start date (defaults to false).        |
 
 
 #### QuerySleepResult
@@ -505,33 +505,29 @@ Queries hydration records from the native health store on Android (Health Connec
 #### ReadAuthorizationType
 
 Data types that can be requested for read authorization.
+Includes 'workouts' for querying workout sessions via queryWorkouts().
 Includes 'sleep' for querying sleep sessions via querySleep().
 Includes 'hydration' for querying hydration records via queryHydration().
 
-<code><a href="#healthdatatype">HealthDataType</a> | 'sleep' | 'hydration'</code>
+<code>'workouts' | 'sleep' | 'hydration'</code>
 
 
-#### HealthDataType
+#### WorkoutType
 
-<code>'steps'</code>
+<code>'running' | 'cycling' | 'walking' | 'swimming' | 'yoga' | 'strengthTraining' | 'hiking' | 'tennis' | 'basketball' | 'soccer' | 'americanFootball' | 'baseball' | 'crossTraining' | 'elliptical' | 'rowing' | 'stairClimbing' | 'traditionalStrengthTraining' | 'waterFitness' | 'waterPolo' | 'waterSports' | 'wrestling' | 'other'</code>
 
 
-#### HealthUnit
+#### Record
+
+Construct a type with a set of properties K of type T
 
-<code>'count'</code>
+<code>{
 [P in K]: T;
 }</code>
 
 
 #### SleepStage
 
 <code>'unknown' | 'awake' | 'sleeping' | 'outOfBed' | 'awakeInBed' | 'light' | 'deep' | 'rem'</code>
 
-
-#### Record
-
-Construct a type with a set of properties K of type T
-
-<code>{
 [P in K]: T;
 }</code>
-
 </docgen-api>
 
 ### Credits:

package/android/src/main/AndroidManifest.xml

@@ -1,7 +1,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.health.READ_SLEEP" />
     <uses-permission android:name="android.permission.health.READ_HYDRATION" />
-    <uses-permission android:name="android.permission.health.READ_STEPS" />
+    <uses-permission android:name="android.permission.health.READ_EXERCISE" />
+
     <!-- Query for Health Connect availability -->
     <queries>
         <package android:name="com.google.android.apps.healthdata" />

package/android/src/main/java/app/capgo/plugin/health/HealthManager.kt

@@ -2,19 +2,15 @@ package app.capgo.plugin.health
 
 import androidx.health.connect.client.HealthConnectClient
 import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.records.ExerciseSessionRecord
 import androidx.health.connect.client.records.HydrationRecord
 import androidx.health.connect.client.records.SleepSessionRecord
-import androidx.health.connect.client.records.StepsRecord
-import androidx.health.connect.client.records.Record
 import androidx.health.connect.client.request.ReadRecordsRequest
 import androidx.health.connect.client.time.TimeRangeFilter
-import androidx.health.connect.client.records.metadata.Metadata
 import java.time.Duration
 import com.getcapacitor.JSArray
 import com.getcapacitor.JSObject
 import java.time.Instant
-import java.time.ZoneId
-import java.time.ZoneOffset
 import java.time.format.DateTimeFormatter
 import kotlin.math.min
 import kotlin.collections.buildSet
@@ -23,8 +19,11 @@ class HealthManager {
 
     private val formatter: DateTimeFormatter = DateTimeFormatter.ISO_INSTANT
 
-    fun permissionsFor(readTypes: Collection<HealthDataType>, includeSleep: Boolean = false, includeHydration: Boolean = false): Set<String> = buildSet {
-        readTypes.forEach { add(it.readPermission) }
+    fun permissionsFor(includeWorkouts: Boolean = false, includeSleep: Boolean = false, includeHydration: Boolean = false): Set<String> = buildSet {
+        // Include workout read permission if explicitly requested
+        if (includeWorkouts) {
+            add(HealthPermission.getReadPermission(ExerciseSessionRecord::class))
+        }
         // Include sleep read permission if explicitly requested
         if (includeSleep) {
             add(HealthPermission.getReadPermission(SleepSessionRecord::class))
@@ -37,7 +36,7 @@ class HealthManager {
 
     suspend fun authorizationStatus(
         client: HealthConnectClient,
-        readTypes: Collection<HealthDataType>,
+        includeWorkouts: Boolean = false,
         includeSleep: Boolean = false,
         includeHydration: Boolean = false
     ): JSObject {
@@ -46,11 +45,13 @@ class HealthManager {
         val readAuthorized = JSArray()
         val readDenied = JSArray()
 
-        readTypes.forEach { type ->
-            if (granted.contains(type.readPermission)) {
-                readAuthorized.put(type.identifier)
+        // Check workout permission if requested
+        if (includeWorkouts) {
+            val workoutPermission = HealthPermission.getReadPermission(ExerciseSessionRecord::class)
+            if (granted.contains(workoutPermission)) {
+                readAuthorized.put("workouts")
             } else {
-                readDenied.put(type.identifier)
+                readDenied.put("workouts")
             }
         }
 
@@ -86,83 +87,87 @@ class HealthManager {
     }
 
 
-    suspend fun readSamples(
-        client: HealthConnectClient,
-        dataType: HealthDataType,
-        startTime: Instant,
-        endTime: Instant,
-        limit: Int,
-        ascending: Boolean
-    ): JSArray {
-        val samples = mutableListOf<Pair<Instant, JSObject>>()
-        when (dataType) {
-            HealthDataType.STEPS -> readRecords(client, StepsRecord::class, startTime, endTime, limit) { record ->
-                val payload = createSamplePayload(
-                    dataType,
-                    record.startTime,
-                    record.endTime,
-                    record.count.toDouble(),
-                    record.metadata
-                )
-                samples.add(record.startTime to payload)
-            }
+    fun parseInstant(value: String?, defaultInstant: Instant): Instant {
+        if (value.isNullOrBlank()) {
+            return defaultInstant
         }
+        return Instant.parse(value)
+    }
 
-        val sorted = samples.sortedBy { it.first }
-        val ordered = if (ascending) sorted else sorted.asReversed()
-        val limited = if (limit > 0) ordered.take(limit) else ordered
 
-        val array = JSArray()
-        limited.forEach { array.put(it.second) }
-        return array
+    private fun zoneOffset(instant: Instant): ZoneOffset? {
+        return ZoneId.systemDefault().rules.getOffset(instant)
     }
 
-    private suspend fun <T : Record> readRecords(
+    suspend fun queryWorkouts(
         client: HealthConnectClient,
-        recordClass: kotlin.reflect.KClass<T>,
+        workoutType: String?,
         startTime: Instant,
         endTime: Instant,
         limit: Int,
-        consumer: (record: T) -> Unit
-    ) {
+        ascending: Boolean
+    ): JSArray {
+        val workouts = mutableListOf<Pair<Instant, JSObject>>()
+
         var pageToken: String? = null
         val pageSize = if (limit > 0) min(limit, MAX_PAGE_SIZE) else DEFAULT_PAGE_SIZE
         var fetched = 0
 
+        val exerciseTypeFilter = WorkoutType.fromString(workoutType)
+
         do {
             val request = ReadRecordsRequest(
-                recordType = recordClass,
+                recordType = ExerciseSessionRecord::class,
                 timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
                 pageSize = pageSize,
                 pageToken = pageToken
             )
             val response = client.readRecords(request)
+
             response.records.forEach { record ->
-                consumer(record)
+                val session = record as ExerciseSessionRecord
+
+                // Filter by exercise type if specified
+                if (exerciseTypeFilter != null && session.exerciseType != exerciseTypeFilter) {
+                    return@forEach
+                }
+
+                val payload = createWorkoutPayload(session)
+                workouts.add(session.startTime to payload)
             }
+
             fetched += response.records.size
             pageToken = response.pageToken
         } while (pageToken != null && (limit <= 0 || fetched < limit))
+
+        val sorted = workouts.sortedBy { it.first }
+        val ordered = if (ascending) sorted else sorted.asReversed()
+        val limited = if (limit > 0) ordered.take(limit) else ordered
+
+        val array = JSArray()
+        limited.forEach { array.put(it.second) }
+        return array
     }
 
-    private fun createSamplePayload(
-        dataType: HealthDataType,
-        startTime: Instant,
-        endTime: Instant,
-        value: Double,
-        metadata: Metadata
-    ): JSObject {
+    private fun createWorkoutPayload(session: ExerciseSessionRecord): JSObject {
         val payload = JSObject()
-        payload.put("dataType", dataType.identifier)
-        payload.put("value", value)
-        payload.put("unit", dataType.unit)
-        payload.put("startDate", formatter.format(startTime))
-        payload.put("endDate", formatter.format(endTime))
 
-        val dataOrigin = metadata.dataOrigin
+        // Workout type
+        payload.put("workoutType", WorkoutType.toWorkoutTypeString(session.exerciseType))
+
+        // Duration in seconds
+        val durationSeconds = Duration.between(session.startTime, session.endTime).seconds.toInt()
+        payload.put("duration", durationSeconds)
+
+        // Start and end dates
+        payload.put("startDate", formatter.format(session.startTime))
+        payload.put("endDate", formatter.format(session.endTime))
+
+        // Source information
+        val dataOrigin = session.metadata.dataOrigin
         payload.put("sourceId", dataOrigin.packageName)
         payload.put("sourceName", dataOrigin.packageName)
-        metadata.device?.let { device ->
+        session.metadata.device?.let { device ->
             val manufacturer = device.manufacturer?.takeIf { it.isNotBlank() }
             val model = device.model?.takeIf { it.isNotBlank() }
             val label = listOfNotNull(manufacturer, model).joinToString(" ").trim()
@@ -174,19 +179,6 @@ class HealthManager {
         return payload
     }
 
-    fun parseInstant(value: String?, defaultInstant: Instant): Instant {
-        if (value.isNullOrBlank()) {
-            return defaultInstant
-        }
-        return Instant.parse(value)
-    }
-
-
-    private fun zoneOffset(instant: Instant): ZoneOffset? {
-        return ZoneId.systemDefault().rules.getOffset(instant)
-    }
-
-
     suspend fun querySleep(
         client: HealthConnectClient,
         startTime: Instant,

package/android/src/main/java/app/capgo/plugin/health/HealthPlugin.kt

@@ -23,7 +23,7 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 
 data class ReadAuthorizationTypes(
-    val dataTypes: List<HealthDataType>,
+    val includeWorkouts: Boolean,
     val includeSleep: Boolean,
     val includeHydration: Boolean
 )
@@ -36,7 +36,7 @@ class HealthPlugin : Plugin() {
     private val permissionContract = PermissionController.createRequestPermissionResultContract()
 
     // Store pending request data for callback
-    private var pendingReadTypes: List<HealthDataType> = emptyList()
+    private var pendingIncludeWorkouts: Boolean = false
     private var pendingIncludeSleep: Boolean = false
     private var pendingIncludeHydration: Boolean = false
 
@@ -63,7 +63,7 @@ class HealthPlugin : Plugin() {
         pluginScope.launch {
             val client = getClientOrReject(call) ?: return@launch
             val permissions = manager.permissionsFor(
-                readAuth.dataTypes,
+                readAuth.includeWorkouts,
                 readAuth.includeSleep,
                 readAuth.includeHydration
             )
@@ -71,7 +71,7 @@ class HealthPlugin : Plugin() {
             if (permissions.isEmpty()) {
                 val status = manager.authorizationStatus(
                     client,
-                    readAuth.dataTypes,
+                    readAuth.includeWorkouts,
                     readAuth.includeSleep,
                     readAuth.includeHydration
                 )
@@ -83,7 +83,7 @@ class HealthPlugin : Plugin() {
             if (granted.containsAll(permissions)) {
                 val status = manager.authorizationStatus(
                     client,
-                    readAuth.dataTypes,
+                    readAuth.includeWorkouts,
                     readAuth.includeSleep,
                     readAuth.includeHydration
                 )
@@ -92,7 +92,7 @@ class HealthPlugin : Plugin() {
             }
 
             // Store types for callback
-            pendingReadTypes = readAuth.dataTypes
+            pendingIncludeWorkouts = readAuth.includeWorkouts
             pendingIncludeSleep = readAuth.includeSleep
             pendingIncludeHydration = readAuth.includeHydration
 
@@ -113,16 +113,16 @@ class HealthPlugin : Plugin() {
             return
         }
 
-        val readTypes = pendingReadTypes
+        val includeWorkouts = pendingIncludeWorkouts
         val includeSleep = pendingIncludeSleep
         val includeHydration = pendingIncludeHydration
-        pendingReadTypes = emptyList()
+        pendingIncludeWorkouts = false
         pendingIncludeSleep = false
         pendingIncludeHydration = false
 
         pluginScope.launch {
             val client = getClientOrReject(call) ?: return@launch
-            val status = manager.authorizationStatus(client, readTypes, includeSleep, includeHydration)
+            val status = manager.authorizationStatus(client, includeWorkouts, includeSleep, includeHydration)
             call.resolve(status)
         }
     }
@@ -140,7 +140,7 @@ class HealthPlugin : Plugin() {
             val client = getClientOrReject(call) ?: return@launch
             val status = manager.authorizationStatus(
                 client,
-                readAuth.dataTypes,
+                readAuth.includeWorkouts,
                 readAuth.includeSleep,
                 readAuth.includeHydration
             )
@@ -148,72 +148,22 @@ class HealthPlugin : Plugin() {
         }
     }
 
-    @PluginMethod
-    fun readSamples(call: PluginCall) {
-        val identifier = call.getString("dataType")
-        if (identifier.isNullOrBlank()) {
-            call.reject("dataType is required")
-            return
-        }
-
-        val dataType = HealthDataType.from(identifier)
-        if (dataType == null) {
-            call.reject("Unsupported data type: $identifier")
-            return
-        }
-
-        val limit = (call.getInt("limit") ?: DEFAULT_LIMIT).coerceAtLeast(0)
-        val ascending = call.getBoolean("ascending") ?: false
-
-        val startInstant = try {
-            manager.parseInstant(call.getString("startDate"), Instant.now().minus(DEFAULT_PAST_DURATION))
-        } catch (e: DateTimeParseException) {
-            call.reject(e.message, null, e)
-            return
-        }
-
-        val endInstant = try {
-            manager.parseInstant(call.getString("endDate"), Instant.now())
-        } catch (e: DateTimeParseException) {
-            call.reject(e.message, null, e)
-            return
-        }
-
-        if (endInstant.isBefore(startInstant)) {
-            call.reject("endDate must be greater than or equal to startDate")
-            return
-        }
-
-        pluginScope.launch {
-            val client = getClientOrReject(call) ?: return@launch
-            try {
-                val samples = manager.readSamples(client, dataType, startInstant, endInstant, limit, ascending)
-                val result = JSObject().apply { put("samples", samples) }
-                call.resolve(result)
-            } catch (e: Exception) {
-                call.reject(e.message ?: "Failed to read samples.", null, e)
-            }
-        }
-    }
 
     private fun parseReadAuthorizationTypes(call: PluginCall, key: String): ReadAuthorizationTypes {
         val array = call.getArray(key) ?: JSArray()
-        val result = mutableListOf<HealthDataType>()
+        var includeWorkouts = false
         var includeSleep = false
         var includeHydration = false
         for (i in 0 until array.length()) {
             val identifier = array.optString(i, null) ?: continue
             when (identifier) {
+                "workouts" -> includeWorkouts = true
                 "sleep" -> includeSleep = true
                 "hydration" -> includeHydration = true
-                else -> {
-                    val dataType = HealthDataType.from(identifier)
-                        ?: throw IllegalArgumentException("Unsupported data type: $identifier")
-                    result.add(dataType)
-                }
+                else -> throw IllegalArgumentException("Unsupported data type: $identifier")
             }
         }
-        return ReadAuthorizationTypes(result, includeSleep, includeHydration)
+        return ReadAuthorizationTypes(includeWorkouts, includeSleep, includeHydration)
     }
 
     private fun getClientOrReject(call: PluginCall): HealthConnectClient? {
@@ -278,6 +228,43 @@ class HealthPlugin : Plugin() {
         }
     }
 
+    @PluginMethod
+    fun queryWorkouts(call: PluginCall) {
+        val workoutType = call.getString("workoutType")
+        val limit = (call.getInt("limit") ?: DEFAULT_LIMIT).coerceAtLeast(0)
+        val ascending = call.getBoolean("ascending") ?: false
+
+        val startInstant = try {
+            manager.parseInstant(call.getString("startDate"), Instant.now().minus(DEFAULT_PAST_DURATION))
+        } catch (e: DateTimeParseException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        val endInstant = try {
+            manager.parseInstant(call.getString("endDate"), Instant.now())
+        } catch (e: DateTimeParseException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        if (endInstant.isBefore(startInstant)) {
+            call.reject("endDate must be greater than or equal to startDate")
+            return
+        }
+
+        pluginScope.launch {
+            val client = getClientOrReject(call) ?: return@launch
+            try {
+                val workouts = manager.queryWorkouts(client, workoutType, startInstant, endInstant, limit, ascending)
+                val result = JSObject().apply { put("workouts", workouts) }
+                call.resolve(result)
+            } catch (e: Exception) {
+                call.reject(e.message ?: "Failed to query workouts.", null, e)
+            }
+        }
+    }
+
     @PluginMethod
     fun querySleep(call: PluginCall) {
         val limit = (call.getInt("limit") ?: DEFAULT_LIMIT).coerceAtLeast(0)

package/android/src/main/java/app/capgo/plugin/health/WorkoutType.kt

@@ -0,0 +1,64 @@
+package app.capgo.plugin.health
+
+import androidx.health.connect.client.records.ExerciseSessionRecord
+
+object WorkoutType {
+    fun fromString(type: String?): Int? {
+        if (type.isNullOrBlank()) return null
+
+        return when (type) {
+            "running" -> ExerciseSessionRecord.EXERCISE_TYPE_RUNNING
+            "cycling" -> ExerciseSessionRecord.EXERCISE_TYPE_BIKING
+            "walking" -> ExerciseSessionRecord.EXERCISE_TYPE_WALKING
+            "swimming" -> ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_POOL
+            "yoga" -> ExerciseSessionRecord.EXERCISE_TYPE_YOGA
+            "strengthTraining" -> ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING
+            "hiking" -> ExerciseSessionRecord.EXERCISE_TYPE_HIKING
+            "tennis" -> ExerciseSessionRecord.EXERCISE_TYPE_TENNIS
+            "basketball" -> ExerciseSessionRecord.EXERCISE_TYPE_BASKETBALL
+            "soccer" -> ExerciseSessionRecord.EXERCISE_TYPE_SOCCER
+            "americanFootball" -> ExerciseSessionRecord.EXERCISE_TYPE_FOOTBALL_AMERICAN
+            "baseball" -> ExerciseSessionRecord.EXERCISE_TYPE_BASEBALL
+            "crossTraining" -> ExerciseSessionRecord.EXERCISE_TYPE_HIGH_INTENSITY_INTERVAL_TRAINING
+            "elliptical" -> ExerciseSessionRecord.EXERCISE_TYPE_ELLIPTICAL
+            "rowing" -> ExerciseSessionRecord.EXERCISE_TYPE_ROWING
+            "stairClimbing" -> ExerciseSessionRecord.EXERCISE_TYPE_STAIR_CLIMBING
+            "traditionalStrengthTraining" -> ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING
+            "waterFitness" -> ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_POOL
+            "waterPolo" -> ExerciseSessionRecord.EXERCISE_TYPE_WATER_POLO
+            "waterSports" -> ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_OPEN_WATER
+            "wrestling" -> ExerciseSessionRecord.EXERCISE_TYPE_MARTIAL_ARTS
+            "other" -> ExerciseSessionRecord.EXERCISE_TYPE_OTHER_WORKOUT
+            else -> null
+        }
+    }
+
+    fun toWorkoutTypeString(exerciseType: Int): String {
+        return when (exerciseType) {
+            ExerciseSessionRecord.EXERCISE_TYPE_RUNNING -> "running"
+            ExerciseSessionRecord.EXERCISE_TYPE_BIKING -> "cycling"
+            ExerciseSessionRecord.EXERCISE_TYPE_BIKING_STATIONARY -> "cycling"
+            ExerciseSessionRecord.EXERCISE_TYPE_WALKING -> "walking"
+            ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_POOL -> "swimming"
+            ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_OPEN_WATER -> "swimming"
+            ExerciseSessionRecord.EXERCISE_TYPE_YOGA -> "yoga"
+            ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING -> "strengthTraining"
+            ExerciseSessionRecord.EXERCISE_TYPE_HIKING -> "hiking"
+            ExerciseSessionRecord.EXERCISE_TYPE_TENNIS -> "tennis"
+            ExerciseSessionRecord.EXERCISE_TYPE_BASKETBALL -> "basketball"
+            ExerciseSessionRecord.EXERCISE_TYPE_SOCCER -> "soccer"
+            ExerciseSessionRecord.EXERCISE_TYPE_FOOTBALL_AMERICAN -> "americanFootball"
+            ExerciseSessionRecord.EXERCISE_TYPE_BASEBALL -> "baseball"
+            ExerciseSessionRecord.EXERCISE_TYPE_HIGH_INTENSITY_INTERVAL_TRAINING -> "crossTraining"
+            ExerciseSessionRecord.EXERCISE_TYPE_ELLIPTICAL -> "elliptical"
+            ExerciseSessionRecord.EXERCISE_TYPE_ROWING -> "rowing"
+            ExerciseSessionRecord.EXERCISE_TYPE_ROWING_MACHINE -> "rowing"
+            ExerciseSessionRecord.EXERCISE_TYPE_STAIR_CLIMBING -> "stairClimbing"
+            ExerciseSessionRecord.EXERCISE_TYPE_STAIR_CLIMBING_MACHINE -> "stairClimbing"
+            ExerciseSessionRecord.EXERCISE_TYPE_WATER_POLO -> "waterPolo"
+            ExerciseSessionRecord.EXERCISE_TYPE_MARTIAL_ARTS -> "wrestling"
+            ExerciseSessionRecord.EXERCISE_TYPE_OTHER_WORKOUT -> "other"
+            else -> "other"
+        }
+    }
+}