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

package/android/src/main/java/com/rooksdk/RookSdkModule.kt

@@ -18,6 +18,7 @@ import com.rookmotion.rook.sdk.RookPermissionsManager
 import com.rookmotion.rook.sdk.RookStepsManager
 import com.rookmotion.rook.sdk.RookSummaryManager
 import com.rookmotion.rook.sdk.RookYesterdaySyncManager
+import com.rookmotion.rook.sdk.domain.enums.DataSourceType
 import com.rookmotion.rook.sdk.domain.enums.HealthConnectAvailability
 import com.rookmotion.rook.sdk.domain.environment.RookAndroidClass
 import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
@@ -37,31 +38,41 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 
-class RookSdkModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+/**
+ * The `RookSdkHealthConnectModule` class is a React Native module that interfaces
+ * with the Rook SDK for managing and syncing health data using Android's Health Connect.
+ * It provides methods for initializing the SDK, handling user configuration, syncing
+ * health data, and managing permissions.
+ *
+ * Main Responsibilities:
+ * - Initialize and configure the Rook SDK.
+ * - Manage user-related information such as user ID.
+ * - Sync health-related summaries and events (e.g., sleep, body metrics, physical activities).
+ * - Handle Health Connect permissions and check availability.
+ * - Transmit permission changes through Android and Health Connect.
+ * - Provide the ability to listen to permission changes using Android broadcast receivers.
+ * - Expose methods to JavaScript for requesting or syncing data.
+ *
+ * Key Components:
+ * - `RookConfigurationManager`: Manages configuration settings for the SDK.
+ * - `RookSummaryManager`: Handles syncing health data summaries (e.g., sleep, physical, body).
+ * - `RookEventManager`: Manages the synchronization of health-related events (e.g., physical activities, blood pressure, etc.).
+ * - `RookPermissionsManager`: Handles permission management and availability checks for Health Connect.
+ * - `RookStepsManager`: Manages steps data synchronization.
+ * - `CoroutineScope`: Used to launch asynchronous operations.
+ */
+class RookSdkModule(
+  reactContext: ReactApplicationContext,
+  private val rookConfigurationManager: RookConfigurationManager
+): ReactContextBaseJavaModule(reactContext) {
 
-  private val rookConfigurationManager = RookConfigurationManager(reactApplicationContext)
-  private val rookSummaryManager = RookSummaryManager(rookConfigurationManager)
-  private val rookEventManager = RookEventManager(rookConfigurationManager)
   private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
   private var listenerCount = 0
 
-  private val rookSynManager: RookYesterdaySyncManager by lazy {
-    RookYesterdaySyncManager(reactApplicationContext)
-  }
-
   private val stepsScope: CoroutineScope by lazy {
     CoroutineScope(SupervisorJob() + Dispatchers.Main)
   }
 
-  private val rookStepsManager: RookStepsManager by lazy {
-    RookStepsManager(reactApplicationContext)
-  }
-
-  private val rookPermissionsManager: RookPermissionsManager by lazy {
-    RookPermissionsManager(reactApplicationContext)
-  }
-
   private val androidPermissionsReceiverTransmitter: AndroidPermissionsReceiverTransmitter by lazy {
     AndroidPermissionsReceiverTransmitter()
   }
@@ -109,106 +120,22 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  private fun determineSummaryValue(summaryString: String): HealthDataType {
-    return when (summaryString) {
-      "SLEEP" -> HealthDataType.SLEEP_SUMMARY
-      "PHYSICAL" -> HealthDataType.PHYSICAL_SUMMARY
-      "BODY" -> HealthDataType.BODY_SUMMARY
-      "BLOOD_GLUCOSE_EVENT" -> HealthDataType.BLOOD_GLUCOSE_BODY_EVENT
-      "BLOOD_PRESSURE_EVENT" -> HealthDataType.BLOOD_PRESSURE_BODY_EVENT
-      "BODY_METRICS_EVENT" -> HealthDataType.BODY_METRICS_EVENT
-      "HEART_RATE_EVENT" -> HealthDataType.HEART_RATE_BODY_EVENT
-      "HYDRATION_EVENT" -> HealthDataType.HYDRATION_BODY_EVENT
-      "NUTRITION_EVENT" -> HealthDataType.NUTRITION_BODY_EVENT
-      "OXYGENATION_EVENT" -> HealthDataType.OXYGENATION_BODY_EVENT
-      "PHYSICAL_EVENT" -> HealthDataType.PHYSICAL_EVENT
-      "TEMPERATURE_EVENT" -> HealthDataType.TEMPERATURE_BODY_EVENT
-      else -> HealthDataType.SLEEP_SUMMARY
-    }
-  }
-
-  private 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.image)
-      map.putBoolean("connected", dataSource.connected)
-      dataSource.authorizationUrl?.let {
-        map.putString("authorizationUrl", it)
-      }
-      array.pushMap(map)
-    }
-    return array
-  }
-
-  @ReactMethod
-  fun getUserID(promise: Promise) {
-    scope.launch {
-      try {
-        promise.resolve(rookConfigurationManager.getUserID())
-      }
-      catch (e: Exception) {
-        promise.reject(e)
-      }
-    }
-  }
-
-  @ReactMethod
-  fun updateUserID(userID: String, promise: Promise) {
-    scope.launch {
-        rookConfigurationManager.updateUserID(userID)
-          .fold({
-            promise.resolve(true)
-          }, {
-            promise.reject(it)
-          })
-    }
-  }
-
-  @ReactMethod
-  fun clearUserID(promise: Promise) {
-    scope.launch {
-      rookConfigurationManager.clearUserID().fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun removeUserFromRook(promise: Promise) {
-    scope.launch {
-      val result = rookConfigurationManager.deleteUserFromRook()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncUserTimeZone(promise: Promise) {
-    scope.launch {
-      val result = rookConfigurationManager.syncUserTimeZone()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-
-
+  /**
+   * Initializes the Rook SDK with the specified configuration settings (environment, clientUUID, secretKey).
+   * This is required before any data synchronization or user management can occur.
+   * @param config A map containing the environment, clientUUID, secretKey, and other settings.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
   @ReactMethod
   fun initRook(config: ReadableMap,promise: Promise) {
     try {
+      val clientUUID = config.getString("clientUUID")?.trim() ?: ""
+      val secretKey = config.getString("password")?.trim() ?: ""
+
+      if (clientUUID.isBlank() || secretKey.isBlank()) {
+        promise.reject("Invalid Credentials", "Invalid credentials")
+        return
+      }
 
       var environment = RookEnvironment.SANDBOX
 
@@ -220,8 +147,8 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
 
       val rookConfiguration = RookConfiguration(
         environment = environment,
-        clientUUID = config.getString("clientUUID") ?: "",
-        secretKey = config.getString("password") ?: ""
+        clientUUID = clientUUID,
+        secretKey = secretKey
       )
 
       val enableLogs = config.getBoolean("enableLogs")
@@ -248,487 +175,14 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
 
   }
 
-  // MARK: - Permissions
-  @ReactMethod
-  fun shouldRequestPermissions(promise: Promise) {
-    val activity = reactApplicationContext.currentActivity
-
-    if (activity == null) {
-      promise.reject(Exception("Error trying to request permissions"))
-      return
-    }
-
-    try {
-      val r = RookPermissionsManager.shouldRequestAndroidPermissions(activity)
-      promise.resolve(r)
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  @ReactMethod
-  fun checkAvailability(promise: Promise) {
-
-    val r = rookPermissionsManager.checkHealthConnectAvailability()
-
-    when(r) {
-      HealthConnectAvailability.INSTALLED -> promise.resolve("INSTALED")
-      HealthConnectAvailability.NOT_INSTALLED -> promise.resolve("NOT_INSTALED")
-      HealthConnectAvailability.NOT_SUPPORTED -> promise.resolve("NOT_SUPPORTED")
-    }
-
-  }
-
-  @ReactMethod
-  fun openHealthConnectSettings(promise: Promise) {
-    scope.launch {
-
-      val result = rookPermissionsManager.openHealthConnectSettings()
-
-      result.fold({
-        promise.resolve(true)
-      },{
-        promise.reject(it)
-      })
-
-    }
-  }
-
-  @ReactMethod
-  fun checkPermissions(promise: Promise) {
-    scope.launch {
-      val result = rookPermissionsManager.checkHealthConnectPermissions()
-
-      result.fold({
-        promise.resolve(it)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun requestPermissions(promise: Promise) {
-    scope.launch {
-      rookPermissionsManager.requestHealthConnectPermissions().fold({
-        when(it) {
-          RequestPermissionsStatus.REQUEST_SENT -> {
-            promise.resolve("REQUEST_SENT")
-          }
-          RequestPermissionsStatus .ALREADY_GRANTED -> {
-            promise.resolve("ALREADY_GRANTED")
-          }
-        }
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // MARK: - Sync Summaries
-  @ReactMethod
-  fun shouldSyncFor(summaryString: String, date: String,promise: Promise) {
-    scope.launch {
-      RookHelpers.shouldSyncFor(
-        healthDataType = determineSummaryValue(summaryString),
-        localDate = RookDateTime.stringToLocalDate(date)
-      ).fold({
-        promise.resolve(it)
-      },{
-        promise.reject(it)
-      })
-    }
-  }
-
-  @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
-  @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
-  @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)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncPendingSummaries(promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncPendingSummaries()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // MARK: - Events
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @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)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncPendingEvents(promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPendingEvents()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // MARK: - Health Connect Background
-  @ReactMethod
-  fun scheduleYesterdaySync(config: ReadableMap, promise: Promise) {
-    scope.launch {
-      try {
-        var environment = RookEnvironment.SANDBOX
-
-        if (config.getString("environment") == "production")
-          environment = RookEnvironment.PRODUCTION
-
-        rookSynManager.scheduleYesterdaySync(
-          enableLogs = true,
-          clientUUID = config.getString("clientUUID") ?: "",
-          secretKey = config.getString(",") ?: "",
-          environment = environment,
-        )
-
-        promise.resolve(true)
-
-      }
-      catch (e: Exception) {
-        promise.reject(e)
-      }
-    }
-
-  }
-
-  @ReactMethod
-  fun requestAndroidBackgroundPermissions(promise: Promise) {
-    try {
-      val response = rookPermissionsManager.requestAndroidPermissions()
-
-      if (response == RequestPermissionsStatus.REQUEST_SENT)
-        promise.resolve("REQUEST_SENT")
-      else promise.resolve("ALREADY_GRANTED")
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  @ReactMethod
-  fun hasAndroidBackgroundPermissions(promise: Promise) {
-    try {
-      val result = rookPermissionsManager.checkAndroidPermissions()
-      promise.resolve(result)
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  // MARK: - Steps
-  @ReactMethod
-  fun isStepsAvailable(promise: Promise) {
-    promise.resolve(rookStepsManager.isAvailable())
-  }
-
-  @ReactMethod
-  fun hasStepsPermissions(promise: Promise) {
-    promise.resolve(rookPermissionsManager.checkAndroidPermissions())
-  }
-
-  @ReactMethod
-  fun enableBackgroundAndroidSteps(promise: Promise) {
-    rookStepsManager.enableBackgroundAndroidSteps().fold({
-      promise.resolve(true)
-    }, {
-      promise.reject(it)
-    })
-  }
-
-  @ReactMethod
-  fun disableBackgroundAndroidSteps(promise: Promise) {
-    rookStepsManager
-      .disableBackgroundAndroidSteps()
-      .fold({
-        stepsScope.cancel()
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-  }
-
-  @ReactMethod
-  fun isBackgroundAndroidStepsActive(promise: Promise) {
-    scope.launch {
-      val response = rookStepsManager.isBackgroundAndroidStepsActive()
-      promise.resolve(response)
-    }
-  }
-
-  @ReactMethod
-  fun syncTodayAndroidStepsCount(promise: Promise) {
-    scope.launch {
-      rookStepsManager
-        .syncTodayAndroidStepsCount()
-        .fold({
-          promise.resolve(it.toString())
-        }, {
-          promise.reject(it)
-        })
-    }
-  }
-
-  @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)
-        }
-      )
-    }
-  }
-
-  // MARK: - Datasources
-  @ReactMethod
-  fun getAvailableDataSources(options: ReadableMap?, promise: Promise) {
-    val rookDataSources = RookDataSources(reactApplicationContext)
-    println(options)
-    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)
-        },
-      )
-    }
-  }
-
-  @ReactMethod
-  fun presentDataSourceView(options: ReadableMap?, promise: Promise) {
-    val rookDataSources = RookDataSources(reactApplicationContext)
-    var redirectURL: String? = null
-
-    if (options !== null) redirectURL = options.getString("redirectURL")
-
-    rookDataSources.presentDataSourceView(redirectURL).fold({
-      promise.resolve(true)
-    }, {
-      promise.reject(it)
-    })
-  }
-
+  /**
+   * Sends a broadcast message to the React Native layer.
+   * This method emits a message event to the React Native side via the
+   * `ROOK_NOTIFICATION` channel, allowing communication from the native module.
+   *
+   * @param message A ReadableMap containing the message data to send.
+   * @param promise A promise object that resolves with true if the message was sent successfully.
+   */
   @ReactMethod
   fun sendMessageToBroadcast(message: ReadableMap, promise: Promise) {
     if (listenerCount <= 0) return

package/android/src/main/java/com/rooksdk/RookSdkPackage.kt

@@ -4,11 +4,27 @@ import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
+import com.rookmotion.rook.sdk.RookConfigurationManager
+import com.rooksdk.modules.RookConfigurationModule
+import com.rooksdk.modules.RookPermissionsModule
+import com.rooksdk.modules.RookStepsModule
+import com.rooksdk.modules.RookSyncModule
 
 
 class RookSdkPackage : ReactPackage {
+  private var rookConfigurationManager: RookConfigurationManager? = null
+
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(RookSdkModule(reactContext))
+    if (rookConfigurationManager == null)
+      rookConfigurationManager = RookConfigurationManager(reactContext)
+
+    return listOf(
+      RookSdkModule(reactContext, rookConfigurationManager!!),
+      RookPermissionsModule(reactContext),
+      RookConfigurationModule(reactContext, rookConfigurationManager!!),
+      RookSyncModule(reactContext, rookConfigurationManager!!),
+      RookStepsModule(reactContext)
+    )
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {