react-native-rook-sdk 0.6.2 → 1.0.0-rc.0

package/android/src/main/java/com/rooksdk/modules/RookSyncModule.kt

@@ -0,0 +1,497 @@
+package com.rooksdk.modules
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.rookmotion.rook.sdk.RookConfigurationManager
+import com.rookmotion.rook.sdk.RookDataSources
+import com.rookmotion.rook.sdk.RookEventManager
+import com.rookmotion.rook.sdk.RookSummaryManager
+import com.rookmotion.rook.sdk.RookYesterdaySyncManager
+import com.rookmotion.rook.sdk.domain.enums.SyncStatus
+import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
+import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
+import com.rooksdk.utils.DatasourcesUtils.dataSourcesToWritableArray
+import com.rooksdk.utils.DatasourcesUtils.mapToDataSourceType
+import com.rooksdk.utils.RookDateTime
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class RookSyncModule(
+  reactContext: ReactApplicationContext,
+  rookConfigurationManager: RookConfigurationManager
+): ReactContextBaseJavaModule(reactContext) {
+
+  private val rookSynManager: RookYesterdaySyncManager by lazy {
+    RookYesterdaySyncManager(reactApplicationContext)
+  }
+
+  private val rookEventManager by lazy {
+    RookEventManager(rookConfigurationManager)
+  }
+
+  private val rookSummaryManager by lazy {
+    RookSummaryManager(rookConfigurationManager)
+  }
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  private val rookDataSources: RookDataSources by lazy {
+    RookDataSources(reactApplicationContext)
+  }
+
+  /**
+   * Schedules a background sync for yesterday's data, which automatically retrieves and processes data
+   * from connected devices or platforms.
+   * @param config The configuration settings to apply when scheduling the sync.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun scheduleYesterdaySync(config: ReadableMap, promise: Promise) {
+    scope.launch {
+      try {
+        val clientUUID = config.getString("clientUUID")?.trim() ?: return@launch
+        val secretKey = config.getString("clientPassword")?.trim() ?: return@launch
+
+        if (clientUUID.isBlank() || secretKey.isBlank()) return@launch
+
+        var environment = RookEnvironment.SANDBOX
+
+        if (config.getString("environment") == "production")
+          environment = RookEnvironment.PRODUCTION
+
+        rookSynManager.scheduleYesterdaySync(
+          enableLogs = true,
+          clientUUID = clientUUID,
+          secretKey = secretKey,
+          environment = environment,
+        )
+
+        promise.resolve(true)
+      }
+      catch (e: Exception) {
+        promise.reject(e)
+      }
+    }
+  }
+
+  // Sleep
+  /**
+   * Synchronizes the sleep summary data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncSleepSummary(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncSleepSummary(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  // Body
+  /**
+   * Synchronizes the body summary data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncBodySummary(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncBodySummary(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  // Physical
+  /**
+   * Synchronizes the physical summary data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncPhysicalSummary(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncPhysicalSummary(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Sync all failed summaries
+   */
+  @ReactMethod
+  fun syncPendingSummaries(promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncPendingSummaries()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  // MARK: - Events
+  /**
+   * Synchronizes the physical events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncPhysicalEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPhysicalEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the blood glucose events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncBloodGlucoseEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBloodGlucoseEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the blood pressure events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncBloodPressureEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBloodPressureEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the body metrics event data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncBodyMetricsEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBodyMetricsEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the body heart Rate events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncBodyHeartRateEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBodyHeartRateEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the physical heart rate events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncPhysicalHeartRateEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPhysicalHeartRateEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the nutrition events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncNutritionEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncNutritionEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the hydration events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncHydrationEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncHydrationEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the physical oxygenation events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncPhysicalOxygenationEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPhysicalOxygenationEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the body oxygenation events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncBodyOxygenationEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBodyOxygenationEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the sync temperature events data for the given date.
+   * @param date The date for which to sync the data (in string format).
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncTemperatureEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncTemperatureEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes all failed events
+   */
+  @ReactMethod
+  fun syncPendingEvents(promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPendingEvents()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * Synchronizes the step count for the current day from Health Connect.
+   * This method queries the Health Connect platform via the Rook SDK to retrieve
+   * the step count for today. If no records are found, it rejects the promise with an error message.
+   *
+   * @param promise A promise object that resolves with the step count if data is found,
+   *                or rejects with an error if records are not found or synchronization fails.
+   */
+  @ReactMethod
+  fun syncTodayHealthConnectStepsCount(promise: Promise) {
+    scope.launch {
+      rookEventManager.syncTodayHealthConnectStepsCount().fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("syncTodayHealthConnect", "Records Not Found")
+            }
+
+            is SyncStatusWithData.Synced -> {
+              val steps = it.data
+              promise.resolve(steps)
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        }
+      )
+    }
+  }
+
+
+  /**
+   * Retrieves the available data sources that can be connected to the app.
+   * This method fetches data sources such as Garmin, Fitbit, Oura, etc.,
+   * that the user can authorize to sync their health data.
+   *
+   * @param options Optional parameters that may include a redirect URL to be used during authorization.
+   * @param promise A promise object that resolves with a list of available data sources
+   *                or rejects with an error if the operation fails.
+   */
+  @ReactMethod
+  fun getAvailableDataSources(options: ReadableMap?, promise: Promise) {
+    var redirectURL: String? = null
+
+    if (options !== null) redirectURL = options.getString("redirectURL")
+
+    scope.launch {
+      rookDataSources.getAvailableDataSources(redirectURL).fold(
+        { dataSources ->
+          promise.resolve(dataSourcesToWritableArray(dataSources))
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  /**
+   * Presents a view to the user where they can authorize and connect a specific data source.
+   * This method initiates the user interface for connecting a health data source (e.g., Garmin, Fitbit).
+   *
+   * @param options Optional parameters that may include a redirect URL for the authorization flow.
+   * @param promise A promise object that resolves with true if the data source view was presented successfully,
+   *                or rejects with an error if the operation fails.
+   */
+  @ReactMethod
+  fun presentDataSourceView(options: ReadableMap?, promise: Promise) {
+    var redirectURL: String? = null
+
+    if (options !== null) redirectURL = options.getString("redirectURL")
+
+    rookDataSources.presentDataSourceView(redirectURL).fold({
+      promise.resolve(true)
+    }, {
+      promise.reject(it)
+    })
+  }
+
+  /**
+   * Revokes authorization for a specific data source, disconnecting it from the app.
+   * This method allows the user to revoke a previously authorized data source,
+   * such as Garmin, Fitbit, or Oura, preventing further data synchronization.
+   *
+   * @param source The name of the data source to revoke (e.g., "Garmin", "Fitbit").
+   * @param promise A promise object that resolves with true if the data source was revoked successfully,
+   *                or rejects with an error if the operation fails or if the source is invalid.
+   */
+  @ReactMethod
+  fun revokeDataSource(source: String, promise: Promise) {
+    val type = mapToDataSourceType(source)
+
+    if (type == null) {
+      promise.reject("Invalid", "Enter a valid data source")
+      return
+    }
+
+    scope.launch {
+      rookDataSources.revokeDataSource(type).fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  override fun getName(): String {
+    return "RookSyncModule"
+  }
+
+}

package/android/src/main/java/com/rooksdk/utils/DatasourcesUtils.kt

@@ -0,0 +1,49 @@
+package com.rooksdk.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.rookmotion.rook.sdk.domain.enums.DataSourceType
+import com.rookmotion.rook.sdk.domain.model.DataSource
+
+object DatasourcesUtils {
+
+  /**
+   * Maps a data source string to its corresponding DataSourceType enum.
+   * @param string The data source name as a string (e.g., "Garmin", "Fitbit").
+   * @return The corresponding DataSourceType enum or null if the string does not match.
+   */
+  fun mapToDataSourceType(string: String): DataSourceType? {
+    return when (string) {
+      "Garmin" -> DataSourceType.GARMIN
+      "Oura" -> DataSourceType.OURA
+      "Polar" -> DataSourceType.POLAR
+      "Fitbit" -> DataSourceType.FITBIT
+      "Withings" -> DataSourceType.WITHINGS
+      "Whoop" -> DataSourceType.WHOOP
+      else -> null
+    }
+  }
+
+  /**
+   * Converts a list of DataSource objects to a WritableArray to be sent to the React Native layer.
+   * Each DataSource object contains information such as name, description, image URL, and connection status.
+   * @param dataSources A list of DataSource objects.
+   * @return A WritableArray to be sent to the React Native layer.
+   */
+  fun dataSourcesToWritableArray(dataSources: List<DataSource>): WritableArray {
+    val array = Arguments.createArray()
+    for (dataSource in dataSources) {
+      val map = Arguments.createMap()
+      map.putString("name", dataSource.name)
+      map.putString("description", dataSource.description)
+      map.putString("imageUrl", dataSource.imageUrl)
+      map.putBoolean("connected", dataSource.connected)
+      dataSource.authorizationUrl?.let {
+        map.putString("authorizationUrl", it)
+      }
+      array.pushMap(map)
+    }
+    return array
+  }
+
+}

package/android/src/main/java/com/rooksdk/utils/ReadableToWritable.kt

@@ -0,0 +1,64 @@
+package com.rooksdk.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * ReadableToWritable is a utility object that provides methods to convert between
+ * React Native's ReadableMap and WritableMap, and Kotlin's HashMap.
+ * This is useful when you need to transform data between JavaScript and native code.
+ */
+object ReadableToWritable {
+
+  /**
+   * Converts a ReadableMap (from JavaScript/React Native) to a HashMap (native Kotlin data structure).
+   * It iterates through all the keys in the ReadableMap and converts its values based on their type.
+   *
+   * @param readableMap The ReadableMap to convert.
+   * @return A HashMap<String, Any> with equivalent values.
+   */
+  fun readableMapToHashMap(readableMap: ReadableMap): HashMap<String, Any> {
+    val map = HashMap<String, Any>()
+    val iterator = readableMap.keySetIterator()
+
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      when (readableMap.getType(key)) {
+        ReadableType.Boolean -> map[key] = readableMap.getBoolean(key)
+        ReadableType.Number -> map[key] = readableMap.getDouble(key)
+        ReadableType.String -> map[key] = readableMap.getString(key) ?: ""
+        ReadableType.Map -> map[key] = readableMapToHashMap(readableMap.getMap(key)!!)
+        ReadableType.Array -> map[key] = readableMap.getArray(key)!!.toArrayList()
+        else -> {} // Manejar otros tipos si es necesario
+      }
+    }
+
+    return map
+  }
+
+  /**
+   * Converts a HashMap (native Kotlin data structure) to a WritableMap (to be sent to JavaScript/React Native).
+   * It iterates through all the entries in the HashMap and converts its values based on their type.
+   *
+   * @param hashMap The HashMap<String, Any> to convert.
+   * @return A WritableMap with equivalent values.
+   */
+  fun hashMapToWritableMap(hashMap: HashMap<String, Any>): WritableMap {
+    val writableMap = Arguments.createMap()
+
+    for ((key, value) in hashMap) {
+      when (value) {
+        is Boolean -> writableMap.putBoolean(key, value)
+        is Double -> writableMap.putDouble(key, value)
+        is String -> writableMap.putString(key, value)
+        is HashMap<*, *> -> writableMap.putMap(key, hashMapToWritableMap(value as HashMap<String, Any>))
+        is ArrayList<*> -> writableMap.putArray(key, Arguments.fromArray(value))
+      }
+    }
+
+    return writableMap
+  }
+
+}

package/android/src/main/java/com/rooksdk/utils/RookDateTime.kt

@@ -0,0 +1,20 @@
+package com.rooksdk.utils
+
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+/**
+ * RookDateTime is a utility object for handling date-related operations.
+ * It provides methods to format and parse dates using the ISO_LOCAL_DATE format.
+ */
+object RookDateTime {
+  private val rookDateFormatter: DateTimeFormatter get() = DateTimeFormatter.ISO_LOCAL_DATE
+
+  /**
+   * A DateTimeFormatter using the ISO_LOCAL_DATE pattern (e.g., "YYYY-MM-DD").
+   * It formats or parses dates in the standard ISO 8601 format.
+   */
+  fun stringToLocalDate(string: String): LocalDate {
+    return LocalDate.parse(string, rookDateFormatter)
+  }
+}