react-native-spike-sdk 4.0.13-beta.6 → 4.0.13-beta.7

package/android/build.gradle

@@ -76,7 +76,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-android:0.71.3"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'com.spikeapi.sdk:spike-sdk:4.0.12-beta.3'
+  implementation 'com.spikeapi.sdk:spike-sdk:4.0.12-beta.4'
   implementation 'androidx.core:core-ktx:1.9.0'
   implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.5.1'
   implementation 'com.google.code.gson:gson:2.10.1'

package/android/src/main/java/com/spikesdk/SpikeSdkModule.kt

@@ -16,7 +16,13 @@ import com.spikeapi.SpikePackageChecker
 import com.spikeapi.healthconnect.HealthConnectAvailability
 import com.spikeapi.apiv3.SpikeConnectionAPIv3
 import com.spikeapi.apiv3.datamodels.MetricType
+import com.spikeapi.apiv3.datamodels.ActivityConfig
 import com.spikeapi.apiv3.datamodels.StatisticsType
+import com.spikeapi.apiv3.datamodels.utils.ActivityConfigUtils
+import com.spikeapi.apiv3.datamodels.utils.SleepConfigUtils
+import com.spikeapi.apiv3.datamodels.utils.StatisticsTypeUtils
+import com.spikeapi.apiv3.datamodels.utils.StatisticsIntervalUtils
+import com.spikeapi.apiv3.datamodels.utils.MetricTypeUtils
 import com.spikeapi.apiv3.datamodels.StatisticsInterval
 import com.spikeapi.apiv3.datamodels.StatisticsFilter
 import com.spikeapi.apiv3.healthconnect.HealthConnectPermissionManager
@@ -608,7 +614,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     /// --- Read Health connect data ---
 
     @ReactMethod
-    fun getStatisticsconnectionUUID(
+    fun getStatistics(
         connectionUUID: String,
         types: ReadableArray, // [StatisticsType]
         from: String, // Instant
@@ -618,32 +624,37 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         promise: Promise
     ) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (enableHealthConnectIntegration)"
-            )
-            val statTypes = types.toArrayList().mapNotNull {
-                StatisticsType.fromValue(it as String)
-            }.toSet()
-            val dateFrom = convertIsoStringToInstant(from)
-            val dateTo = convertIsoStringToInstant(to)
-            val statsInterval = StatisticsInterval.fromValue(interval)
-            val statsFilter = StatisticsFilter.fromValue(filter)
-
-            val result = connection.getStatistics(
-                types = statTypes,
-                from = dateFrom,
-                to = dateTo,
-                interval = statsInterval,
-                filter = statsFilter
-            )
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (enableHealthConnectIntegration)"
+                )
+                val statTypes = types.toArrayList().mapNotNull {
+                    StatisticsTypeUtils.fromValue(it as String)
+                }.toSet()
+                val dateFrom = convertIsoStringToInstant(from)
+                val dateTo = convertIsoStringToInstant(to)
+                val statsInterval = StatisticsIntervalUtils.fromValue(interval)
+                val statsFilter = StatisticsFilter.fromValue(filter)
+
+                val result = connection.getStatistics(
+                    types = statTypes,
+                    from = dateFrom,
+                    to = dateTo,
+                    interval = statsInterval,
+                    filter = statsFilter
+                )
+
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
 
-            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
-    fun getRecordsconnectionUUID(
+    fun getRecords(
         connectionUUID: String,
         types: ReadableArray, // [MetricType]
         from: String, // Instant
@@ -652,25 +663,68 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         promise: Promise
     ) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (enableHealthConnectIntegration)"
-            )
-            val statTypes = types.toArrayList().mapNotNull {
-                MetricType.fromValue(it as String)
-            }.toSet()
-            val dateFrom = convertIsoStringToInstant(from)
-            val dateTo = convertIsoStringToInstant(to)
-            val statsFilter = StatisticsFilter.fromValue(filter)
-
-            val result = connection.getRecords(
-                types = statTypes,
-                from = dateFrom,
-                to = dateTo,
-                filter = statsFilter
-            )
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (enableHealthConnectIntegration)"
+                )
+                val statTypes = types.toArrayList().mapNotNull {
+                    MetricTypeUtils.fromValue(it as String)
+                }.toSet()
+                val dateFrom = convertIsoStringToInstant(from)
+                val dateTo = convertIsoStringToInstant(to)
+                val statsFilter = StatisticsFilter.fromValue(filter)
+
+                val result = connection.getRecords(
+                    types = statTypes,
+                    from = dateFrom,
+                    to = dateTo,
+                    filter = statsFilter
+                )
+
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+            
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
 
