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

package/android/src/main/java/com/rooksdk/broadcasts/HealthConnectPermissionsReceiverTransmitter.kt

@@ -0,0 +1,70 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.rookmotion.rook.sdk.RookPermissionsManager
+
+/**
+ * HealthConnectPermissionsReceiverTransmitter is a custom BroadcastReceiver used to listen for updates
+ * on Android permission changes and transmit them back to the React Native layer.
+ * It listens for a broadcast containing permission status, then emits a corresponding event to JavaScript.
+ */
+class HealthConnectPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  /**
+   * This method is called when a broadcast is received.
+   * It checks whether the broadcast includes the permission status and emits an event to the React Native
+   * JavaScript layer with the results.
+   *
+   * @param context The context in which the receiver is running.
+   * @param intent The intent containing permission-related data.
+   */
+  override fun onReceive(context: Context?, intent: Intent?) {
+    val permissionsGranted = intent?.getBooleanExtra(
+      /* name = */ RookPermissionsManager.EXTRA_HEALTH_CONNECT_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    val partiallyGranted = intent?.getBooleanExtra(
+      RookPermissionsManager.EXTRA_HEALTH_CONNECT_PERMISSIONS_PARTIALLY_GRANTED,
+      false
+    ) ?: false
+
+    val backgroundReadStatus = intent?.getBooleanExtra(
+      RookPermissionsManager.EXTRA_HEALTH_CONNECT_BACKGROUND_PERMISSION_GRANTED,
+      false
+    ) ?: false
+
+    reactApplicationContext?.also { reactContext ->
+      val events = listOf(
+        "ROOK_HEALTH_CONNECT_PERMISSIONS" to permissionsGranted,
+        "ROOK_HEALTH_CONNECT_PERMISSIONS_PARTIALLY_GRANTED" to partiallyGranted,
+        "ROOK_HEALTH_CONNECT_BACKGROUND_PERMISSIONS" to backgroundReadStatus,
+      )
+
+      val emitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+
+      events.forEach { (type, value) ->
+        Arguments.createMap().apply {
+          putString("type", type)
+          putBoolean("value", value)
+          emitter.emit("ROOK_NOTIFICATION", this)
+        }
+      }
+    }
+  }
+
+  /**
+   * Sets the ReactApplicationContext to be used for emitting events to the React Native side.
+   *
+   * @param context The ReactApplicationContext provided by React Native.
+   */
+  fun setReactApplicationContext(context: ReactApplicationContext) {
+    this.reactApplicationContext = context
+  }
+}

package/android/src/main/java/com/rooksdk/broadcasts/SamsungHealthPermissionsReceiverTransmitter.kt

