react-native-rook-sdk 1.3.1 → 2.0.0-beta.0

package/android/build.gradle

@@ -90,8 +90,9 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'com.google.code.gson:gson:2.11.0'
+  implementation 'com.google.code.gson:gson:2.13.0'
 
-  implementation 'com.rookmotion.android:rook-sdk:2.1.0-alpha02'
+  implementation("io.tryrook.android:rook-sdk-samsung:1.0.0-beta01")
+  implementation 'com.rookmotion.android:rook-sdk:2.1.0'
 }
 

package/android/src/main/java/com/rooksdk/RookSdkModule.kt

@@ -1,6 +1,7 @@
 package com.rooksdk
 
 import android.content.IntentFilter
+import android.util.Log
 import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -17,7 +18,18 @@ import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
 import com.rookmotion.rook.sdk.domain.model.RookConfiguration
 import com.rooksdk.broadcasts.AndroidPermissionsReceiverTransmitter
 import com.rooksdk.broadcasts.HealthConnectPermissionsReceiverTransmitter
+import com.rooksdk.broadcasts.SamsungHealthPermissionsReceiverTransmitter
 import com.rooksdk.utils.ReadableToWritable
+import com.rooksdk.utils.SamsungAvailability
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.RookSamsungObject
+import io.tryrook.sdk.samsung.domain.analytics.SHRookAnalytics
+import io.tryrook.sdk.samsung.domain.analytics.SHRookFramework
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+import io.tryrook.sdk.samsung.domain.environment.SHAndroidClass
+import io.tryrook.sdk.samsung.domain.environment.SHEnvironment
+import io.tryrook.sdk.samsung.domain.model.SHConfiguration
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -49,7 +61,8 @@ import kotlinx.coroutines.launch
  */
 class RookSdkModule(
   reactContext: ReactApplicationContext,
-  private val rookConfigurationManager: RookConfigurationManager
+  private val rookConfigurationManager: RookConfigurationManager,
+  private val rookSamsung: RookSamsung
 ): ReactContextBaseJavaModule(reactContext) {
 
   private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
@@ -67,6 +80,10 @@ class RookSdkModule(
     HealthConnectPermissionsReceiverTransmitter()
   }
 
+  private val shHealthPermissionsReceiverTransmitter: SamsungHealthPermissionsReceiverTransmitter by lazy {
+    SamsungHealthPermissionsReceiverTransmitter()
+  }
+
   override fun getName(): String {
     return NAME
   }
@@ -76,6 +93,7 @@ class RookSdkModule(
     if (listenerCount == 0) {
       androidPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
       hcPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+      shHealthPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
 
       ContextCompat.registerReceiver(
         reactApplicationContext,
@@ -90,6 +108,13 @@ class RookSdkModule(
         IntentFilter(RookPermissionsManager.ACTION_HEALTH_CONNECT_PERMISSIONS),
         ContextCompat.RECEIVER_EXPORTED,
       )
+
+      ContextCompat.registerReceiver(
+        reactApplicationContext,
+        shHealthPermissionsReceiverTransmitter,
+        IntentFilter(SamsungHealthPermission.ACTION_SAMSUNG_HEALTH_PERMISSIONS),
+        ContextCompat.RECEIVER_EXPORTED
+      )
     }
 
     listenerCount += 1
@@ -124,12 +149,12 @@ class RookSdkModule(
       }
 
       var environment = RookEnvironment.SANDBOX
+      var shEnv = SHEnvironment.SANDBOX
 
-      if (config.getString("environment") == "production")
+      if (config.getString("environment") == "production") {
         environment = RookEnvironment.PRODUCTION
-
-      if (config.getString("environment") == "development") RookAndroidClass.test()
-      else RookAndroidClass.disableTest()
+        shEnv = SHEnvironment.SANDBOX
+      }
 
       val rookConfiguration = RookConfiguration(
         environment = environment,
@@ -137,24 +162,39 @@ class RookSdkModule(
         secretKey = secretKey
       )
 
+      val shConfig = SHConfiguration(
+        environment = shEnv,
+        clientUUID = clientUUID,
+        secretKey = secretKey
+      )
+
       val enableLogs = config.getBoolean("enableLogs")
-      if(enableLogs) rookConfigurationManager.enableLocalLogs()
+      if(enableLogs) {
+        rookConfigurationManager.enableLocalLogs()
+        rookSamsung.enableLocalLogs()
+      }
 
       rookConfigurationManager.setConfiguration(rookConfiguration)
 
       RookAnalytics.setFramework(RookFramework.REACT_NATIVE)
+      SHRookAnalytics.setFramework(SHRookFramework.REACT_NATIVE)
 
       scope.launch {
-        val result = rookConfigurationManager.initRook()
-
-        result.fold(
-          {
-            promise.resolve(true)
-          },
-          {
-            promise.reject(it)
+        try {
+          val result = rookConfigurationManager.initRook()
+          result.getOrThrow()
+
+          val availableResult = SamsungAvailability.getSamsungHealthAvailabilityOrDefault(rookSamsung)
+
+          if (availableResult == SamsungHealthAvailability.INSTALLED) {
+            rookSamsung.initRook(shConfig)
+            tryToSetSamsungUserId()
           }
-        )
+
+          promise.resolve(true)
+        } catch (e: Throwable) {
+          promise.reject(e)
+        }
       }
     }
     catch (e: Exception) {
@@ -163,6 +203,17 @@ class RookSdkModule(
 
   }
 
+  private fun tryToSetSamsungUserId() {
+    scope.launch {
+      val result = rookConfigurationManager.getUserID()
+
+      if (result != null) {
+        val user =  rookSamsung.updateUserID(result)
+        user.getOrNull()
+      }
+    }
+  }
+
   /**
    * Sends a broadcast message to the React Native layer.
    * This method emits a message event to the React Native side via the

package/android/src/main/java/com/rooksdk/RookSdkPackage.kt

@@ -1,5 +1,6 @@
 package com.rooksdk
 
+import RookSyncModule
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
@@ -9,21 +10,25 @@ import com.rooksdk.modules.RookBackgroundSyncModule
 import com.rooksdk.modules.RookConfigurationModule
 import com.rooksdk.modules.RookPermissionsModule
 import com.rooksdk.modules.RookStepsModule
-import com.rooksdk.modules.RookSyncModule
+import io.tryrook.sdk.samsung.RookSamsung
 
 
 class RookSdkPackage : ReactPackage {
   private var rookConfigurationManager: RookConfigurationManager? = null
+  private var rookSamsung: RookSamsung? = null
 
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
     if (rookConfigurationManager == null)
       rookConfigurationManager = RookConfigurationManager(reactContext)
 
+    if (rookSamsung == null)
+      rookSamsung = RookSamsung(reactContext)
+
     return listOf(
-      RookSdkModule(reactContext, rookConfigurationManager!!),
-      RookPermissionsModule(reactContext),
-      RookConfigurationModule(reactContext, rookConfigurationManager!!),
-      RookSyncModule(reactContext, rookConfigurationManager!!),
+      RookSdkModule(reactContext, rookConfigurationManager!!, rookSamsung!!),
+      RookPermissionsModule(reactContext, rookSamsung!!),
+      RookConfigurationModule(reactContext, rookConfigurationManager!!, rookSamsung!!),
+      RookSyncModule(reactContext, rookSamsung!!),
       RookBackgroundSyncModule(reactContext),
       RookStepsModule(reactContext)
     )

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

@@ -0,0 +1,52 @@
+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 io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+
+class SamsungHealthPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  /**
+   * 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
+  }
+
+  override fun onReceive(conext: Context?, intent: Intent?) {
+    val allPermissionsGranted = intent?.getBooleanExtra(
+      /* name = */ SamsungHealthPermission.EXTRA_SAMSUNG_HEALTH_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    val permissionsPartiallyGranted = intent?.getBooleanExtra(
+      /* name = */ SamsungHealthPermission.EXTRA_SAMSUNG_HEALTH_PERMISSIONS_PARTIALLY_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    reactApplicationContext?.also { reactContext ->
+      val events = listOf(
+        "ROOK_SAMSUNG_HEALTH_PERMISSIONS" to allPermissionsGranted,
+        "ROOK_SAMSUNG_HEALTH_PERMISSIONS_PARTIALLY_GRANTED" to permissionsPartiallyGranted,
+      )
+
+      val emitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+
+      events.forEach { (type, value) ->
+        Arguments.createMap().apply {
+          putString("type", type)
+          putBoolean("value", value)
+          emitter.emit("ROOK_NOTIFICATION", this)
+        }
+      }
+    }
+
+  }
+}

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

@@ -4,7 +4,13 @@ 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
@@ -12,7 +18,8 @@ import kotlinx.coroutines.launch
 
 class RookConfigurationModule(
   reactContext: ReactApplicationContext,
-  private val rookConfigurationManager: RookConfigurationManager
+  private val rookConfigurationManager: RookConfigurationManager,
+  private val rookSamsung: RookSamsung,
 ): ReactContextBaseJavaModule(reactContext) {
 
   private val scope: CoroutineScope by lazy {
@@ -27,7 +34,8 @@ class RookConfigurationModule(
   fun getUserID(promise: Promise) {
     scope.launch {
       try {
-        promise.resolve(rookConfigurationManager.getUserID())
+        val user = rookConfigurationManager.getUserID()
+        promise.resolve(user)
       }
       catch (e: Exception) {
         promise.reject(e)
@@ -43,11 +51,17 @@ class RookConfigurationModule(
   @ReactMethod
   fun updateUserID(userID: String, promise: Promise) {
     scope.launch {
-      rookConfigurationManager.updateUserID(userID).fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
+      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()
+      } catch (e: Exception) {
+        promise.reject(e)
+      }
     }
   }
 
@@ -56,13 +70,24 @@ class RookConfigurationModule(
    * @param promise A promise object to handle the result (resolved on success, rejected on failure).
    */
   @ReactMethod
-  fun clearUserID(promise: Promise) {
+  fun clearUserID(rawSources: ReadableArray, promise: Promise) {
     scope.launch {
-      rookConfigurationManager.clearUserID().fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
+      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()
+        }
+      }
+      catch (e: Exception) {
+        promise.reject(e)
+      }
     }
   }
 
@@ -71,15 +96,24 @@ class RookConfigurationModule(
    * @param promise A promise object to handle the result (resolved on success, rejected on failure).
    */
   @ReactMethod
-  fun removeUserFromRook(promise: Promise) {
+  fun removeUserFromRook(rawSources: ReadableArray, promise: Promise) {
     scope.launch {
-      val result = rookConfigurationManager.deleteUserFromRook()
+      try {
+        val sources = DatasourcesUtils.readableArrayToSourceList(rawSources)
 
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
+        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()
+        }
+      }
+      catch (e: Exception) {
+        promise.reject(e)
+      }
     }
   }
 

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

@@ -4,16 +4,23 @@ 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):
+class RookPermissionsModule(reactContext: ReactApplicationContext, private val rookSamsung: RookSamsung):
   ReactContextBaseJavaModule(reactContext) {
 
   private val rookPermissionsManager: RookPermissionsManager by lazy {
@@ -24,6 +31,27 @@ class RookPermissionsModule(reactContext: ReactApplicationContext):
     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).
@@ -58,8 +86,46 @@ class RookPermissionsModule(reactContext: ReactApplicationContext):
     }
   }
 
+  @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 Connect to ensure the application has the necessary access.
+   * 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
@@ -110,6 +176,30 @@ class RookPermissionsModule(reactContext: ReactApplicationContext):
     }
   }
 
+  @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
    * */