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

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

@@ -1,359 +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.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)
-      }
-    }
-  }
-
-  /**
-   * 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)
-      }
-    }
-  }
-
-  /**
-   * 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

@@ -1,102 +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.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

@@ -1,119 +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.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)
-  }
-
-  /**
-   * 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)
-          }
-        })
-    }
-  }
-
-  override fun getName(): String {
-    return "RookStepsModule"
-  }
-}