react-native-spike-sdk 4.0.13-beta.1 → 4.0.13-beta.11

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:3.1.6'
+  implementation 'com.spikeapi.sdk:spike-sdk:4.0.12-beta.6'
   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

@@ -14,6 +14,19 @@ import com.spikeapi.SpikeExceptions
 import com.spikeapi.SpikeLogger
 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.SleepConfig
+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
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -22,6 +35,10 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import java.time.OffsetDateTime
 import java.util.UUID
+import android.util.Log
+import java.time.Instant
+import java.time.format.DateTimeParseException
+
 
 fun <I, O> ComponentActivity.registerActivityResultLauncher(
     contract: ActivityResultContract<I, O>,
@@ -513,7 +530,9 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
             .emit(eventName, params)
     }
+
     override fun onHostResume() {
+        // Old SDK
         checkPermissionsFor?.let {
             it.second.forEach { permission ->
                 checkPermissionsGranted(
@@ -524,6 +543,12 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             }
         }
         checkPermissionsFor = null
+
+        // New SDK V3
+        checkPermissionsForV3?.let {
+            areAllPermissionsGranted(it.first, it.second, it.third)
+        }
+        checkPermissionsForV3 = null
     }
 
     override fun onHostPause() {
@@ -554,4 +579,564 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    // ------------------------- V3 -------------------------
+    
+    @ReactMethod
+    fun setWrapper(type: String, version: String) {
+        SpikeConnectionAPIv3.setWrapper(type, version)
+    }
+
+    @ReactMethod
+    fun createConnectionAPIv3(
+        uuid: String,
+        appId: String,
+        authToken: String,
+        customerEndUserId: String,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val connection = SpikeConnectionAPIv3.createConnection(
+                    appId = appId,
+                    authToken = authToken,
+                    customerEndUserId = customerEndUserId,
+                    context = reactApplicationContext
+                )
+
+                addConnectionV3(connection, uuid)
+                promise.resolve(uuid)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    /// --- Read user info ---
+
+    @ReactMethod
+    fun getUserInfo(
+        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)
+            }
+        }
+    }
+
+    /// --- Read Health connect data ---
+
+    @ReactMethod
+    fun getStatistics(
+        connectionUUID: String,
+        types: ReadableArray, // [StatisticsType]
+        from: String, // Instant
+        to: String, // Instant
+        interval: String, // StatisticsInterval
+        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))
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getRecords(
+        connectionUUID: String,
+        types: ReadableArray, // [MetricType]
+        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 (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
+                )
+
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+            
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @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 (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
+                )
+
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+            
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getSleep(
+        connectionUUID: String,
+        configJson: String, // SleepConfig
+        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 (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
+                )
+
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+            
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    /// --- Health connect permissions ---
+
+    @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)
+            }
+        }
+    }
+
+    @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)
+            }
+        }
+    }
+
+    @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)
+            }
+        }
+    }
+
+    @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)
+            }
+        }
+    }
+
+    @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)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getGrantedHealthKitPermissions(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            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 result = Arguments.createArray()
+                permissions.forEach {
+                    result.pushString(it)
+                }
+                
+                Log.w("SpikeSdkModule", "$permissions")
+                promise.resolve(result)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getHealthConnectPermissions(
+        connectionUUID: String, 
+        statisticTypes: ReadableArray, 
+        metricTypes: ReadableArray, 
+        activityConfigs: ReadableArray, 
+        sleepConfigs: ReadableArray, 
+        includeEnhancedPermissions: Boolean,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                    "Connection not found (getHealthConnectPermissions)"
+                )
+                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 result = Arguments.createArray()
+                permissions.forEach {
+                    result.pushString(it)
+                }
+                
+                // Log.w("SpikeSdkModule", "$permissions")
+                promise.resolve(result)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @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)
+            }
+        }
+    }
+
+    @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()
+
+                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)
+                }
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    private fun startHealthConnectRequest_oldAndroid(connectionUUID: String, permissionManager: HealthConnectPermissionManager, permissions: Set<String>, promise: Promise) {
+        // val availability = connection.getHealthConnectAvailability()
+        //  && availability == HealthConnectAvailability.INSTALLED
+        try {
+            val intent = permissionManager.getRequestPermissionResultContract().createIntent(
+                reactApplicationContext, permissions
+            )
+
+            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) {
+        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)
+        }
+    }
+
+    @ReactMethod
+    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)
+            }
+        }
+    }
+
+    private suspend fun checkIfAllPermissionsAreGranted(permissionManager: HealthConnectPermissionManager, permissions: Set<String>): Boolean {
+        return permissionManager.getGrantedPermissions().containsAll(permissions)
+    }
+
+    /// --- Private stuff ---
+
+    // Do not use this directly, use `addConnection` and `getConnection` instead
+    private val _connectionsV3 = mutableMapOf<String, SpikeConnectionAPIv3>()
+
+    private val mutexV3 = Mutex()
+
+    // Add new connection to the dictionary in a thread-safe manner
+    private suspend fun addConnectionV3(connection: SpikeConnectionAPIv3, uuid: String) {
+        mutex.withLock {
+            _connectionsV3[uuid] = connection
+        }
+    }
+
+    // Synchronised read for safe multithreaded usage
+    private suspend fun getConnectionV3(uuid: String): SpikeConnectionAPIv3? {
+        mutex.withLock {
+            return _connectionsV3[uuid]
+        }
+    }
+
 }
+
+private fun convertIsoStringToInstant(isoString: String): Instant {
+    return Instant.parse(isoString)
+}