react-native-rook-sdk 0.6.2 → 0.7.1

package/android/build.gradle

@@ -90,6 +90,6 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'com.rookmotion.android:rook-sdk:1.4.0'
+  implementation 'com.rookmotion.android:rook-sdk:1.6.0'
 }
 

package/android/src/main/AndroidManifestNew.xml

@@ -33,12 +33,4 @@
   <uses-permission android:name="android.permission.health.READ_NUTRITION"/>
   <uses-permission android:name="android.permission.health.READ_MENSTRUATION"/>
   <uses-permission android:name="android.permission.health.READ_POWER"/>
-
-  <application>
-    <activity
-      android:name=".HealthConnectPermissionsActivity"
-      android:theme="@style/HealthConnectTheme"
-      android:excludeFromRecents="true"
-      android:exported="false"/>
-  </application>
 </manifest>

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

@@ -1,5 +1,7 @@
 package com.rooksdk
 
+import android.content.IntentFilter
+import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -11,21 +13,24 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.rookmotion.rook.sdk.RookConfigurationManager
 import com.rookmotion.rook.sdk.RookDataSources
 import com.rookmotion.rook.sdk.RookEventManager
-import com.rookmotion.rook.sdk.RookHealthPermissionsManager
 import com.rookmotion.rook.sdk.RookHelpers
+import com.rookmotion.rook.sdk.RookPermissionsManager
 import com.rookmotion.rook.sdk.RookStepsManager
-import com.rookmotion.rook.sdk.RookStepsPermissions
 import com.rookmotion.rook.sdk.RookSummaryManager
 import com.rookmotion.rook.sdk.RookYesterdaySyncManager
-import com.rookmotion.rook.sdk.RookYesterdaySyncPermissions
+import com.rookmotion.rook.sdk.domain.enums.HealthConnectAvailability
 import com.rookmotion.rook.sdk.domain.environment.RookAndroidClass
 import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
 import com.rookmotion.rook.sdk.domain.model.RookConfiguration
 import com.rookmotion.rook.sdk.domain.enums.HealthDataType
-import com.rookmotion.rook.sdk.domain.enums.SyncInstruction
+import com.rookmotion.rook.sdk.domain.enums.RequestPermissionsStatus
 import com.rookmotion.rook.sdk.domain.enums.SyncStatus
 import com.rookmotion.rook.sdk.domain.model.DataSource
 import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
+import com.rooksdk.broadcasts.AndroidPermissionsReceiverTransmitter
+import com.rooksdk.broadcasts.HealthConnectPermissionsReceiverTransmitter
+import com.rooksdk.utils.ReadableToWritable
+import com.rooksdk.utils.RookDateTime
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -36,7 +41,6 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext) {
 
   private val rookConfigurationManager = RookConfigurationManager(reactApplicationContext)
-  private val rookHealthPermissionsManager = RookHealthPermissionsManager(rookConfigurationManager)
   private val rookSummaryManager = RookSummaryManager(rookConfigurationManager)
   private val rookEventManager = RookEventManager(rookConfigurationManager)
   private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
@@ -54,12 +58,43 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
     RookStepsManager(reactApplicationContext)
   }
 
+  private val rookPermissionsManager: RookPermissionsManager by lazy {
+    RookPermissionsManager(reactApplicationContext)
+  }
+
+  private val androidPermissionsReceiverTransmitter: AndroidPermissionsReceiverTransmitter by lazy {
+    AndroidPermissionsReceiverTransmitter()
+  }
+
+  private val hcPermissionsReceiverTransmitter: HealthConnectPermissionsReceiverTransmitter by lazy {
+    HealthConnectPermissionsReceiverTransmitter()
+  }
+
   override fun getName(): String {
     return NAME
   }
 
   @ReactMethod
   fun addListener(eventName: String) {
+    if (listenerCount == 0) {
+      androidPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+      hcPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+
+      ContextCompat.registerReceiver(
+        reactApplicationContext,
+        androidPermissionsReceiverTransmitter,
+        IntentFilter(RookPermissionsManager.ACTION_ANDROID_PERMISSIONS),
+        ContextCompat.RECEIVER_EXPORTED
+      )
+
+      ContextCompat.registerReceiver(
+        reactApplicationContext,
+        hcPermissionsReceiverTransmitter,
+        IntentFilter(RookPermissionsManager.ACTION_HEALTH_CONNECT_PERMISSIONS),
+        ContextCompat.RECEIVER_EXPORTED,
+      )
+    }
+
     listenerCount += 1
   }
 
