react-native-rook-sdk 4.0.0-beta.1 → 4.0.0

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

@@ -0,0 +1,551 @@
+package com.rooksdk.modules
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+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.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.rookmotion.rook.sdk.RookSyncManager
+import com.rookmotion.rook.sdk.domain.enums.SyncStatus
+import com.rookmotion.rook.sdk.domain.exception.HCException
+import com.rookmotion.rook.sdk.domain.exception.HCRecordsNotFoundException
+import com.rookmotion.rook.sdk.domain.model.HCHeartRate
+import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
+import com.rooksdk.utils.RookDateTime
+import com.rooksdk.utils.SamsungAvailability
+import com.rooksdk.utils.StringToSyncType
+import com.rooksdk.utils.serializers.InstantSerializer
+import com.rooksdk.utils.serializers.LocalDateSerializer
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.enums.SHSyncStatus
+import io.tryrook.sdk.samsung.domain.exception.SHException
+import io.tryrook.sdk.samsung.domain.model.SHSyncStatusWithData
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import java.time.Instant
+import java.time.LocalDate
+
+class RookSyncModule(
+  reactContext: ReactApplicationContext,
+  private val rookSamsung: RookSamsung
+): ReactContextBaseJavaModule(reactContext) {
+
+  private val rookSync by lazy {
+    RookSyncManager(reactContext)
+  }
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  private val gsonBuilder: Gson by lazy {
+    GsonBuilder()
+      .registerTypeAdapter(Instant::class.java, InstantSerializer())
+      .registerTypeAdapter(LocalDate::class.java, LocalDateSerializer())
+      .create()
+  }
+
+  @ReactMethod
+  fun enableSamsungSync(promise: Promise) {
+     scope.launch {
+       rookSamsung.schedule(true)
+       promise.resolve(true)
+     }
+  }
+
+  @ReactMethod
+  fun isSamsungSyncEnabled(promise: Promise) {
+    scope.launch {
+      rookSamsung.isScheduled().fold(
+        {
+          promise.resolve(it)
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun disableSamsungSync(promise: Promise) {
+    scope.launch {
+      rookSamsung.cancel()
+      promise.resolve(true)
+    }
+  }
+
+  @ReactMethod
+  fun syncTodaySamsungHealthStepsCount(promise: Promise) {
+    scope.launch {
+      rookSamsung.getTodayStepsCount().fold({
+        when (it) {
+          SHSyncStatusWithData.RecordsNotFound -> {
+            promise.reject("SamsungStepsCount", "Records Not Found")
+          }
+
+          is SHSyncStatusWithData.Synced -> {
+            val steps = it.data
+            promise.resolve(steps)
+          }
+        }
+      }, {
+        if (it is SHException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, 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 {
+      rookSync.getTodayStepsCount().fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectStepsCount", "Records Not Found")
+            }
+
+            is SyncStatusWithData.Synced -> {
+              val steps = it.data
+              promise.resolve(steps)
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun syncSHTodayCaloriesCount(promise: Promise) {
+    scope.launch {
+      rookSamsung.getTodayCaloriesCount().fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("7", "The SDK could not find any health data related with calories")
+            }
+
+            is SHSyncStatusWithData.Synced -> {
+              val data = Arguments.createMap().apply {
+                putDouble("basal", it.data.basal ?: 0.0)
+                putDouble("active", it.data.active ?: 0.0)
+              }
+
+              promise.resolve(data)
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  /**
+   * Synchronizes the calories count for the current day from Health Connect.
+   * This method queries the Health Connect platform via the Rook SDK to retrieve
+   * the calories 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 syncTodayCaloriesCount(promise: Promise) {
+    scope.launch {
+      rookSync.getTodayCaloriesCount().fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("7", "The SDK could not find any health data related with calories")
+            }
+
+            is SyncStatusWithData.Synced -> {
+              val data = Arguments.createMap().apply {
+                putDouble("basal", it.data.basal ?: 0.0)
+                putDouble("active", it.data.active ?: 0.0)
+              }
+
+              promise.resolve(data)
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getTodayHeartRate(promise: Promise) {
+    scope.launch {
+     rookSync.getTodayHeartRate().fold(
+       { syncStatus ->
+         when (syncStatus) {
+           SyncStatusWithData.RecordsNotFound -> {
+             promise.reject("7", "The SDK could not find any health data related with calories")
+           }
+
+           is SyncStatusWithData.Synced -> {
+             promise.resolve(gsonBuilder.toJson(syncStatus.data))
+           }
+         }
+       },
+       {
+         if (it is HCException) {
+           promise.reject(it.code.toString(), it.message, it)
+         } else {
+           promise.reject("1001", it.message, it)
+         }
+       },
+     )
+    }
+  }
+
+  @ReactMethod
+  fun getSHTodayHeartRate(promise: Promise) {
+    scope.launch {
+      rookSamsung.getTodayHeartRate().fold(
+        { syncStatus ->
+          when (syncStatus) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("7", "The SDK could not find any health data related with calories")
+            }
+
+            is SHSyncStatusWithData.Synced -> {
+              promise.resolve(gsonBuilder.toJson(syncStatus.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun sync(enableLogs: Boolean, callback: Callback) {
+    scope.launch {
+      rookSync.sync(enableLogs).fold({ result ->
+        callback.invoke(null, result)
+      }, {
+        val params = Arguments.createMap().apply {
+          if (it is HCException) {
+            putString(it.code.toString(), it.message)
+          } else {
+            putString("1001", it.localizedMessage ?: it.message)
+          }
+        }
+
+        callback.invoke(params, false)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncByDate(date: String, callback: Callback) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      val result = rookSync.sync(localDate)
+
+      try {
+        val sleepSummaryStatus = result.sleepSummary.getOrThrow()
+        val physicalSummaryStatus = result.physicalSummary.getOrThrow()
+        val bodySummaryStatus = result.bodySummary.getOrThrow()
+
+        val noSleepData = sleepSummaryStatus == SyncStatus.RECORDS_NOT_FOUND
+        val noPhysicalData = physicalSummaryStatus == SyncStatus.RECORDS_NOT_FOUND
+        val noBodyData = bodySummaryStatus == SyncStatus.RECORDS_NOT_FOUND
+
+        if (noSleepData && noPhysicalData && noBodyData) {
+          val throwable = HCRecordsNotFoundException("Sleep, Physical and Body summary")
+
+          val params = Arguments.createMap().apply {
+            putString(throwable.code.toString(), throwable.message)
+          }
+
+          callback.invoke(params, false)
+        } else {
+          callback.invoke(null, true)
+        }
+      } catch (e: Exception) {
+        val params = Arguments.createMap().apply {
+          if (e is HCException){
+            putString(e.code.toString(), e.message)
+          } else {
+            putString("1001", e.message ?: "Unknown error")
+          }
+        }
+
+        callback.invoke(params, false)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun syncByDefinition(summary: String, date: String, callback: Callback) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToSummary(summary)
+
+    scope.launch {
+      val result = rookSync.sync(localDate, type)
+      result.onSuccess {
+        when (it) {
+          SyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            val params = Arguments.createMap().apply {
+              putString(throwable.code.toString(), throwable.message)
+            }
+
+            callback.invoke(params, false)
+          }
+          SyncStatus.SYNCED -> callback.invoke(null, true)
+        }
+      }
+
+      result.onFailure {
+        val params = Arguments.createMap().apply {
+          if (it is HCException) {
+            putString(it.code.toString(), it.message)
+          } else {
+            putString("1001", it.localizedMessage ?: it.message)
+          }
+        }
+
+        callback.invoke(params, false)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun syncEvent(date: String, event: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToEvent(event)
+
+    scope.launch {
+      rookSync.syncEvents(localDate, type).fold({ result ->
+        when(result) {
+          SyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            promise.reject(throwable.code.toString(), throwable.message, throwable)
+          }
+          SyncStatus.SYNCED -> promise.resolve(true)
+        }
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  @ReactMethod
+  fun shSync(enableLogs: Boolean, callback: Callback) {
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("5", "Samsung health is not available")
+        }
+
+        callback.invoke(params, false)
+        return@launch
+      }
+
+      rookSamsung.sync(enableLogs).fold(
+        {
+          callback(null, true)
+        }, {
+          val params = Arguments.createMap().apply {
+            if (it is SHException) {
+              putString(it.code.toString(), it.message)
+            } else {
+              putString("1001", it.localizedMessage ?: it.message)
+            }
+          }
+
+          callback.invoke(params, false)
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun shSyncByDate(date: String, callback: Callback) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("5", "Samsung health is not available")
+        }
+
+        callback.invoke(params, false)
+        return@launch
+      }
+
+      val result = rookSamsung.sync(localDate)
+
+      try {
+        val sleepSummaryStatus = result.sleepSummary.getOrThrow()
+        val physicalSummaryStatus = result.physicalSummary.getOrThrow()
+        val bodySummaryStatus = result.bodySummary.getOrThrow()
+
+        val noSleepData = sleepSummaryStatus == SHSyncStatus.RECORDS_NOT_FOUND
+        val noPhysicalData = physicalSummaryStatus == SHSyncStatus.RECORDS_NOT_FOUND
+        val noBodyData = bodySummaryStatus == SHSyncStatus.RECORDS_NOT_FOUND
+
+        if (noSleepData && noPhysicalData && noBodyData) {
+          val throwable = HCRecordsNotFoundException("Sleep, Physical and Body summary")
+
+          val params = Arguments.createMap().apply {
+            putString(throwable.code.toString(), throwable.message)
+          }
+
+          callback.invoke(params, false)
+        } else {
+          callback.invoke(null, true)
+        }
+      } catch (e: Exception) {
+        val params = Arguments.createMap().apply {
+          if (e is HCException){
+            putString(e.code.toString(), e.message)
+          } else {
+            putString("1001", e.message ?: "Unknown error")
+          }
+        }
+
+        callback.invoke(params, false)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun shSyncByDefinition(summary: String, date: String, callback: Callback) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToSamsungPillar(summary)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("5", "Samsung health is not available")
+        }
+
+        callback.invoke(params, false)
+        return@launch
+      }
+
+      val result = rookSamsung.sync(localDate, type)
+      result.onSuccess {
+        when (it) {
+          SHSyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            val params = Arguments.createMap().apply {
+              putString(throwable.code.toString(), throwable.message)
+            }
+
+            callback.invoke(params, false)
+          }
+          SHSyncStatus.SYNCED -> callback.invoke(null, true)
+        }
+      }
+
+      result.onFailure {
+        val params = Arguments.createMap().apply {
+          if (it is HCException) {
+            putString(it.code.toString(), it.message)
+          } else {
+            putString("1001", it.localizedMessage ?: it.message)
+          }
+        }
+
+        callback.invoke(params, false)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun shSyncEvent(date: String, event: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToSamsungEvent(event)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        promise.reject(
+          "5",
+          "Samsung health is not available",
+          Throwable("Samsung health is not available")
+        )
+        return@launch
+      }
+
+      rookSamsung.syncEvents(localDate, type).fold({ result ->
+        when(result) {
+          SHSyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            promise.reject(throwable.code.toString(), throwable.message, throwable)
+          }
+          SHSyncStatus.SYNCED -> promise.resolve(true)
+        }
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+  override fun getName(): String {
+    return "RookSyncModule"
+  }
+
+}

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

@@ -0,0 +1,34 @@
+package com.rooksdk.utils
+
+import com.facebook.react.bridge.ReadableArray
+import io.tryrook.api.sources.domain.enums.DataSourceType
+
+object DatasourcesUtils {
+
+  /**
+   * Maps a data source string to its corresponding DataSourceType enum.
+   * @param source 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(source: String): DataSourceType? {
+    return try {
+      DataSourceType.valueOf(source)
+    } catch (e: IllegalArgumentException) {
+      null
+    }
+  }
+
+  fun readableArrayToSourceList(sources: ReadableArray): List<Source> {
+    val rawList = sources.toArrayList()
+
+    return rawList
+        .mapNotNull { it as? String }
+        .mapNotNull {
+          try {
+            Source.valueOf(it)
+          } catch (e: IllegalArgumentException) {
+            null
+          }
+        }
+  }
+}

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

@@ -0,0 +1,21 @@
+package com.rooksdk.utils
+
+import com.facebook.react.bridge.ReadableArray
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+
+object PermissionConversion {
+
+fun parseSamsungPermissions(rawPermissions: ReadableArray): Set<SamsungHealthPermission> {
+    val rawList = rawPermissions.toArrayList()
+
+    return rawList
+      .mapNotNull { it as? String }
+      .mapNotNull {
+        try {
+          SamsungHealthPermission.valueOf(it)
+        } catch (e: IllegalArgumentException) {
+          null
+        }
+      }.toSet()
+  }
+}