@@ -0,0 +1,52 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+
+class SamsungHealthPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  /**
+   * Sets the ReactApplicationContext to be used for emitting events to the React Native side.
+   *
+   * @param context The ReactApplicationContext provided by React Native.
+   */
+  fun setReactApplicationContext(context: ReactApplicationContext) {
+    this.reactApplicationContext = context
+  }
+
+  override fun onReceive(conext: Context?, intent: Intent?) {
+    val allPermissionsGranted = intent?.getBooleanExtra(
+      /* name = */ SamsungHealthPermission.EXTRA_SAMSUNG_HEALTH_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    val permissionsPartiallyGranted = intent?.getBooleanExtra(
+      /* name = */ SamsungHealthPermission.EXTRA_SAMSUNG_HEALTH_PERMISSIONS_PARTIALLY_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    reactApplicationContext?.also { reactContext ->
+      val events = listOf(
+        "ROOK_SAMSUNG_HEALTH_PERMISSIONS" to allPermissionsGranted,
+        "ROOK_SAMSUNG_HEALTH_PERMISSIONS_PARTIALLY_GRANTED" to permissionsPartiallyGranted,
+      )
+
+      val emitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+
+      events.forEach { (type, value) ->
+        Arguments.createMap().apply {
+          putString("type", type)
+          putBoolean("value", value)
+          emitter.emit("ROOK_NOTIFICATION", this)
+        }
+      }
+    }
+
+  }
+}

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

@@ -0,0 +1,99 @@
+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.rookmotion.rook.sdk.RookBackgroundSyncManager
+import com.rookmotion.rook.sdk.domain.exception.HCException
+import io.tryrook.api.sources.domain.exception.ApiException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class RookBackgroundSyncModule (reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+  private val backgroundSyncManager = RookBackgroundSyncManager(reactContext)
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  override fun getName(): String {
+    return "RookBackgroundModule"
+  }
+
+  /**
+   * Schedules the background synchronization of health data using Rook.
+   *
+   * This function enables automatic background data synchronization with Rook.
+   * It ensures that health data is periodically fetched and sent to Rook’s API
+   * based on the defined configuration.
+   *
+   * If the scheduling is successful, the promise resolves with "SUCCESS".
+   * If an error occurs, the promise rejects with an error message.
+   *
+   * @param promise A React Native promise that resolves when the sync is scheduled successfully or rejects with an error.
+   */
+  @ReactMethod
+  fun scheduleBackgroundSync(enableLogs: Boolean, promise: Promise) {
+    try {
+      backgroundSyncManager.schedule(enableLogs)
+      promise.resolve(true)
+    }
+    catch (e: Exception) {
+      if (e is HCException) {
+        promise.reject(e.code.toString(), e.message, e)
+      } else {
+        promise.reject("1001", e.message, e)
+      }
+    }
+
+  }
+
+  /**
+   * Cancels the scheduled background synchronization of health data.
+   *
+   * This function stops the automatic background sync previously scheduled using Rook.
+   * It ensures that no further health data is fetched and sent until scheduled again.
+   *
+   * If the cancellation is successful, the promise resolves with "SUCCESS".
+   * If an error occurs, the promise rejects with an error message.
+   *
+   * @param promise A React Native promise that resolves when the sync is canceled successfully or rejects with an error.
+   */
+  @ReactMethod
+  fun cancelBackgroundSync(promise: Promise) {
+    scope.launch {
+      try {
+        backgroundSyncManager.cancel()
+        promise.resolve(true)
+      } catch (e: Exception) {
+        if (e is HCException) {
+          promise.reject(e.code.toString(), e.message, e)
+        } else {
+          promise.reject("1001", e.message, e)
+        }
+      }
+    }
+  }
+
+@ReactMethod
+  fun isBackgroundSyncEnabled(promise: Promise) {
+    scope.launch {
+      backgroundSyncManager.isScheduled().fold(
+        {
+          promise.resolve(it)
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+}

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

@@ -0,0 +1,182 @@
+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.ReadableArray
+import com.google.gson.Gson
+import com.rookmotion.rook.sdk.RookConfigurationManager
+import com.rookmotion.rook.sdk.domain.exception.HCException
+import com.rooksdk.utils.DatasourcesUtils
+import com.rooksdk.utils.RookGsonBuilder
+import com.rooksdk.utils.SamsungAvailability
+import com.rooksdk.utils.Source
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class RookConfigurationModule(
+  reactContext: ReactApplicationContext,
+  private val rookConfigurationManager: RookConfigurationManager,
+  private val rookSamsung: RookSamsung,
+): ReactContextBaseJavaModule(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  private val gsonBuilder: Gson by lazy {
+    RookGsonBuilder.getGsonBuilder()
+  }
+  /**
+   * Retrieves the currently stored user ID in the Rook SDK configuration.
+   * @param promise A promise object to handle the result (resolved with the user ID or rejected with an error).
+   */
+  @ReactMethod
+  fun getUserID(promise: Promise) {
+    scope.launch {
+      try {
+        val user = rookConfigurationManager.getUserID()
+        promise.resolve(user)
+      }
+      catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  /**
+   * Updates the user ID in the Rook SDK configuration.
+   * @param userID The new user ID to be set.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun updateUserID(userID: String, promise: Promise) {
+    scope.launch {
+      try {
+        if (SamsungAvailability.isSamsungAvailable(rookSamsung)) {
+          val samsungResult = rookSamsung.updateUserID(userID)
+
+          if (samsungResult.isFailure) {
+            println("We couldn't initiate the user id in Samsung Health")
+          }
+
+          samsungResult.getOrThrow()
+        }
+
+        val healthConnectResult =  rookConfigurationManager.updateUserID(userID)
+
+        if (healthConnectResult.isFailure) {
+          println("We couldn't initiate the user id in Health Connect")
+        }
+
+        healthConnectResult.getOrThrow()
+
+        promise.resolve(true)
+      } catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  /**
+   * Deletes the user data from the Rook platform by removing the user from the system.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun removeUserFromRook(rawSources: ReadableArray, promise: Promise) {
+    scope.launch {
+      try {
+        val sources = DatasourcesUtils.readableArrayToSourceList(rawSources)
+
+        if(Source.HEALTH_CONNECT in sources) {
+          val hcResult = rookConfigurationManager.deleteUserFromRook()
+          hcResult.getOrThrow()
+        }
+
+        if(Source.SAMSUNG_HEALTH in sources && SamsungAvailability.isSamsungAvailable(rookSamsung)) {
+          val hcResult = rookSamsung.deleteUserFromRook()
+          hcResult.getOrThrow()
+        }
+
+        promise.resolve(true)
+      }
+      catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  /**
+   * Synchronizes the user's time zone with the Rook platform to ensure data is processed correctly.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun syncUserTimeZone(promise: Promise) {
+    scope.launch {
+      val result = rookConfigurationManager.syncUserTimeZone()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  @ReactMethod
+  fun getHealthConnectDiagnosticState(promise: Promise) {
+    scope.launch {
+      try {
+        val result = rookConfigurationManager.getDiagnosticState().getOrThrow()
+        promise.resolve(gsonBuilder.toJson(result))
+      } catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun getSamsungHealthDiagnosticState(promise: Promise) {
+    scope.launch {
+      try {
+        val result = rookSamsung.getDiagnosticState().getOrThrow()
+        promise.resolve(gsonBuilder.toJson(result))
+      } catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  override fun getName(): String {
+    return "RookConfigurationModule"
+  }
+}

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

@@ -0,0 +1,301 @@
+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.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.rookmotion.rook.sdk.RookSyncManager
+import com.rookmotion.rook.sdk.RookWriteManager
+import com.rookmotion.rook.sdk.domain.annotation.ExperimentalRookApi
+import com.rookmotion.rook.sdk.domain.exception.HCException
+import com.rookmotion.rook.sdk.domain.model.HCActivityEvent
+import com.rookmotion.rook.sdk.domain.model.HCBodySummary
+import com.rookmotion.rook.sdk.domain.model.HCPhysicalSummary
+import com.rookmotion.rook.sdk.domain.model.HCSleepSummary
+import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
+import com.rooksdk.utils.ReadableToWritable
+import com.rooksdk.utils.serializers.InstantSerializer
+import com.rooksdk.utils.RookDateTime
+import com.rooksdk.utils.RookGsonBuilder
+import com.rooksdk.utils.serializers.LocalDateSerializer
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.exception.SHException
+import io.tryrook.sdk.samsung.domain.model.SHActivityEvent
+import io.tryrook.sdk.samsung.domain.model.SHBodySummary
+import io.tryrook.sdk.samsung.domain.model.SHPhysicalSummary
+import io.tryrook.sdk.samsung.domain.model.SHSleepSummary
+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 RookLocalData (
+  private val reactContext: ReactApplicationContext,
+  private val rookSamsung: RookSamsung,
+): ReactContextBaseJavaModule(reactContext){
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  private val rookHealthConnect by lazy {
+    RookSyncManager(reactContext)
+  }
+
+  private val gsonBuilder: Gson by lazy {
+    RookGsonBuilder.getGsonBuilder()
+  }
+
+  @ReactMethod
+  fun getSamsungSleepSummary(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getSleepSummary(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungSleepSummary", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<List<SHSleepSummary>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getSamsungPhysicalSummary(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getPhysicalSummary(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungPhysicalSummary", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<SHPhysicalSummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getSamsungBodySummary(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getBodySummary(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungBodySummary", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<SHBodySummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getSamsungActivityEvents(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getActivityEvents(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungActivityEvents", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<List<SHActivityEvent>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  // Health Connect
+  @ReactMethod
+  fun getHealthConnectSleepSummary(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getSleepSummary(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectSleepSummary", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<List<HCSleepSummary>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getHealthConnectPhysicalSummary(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getPhysicalSummary(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectPhysicalSummary", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<HCPhysicalSummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getHealthConnectBodySummary(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getBodySummary(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectBodySummary", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<HCBodySummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getHealthConnectActivityEvents(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getActivityEvents(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectActivityEvents", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<List<HCActivityEvent>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+ @OptIn(ExperimentalRookApi::class)
+ @ReactMethod
+ fun writeHealthConnectMealData(data: ReadableMap, promise: Promise){
+   val mealData = ReadableToWritable.mapReadableMapToHCMealData(data)
+
+   scope.launch {
+     RookWriteManager.writeNutritionEvent(reactContext, mealData).fold({
+       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 "RookLocalData"
+  }
+}