-            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+    @ReactMethod
+    fun getActivities(
+        connectionUUID: String,
+        configJson: String, // ActivityConfig
+        from: String, // Instant
+        to: String, // Instant
+        filter: String?, // StatisticsFilter?
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (enableHealthConnectIntegration)"
+                )
+                // val statTypes = types.toArrayList().mapNotNull {
+                //     MetricTypeUtils.fromValue(it as String)
+                // }.toSet()
+                val dateFrom = convertIsoStringToInstant(from)
+                val dateTo = convertIsoStringToInstant(to)
+                val statsFilter = StatisticsFilter.fromValue(filter)
+                val configObject = ActivityConfigUtils.fromValue(configJson) ?: ActivityConfig()
+
+                val result = connection.getActivities(
+                    config = configObject,
+                    from = dateFrom,
+                    to = dateTo,
+                    filter = statsFilter
+                )
+
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+            
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
@@ -679,183 +733,253 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     @ReactMethod
     fun checkHealthConnectAvailability(connectionUUID: String, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (checkHealthConnectAvailability)"
-            )
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (checkHealthConnectAvailability)"
+                )
 
-            val result = connection.checkHealthConnectAvailability()
-            promise.resolve(result.value)
+                val result = connection.checkHealthConnectAvailability()
+                promise.resolve(result.value)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun openHealthConnectInstallation(connectionUUID: String, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (openHealthConnectInstallation)"
-            )
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (openHealthConnectInstallation)"
+                )
 
-            connection.openHealthConnectInstallation()
-            promise.resolve(true)
+                connection.openHealthConnectInstallation()
+                promise.resolve(true)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun enableHealthConnectIntegration(connectionUUID: String, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (enableHealthConnectIntegration)"
-            )
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (enableHealthConnectIntegration)"
+                )
 
-            connection.enableHealthConnectIntegration()
-            Log.d("SpikeSdkModule", "Health Connect integration enabled")
-            promise.resolve(true)
+                connection.enableHealthConnectIntegration()
+                Log.d("SpikeSdkModule", "Health Connect integration enabled")
+                promise.resolve(true)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun disableHealthConnectIntegration(connectionUUID: String, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (enableHealthConnectIntegration)"
-            )
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (enableHealthConnectIntegration)"
+                )
 
-            connection.disableHealthConnectIntegration()
-            Log.d("SpikeSdkModule", "Health Connect integration disabled")
-            promise.resolve(true)
+                connection.disableHealthConnectIntegration()
+                Log.d("SpikeSdkModule", "Health Connect integration disabled")
+                promise.resolve(true)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun isHealthConnectIntegrationEnabled(connectionUUID: String, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (enableHealthConnectIntegration)"
-            )
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (enableHealthConnectIntegration)"
+                )
+
+                val result = connection.isHealthConnectIntegrationEnabled()
+                Log.d("SpikeSdkModule", "Health Connect integration is " + if (result) { "enabled" } else ( "disabled" ))
+                promise.resolve(result)
 
-            val result = connection.isHealthConnectIntegrationEnabled()
-            Log.d("SpikeSdkModule", "Health Connect integration is " + if (result) { "enabled" } else ( "disabled" ))
-            promise.resolve(result)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun getGrantedHealthKitPermissions(connectionUUID: String, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (getGrantedHealthKitPermissions)"
-            )
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                    "Health Connect should be enabled before calling getGrantedHealthKitPermissions"
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (getGrantedHealthKitPermissions)"
                 )
-            }
+                if (!connection.isHealthConnectIntegrationEnabled()) {
+                    return@launch promise.reject(
+                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                        "Health Connect should be enabled before calling getGrantedHealthKitPermissions"
+                    )
+                }
 
-            val permissions = connection
-                .getHealthConnectPermissionManager()
-                .getGrantedPermissions()
+                val permissions = connection
+                    .getHealthConnectPermissionManager()
+                    .getGrantedPermissions()
+
+                val result = Arguments.createArray()
+                permissions.forEach {
+                    result.pushString(it)
+                }
+                
+                Log.w("SpikeSdkModule", "$permissions")
+                promise.resolve(result)
 
