react-native-spike-sdk 4.3.43 → 4.3.63

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

@@ -597,21 +597,16 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         customerEndUserId: String,
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = SpikeConnectionAPIv3.createConnectionLegacy(
-                    appId = appId,
-                    authToken = authToken,
-                    customerEndUserId = customerEndUserId,
-                    context = reactApplicationContext
-                )
-
-                addConnectionV3(connection, uuid)
-                promise.resolve(uuid)
+        executeV3Method(promise) {
+            val connection = SpikeConnectionAPIv3.createConnectionLegacy(
+                appId = appId,
+                authToken = authToken,
+                customerEndUserId = customerEndUserId,
+                context = reactApplicationContext
+            )
 
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+            addConnectionV3(connection, uuid)
+            promise.resolve(uuid)
         }
     }
 
@@ -623,21 +618,16 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         endUserId: String,
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = SpikeConnectionAPIv3.createConnection(
-                    applicationId = applicationId,
-                    signature = signature,
-                    endUserId = endUserId,
-                    context = reactApplicationContext
-                )
-
-                addConnectionV3(connection, uuid)
-                promise.resolve(uuid)
+        executeV3Method(promise) {
+            val connection = SpikeConnectionAPIv3.createConnection(
+                applicationId = applicationId,
+                signature = signature,
+                endUserId = endUserId,
+                context = reactApplicationContext
+            )
 
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+            addConnectionV3(connection, uuid)
+            promise.resolve(uuid)
         }
     }
 
@@ -648,20 +638,9 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         connectionUUID: String,
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (getUserInfo)"
-                )
-
-                val result = connection.getUserInfo()
-
-                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+        executeV3MethodWithConnection("getUserInfo", connectionUUID, promise) { connection ->
+            val result = connection.getUserInfo()
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
         }
     }
 
@@ -674,26 +653,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         config: String?,
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (getIntegrationInitUrl)"
-                )
-
-                val providerObject = Provider.values().find { it.value == provider } ?: Provider.UNKNOWN
-                val configObject = if (config != null) {
-                    IntegrationInitConfigUtils.fromValue(config)
-                } else {
-                    null
-                }
-                val result = connection.getIntegrationInitUrl(providerObject, configObject)
-
-                promise.resolve(result)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+        executeV3MethodWithConnection("getIntegrationInitUrl", connectionUUID, promise) { connection ->
+            val providerObject = Provider.values().find { it.value == provider } ?: Provider.UNKNOWN
+            val configObject = if (config != null) {
+                IntegrationInitConfigUtils.fromValue(config)
+            } else {
+                null
             }
+            val result = connection.getIntegrationInitUrl(providerObject, configObject)
+            promise.resolve(result)
         }
     }
 
@@ -709,33 +677,24 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         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 (getStatistics)"
-                )
-                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))
+        executeV3MethodWithConnection("getStatistics", connectionUUID, promise) { connection ->
+            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
+            )
 
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
         }
     }
 
@@ -748,31 +707,22 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         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 (getRecords)"
-                )
-                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
-                )
+        executeV3MethodWithConnection("getRecords", connectionUUID, promise) { connection ->
+            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))
         }
     }
 
@@ -785,29 +735,20 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         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 (getActivities)"
-                )
-                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
-                )
+        executeV3MethodWithConnection("getActivities", connectionUUID, promise) { connection ->
+            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)
-            }
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
         }
     }
 
@@ -820,29 +761,20 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         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 (getSleep)"
-                )
-                val dateFrom = convertIsoStringToInstant(from)
-                val dateTo = convertIsoStringToInstant(to)
-                val statsFilter = StatisticsFilter.fromValue(filter)
-                val configObject = SleepConfigUtils.fromValue(configJson) ?: SleepConfig()
-
-                val result = connection.getSleep(
-                    config = configObject,
-                    from = dateFrom,
-                    to = dateTo,
-                    filter = statsFilter
-                )
+        executeV3MethodWithConnection("getSleep", connectionUUID, promise) { connection ->
+            val dateFrom = convertIsoStringToInstant(from)
+            val dateTo = convertIsoStringToInstant(to)
+            val statsFilter = StatisticsFilter.fromValue(filter)
+            val configObject = SleepConfigUtils.fromValue(configJson) ?: SleepConfig()
+
+            val result = connection.getSleep(
+                config = configObject,
+                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))
         }
     }
 