@@ -68,6 +103,9 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
     listenerCount -= count
     if (listenerCount == 0) {
       stepsScope.cancel()
+
+      reactApplicationContext.unregisterReceiver(hcPermissionsReceiverTransmitter)
+      reactApplicationContext.unregisterReceiver(androidPermissionsReceiverTransmitter)
     }
   }
 
@@ -95,7 +133,7 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
       val map = Arguments.createMap()
       map.putString("name", dataSource.name)
       map.putString("description", dataSource.description)
-      map.putString("image", dataSource.image)
+      map.putString("imageUrl", dataSource.image)
       map.putBoolean("connected", dataSource.connected)
       dataSource.authorizationUrl?.let {
         map.putString("authorizationUrl", it)
@@ -105,21 +143,15 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
     return array
   }
 
-  private fun determineDoEndValue(permissionString: String): SyncInstruction {
-    return when (permissionString) {
-      "oldest" -> SyncInstruction.SYNC_OLDEST
-      "latest" -> SyncInstruction.SYNC_LATEST
-      else -> SyncInstruction.NOTHING
-    }
-  }
-
   @ReactMethod
   fun getUserID(promise: Promise) {
-    try {
-      promise.resolve(rookConfigurationManager.getUserID())
-    }
-    catch (e: Exception) {
-      promise.reject(e)
+    scope.launch {
+      try {
+        promise.resolve(rookConfigurationManager.getUserID())
+      }
+      catch (e: Exception) {
+        promise.reject(e)
+      }
     }
   }
 
@@ -217,10 +249,34 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   }
 
   // MARK: - Permissions
+  @ReactMethod
+  fun shouldRequestPermissions(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 checkAvailability(promise: Promise) {
 
-    promise.resolve(RookHealthPermissionsManager.checkAvailability(reactApplicationContext).toString())
+    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")
+    }
 
   }
 