-            val result = Arguments.createArray()
-            permissions.forEach {
-                result.pushString(it)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
             }
-            
-            Log.w("SpikeSdkModule", "$permissions")
-            promise.resolve(result)
         }
     }
 
     @ReactMethod
-    fun getHealthConnectPermissionsForStatisticTypes(connectionUUID: String, statisticTypes: ReadableArray, promise: Promise) {
+    fun getHealthConnectPermissions(
+        connectionUUID: String, 
+        statisticTypes: ReadableArray, 
+        metricTypes: ReadableArray, 
+        activityConfigs: ReadableArray, 
+        sleepConfigs: ReadableArray, 
+        includeEnhancedPermissions: Boolean,
+        promise: Promise
+    ) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (getPermissionsForHealthConnect)"
-            )
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                    "Health Connect should be enabled before calling getHealthConnectPermissionsForStatisticTypes"
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (getHealthConnectPermissions)"
                 )
-            }
-            val permissionManager = connection.getHealthConnectPermissionManager()
-
-            val statTypes = statisticTypes.toArrayList().mapNotNull {
-                StatisticsType.fromValue(it as String)
-            }.toSet()
+                if (!connection.isHealthConnectIntegrationEnabled()) {
+                    return@launch promise.reject(
+                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                        "Health Connect should be enabled before calling getHealthConnectPermissionsForStatisticTypes"
+                    )
+                }
+                val permissionManager = connection.getHealthConnectPermissionManager()
+
+                val statTypes = statisticTypes.toArrayList().mapNotNull {
+                    StatisticsTypeUtils.fromValue(it as String)
+                }.toSet()
+
+                val mTypes = metricTypes.toArrayList().mapNotNull {
+                    MetricTypeUtils.fromValue(it as String)
+                }.toSet()
+
+                val aConfigs = activityConfigs.toArrayList().mapNotNull {
+                    ActivityConfigUtils.fromValue(it as String)
+                }.toSet()
+
+                val sConfigs = sleepConfigs.toArrayList().mapNotNull {
+                    SleepConfigUtils.fromValue(it as String)
+                }.toSet()
+
+                val permissions = permissionManager
+                    .getPermissions(
+                        statisticsTypes = statTypes,
+                        metricTypes = mTypes,
+                        activityConfigs = aConfigs,
+                        sleepConfigs = sConfigs,
+                        includeEnhancedPermissions = includeEnhancedPermissions
+                    )
 
-            val permissions = permissionManager
-                .getPermissionsForStatistics(statisticsTypes = statTypes)
+                val result = Arguments.createArray()
+                permissions.forEach {
+                    result.pushString(it)
+                }
+                
+                // Log.w("SpikeSdkModule", "$permissions")
+                promise.resolve(result)
 
-            val result = Arguments.createArray()
-            permissions.forEach {
-                result.pushString(it)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
             }
-            
-            // Log.w("SpikeSdkModule", "$permissions")
-            promise.resolve(result)
         }
     }
 
     @ReactMethod
     fun revokeAllHealthConnectPermissions(connectionUUID: String, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                "Connection not found (revokeAllHealthConnectPermissions)"
-            )
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                    "Health Connect should be enabled before calling revokeAllHealthConnectPermissions"
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (revokeAllHealthConnectPermissions)"
                 )
-            }
+                if (!connection.isHealthConnectIntegrationEnabled()) {
+                    return@launch promise.reject(
+                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                        "Health Connect should be enabled before calling revokeAllHealthConnectPermissions"
+                    )
+                }
 
-            connection
-                .getHealthConnectPermissionManager()
-                .revokeAllPermissions()
-            
-            promise.resolve(true)
+                connection
+                    .getHealthConnectPermissionManager()
+                    .revokeAllPermissions()
+                
+                promise.resolve(true)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun requestPermissionsFromHealthConnect(connectionUUID: String, permissions: ReadableArray, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                    "Health Connect should be enabled before calling requestPermissionsFromHealthConnect"
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
                 )
-            }
+                if (!connection.isHealthConnectIntegrationEnabled()) {
+                    return@launch promise.reject(
+                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                        "Health Connect should be enabled before calling requestPermissionsFromHealthConnect"
+                    )
+                }
 
-            val permissionManager = connection.getHealthConnectPermissionManager()
-            val permissionsStrings = permissions.toArrayList().map{ it as String }.toSet()
+                val permissionManager = connection.getHealthConnectPermissionManager()
+                val permissionsStrings = permissions.toArrayList().map{ it as String }.toSet()
 
