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

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

@@ -1,309 +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.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 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 checkAvailability(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)
-      },{
-        promise.reject(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.entries.toSet()).fold(
-        { hasAllPermissions ->
-          promise.resolve(hasAllPermissions)
-        },
-        {
-          promise.reject(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.entries.toSet()).fold(
-        { hasAllPermissions ->
-          promise.resolve(hasAllPermissions)
-        },
-        {
-          promise.reject(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 checkPermissions(promise: Promise) {
-    scope.launch {
-      val result = rookPermissionsManager.checkHealthConnectPermissions()
-
-      result.fold({
-        promise.resolve(it)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun checkHealthConnectPermissionsPartially(promise: Promise) {
-    scope.launch {
-      val result = rookPermissionsManager.checkHealthConnectPermissionsPartially()
-
-      result.fold({
-        promise.resolve(it)
-      }, {
-        promise.reject(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 requestAllPermissions(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)
-      })
-    }
-  }
-
-  @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")
-          }
-        },
-        {
-          promise.reject(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 (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  /**
-   * 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 (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  /**
-   * 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 (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  @ReactMethod
-  fun revokeHealthConnectPermissions(promise: Promise) {
-    scope.launch {
-      rookPermissionsManager.revokeHealthConnectPermissions()
-        .fold({
-          promise.resolve(true)
-        }, {
-          promise.reject(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 checkBackgroundReadStatus(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")
-          }
-        },
-        { throwable ->
-          promise.reject(throwable)
-        }
-      )
-    }
-  }
-
-  companion object {
-    const val NAME = "RookPermissionsModule"
-  }
-
-  override fun getName(): String {
-    return NAME
-  }
-}

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

@@ -1,105 +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 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)
-    }, {
-      promise.reject(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)
-      }, {
-        promise.reject(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())
-        }, {
-          promise.reject(it)
-        })
-    }
-  }
-
-  override fun getName(): String {
-    return "RookStepsModule"
-  }
-}