@@ -852,24 +784,13 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         metrics: ReadableArray,
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (getUserProperties)"
-                )
-
-                val mTypes = metrics.toArrayList().mapNotNull {
-                    MetricTypeUtils.fromValue(it as String)
-                }.toSet()
-
-                val result = connection.getUserProperties(types = mTypes)
-
-                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        executeV3MethodWithConnection("getUserProperties", connectionUUID, promise) { connection ->
+            val mTypes = metrics.toArrayList().mapNotNull {
+                MetricTypeUtils.fromValue(it as String)
+            }.toSet()
 
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+            val result = connection.getUserProperties(types = mTypes)
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
         }
     }
 
@@ -878,126 +799,65 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun checkHealthConnectAvailability(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            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)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+        executeV3MethodWithConnection("checkHealthConnectAvailability", connectionUUID, promise) { connection ->
+            val result = connection.checkHealthConnectAvailability()
+            promise.resolve(result.value)
         }
     }
 
     @ReactMethod
     fun openHealthConnectInstallation(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (openHealthConnectInstallation)"
-                )
-
-                connection.openHealthConnectInstallation()
-                promise.resolve(true)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+        executeV3MethodWithConnection("openHealthConnectInstallation", connectionUUID, promise) { connection ->
+            connection.openHealthConnectInstallation()
+            promise.resolve(true)
         }
     }
 
     @ReactMethod
     fun enableHealthConnectIntegration(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            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)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+        executeV3MethodWithConnection("enableHealthConnectIntegration", connectionUUID, promise) { connection ->
+            connection.enableHealthConnectIntegration()
+            Log.d("SpikeSdkModule", "Health Connect integration enabled")
+            promise.resolve(true)
         }
     }
 
     @ReactMethod
     fun disableHealthConnectIntegration(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            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)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+        executeV3MethodWithConnection("disableHealthConnectIntegration", connectionUUID, promise) { connection ->
+            connection.disableHealthConnectIntegration()
+            Log.d("SpikeSdkModule", "Health Connect integration disabled")
+            promise.resolve(true)
         }
     }
 
     @ReactMethod
     fun isHealthConnectIntegrationEnabled(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            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)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+        executeV3MethodWithConnection("isHealthConnectIntegrationEnabled", connectionUUID, promise) { connection ->
+            val result = connection.isHealthConnectIntegrationEnabled()
+            Log.d("SpikeSdkModule", "Health Connect integration is " + if (result) { "enabled" } else ( "disabled" ))
+            promise.resolve(result)
         }
     }
 
     @ReactMethod
     fun getGrantedHealthConnectPermissions(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (getGrantedHealthConnectPermissions)"
-                )
-                if (!connection.isHealthConnectIntegrationEnabled()) {
-                    return@launch promise.reject(
-                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                        "Health Connect should be enabled before calling getGrantedHealthConnectPermissions"
-                    )
-                }
+        executeV3MethodWithConnection("getGrantedHealthConnectPermissions", connectionUUID, promise) { connection ->
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Health Connect should be enabled before calling getGrantedHealthConnectPermissions")
+            }
 
-                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)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
             }
+            
+            Log.w("SpikeSdkModule", "$permissions")
+            promise.resolve(result)
         }
     }
 
@@ -1012,122 +872,85 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         includeBackgroundDelivery: Boolean,
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (getHealthConnectPermissions)"
+        executeV3MethodWithConnection("getHealthConnectPermissions", connectionUUID, promise) { connection ->
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("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,
+                    includeBackgroundDelivery = includeBackgroundDelivery
                 )
-                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,
-                        includeBackgroundDelivery = includeBackgroundDelivery
-                    )
 
-                val result = Arguments.createArray()
-                permissions.forEach {
-                    result.pushString(it)
-                }
-                
-                // Log.w("SpikeSdkModule", "$permissions")
-                promise.resolve(result)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
             }
+            
+            // Log.w("SpikeSdkModule", "$permissions")
+            promise.resolve(result)
         }
     }
 
     @ReactMethod
     fun revokeAllHealthConnectPermissions(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            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)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+        executeV3MethodWithConnection("revokeAllHealthConnectPermissions", connectionUUID, promise) { connection ->
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Health Connect should be enabled before calling revokeAllHealthConnectPermissions")
             }
+
+            connection
+                .getHealthConnectPermissionManager()
+                .revokeAllPermissions()
+            
+            promise.resolve(true)
         }
     }
 
     @ReactMethod
     fun requestPermissionsFromHealthConnect(connectionUUID: String, permissions: ReadableArray, promise: Promise) {
-        scope.launch {
-            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()
+        executeV3MethodWithConnection("requestPermissionsFromHealthConnect", connectionUUID, promise) { connection ->
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Health Connect should be enabled before calling requestPermissionsFromHealthConnect")
+            }
 
-                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")
+            val permissionManager = connection.getHealthConnectPermissionManager()
+            val permissionsStrings = permissions.toArrayList().map{ it as String }.toSet()
 
-                if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-                    startHealthConnectRequest_oldAndroid(connectionUUID, permissionManager, permissionsStrings, promise)
-                } else {
-                    startHealthConnectRequest(connectionUUID, permissionManager, permissionsStrings, promise)
-                }
+            if (checkIfAllPermissionsAreGranted(permissionManager, permissionsStrings)) {
+                // All permissions granted, nothing to do here
+                promise.resolve(true)
+                return@executeV3MethodWithConnection
+            }
+            
+            Log.d("SpikeSdkModule", "Will ask for following Health Connect permissions: $permissions")
 
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
+                startHealthConnectRequest_oldAndroid(connectionUUID, permissionManager, permissionsStrings, promise)
+            } else {
+                startHealthConnectRequest(connectionUUID, permissionManager, permissionsStrings, promise)
             }
         }
     }
@@ -1176,27 +999,14 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     }
 
     fun areAllPermissionsGranted(connectionUUID: String, permissions: Set<String>, promise: Promise) {
-        scope.launch {
-            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 areAllPermissionsGranted"
-                    )
-                }
-                val permissionManager = connection.getHealthConnectPermissionManager()
-
-                val permissionsGranted: Boolean = checkIfAllPermissionsAreGranted(permissionManager, permissions)
-                promise.resolve(permissionsGranted)
-
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+        executeV3MethodWithConnection("areAllPermissionsGranted", connectionUUID, promise) { connection ->
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Health Connect should be enabled before calling areAllPermissionsGranted")
             }
+            val permissionManager = connection.getHealthConnectPermissionManager()
+
+            val permissionsGranted: Boolean = checkIfAllPermissionsAreGranted(permissionManager, permissions)
+            promise.resolve(permissionsGranted)
         }
     }
 
@@ -1215,47 +1025,38 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         sleepConfigs: ReadableArray, 
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (enableBackgroundDelivery)"
-                )
-                if (!connection.isHealthConnectIntegrationEnabled()) {
-                    return@launch promise.reject(
-                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                        "Health Connect should be enabled before calling enableBackgroundDelivery"
-                    )
-                }
-
-                val statTypes = statisticTypes.toArrayList().mapNotNull {
-                    StatisticsTypeUtils.fromValue(it as String)
-                }.toSet()
+        executeV3MethodWithConnection("enableBackgroundDelivery", connectionUUID, promise) { connection ->
+            val healthConnectEnabled = connection.isHealthConnectIntegrationEnabled()
+            val samsungHealthDataEnabled = connection.isSamsungHealthDataIntegrationEnabled()
+            
+            if (!healthConnectEnabled && !samsungHealthDataEnabled) {
+                throw SpikeExceptions.SpikeException("Either Health Connect or Samsung Health Data should be enabled before calling enableBackgroundDelivery")
+            }
 
-                val mTypes = metricTypes.toArrayList().mapNotNull {
-                    MetricTypeUtils.fromValue(it as String)
-                }.toSet()
+            val statTypes = statisticTypes.toArrayList().mapNotNull {
+                StatisticsTypeUtils.fromValue(it as String)
+            }.toSet()
 
-                val aConfigs = activityConfigs.toArrayList().mapNotNull {
-                    ActivityConfigUtils.fromValue(it as String)
-                }.toSet()
+            val mTypes = metricTypes.toArrayList().mapNotNull {
+                MetricTypeUtils.fromValue(it as String)
+            }.toSet()
 
-                val sConfigs = sleepConfigs.toArrayList().mapNotNull {
-                    SleepConfigUtils.fromValue(it as String)
-                }.toSet()
+            val aConfigs = activityConfigs.toArrayList().mapNotNull {
+                ActivityConfigUtils.fromValue(it as String)
+            }.toSet()
 
-                connection.enableBackgroundDelivery(
-                        statisticsTypes = statTypes,
-                        metricTypes = mTypes,
-                        activityConfigs = aConfigs,
-                        sleepConfigs = sConfigs
-                    )
+            val sConfigs = sleepConfigs.toArrayList().mapNotNull {
+                SleepConfigUtils.fromValue(it as String)
+            }.toSet()
 
-                promise.resolve(true)
+            connection.enableBackgroundDelivery(
+                    statisticsTypes = statTypes,
+                    metricTypes = mTypes,
+                    activityConfigs = aConfigs,
+                    sleepConfigs = sConfigs
+                )
 
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
+            promise.resolve(true)
         }
     }
 