-            if (checkIfAllPermissionsAreGranted(permissionManager, permissionsStrings)) {
-                // All permissions granted, nothing to do here
-                promise.resolve(true)
-                return@launch
-            }
-            
-            Log.d("SpikeSdkModule", "Will ask for following Health Connect permissions: $permissions")
+                if (checkIfAllPermissionsAreGranted(permissionManager, permissionsStrings)) {
+                    // All permissions granted, nothing to do here
+                    promise.resolve(true)
+                    return@launch
+                }
+                
+                Log.d("SpikeSdkModule", "Will ask for following Health Connect permissions: $permissions")
 
-            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-                startHealthConnectRequest_oldAndroid(connectionUUID, permissionManager, permissionsStrings, promise)
-            } else {
-                startHealthConnectRequest(connectionUUID, permissionManager, permissionsStrings, promise)
+                if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
+                    startHealthConnectRequest_oldAndroid(connectionUUID, permissionManager, permissionsStrings, promise)
+                } else {
+                    startHealthConnectRequest(connectionUUID, permissionManager, permissionsStrings, promise)
+                }
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
             }
         }
     }
@@ -863,54 +987,69 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     private fun startHealthConnectRequest_oldAndroid(connectionUUID: String, permissionManager: HealthConnectPermissionManager, permissions: Set<String>, promise: Promise) {
         // val availability = connection.getHealthConnectAvailability()
         //  && availability == HealthConnectAvailability.INSTALLED
-        val intent = permissionManager.getRequestPermissionResultContract().createIntent(
-            reactApplicationContext, permissions
-        )
+        try {
+            val intent = permissionManager.getRequestPermissionResultContract().createIntent(
+                reactApplicationContext, permissions
+            )
 
-        reactApplicationContext.currentActivity?.startActivityForResult(
-            intent,
-            REQUEST_CODE
-        )
-        promise.resolve(true)
+            reactApplicationContext.currentActivity?.startActivityForResult(
+                intent,
+                REQUEST_CODE
+            )
+            promise.resolve(true)
+
+        } catch (e: SpikeExceptions) {
+            promise.reject(e.mapException(), e.message)
+        }
     }
 
     private var checkPermissionsForV3: Triple<String, Set<String>, Promise>? = null
 
     private fun startHealthConnectRequest(connectionUUID: String, permissionManager: HealthConnectPermissionManager, permissions: Set<String>, promise: Promise) {
-        val activity = reactApplicationContext.currentActivity
-        if (!(activity is ComponentActivity)) {
-            promise.resolve(false)
-            return
-        }
-        checkPermissionsForV3 = Triple(
-            connectionUUID,
-            permissions,
-            promise
-        )
-        val launcher = activity.registerActivityResultLauncher(permissionManager.getRequestPermissionResultContract()) {
+        try {
+            val activity = reactApplicationContext.currentActivity
+            if (!(activity is ComponentActivity)) {
+                promise.resolve(false)
+                return
+            }
+            checkPermissionsForV3 = Triple(
+                connectionUUID,
+                permissions,
+                promise
+            )
+            val launcher = activity.registerActivityResultLauncher(permissionManager.getRequestPermissionResultContract()) {
 
+            }
+            launcher.launch(permissions) 
+
+        } catch (e: SpikeExceptions) {
+            promise.reject(e.mapException(), e.message)
         }
-        launcher.launch(permissions) 
     }
 
     @ReactMethod
     fun areAllPermissionsGranted(connectionUUID: String, permissions: Set<String>, promise: Promise) {
         scope.launch {
-            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                    "Health Connect should be enabled before calling areAllPermissionsGranted"
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
                 )
-            }
-            val permissionManager = connection.getHealthConnectPermissionManager()
+                if (!connection.isHealthConnectIntegrationEnabled()) {
+                    return@launch promise.reject(
+                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                        "Health Connect should be enabled before calling areAllPermissionsGranted"
+                    )
+                }
+                val permissionManager = connection.getHealthConnectPermissionManager()
 
-            val permissionsGranted: Boolean = checkIfAllPermissionsAreGranted(permissionManager, permissions)
-            promise.resolve(permissionsGranted)
+                val permissionsGranted: Boolean = checkIfAllPermissionsAreGranted(permissionManager, permissions)
+                promise.resolve(permissionsGranted)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }