react-native-rook-sdk 2.1.1 → 4.0.0-beta.0

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

@@ -1,85 +0,0 @@
-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 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) {
-      promise.reject(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) {
-        promise.reject(e)
-      }
-    }
-  }
-
-@ReactMethod
-  fun isBackgroundSyncEnabled(promise: Promise) {
-    scope.launch {
-      backgroundSyncManager.isScheduled().fold(
-        {
-          promise.resolve(it)
-        },
-        {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-}

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

@@ -1,148 +0,0 @@
-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.rookmotion.rook.sdk.RookConfigurationManager
-import com.rooksdk.utils.DatasourcesUtils
-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)
-  }
-
-  /**
-   * 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 (e: Exception) {
-        promise.reject(e)
-      }
-    }
-  }
-
-  /**
-   * 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 r = rookSamsung.updateUserID(userID).getOrNull()
-          if (r == null) println("We couldn't initiate the user id in Samsung Health")
-        }
-
-        val result =  rookConfigurationManager.updateUserID(userID)
-        result.getOrThrow()
-
-        promise.resolve(true)
-      } catch (e: Exception) {
-        promise.reject(e)
-      }
-    }
-  }
-
-  /**
-   * Clears the user ID stored in the Rook SDK configuration.
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun clearUserID(rawSources: ReadableArray, promise: Promise) {
-    scope.launch {
-      try {
-        val sources = DatasourcesUtils.readableArrayToSourceList(rawSources)
-
-        if(Source.HEALTH_CONNECT in sources) {
-          val hcResult = rookConfigurationManager.clearUserID()
-          hcResult.getOrThrow()
-        }
-
-        if(Source.SAMSUNG_HEALTH in sources && SamsungAvailability.isSamsungAvailable(rookSamsung)) {
-          val hcResult = rookSamsung.clearUserID()
-          hcResult.getOrThrow()
-        }
-
-        promise.resolve(true)
-      }
-      catch (e: Exception) {
-        promise.reject(e)
-      }
-    }
-  }
-
-  /**
-   * 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 (e: Exception) {
-        promise.reject(e)
-      }
-    }
-  }
-
-  /**
-   * 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)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  override fun getName(): String {
-    return "RookConfigurationModule"
-  }
-
-
-}

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

@@ -1,247 +0,0 @@
-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.google.gson.Gson
-import com.google.gson.GsonBuilder
-import com.rookmotion.rook.sdk.RookSyncManager
-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.serializers.InstantSerializer
-import com.rooksdk.utils.RookDateTime
-import com.rooksdk.utils.serializers.LocalDateSerializer
-import io.tryrook.sdk.samsung.RookSamsung
-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 (
-  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 {
-    GsonBuilder()
-      .registerTypeAdapter(Instant::class.java, InstantSerializer())
-      .registerTypeAdapter(LocalDate::class.java, LocalDateSerializer())
-      .create()
-  }
-
-  @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))
-            }
-          }
-        },
-        {
-          promise.reject(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))
-            }
-          }
-        },
-        {
-          promise.reject(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))
-            }
-          }
-        },
-        {
-          promise.reject(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))
-            }
-          }
-        },
-        {
-          promise.reject(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))
-            }
-          }
-        },
-        {
-          promise.reject(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))
-            }
-          }
-        },
-        {
-          promise.reject(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))
-            }
-          }
-        },
-        {
-          promise.reject(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))
-            }
-          }
-        },
-        {
-          promise.reject(it)
-        },
-      )
-    }
-  }
-
-  override fun getName(): String {
-    return "RookLocalData"
-  }
-}