react-native-spike-sdk 4.6.13 → 4.7.13

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.6.12'
+  implementation 'com.spikeapi.sdk:spike-sdk:4.7.12'
   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/SpikeMappers.kt

@@ -1,12 +1,6 @@
 package com.spikesdk
 
-import com.spikeapi.SpikeDataTypes
 import com.spikeapi.SpikeExceptions
-import com.spikeapi.healthconnect.HealthConnectAvailability
-import com.spikeapi.model.SpikeData
-import com.spikeapi.model.SpikeDataType
-import java.time.Instant
-import java.time.OffsetDateTime
 
 fun SpikeExceptions.mapException(): String {
     return when (this) {
@@ -20,43 +14,3 @@ fun SpikeExceptions.mapException(): String {
         else -> "SpikeException"
     }
 }
-
-fun SpikeDataType<out SpikeData>.toStringType(): String = when (this) {
-    SpikeDataTypes.GLUCOSE -> "glucose"
-    SpikeDataTypes.HEART_RATE -> "heart"
-    SpikeDataTypes.SLEEP -> "sleep"
-    SpikeDataTypes.STEPS -> "steps"
-    SpikeDataTypes.STEPS_INTRADAY -> "steps_intraday"
-    SpikeDataTypes.ACTIVITIES_STREAM -> "activities_stream"
-    SpikeDataTypes.ACTIVITIES_SUMMARY -> "activities_summary"
-    SpikeDataTypes.BREATHING -> "breathing"
-    SpikeDataTypes.CALORIES -> "calories"
-    SpikeDataTypes.DISTANCE -> "distance"
-    SpikeDataTypes.OXYGEN_SATURATION -> "oxygen_saturation"
-    SpikeDataTypes.BODY -> "body"
-    else -> "activities_summary"
-}
-
-fun String.toSpikeDataType(): SpikeDataType<out SpikeData> = when (this) {
-    "glucose" -> SpikeDataTypes.GLUCOSE
-    "heart" -> SpikeDataTypes.HEART_RATE
-    "sleep" -> SpikeDataTypes.SLEEP
-    "steps" -> SpikeDataTypes.STEPS
-    "steps_intraday" -> SpikeDataTypes.STEPS_INTRADAY
-    "activities_stream" -> SpikeDataTypes.ACTIVITIES_STREAM
-    "activities_summary" -> SpikeDataTypes.ACTIVITIES_SUMMARY
-    "breathing" -> SpikeDataTypes.BREATHING
-    "calories" -> SpikeDataTypes.CALORIES
-    "distance" -> SpikeDataTypes.DISTANCE
-    "oxygen_saturation" -> SpikeDataTypes.OXYGEN_SATURATION
-    "body" -> SpikeDataTypes.BODY
-    else -> SpikeDataTypes.ACTIVITIES_SUMMARY
-}
-
-fun Long.millisToOffsetDataTime(): OffsetDateTime =
-    OffsetDateTime.ofInstant(Instant.ofEpochMilli(this), java.time.ZoneId.systemDefault())
-
-fun HealthConnectAvailability.toStringType(): String = when (this) {
-    HealthConnectAvailability.INSTALLED -> "installed"
-    HealthConnectAvailability.NOT_INSTALLED -> "notInstalled"
-}

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

@@ -8,12 +8,8 @@ import androidx.activity.result.contract.ActivityResultContract
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.google.gson.GsonBuilder
-import com.spikeapi.SpikeConnection
-import com.spikeapi.SpikeEnvironment
 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
@@ -62,9 +58,6 @@ fun <I, O> ComponentActivity.registerActivityResultLauncher(
 class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
 
-    // Do not use this directly, use `addConnection` and `getConnection` instead
-    private val _connections = mutableMapOf<String, SpikeConnection>()
-
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
 
     private val gson = GsonBuilder()
@@ -73,8 +66,6 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             OffsetDateTime::class.java,
             OffsetDateTimeSerializer()
         ).create()
-    private var checkPermissionsFor: Triple<String, Set<String>, Promise>? = null
-
     override fun getName(): String {
         return NAME
     }
@@ -99,443 +90,6 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    @ReactMethod
-    fun createConnection(
-        uuid: String,
-        appId: String,
-        authToken: String,
-        customerEndUserId: String,
-        callbackUrl: String?,
-        useLogger: Boolean,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val logger = if (useLogger) {
-                    createLogger(uuid)
-                } else {
-                    null
-                }
-                addConnection(connection = SpikeConnection.createConnection(
-                    context = reactApplicationContext,
-                    authToken = authToken,
-                    customerEndUserId = customerEndUserId,
-                    appId = appId,
-                    callbackUrl = callbackUrl,
-                    env = SpikeEnvironment.PROD,
-                    logger = logger,
-                ), uuid = uuid)
-                promise.resolve(uuid)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getAppId(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val appId = connection.getAppId()
-                promise.resolve(appId)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getSpikeEndUserId(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val spikeEndUserId = connection.getSpikeUserId()
-                promise.resolve(spikeEndUserId)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getCustomerEndUserId(uuid: String, promise: Promise) {
-        scope.launch {
-        try {
-            val connection = getConnection(uuid) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-            val customerEndUserId = connection.getCustomerUserId()
-            promise.resolve(customerEndUserId)
-        } catch (e: SpikeExceptions) {
-            promise.reject(e.mapException(), e.message)
-        }
-            }
-    }
-
-    @ReactMethod
-    fun getCallbackUrl(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val callbackUrl = connection.getPostbackUrl()
-                promise.resolve(callbackUrl)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-
-    @ReactMethod
-    fun close(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                connection.close()
-                promise.resolve(true)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractDataInRange(
-        connectionUUID: String,
-        dataType: String,
-        fromDateMillis: Double,
-        toDateMillis: Double,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractData(
-                    dataType = dataType.toSpikeDataType(),
-                    from = fromDateMillis.toLong().millisToOffsetDataTime(),
-                    to = toDateMillis.toLong().millisToOffsetDataTime()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractAndPostDataInRange(
-        connectionUUID: String,
-        dataType: String,
-        fromDateMillis: Double,
-        toDateMillis: Double,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractAndPostData(
-                    dataType = dataType.toSpikeDataType(),
-                    from = fromDateMillis.toLong().millisToOffsetDataTime(),
-                    to = toDateMillis.toLong().millisToOffsetDataTime()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractData(
-        connectionUUID: String,
-        dataType: String,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractData(
-                    dataType = dataType.toSpikeDataType()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractAndPostData(
-        connectionUUID: String,
-        dataType: String,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractAndPostData(
-                    dataType = dataType.toSpikeDataType()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun manageHealthConnect(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                connection.manageHealthConnect()
-                promise.resolve(true)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun checkPermissionsGranted(connectionUUID: String, dataType: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val requiredPermissions = connection.getRequiredHealthPermissionsMetadata(
-                    dataType.toSpikeDataType()
-                )
-                val permissionsGranted: Boolean =
-                    connection.hasHealthPermissionsGranted(requiredPermissions)
-                promise.resolve(permissionsGranted)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getHealthConnectAvailability(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val availability = connection.getHealthConnectAvailability()
-                promise.resolve(availability.toStringType())
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun revokeAllPermissions(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                connection.revokeAllPermissions()
-                promise.resolve(true)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun requestHealthPermissions(connectionUUID: String, dataType: String, promise: Promise) {
-        scope.launch {
-            val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-
-            val permissions =
-                connection.getRequiredHealthPermissionsMetadata(dataType.toSpikeDataType())
-
-            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-                val intent = SpikeConnection.requestReadAuthorization().createIntent(
-                    reactApplicationContext, permissions
-                )
-
-                val availability = connection.getHealthConnectAvailability()
-                if (availability == HealthConnectAvailability.INSTALLED) {
-                    reactApplicationContext.currentActivity?.startActivityForResult(
-                        intent,
-                        REQUEST_CODE
-                    )
-                    promise.resolve(true)
-                } else {
-                    promise.reject(
-                        SpikeExceptions.SpikeException().mapException(),
-                        SpikeExceptions.SpikeException().message
-                    )
-                }
-            } else {
-                val activity = reactApplicationContext.currentActivity
-                if (activity is ComponentActivity) {
-                    checkPermissionsFor = Triple(connectionUUID, setOf(dataType), promise)
-                    val launcher =
-                        activity.registerActivityResultLauncher(
-                            SpikeConnection.requestReadAuthorization()
-                        ) {
-
-                        }
-
-                    if (permissions.isNotEmpty()) {
-                        launcher.launch(permissions)
-                    } else {
-                        promise.resolve(false)
-                    }
-                } else {
-                    promise.resolve(false)
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun requestMultipleHealthPermissions(connectionUUID: String, dataTypes: ReadableArray, promise: Promise) {
-        scope.launch {
-            val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-
-            val permissions = mutableSetOf<String>()
-            dataTypes.toArrayList().forEach {
-                connection.getRequiredHealthPermissionsMetadata((it as String).toSpikeDataType())
-                    .forEach {
-                        permissions.add(it)
-                    }
-            }
-
-            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-                val availability = connection.getHealthConnectAvailability()
-                if (permissions.isNotEmpty() && availability == HealthConnectAvailability.INSTALLED) {
-                    val intent = SpikeConnection.requestReadAuthorization().createIntent(
-                        reactApplicationContext, permissions
-                    )
-
-                    reactApplicationContext.currentActivity?.startActivityForResult(
-                        intent,
-                        REQUEST_CODE
-                    )
-                    promise.resolve(true)
-                } else {
-                    promise.reject(
-                        SpikeExceptions.SpikeException().mapException(),
-                        SpikeExceptions.SpikeException().message
-                    )
-                }
-            } else {
-                val activity = reactApplicationContext.currentActivity
-                if (activity is ComponentActivity) {
-                    checkPermissionsFor = Triple(
-                        connectionUUID,
-                        dataTypes.toArrayList().toSet() as Set<String>,
-                        promise
-                    )
-                    val launcher =
-                        activity.registerActivityResultLauncher(
-                            SpikeConnection.requestReadAuthorization()
-                        ) {
-
-                        }
-                    if (permissions.isNotEmpty()) {
-                        launcher.launch(permissions)
-                    } else {
-                        promise.reject(
-                            SpikeExceptions.SpikeException().mapException(),
-                            SpikeExceptions.SpikeException().message
-                        )
-                    }
-                } else {
-                    promise.resolve(false)
-                }
-            }
-        }
-    }
-
-    private fun createLogger(connectionUUID: String): SpikeLogger {
-        return SpikeConnectionLogger(connectionUUID) { _, logLevel, message ->
-            val body = WritableNativeMap().apply {
-                putString("connectionUUID", connectionUUID)
-                putString("message", message)
-            }
-
-            when (logLevel) {
-                SpikeLogLevel.DEBUG -> sendEvent(
-                    reactContext = reactApplicationContext,
-                    eventName = logLevel.jsEventName,
-                    params = body
-                )
-
-                SpikeLogLevel.ERROR -> sendEvent(
-                    reactContext = reactApplicationContext,
-                    eventName = logLevel.jsEventName,
-                    params = body
-                )
-
-                SpikeLogLevel.INFO -> sendEvent(
-                    reactContext = reactApplicationContext,
-                    eventName = logLevel.jsEventName,
-                    params = body
-                )
-            }
-        }
-    }
-
     private fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap?) {
         reactContext
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
@@ -543,19 +97,6 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     }
 
     override fun onHostResume() {
-        // Old SDK
-        checkPermissionsFor?.let {
-            it.second.forEach { permission ->
-                checkPermissionsGranted(
-                    it.first,
-                    permission,
-                    it.third
-                )
-            }
-        }
-        checkPermissionsFor = null
-
-        // New SDK V3
         checkPermissionsForV3?.let {
             areAllPermissionsGranted(it.first, it.second, it.third)
         }
@@ -572,25 +113,9 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         const val REQUEST_CODE = 4200
     }
 
-    // Connections
+    // ------------------------- V3 -------------------------
 
     private val mutex = Mutex()
-
-    // Add new connection to the dictionary in a thread-safe manner
-    private suspend fun addConnection(connection: SpikeConnection, uuid: String) {
-        mutex.withLock {
-            _connections[uuid] = connection
-        }
-    }
-
-    // Synchronised read for safe multithreaded usage
-    private suspend fun getConnection(uuid: String): SpikeConnection? {
-        mutex.withLock {
-            return _connections[uuid]
-        }
-    }
-
-    // ------------------------- V3 -------------------------
     
     @ReactMethod
     fun setWrapper(type: String, version: String) {

package/ios/SpikeExceptionMapper.swift

@@ -1,5 +1,7 @@
 import Foundation
+import BackgroundTasks
 import SpikeSDK
+import SwiftUI
 
 class SpikeConnectionNotFoundException: Error, Codable {}
 class SpikeDataExtractionException: Error, Codable {}
@@ -11,26 +13,16 @@ class SpikeExceptionMapper {
     /// in `src/SpikeException.ts`
     static func extractErrorCode(_ error: Error) -> String {
          switch error {
-         case is SpikeConnectionIsClosedException:
-             return "SpikeConnectionIsClosedException"
          case is SpikeInvalidCredentialsException:
              return "SpikeInvalidCredentialsException"
-         case is SpikeInvalidDateRangeException:
-             return "SpikeInvalidDateRangeException"
-         case is SpikeInvalidCallbackUrlException:
-             return "SpikeInvalidCallbackUrlException"
-         case is SpikePackException:
-             return "SpikePackException"
          case is SpikePermissionsNotGrantedException:
              return "SpikePermissionsNotGrantedException"
          case is SpikeServerException:
              return "SpikeServerException"
-         case is SpikeUnpackException:
-             return "SpikeUnpackException"
-         case is SpikeCallbackURLNotProvidedException:
-             return "SpikeCallbackURLNotProvidedException"
          case is SpikeHealthDataNotAvailableException:
              return "SpikeHealthDataNotAvailableException"
+         case is SpikeIntegrationDeletedException:
+             return "SpikeIntegrationDeletedException"
          case is SpikeConnectionNotFoundException:
              return "SpikeConnectionNotFoundException"
          case is SpikeDataExtractionException: