react-native-rook-sdk 4.0.0-beta.2 → 4.1.0

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

@@ -0,0 +1,382 @@
+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.RookPermissionsManager
+import com.rookmotion.rook.sdk.domain.enums.BackgroundReadStatus
+import com.rookmotion.rook.sdk.domain.enums.HealthConnectAvailability
+import com.rookmotion.rook.sdk.domain.enums.RequestPermissionsStatus
+import com.rookmotion.rook.sdk.domain.exception.HCException
+import com.rooksdk.utils.PermissionConversion
+import com.rooksdk.utils.SamsungAvailability
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.enums.SHRequestPermissionsStatus
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+import io.tryrook.sdk.samsung.domain.exception.SHException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class RookPermissionsModule(reactContext: ReactApplicationContext, private val rookSamsung: RookSamsung):
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val rookPermissionsManager: RookPermissionsManager by lazy {
+    RookPermissionsManager(reactContext)
+  }
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  @ReactMethod
+  fun checkSamsungAvailability(promise: Promise) {
+    scope.launch {
+      rookSamsung.checkSamsungHealthAvailability().fold(
+        { availability ->
+          when (availability) {
+            SamsungHealthAvailability.INSTALLED -> promise.resolve("INSTALLED")
+            SamsungHealthAvailability.NOT_INSTALLED -> promise.resolve("NOT_INSTALLED")
+            SamsungHealthAvailability.OUTDATED -> promise.resolve("OUTDATED")
+            SamsungHealthAvailability.DISABLED -> promise.resolve("DISABLED")
+            SamsungHealthAvailability.NOT_READY -> promise.resolve("NOT_READY")
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+
+    }
+  }
+
+  /**
+   * Checks the availability of Health Connect on the device (whether it is installed, not installed, or not supported).
+   * @param promise A promise object to handle the result (resolved with the availability status or rejected on failure).
+   */
+  @ReactMethod
+  fun checkHealthConnectAvailability(promise: Promise) {
+    val r = rookPermissionsManager.checkHealthConnectAvailability()
+
+    when(r) {
+      HealthConnectAvailability.INSTALLED -> promise.resolve("INSTALLED")
+      HealthConnectAvailability.NOT_INSTALLED -> promise.resolve("NOT_INSTALLED")
+      HealthConnectAvailability.NOT_SUPPORTED -> promise.resolve("NOT_SUPPORTED")
+    }
+  }
+
+  /**
+   * Opens the Health Connect settings page on the device for the user to manage permissions.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun openHealthConnectSettings(promise: Promise) {
+    scope.launch {
+
+      val result = rookPermissionsManager.openHealthConnectSettings()
+
+      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 checkSamsungHealthPermissions(promise: Promise){
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        promise.reject(Throwable("Samsung health is not available"))
+        return@launch
+      }
+
+      rookSamsung.checkSamsungHealthPermissions(SamsungHealthPermission.values().toSet()).fold(
+        { hasAllPermissions ->
+          promise.resolve(hasAllPermissions)
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun checkSamsungHealthPermissionsPartially(promise: Promise){
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        promise.reject(Throwable("Samsung health is not available"))
+        return@launch
+      }
+
+      rookSamsung.checkSamsungHealthPermissionsPartially(SamsungHealthPermission.values().toSet()).fold(
+        { hasAllPermissions ->
+          promise.resolve(hasAllPermissions)
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  /**
+   * Checks the current permissions granted by Health Conect to ensure the application has the necessary access.
+   * @param promise A promise object to handle the result (resolved with permission status or rejected on failure).
+   */
+  @ReactMethod
+  fun checkHealthConnectPermissions(promise: Promise) {
+    scope.launch {
+      val result = rookPermissionsManager.checkHealthConnectPermissions()
+
+      result.fold({
+        promise.resolve(it)
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  @ReactMethod
+  fun checkHealthConnectPermissionsPartially(promise: Promise) {
+    scope.launch {
+      val result = rookPermissionsManager.checkHealthConnectPermissionsPartially()
+
+      result.fold({
+        promise.resolve(it)
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  /**
+   * Requests Health Connect permissions from the user if they are not already granted.
+   * @param promise A promise object to handle the result (resolved with the permission status or rejected on failure).
+   */
+  @ReactMethod
+  fun requestHealthConnectPermissions(promise: Promise) {
+    scope.launch {
+      rookPermissionsManager.requestHealthConnectPermissions().fold({
+        when(it) {
+          RequestPermissionsStatus.REQUEST_SENT -> {
+            promise.resolve("REQUEST_SENT")
+          }
+          RequestPermissionsStatus .ALREADY_GRANTED -> {
+            promise.resolve("ALREADY_GRANTED")
+          }
+        }
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  @ReactMethod
+  fun requestSamsungPermissions(permissions: ReadableArray, promise: Promise) {
+    val shPermissions = PermissionConversion.parseSamsungPermissions(permissions)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)) {
+        promise.reject(Throwable("Samsung Health is not available"))
+        return@launch
+      }
+
+      rookSamsung.requestSamsungHealthPermissions(shPermissions).fold(
+        {
+          when (it) {
+            SHRequestPermissionsStatus.ALREADY_GRANTED -> promise.resolve("ALREADY_GRANTED")
+            SHRequestPermissionsStatus.REQUEST_SENT -> promise.resolve("REQUEST_SENT")
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  /**
+   * Checks if the SDK has permissions to use background permissions
+   * */
+  @ReactMethod
+  fun hasAndroidBackgroundPermissions(promise: Promise) {
+    try {
+      val result = rookPermissionsManager.checkAndroidPermissions()
+      promise.resolve(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 androidHasAlarmPermissions(promise: Promise) {
+    try {
+      val result = rookPermissionsManager.checkAndroidPermissions()
+      promise.resolve(result)
+    } catch (it: Exception) {
+      promise.reject("1001", it.message, it)
+    }
+  }
+
+  /**
+   * Requests Android permissions for step counting if they are not already granted.
+   * @param promise A promise object to handle the result (resolved with the permission status or rejected on failure).
+   */
+  @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 (it: Exception) {
+      if (it is HCException) {
+        promise.reject(it.code.toString(), it.message, it)
+      } else {
+        promise.reject("1001", it.message, it)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun requestAndroidAlarmPermissions(promise: Promise) {
+    scope.launch {
+      try {
+        rookPermissionsManager.requestExactAlarmPermission()
+        promise.resolve(null)
+      } catch (it: Exception) {
+        promise.reject("1001", it.message, it)
+      }
+    }
+
+  }
+
+  /**
+   * Check if the SDK should request permissions to use android services
+   * to show an sticky notification
+   * */
+  @ReactMethod
+  fun shouldRequestAndroidBackgroundPermissions(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 (it: Exception) {
+      if (it is HCException) {
+        promise.reject(it.code.toString(), it.message, it)
+      } else {
+        promise.reject("1001", it.message, it)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun revokeHealthConnectPermissions(promise: Promise) {
+    scope.launch {
+      rookPermissionsManager.revokeHealthConnectPermissions()
+        .fold({
+          promise.resolve(true)
+        }, {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        })
+    }
+  }
+
+  /**
+   * Checks the status of background read permissions using RookPermissionsManager.
+   *
+   * This function determines whether the app has permission to read health data in the background.
+   * The result is returned as a promise to React Native.
+   *
+   * Possible results:
+   * - "UNAVAILABLE": Background read is not available on this device.
+   * - "PERMISSION_NOT_GRANTED": The background read permission has not been granted.
+   * - "PERMISSION_GRANTED": The background read permission has been granted.
+   *
+   * If an error occurs while checking the permission status, the promise will be rejected.
+   *
+   * @param promise A React Native promise that resolves with the permission status or rejects with an error.
+   */
+  @ReactMethod
+  fun checkHealthConnectBackgroundReadStatus(promise: Promise) {
+    scope.launch {
+      rookPermissionsManager.checkBackgroundReadStatus().fold(
+        { status ->
+          when (status) {
+            BackgroundReadStatus.UNAVAILABLE -> promise.resolve("UNAVAILABLE")
+            BackgroundReadStatus.PERMISSION_NOT_GRANTED -> promise.resolve("PERMISSION_NOT_GRANTED")
+            BackgroundReadStatus.PERMISSION_GRANTED -> promise.resolve("PERMISSION_GRANTED")
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  companion object {
+    const val NAME = "RookPermissionsModule"
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+}

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

@@ -0,0 +1,102 @@
+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.rooksdk.utils.DatasourcesUtils.mapToDataSourceType
+import io.tryrook.api.sources.RookApiSources
+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 RookSourcesModule(
+  private val reactContext: ReactApplicationContext
+): ReactContextBaseJavaModule(reactContext) {
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  /**
+   * 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(userid: String, source: String, promise: Promise) {
+    val type = mapToDataSourceType(source)
+
+    if (type == null) {
+      promise.reject("Invalid", "Enter a valid data source")
+      return
+    }
+
+    scope.launch {
+      RookApiSources(reactContext).revokeDataSource(userID = userid, dataSource = type).fold({
+        promise.resolve(true)
+      }, {
+        if (it is ApiException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  @ReactMethod
+  fun getAuthorizedDataSourcesV2(userid: String, promise: Promise) {
+    scope.launch {
+      RookApiSources(reactContext).getAuthorizedDataSourcesV2(
+        userID = userid
+      ).fold(
+        {
+          val gson = Gson()
+          promise.resolve(gson.toJson(it))
+        }, {
+          if (it is ApiException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getDataSourceAuthorizer(options: ReadableMap, promise: Promise) {
+    val source = options.getString("dataSource") ?: ""
+    val redirect = options.getString("redirectURL")
+    val userid = options.getString("userID") ?: ""
+
+    scope.launch {
+      RookApiSources(reactContext).getDataSourceAuthorizer(
+        dataSource = source,
+        redirectUrl = redirect,
+        userID = userid
+      ).fold({ value ->
+          val gson = Gson()
+          promise.resolve(gson.toJson(value))
+        }, {
+          if (it is ApiException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        })
+    }
+  }
+
+  override fun getName(): String {
+    return "RookSourcesModule"
+  }
+}

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

@@ -0,0 +1,189 @@
+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.RookStepsCounter
+import com.rookmotion.rook.sdk.RookStepsManager
+import com.rookmotion.rook.sdk.domain.exception.HCException
+import io.tryrook.sdk.samsung.domain.exception.SHException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+class RookStepsModule(
+  reactContext: ReactApplicationContext
+): ReactContextBaseJavaModule(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  private val rookStepsManager: RookStepsManager by lazy {
+    RookStepsManager(reactApplicationContext)
+  }
+
+  private val rookStepsCounter: RookStepsCounter by lazy {
+    RookStepsCounter(reactContext)
+  }
+
+  /**
+   * Checks if step count data is available on the device.
+   * @param promise A promise object to handle the result (resolved with true/false).
+   */
+  @ReactMethod
+  fun isStepsAvailable(promise: Promise) {
+    promise.resolve(rookStepsManager.isAvailable())
+  }
+
+  /**
+   * Enables background step counting on Android devices, allowing the app to track steps continuously.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun enableBackgroundAndroidSteps(promise: Promise) {
+    rookStepsManager.enableBackgroundAndroidSteps().fold({
+      promise.resolve(true)
+    }, {
+      if (it is HCException) {
+        promise.reject(it.code.toString(), it.message, it)
+      } else {
+        promise.reject("1001", it.message, it)
+      }
+    })
+  }
+
+  /**
+   * Disables background step counting on Android devices.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
+  @ReactMethod
+  fun disableBackgroundAndroidSteps(promise: Promise) {
+    rookStepsManager
+      .disableBackgroundAndroidSteps()
+      .fold({
+        scope.cancel()
+        promise.resolve(true)
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+  }
+
+  /**
+   * Checks whether background step tracking on Android is currently active.
+   * This method queries the Rook SDK to determine if background step counting
+   * is enabled and active on the device.
+   *
+   * @param promise A promise object that resolves with a boolean value:
+   *                - true if background step tracking is active,
+   *                - false otherwise.
+   */
+  @ReactMethod
+  fun isBackgroundAndroidStepsActive(promise: Promise) {
+    scope.launch {
+      val response = rookStepsManager.isBackgroundAndroidStepsActive()
+      promise.resolve(response)
+    }
+  }
+
+  /**
+   * Synchronizes the step count for the current day
+   * This method queries the Rook SDK to retrieve the number of steps counted today
+   * from the Android platform and returns the result to the React Native layer.
+   *
+   * @param promise A promise object that resolves with the step count as a string
+   *                or rejects with an error if the synchronization fails.
+   */
+  @ReactMethod
+  fun syncTodayAndroidStepsCount(promise: Promise) {
+    scope.launch {
+      rookStepsManager
+        .syncTodayAndroidStepsCount()
+        .fold({
+          promise.resolve(it.toString())
+        }, {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        })
+    }
+  }
+
+  @ReactMethod
+  fun isStepsCounterAvailable(promise: Promise?) {
+    if (promise == null) return
+
+    try {
+      val available = rookStepsCounter.isStepsCounterAvailable()
+      promise.resolve(available)
+    } catch (e: Exception) {
+      promise.reject("1001", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun isStepsCounterActive(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      try {
+        val active = rookStepsCounter.isStepsCounterActive()
+        promise.resolve(active)
+      } catch (e: Exception) {
+        promise.reject("1001", e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun enableStepsCounter(promise: Promise?) {
+    if (promise == null) return
+
+    try {
+      // Using getOrThrow to trigger the catch block on Result.failure
+      rookStepsCounter.enableStepsCounter().getOrThrow()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("1001", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun disableStepsCounter(promise: Promise?) {
+    if (promise == null) return
+
+    try {
+      rookStepsCounter.disableStepsCounter().getOrThrow()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("1001", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun getTodayStepsCount(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      try {
+        val steps = rookStepsCounter.getTodayStepsCount().getOrThrow()
+        promise.resolve(steps.toDouble())
+      } catch (e: Exception) {
+        promise.reject("1001", e.message, e)
+      }
+    }
+  }
+
+  override fun getName(): String {
+    return "RookStepsModule"
+  }
+}