@@ -228,7 +284,7 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   fun openHealthConnectSettings(promise: Promise) {
     scope.launch {
 
-      val result = rookHealthPermissionsManager.openHealthConnectSettings()
+      val result = rookPermissionsManager.openHealthConnectSettings()
 
       result.fold({
         promise.resolve(true)
@@ -242,7 +298,7 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   @ReactMethod
   fun checkPermissions(promise: Promise) {
     scope.launch {
-      val result = rookHealthPermissionsManager.checkPermissions();
+      val result = rookPermissionsManager.checkHealthConnectPermissions()
 
       result.fold({
         promise.resolve(it)
@@ -254,26 +310,22 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun requestPermissions(promise: Promise) {
-    val activity = reactApplicationContext.currentActivity
-
-    if (activity == null) {
-      promise.reject(Exception("Error trying to request permissions"))
-      return
-    }
-
-    try {
-
-      HealthConnectPermissionsActivity.launch(activity)
-      promise.resolve(true)
-
-    }
-    catch (e: Exception) {
-      promise.reject(e)
+    scope.launch {
+      rookPermissionsManager.requestHealthConnectPermissions().fold({
+        when(it) {
+          RequestPermissionsStatus.REQUEST_SENT -> {
+            promise.resolve("REQUEST_SENT")
+          }
+          RequestPermissionsStatus .ALREADY_GRANTED -> {
+            promise.resolve("ALREADY_GRANTED")
+          }
+        }
+      }, {
+        promise.reject(it)
+      })
     }
-
   }
 
-
   // MARK: - Sync Summaries
   @ReactMethod
   fun shouldSyncFor(summaryString: String, date: String,promise: Promise) {
@@ -519,21 +571,24 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   fun scheduleYesterdaySync(config: ReadableMap, promise: Promise) {
     scope.launch {
       try {
+        val clientUUID = config.getString("clientUUID")?.trim() ?: return@launch
+        val secretKey = config.getString("clientPassword")?.trim() ?: return@launch
+
+        if (clientUUID.isBlank() || secretKey.isBlank()) return@launch
+
         var environment = RookEnvironment.SANDBOX
 
         if (config.getString("environment") == "production")
           environment = RookEnvironment.PRODUCTION
 
-        val doEnd = determineDoEndValue(config.getString("doOnEnd") ?: "")
-
         rookSynManager.scheduleYesterdaySync(
           enableLogs = true,
-          clientUUID = config.getString("clientUUID") ?: "",
-          secretKey = config.getString(",") ?: "",
+          clientUUID = clientUUID,
+          secretKey = secretKey,
           environment = environment,
-          doOnEnd = doEnd
         )
 
+
         promise.resolve(true)
 
       }
@@ -547,8 +602,11 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   @ReactMethod
   fun requestAndroidBackgroundPermissions(promise: Promise) {
     try {
-      RookYesterdaySyncPermissions.requestAndroidPermissions(reactApplicationContext)
-      promise.resolve(true)
+      val response = rookPermissionsManager.requestAndroidPermissions()
+
+      if (response == RequestPermissionsStatus.REQUEST_SENT)
+        promise.resolve("REQUEST_SENT")
+      else promise.resolve("ALREADY_GRANTED")
     }
     catch (e: Exception) {
       promise.reject(e)
@@ -558,7 +616,7 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   @ReactMethod
   fun hasAndroidBackgroundPermissions(promise: Promise) {
     try {
-      val result = RookYesterdaySyncPermissions.hasAndroidPermissions(reactApplicationContext)
+      val result = rookPermissionsManager.checkAndroidPermissions()
       promise.resolve(result)
     }
     catch (e: Exception) {
@@ -569,18 +627,12 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
   // MARK: - Steps
   @ReactMethod
   fun isStepsAvailable(promise: Promise) {
-    promise.resolve(RookStepsPermissions.isAvailable(reactApplicationContext))
+    promise.resolve(rookStepsManager.isAvailable())
   }
 
   @ReactMethod
   fun hasStepsPermissions(promise: Promise) {
-    promise.resolve(RookStepsPermissions.hasPermissions(reactApplicationContext))
-  }
-
-  @ReactMethod
-  fun requestStepsPermissions(promise: Promise) {
-    RookStepsPermissions.requestPermissions(reactApplicationContext)
-    promise.resolve(true)
+    promise.resolve(rookPermissionsManager.checkAndroidPermissions())
   }
 
   @ReactMethod
@@ -683,6 +735,20 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
     })
   }
 
+  @ReactMethod
+  fun sendMessageToBroadcast(message: ReadableMap, promise: Promise) {
+    if (listenerCount <= 0) return
+
+    val hash = ReadableToWritable.readableMapToHashMap(message)
+    val writable = ReadableToWritable.hashMapToWritableMap(hash)
+
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("ROOK_NOTIFICATION", writable)
+
+    promise.resolve(true)
+  }
+
   companion object {
     const val NAME = "RookSdk"
   }

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

@@ -0,0 +1,36 @@
+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
+
+class AndroidPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  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)
+  }
+
+  fun setReactApplicationContext(context: ReactApplicationContext) {
+    this.reactApplicationContext = context
+  }
+
+}

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

@@ -0,0 +1,35 @@
+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
+
+class HealthConnectPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  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)
+  }
+
+  fun setReactApplicationContext(context: ReactApplicationContext) {
+    this.reactApplicationContext = context
+  }
+}

package/android/src/main/java/com/rooksdk/utils/ReadableToWritable.kt

@@ -0,0 +1,44 @@
+package com.rooksdk.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableMap
+
+object ReadableToWritable {
+  fun readableMapToHashMap(readableMap: ReadableMap): HashMap<String, Any> {
+    val map = HashMap<String, Any>()
+    val iterator = readableMap.keySetIterator()
+
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      when (readableMap.getType(key)) {
+        ReadableType.Boolean -> map[key] = readableMap.getBoolean(key)
+        ReadableType.Number -> map[key] = readableMap.getDouble(key)
+        ReadableType.String -> map[key] = readableMap.getString(key) ?: ""
+        ReadableType.Map -> map[key] = readableMapToHashMap(readableMap.getMap(key)!!)
+        ReadableType.Array -> map[key] = readableMap.getArray(key)!!.toArrayList()
+        else -> {} // Manejar otros tipos si es necesario
+      }
+    }
+
+    return map
+  }
+
+  fun hashMapToWritableMap(hashMap: HashMap<String, Any>): WritableMap {
+    val writableMap = Arguments.createMap()
+
+    for ((key, value) in hashMap) {
+      when (value) {
+        is Boolean -> writableMap.putBoolean(key, value)
+        is Double -> writableMap.putDouble(key, value)
+        is String -> writableMap.putString(key, value)
+        is HashMap<*, *> -> writableMap.putMap(key, hashMapToWritableMap(value as HashMap<String, Any>))
+        is ArrayList<*> -> writableMap.putArray(key, Arguments.fromArray(value))
+      }
+    }
+
+    return writableMap
+  }
+
+}

package/android/src/main/java/com/rooksdk/{RookDateTime.kt → utils/RookDateTime.kt}

@@ -1,4 +1,4 @@
-package com.rooksdk
+package com.rooksdk.utils
 
 import java.time.LocalDate
 import java.time.format.DateTimeFormatter