@@ -1264,24 +1065,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         connectionUUID: String, 
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (disableBackgroundDelivery)"
-                )
-                if (!connection.isHealthConnectIntegrationEnabled()) {
-                    return@launch promise.reject(
-                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                        "Health Connect should be enabled before calling disableBackgroundDelivery"
-                    )
-                }
-                connection.disableBackgroundDelivery()
-                promise.resolve(true)
-                
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+        executeV3MethodWithConnection("disableBackgroundDelivery", connectionUUID, promise) { connection ->
+            val healthConnectEnabled = connection.isHealthConnectIntegrationEnabled()
+            val samsungHealthDataEnabled = connection.isSamsungHealthDataIntegrationEnabled()
+            
+            if (!healthConnectEnabled && !samsungHealthDataEnabled) {
+                throw SpikeExceptions.SpikeException("Either Health Connect or Samsung Health Data should be enabled before calling disableBackgroundDelivery")
             }
+            connection.disableBackgroundDelivery()
+            promise.resolve(true)
         }
     }
 
@@ -1290,27 +1082,18 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         connectionUUID: String, 
         promise: Promise
     ) {
-        scope.launch {
-            try {
-                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
-                    "Connection not found (getBackgroundDeliveryConfig)"
-                )
-                if (!connection.isHealthConnectIntegrationEnabled()) {
-                    return@launch promise.reject(
-                        SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
-                        "Health Connect should be enabled before calling getBackgroundDeliveryConfig"
-                    )
-                }
-                val result = connection.getBackgroundDeliveryConfig()
-                if (result == null) {
-                    promise.resolve(null)
-                } else {
-                    promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
-                }
-                
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
+        executeV3MethodWithConnection("getBackgroundDeliveryConfig", connectionUUID, promise) { connection ->
+            val healthConnectEnabled = connection.isHealthConnectIntegrationEnabled()
+            val samsungHealthDataEnabled = connection.isSamsungHealthDataIntegrationEnabled()
+            
+            if (!healthConnectEnabled && !samsungHealthDataEnabled) {
+                throw SpikeExceptions.SpikeException("Either Health Connect or Samsung Health Data should be enabled before calling getBackgroundDeliveryConfig")
+            }
+            val result = connection.getBackgroundDeliveryConfig()
+            if (result == null) {
+                promise.resolve(null)
+            } else {
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
             }
         }
     }
@@ -1336,6 +1119,221 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+
+    /**
+     * Centralized error handling for V3 methods
+     * Executes the provided block in a coroutine scope with comprehensive error handling
+     */
+    private fun executeV3Method(
+        promise: Promise,
+        block: suspend () -> Unit
+    ) {
+        scope.launch {
+            try {
+                block()
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            } catch (e: Exception) {
+                promise.reject(e.toString(), e.message)
+            }
+        }
+    }
+
+    /**
+     * Centralized error handling for V3 methods that need connection validation
+     * Executes the provided block in a coroutine scope with connection validation and comprehensive error handling
+     */
+    private fun executeV3MethodWithConnection(
+        methodName: String,
+        connectionUUID: String,
+        promise: Promise,
+        block: suspend (SpikeConnectionAPIv3) -> Unit
+    ) {
+        executeV3Method(promise) {
+            val connection = getConnectionV3(connectionUUID) ?: throw SpikeExceptions.SpikeException(
+                "Connection not found ($methodName)"
+            )
+            block(connection)
+        }
+    }
+
+    /// --- Samsung Health Data permissions ---
+
+    @ReactMethod
+    fun checkSamsungHealthDataAvailability(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("checkSamsungHealthDataAvailability", connectionUUID, promise) { connection ->
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                throw SpikeExceptions.SpikeException("Activity is required to check Samsung Health Data availability")
+            }
+            val result = connection.checkSamsungHealthDataAvailability(activity)
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    @ReactMethod
+    fun enableSamsungHealthDataIntegration(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("enableSamsungHealthDataIntegration", connectionUUID, promise) { connection ->
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                throw SpikeExceptions.SpikeException("Activity is required to enable Samsung Health Data integration")
+            }
+            connection.enableSamsungHealthDataIntegration(activity)
+            Log.d("SpikeSdkModule", "Samsung Health Data integration enabled")
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun disableSamsungHealthDataIntegration(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("disableSamsungHealthDataIntegration", connectionUUID, promise) { connection ->
+            connection.disableSamsungHealthDataIntegration()
+            Log.d("SpikeSdkModule", "Samsung Health Data integration disabled")
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun isSamsungHealthDataIntegrationEnabled(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("isSamsungHealthDataIntegrationEnabled", connectionUUID, promise) { connection ->
+            val result = connection.isSamsungHealthDataIntegrationEnabled()
+            Log.d("SpikeSdkModule", "Samsung Health Data integration is " + if (result) { "enabled" } else ( "disabled" ))
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun getGrantedSamsungHealthDataPermissions(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("getGrantedSamsungHealthDataPermissions", connectionUUID, promise) { connection ->
+            if (!connection.isSamsungHealthDataIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Samsung Health Data should be enabled before calling getGrantedSamsungHealthDataPermissions")
+            }
+
+            val permissions = connection
+                .getSamsungHealthDataPermissionManager()
+                .getGrantedPermissions()
+
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
+            }
+            
+            Log.w("SpikeSdkModule", "$permissions")
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun getSamsungHealthDataPermissions(
+        connectionUUID: String, 
+        statisticTypes: ReadableArray, 
+        metricTypes: ReadableArray, 
+        activityConfigs: ReadableArray, 
+        sleepConfigs: ReadableArray, 
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("getSamsungHealthDataPermissions", connectionUUID, promise) { connection ->
+            if (!connection.isSamsungHealthDataIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Samsung Health Data should be enabled before calling getSamsungHealthDataPermissions")
+            }
+            val permissionManager = connection.getSamsungHealthDataPermissionManager()
+
+            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
+                )
+
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
+            }
+            
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun requestPermissionsFromSamsungHealthData(
+        connectionUUID: String, 
+        statisticTypes: ReadableArray, 
+        metricTypes: ReadableArray, 
+        activityConfigs: ReadableArray, 
+        sleepConfigs: ReadableArray, 
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("requestPermissionsFromSamsungHealthData", connectionUUID, promise) { connection ->
+            if (!connection.isSamsungHealthDataIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Samsung Health Data should be enabled before calling requestPermissionsFromSamsungHealthData")
+            }
+
+            val permissionManager = connection.getSamsungHealthDataPermissionManager()
+
+            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()
+            
+            Log.d("SpikeSdkModule", "Will ask for Samsung Health Data permissions with: statTypes=$statTypes, metricTypes=$mTypes, activityConfigs=$aConfigs, sleepConfigs=$sConfigs")
+
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                throw SpikeExceptions.SpikeException("Activity is required to request Samsung Health Data permissions")
+            }
+
+            try {
+                val grantedPermissions = permissionManager.requestPermissions(
+                    statisticsTypes = statTypes,
+                    metricTypes = mTypes,
+                    activityConfigs = aConfigs,
+                    sleepConfigs = sConfigs
+                )
+                
+                val result = Arguments.createArray()
+                grantedPermissions.forEach {
+                    result.pushString(it)
+                }
+                
+                promise.resolve(result)
+            } catch (e: Exception) {
+                promise.reject(e.toString(), e.message)
+            }
+        }
+    }
+
+
+
+    /// --- 
+
 }
 
 private fun convertIsoStringToInstant(isoString: String): Instant {