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

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<*, *>> {

package/android/src/main/java/com/rooksdk/broadcasts/AndroidPermissionsReceiverTransmitter.kt

@@ -0,0 +1,54 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.rookmotion.rook.sdk.RookPermissionsManager
+
+/**
+ * AndroidPermissionsReceiverTransmitter is a custom BroadcastReceiver used to listen for updates
+ * on Android permission changes and transmit them back to the React Native layer.
+ * It listens for a broadcast containing permission status, then emits a corresponding event to JavaScript.
+ */
+class AndroidPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+ /**
+   * This method is called when a broadcast is received.
+   * It checks whether the broadcast includes the permission status and emits an event to the React Native
+   * JavaScript layer with the results.
+   *
+   * @param context The context in which the receiver is running.
+   * @param intent The intent containing permission-related data.
+   */
+  override fun onReceive(context: Context?, intent: Intent?) {
+    val permissionsGranted = intent?.getBooleanExtra(
+      /* name = */ RookPermissionsManager.EXTRA_ANDROID_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    if (reactApplicationContext == null) return
+
+    val params = Arguments.createMap().apply {
+      putString("type", "ROOK_BACKGROUND_ANDROID_PERMISSIONS")
+      putBoolean("value", permissionsGranted)
+    }
+
+    reactApplicationContext!!
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("ROOK_NOTIFICATION", params)
+  }
+
+  /**
+   * Sets the ReactApplicationContext to be used for emitting events to the React Native side.
+   *
+   * @param context The ReactApplicationContext provided by React Native.
+   */
+  fun setReactApplicationContext(context: ReactApplicationContext) {
+    this.reactApplicationContext = context
+  }
+
+}

package/android/src/main/java/com/rooksdk/broadcasts/HealthConnectPermissionsReceiverTransmitter.kt

@@ -0,0 +1,53 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.rookmotion.rook.sdk.RookPermissionsManager
+
+/**
+ * HealthConnectPermissionsReceiverTransmitter is a custom BroadcastReceiver used to listen for updates
+ * on Android permission changes and transmit them back to the React Native layer.
+ * It listens for a broadcast containing permission status, then emits a corresponding event to JavaScript.
+ */
+class HealthConnectPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  /**
+   * This method is called when a broadcast is received.
+   * It checks whether the broadcast includes the permission status and emits an event to the React Native
+   * JavaScript layer with the results.
+   *
+   * @param context The context in which the receiver is running.
+   * @param intent The intent containing permission-related data.
+   */
+  override fun onReceive(context: Context?, intent: Intent?) {
+    val permissionsGranted = intent?.getBooleanExtra(
+      /* name = */ RookPermissionsManager.EXTRA_HEALTH_CONNECT_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    if (reactApplicationContext == null) return
+
+    val params = Arguments.createMap().apply {
+      putString("type", "ROOK_HEALTH_CONNECT_PERMISSIONS")
+      putBoolean("value", permissionsGranted)
+    }
+
+    reactApplicationContext!!
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("ROOK_NOTIFICATION", params)
+  }
+
+  /**
+   * Sets the ReactApplicationContext to be used for emitting events to the React Native side.
+   *
+   * @param context The ReactApplicationContext provided by React Native.
+   */
+  fun setReactApplicationContext(context: ReactApplicationContext) {
+    this.reactApplicationContext = context
+  }
+}

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

@@ -0,0 +1,108 @@
+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.RookConfigurationManager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class RookConfigurationModule(
+  reactContext: ReactApplicationContext,
+  private val rookConfigurationManager: RookConfigurationManager
+): 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 {
+        promise.resolve(rookConfigurationManager.getUserID())
+      }
+      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 {
+      rookConfigurationManager.updateUserID(userID).fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * 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(promise: Promise) {
+    scope.launch {
+      rookConfigurationManager.clearUserID().fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * 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(promise: Promise) {
+    scope.launch {
+      val result = rookConfigurationManager.deleteUserFromRook()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  /**
+   * 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/RookPermissionsModule.kt

@@ -0,0 +1,160 @@
+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.RookPermissionsManager
+import com.rookmotion.rook.sdk.domain.enums.HealthConnectAvailability
+import com.rookmotion.rook.sdk.domain.enums.RequestPermissionsStatus
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class RookPermissionsModule(reactContext: ReactApplicationContext):
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val rookPermissionsManager: RookPermissionsManager by lazy {
+    RookPermissionsManager(reactContext)
+  }
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  /**
+   * 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("INSTALED")
+      HealthConnectAvailability.NOT_INSTALLED -> promise.resolve("NOT_INSTALED")
+      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)
+      })
+
+    }
+  }
+
+  /**
+   * Checks the current permissions granted by Health Connect 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)
+      })
+    }
+  }
+
+  /**
+   * 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)
+      })
+    }
+  }
+
+  /**
+   * 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)
+    }
+  }
+
+  companion object {
+    const val NAME = "RookPermissionsModule"
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+}

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

@@ -0,0 +1,105 @@
+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"
+  }
+}