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

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

@@ -1,154 +1,152 @@
 package com.rooksdk
 
-import android.content.IntentFilter
-import android.util.Log
-import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
 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.facebook.react.bridge.ReadableMap
-import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import com.google.gson.Gson
+import com.rookmotion.rook.sdk.RookBackgroundSyncManager
 import com.rookmotion.rook.sdk.RookConfigurationManager
 import com.rookmotion.rook.sdk.RookPermissionsManager
+import com.rookmotion.rook.sdk.RookStepsManager
+import com.rookmotion.rook.sdk.RookSyncManager
+import com.rookmotion.rook.sdk.RookWriteManager
 import com.rookmotion.rook.sdk.domain.analytics.HCRookAnalytics
 import com.rookmotion.rook.sdk.domain.analytics.HCRookFramework
+import com.rookmotion.rook.sdk.domain.annotation.ExperimentalRookApi
+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.enums.SyncStatus
 import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
 import com.rookmotion.rook.sdk.domain.exception.HCException
+import com.rookmotion.rook.sdk.domain.exception.HCRecordsNotFoundException
+import com.rookmotion.rook.sdk.domain.model.HCActivityEvent
+import com.rookmotion.rook.sdk.domain.model.HCBodySummary
+import com.rookmotion.rook.sdk.domain.model.HCPhysicalSummary
+import com.rookmotion.rook.sdk.domain.model.HCSleepSummary
 import com.rookmotion.rook.sdk.domain.model.RookConfiguration
+import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
 import com.rooksdk.broadcasts.AndroidPermissionsReceiverTransmitter
 import com.rooksdk.broadcasts.HealthConnectPermissionsReceiverTransmitter
 import com.rooksdk.broadcasts.SamsungHealthPermissionsReceiverTransmitter
+import com.rooksdk.utils.DatasourceUtils
+import com.rooksdk.utils.DatasourceUtils.mapToDataSourceType
+import com.rooksdk.utils.PermissionConversion
 import com.rooksdk.utils.ReadableToWritable
+import com.rooksdk.utils.RookDateTime
+import com.rooksdk.utils.RookGsonBuilder
 import com.rooksdk.utils.SamsungAvailability
+import com.rooksdk.utils.Source
+import com.rooksdk.utils.StringToSyncType
 import io.tryrook.api.sources.RookApiSources
 import io.tryrook.api.sources.domain.environment.ApiEnvironment
+import io.tryrook.api.sources.domain.exception.ApiException
 import io.tryrook.api.sources.domain.model.ApiConfiguration
 import io.tryrook.sdk.samsung.RookSamsung
 import io.tryrook.sdk.samsung.domain.analytics.SHRookAnalytics
 import io.tryrook.sdk.samsung.domain.analytics.SHRookFramework
+import io.tryrook.sdk.samsung.domain.enums.SHRequestPermissionsStatus
+import io.tryrook.sdk.samsung.domain.enums.SHSyncStatus
 import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
 import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
 import io.tryrook.sdk.samsung.domain.environment.SHEnvironment
 import io.tryrook.sdk.samsung.domain.exception.SHException
+import io.tryrook.sdk.samsung.domain.model.SHActivityEvent
+import io.tryrook.sdk.samsung.domain.model.SHBodySummary
 import io.tryrook.sdk.samsung.domain.model.SHConfiguration
+import io.tryrook.sdk.samsung.domain.model.SHPhysicalSummary
+import io.tryrook.sdk.samsung.domain.model.SHSleepSummary
+import io.tryrook.sdk.samsung.domain.model.SHSyncStatusWithData
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 
-/**
- * The `RookSdkHealthConnectModule` class is a React Native module that interfaces
- * with the Rook SDK for managing and syncing health data using Android's Health Connect.
- * It provides methods for initializing the SDK, handling user configuration, syncing
- * health data, and managing permissions.
- *
- * Main Responsibilities:
- * - Initialize and configure the Rook SDK.
- * - Manage user-related information such as user ID.
- * - Sync health-related summaries and events (e.g., sleep, body metrics, physical activities).
- * - Handle Health Connect permissions and check availability.
- * - Transmit permission changes through Android and Health Connect.
- * - Provide the ability to listen to permission changes using Android broadcast receivers.
- * - Expose methods to JavaScript for requesting or syncing data.
- *
- * Key Components:
- * - `RookConfigurationManager`: Manages configuration settings for the SDK.
- * - `RookSummaryManager`: Handles syncing health data summaries (e.g., sleep, physical, body).
- * - `RookEventManager`: Manages the synchronization of health-related events (e.g., physical activities, blood pressure, etc.).
- * - `RookPermissionsManager`: Handles permission management and availability checks for Health Connect.
- * - `RookStepsManager`: Manages steps data synchronization.
- * - `CoroutineScope`: Used to launch asynchronous operations.
- */
-class RookSdkModule(
-  reactContext: ReactApplicationContext,
-  private val rookConfigurationManager: RookConfigurationManager,
-  private val rookSamsung: RookSamsung,
-  private val rookApiSources: RookApiSources,
-): ReactContextBaseJavaModule(reactContext) {
+@ReactModule(name = RookSdkModule.NAME)
+class RookSdkModule(reactContext: ReactApplicationContext) :
+  NativeRookSdkSpec(reactContext) {
 
-  private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
   private var listenerCount = 0
 
-  private val stepsScope: CoroutineScope by lazy {
-    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  override fun getName(): String {
+    return NAME
   }
 
-  private val androidPermissionsReceiverTransmitter: AndroidPermissionsReceiverTransmitter by lazy {
-    AndroidPermissionsReceiverTransmitter()
+  private val rookHealthConnect by lazy {
+    RookSyncManager(reactContext)
   }
 
-  private val hcPermissionsReceiverTransmitter: HealthConnectPermissionsReceiverTransmitter by lazy {
-    HealthConnectPermissionsReceiverTransmitter()
+  private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+  private val rookSync by lazy {
+    RookSyncManager(reactContext)
   }
 
-  private val shHealthPermissionsReceiverTransmitter: SamsungHealthPermissionsReceiverTransmitter by lazy {
-    SamsungHealthPermissionsReceiverTransmitter()
+  private val rookPermissionsManager: RookPermissionsManager by lazy {
+    RookPermissionsManager(reactContext)
   }
 
-  override fun getName(): String {
-    return NAME
+  private val rookConfigurationManager: RookConfigurationManager by lazy {
+    RookConfigurationManager(reactContext)
   }
 
-  @ReactMethod
-  fun addListener(eventName: String) {
-    if (listenerCount == 0) {
-      androidPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
-      hcPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
-      shHealthPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+  private val backgroundSyncManager: RookBackgroundSyncManager by lazy {
+    RookBackgroundSyncManager(reactContext)
+  }
 
-      ContextCompat.registerReceiver(
-        reactApplicationContext,
-        androidPermissionsReceiverTransmitter,
-        IntentFilter(RookPermissionsManager.ACTION_ANDROID_PERMISSIONS),
-        ContextCompat.RECEIVER_EXPORTED
-      )
+  private val rookSamsung: RookSamsung by lazy {
+    RookSamsung(reactContext)
+  }
 
-      ContextCompat.registerReceiver(
-        reactApplicationContext,
-        hcPermissionsReceiverTransmitter,
-        IntentFilter(RookPermissionsManager.ACTION_HEALTH_CONNECT_PERMISSIONS),
-        ContextCompat.RECEIVER_EXPORTED,
-      )
+  private val rookApiSources: RookApiSources by lazy {
+    RookApiSources(reactContext)
+  }
 
-      ContextCompat.registerReceiver(
-        reactApplicationContext,
-        shHealthPermissionsReceiverTransmitter,
-        IntentFilter(SamsungHealthPermission.ACTION_SAMSUNG_HEALTH_PERMISSIONS),
-        ContextCompat.RECEIVER_EXPORTED
-      )
-    }
+  private val gsonBuilder: Gson by lazy {
+    RookGsonBuilder.getGsonBuilder()
+  }
 
-    listenerCount += 1
+  private val rookStepsManager: RookStepsManager by lazy {
+    RookStepsManager(reactContext)
   }
 
-  @ReactMethod
-  fun removeListeners(count: Int) {
-    listenerCount -= count
-    if (listenerCount == 0) {
-      stepsScope.cancel()
+  private fun tryToSetSamsungUserId() {
+    scope.launch {
+      val result = rookConfigurationManager.getUserID()
 
-      reactApplicationContext.unregisterReceiver(hcPermissionsReceiverTransmitter)
-      reactApplicationContext.unregisterReceiver(androidPermissionsReceiverTransmitter)
+      if (result != null) {
+        val user =  rookSamsung.updateUserID(result)
+        user.getOrNull()
+      }
     }
   }
 
-  /**
-   * Initializes the Rook SDK with the specified configuration settings (environment, clientUUID, secretKey).
-   * This is required before any data synchronization or user management can occur.
-   * @param config A map containing the environment, clientUUID, secretKey, and other settings.
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun initRook(config: ReadableMap,promise: Promise) {
+  override fun initRook(
+    options: ReadableMap?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (options == null) {
+      promise.reject(code = "1001", message = "unknown exception")
+      return
+    }
+
     try {
-      val clientUUID = config.getString("clientUUID")?.trim() ?: ""
-      val secret = config.getString("secret")?.trim() ?: ""
-      val packageName = config.getString("packageName")?.trim()
+
+      val clientUUID = options.getString("clientUUID")?.trim() ?: ""
+      val secret = options.getString("secret")?.trim() ?: ""
+      val packageName = options.getString("packageName")?.trim()
 
       if (clientUUID.isBlank() || secret.isBlank()) {
-        promise.reject("3", "Requested operation needs an authorization level that your clientUUID doesn't have.")
+        promise.reject(
+          code ="3",
+          message = "Requested operation needs an authorization level that your clientUUID doesn't have."
+        )
         return
       }
 
@@ -156,7 +154,7 @@ class RookSdkModule(
       var shEnv = SHEnvironment.SANDBOX
       var apiEnv = ApiEnvironment.SANDBOX
 
-      if (config.getString("environment") == "production") {
+      if (options.getString("environment") == "production") {
         environment = RookEnvironment.PRODUCTION
         shEnv = SHEnvironment.SANDBOX
         apiEnv = ApiEnvironment.PRODUCTION
@@ -183,7 +181,7 @@ class RookSdkModule(
         secret = secret
       )
 
-      val enableLogs = config.getBoolean("enableLogs")
+      val enableLogs = options.getBoolean("enableLogs")
       if(enableLogs) {
         rookConfigurationManager.enableLocalLogs()
         rookSamsung.enableLocalLogs()
@@ -238,43 +236,1637 @@ class RookSdkModule(
         }
       }
     }
+  }
+
+  override fun revokeDataSource(
+    userid: String?,
+    type: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (type == null || type == "") {
+      promise.reject(code = "1001", message = "the type is missing")
+      return
+    }
+
+    if (userid == null || userid == "") {
+      promise.reject(code = "1001", message = "the user_id is missing")
+      return
+    }
 
+    val parsed = mapToDataSourceType(type)
+    if(parsed == null) {
+      promise.reject(code = "1001", message = "Invalid datasource")
+      return
+    }
+
+    scope.launch {
+      rookApiSources.revokeDataSource(userID = userid, dataSource = parsed).fold({
+        promise.resolve(true)
+      }, {
+        if (it is ApiException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
   }
 
-  private fun tryToSetSamsungUserId() {
+  override fun getDataSourceAuthorizer(
+    props: ReadableMap?,
+    promise: Promise?
+  ) {
+    if(promise == null) return
+
+    if (props == null){
+      promise.reject(code = "1001", message = "user and datasource missing")
+      return
+    }
+
+    val source = props.getString("dataSource") ?: ""
+    val redirect = props.getString("redirectURL")
+    val userid = props.getString("userID") ?: ""
+
+    if (source == "" || userid == "") {
+      promise.reject(code = "1001", message = "user and datasource missing")
+      return
+    }
+
     scope.launch {
-      val result = rookConfigurationManager.getUserID()
+      rookApiSources.getDataSourceAuthorizer(
+        dataSource = source,
+        redirectUrl = redirect,
+        userID = userid
+      ).fold({ value ->
+        promise.resolve(gsonBuilder.toJson(value))
+      }, {
+        if (it is ApiException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
 
-      if (result != null) {
-        val user =  rookSamsung.updateUserID(result)
-        user.getOrNull()
+  override fun getAuthorizedDataSourcesV2(
+    userid: String?,
+    promise: Promise?
+  ) {
+    if(promise == null) return
+
+    if(userid == null || userid == "") {
+      promise.reject(code = "1001", message = "missing user id")
+      return
+    }
+
+    scope.launch {
+      rookApiSources.getAuthorizedDataSourcesV2(
+        userID = userid
+      ).fold(
+        {
+          promise.resolve(gsonBuilder.toJson(it))
+        }, {
+          if (it is ApiException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun getUserID(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      try {
+        val user = rookConfigurationManager.getUserID()
+        promise.resolve(user)
+      }
+      catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
       }
     }
   }
 
-  /**
-   * Sends a broadcast message to the React Native layer.
-   * This method emits a message event to the React Native side via the
-   * `ROOK_NOTIFICATION` channel, allowing communication from the native module.
-   *
-   * @param message A ReadableMap containing the message data to send.
-   * @param promise A promise object that resolves with true if the message was sent successfully.
-   */
-  @ReactMethod
-  fun sendMessageToBroadcast(message: ReadableMap, promise: Promise) {
-    if (listenerCount <= 0) return
+  override fun updateUserID(userID: String?, promise: Promise?) {
+    if(promise == null) return
 
-    val hash = ReadableToWritable.readableMapToHashMap(message)
-    val writable = ReadableToWritable.hashMapToWritableMap(hash)
+    if (userID == null || userID == "") {
+      promise.reject(code = "1001", message = "Missing user id")
+      return
+    }
 
-    reactApplicationContext
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-      .emit("ROOK_NOTIFICATION", writable)
+    scope.launch {
+      try {
+        if (SamsungAvailability.isSamsungAvailable(rookSamsung)) {
+          val samsungResult = rookSamsung.updateUserID(userID)
 
-    promise.resolve(true)
+          if (samsungResult.isFailure) {
+            println("We couldn't initiate the user id in Samsung Health")
+          }
+
+          samsungResult.getOrThrow()
+        }
+
+        val healthConnectResult =  rookConfigurationManager.updateUserID(userID)
+
+        if (healthConnectResult.isFailure) {
+          println("We couldn't initiate the user id in Health Connect")
+        }
+
+        healthConnectResult.getOrThrow()
+
+        promise.resolve(true)
+      } catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  override fun removeUserFromRook(
+    sources: ReadableArray?,
+    promise: Promise?
+  ) {
+    if(promise == null)return
+    if (sources == null) {
+      promise.reject(code = "1001", message = "Missing datasource")
+      return
+    }
+
+    scope.launch {
+      try {
+        val sources = DatasourceUtils.readableArrayToSourceList(sources)
+
+        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()
+        }
+
+        promise.resolve(true)
+      }
+      catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  override fun syncUserTimeZone(promise: Promise?) {
+    if(promise == null) return
+
+    scope.launch {
+      val result = rookConfigurationManager.syncUserTimeZone()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  override fun getHealthConnectDiagnosticState(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      try {
+        val result = rookConfigurationManager.getDiagnosticState().getOrThrow()
+        promise.resolve(gsonBuilder.toJson(result))
+      } catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  override fun getSamsungHealthDiagnosticState(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      try {
+        val result = rookSamsung.getDiagnosticState().getOrThrow()
+        promise.resolve(gsonBuilder.toJson(result))
+      } catch (it: Exception) {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      }
+    }
+  }
+
+  override fun isStepsAvailable(promise: Promise?) {
+    if (promise == null) return
+    promise.resolve(rookStepsManager.isAvailable())
+  }
+
+  override fun enableBackgroundAndroidSteps(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+      }
+    })
+  }
+
+  override fun disableBackgroundAndroidSteps(promise: Promise?) {
+    if(promise == null) return
+
+    rookStepsManager
+      .disableBackgroundAndroidSteps()
+      .fold({
+        promise.resolve(true)
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+  }
+
+  override fun isBackgroundAndroidStepsActive(promise: Promise?) {
+    if(promise == null) return
+
+    scope.launch {
+      val response = rookStepsManager.isBackgroundAndroidStepsActive()
+      promise.resolve(response)
+    }
+  }
+
+  override fun syncTodayAndroidStepsCount(promise: Promise?) {
+    if(promise == null) return
+
+    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 androidHasBackgroundPermissions(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+      }
+    }
+  }
+
+  override fun checkHealthConnectAvailability(promise: Promise?) {
+    if(promise == null) return
+
+    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")
+    }
+  }
+
+  override fun checkHealthConnectBackgroundReadStatus(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+          }
+        }
+      )
+    }
+  }
+
+  override fun checkSamsungAvailability(promise: Promise?) {
+    if (promise == null) return
+
+    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)
+        },
+      )
+
+    }
+  }
+
+  override fun healthConnectHasPartialPermissions(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+        }
+      })
+    }
+  }
+
+  override fun healthConnectHasPermissions(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+        }
+      })
+    }
+  }
+
+  override fun samsungHealthHasPermissions(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun samsungHealthHasPartialPermissions(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun openHealthConnectSettings(promise: Promise?) {
+    if (promise == null) return
+
+    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)
+        }
+      })
+
+    }
+  }
+
+  override fun requestAndroidBackgroundPermissions(promise: Promise?) {
+    if (promise == null) return
+
+    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)
+      }
+    }
+  }
+
+  override fun requestHealthConnectPermissions(promise: Promise?) {
+    if (promise == null) return
+
+    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)
+        }
+      })
+    }
+  }
+
+
+  override fun requestSamsungHealthPermissions(
+    permissions: ReadableArray?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (permissions == null){
+      promise.reject(code = "1001", message = "Missing permissions")
+      return
+    }
+
+    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)
+          }
+        }
+      )
+    }
+  }
+
+  override fun revokeHealthConnectPermissions(promise: Promise?) {
+    if(promise == null) return
+
+    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)
+          }
+        })
+    }
+  }
+
+  override fun shouldRequestAndroidBackgroundPermissions(promise: Promise?) {
+    if (promise == null) return
+
+    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)
+      }
+    }
+  }
+
+  override fun getHealthConnectSleepSummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "Missing date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getSleepSummary(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectSleepSummary", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<List<HCSleepSummary>> -> {
+              val result =gsonBuilder.toJson(it.data)
+              promise.resolve(result)
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getSamsungSleepSummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "Missin date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getSleepSummary(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungSleepSummary", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<List<SHSleepSummary>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getHealthConnectBodySummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "missing date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getBodySummary(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectBodySummary", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<HCBodySummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getSamsungBodySummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "missing date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getBodySummary(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungBodySummary", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<SHBodySummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getHealthConnectPhysicalSummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "missing date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getPhysicalSummary(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectPhysicalSummary", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<HCPhysicalSummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getSamsungPhysicalSummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "missing date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getPhysicalSummary(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungPhysicalSummary", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<SHPhysicalSummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getHealthConnectActivityEvents(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "missing date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getActivityEvents(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectActivityEvents", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<List<HCActivityEvent>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getSamsungActivityEvents(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (date == null || date == ""){
+      promise.reject(code = "1001", message = "missing date")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getActivityEvents(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungActivityEvents", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<List<SHActivityEvent>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  @OptIn(ExperimentalRookApi::class)
+  override fun writeHealthConnectMealData(
+    meal: ReadableMap?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    if (meal == null){
+      promise.reject(code = "1001", message = "Missing meal data")
+      return
+    }
+
+    val mealData = ReadableToWritable.mapReadableMapToHCMealData(meal)
+
+    scope.launch {
+      RookWriteManager.writeNutritionEvent(reactApplicationContext, mealData).fold({
+        promise.resolve(true)
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  override fun enableSamsungSync(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSamsung.schedule(true)
+      promise.resolve(true)
+    }
+  }
+
+  override fun disableSamsungSync(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSamsung.cancel()
+      promise.resolve(true)
+    }
+  }
+
+  override fun isSamsungSyncEnabled(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSamsung.isScheduled().fold(
+        {
+          promise.resolve(it)
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun scheduleBackgroundSync(
+    enableLogs: Boolean?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+
+    try {
+      backgroundSyncManager.schedule(enableLogs ?: false)
+      promise.resolve(true)
+    }
+    catch (e: Exception) {
+      if (e is HCException) {
+        promise.reject(e.code.toString(), e.message, e)
+      } else {
+        promise.reject("1001", e.message, e)
+      }
+    }
+  }
+
+  override fun cancelBackgroundSync(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      try {
+        backgroundSyncManager.cancel()
+        promise.resolve(true)
+      } catch (e: Exception) {
+        if (e is HCException) {
+          promise.reject(e.code.toString(), e.message, e)
+        } else {
+          promise.reject("1001", e.message, e)
+        }
+      }
+    }
+  }
+
+  override fun isBackgroundSyncEnabled(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      backgroundSyncManager.isScheduled().fold(
+        {
+          promise.resolve(it)
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun syncTodaySamsungHealthStepsCount(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSamsung.getTodayStepsCount().fold({
+        when (it) {
+          SHSyncStatusWithData.RecordsNotFound -> {
+            promise.reject("SamsungStepsCount", "Records Not Found")
+          }
+
+          is SHSyncStatusWithData.Synced -> {
+            val steps = it.data
+            promise.resolve(steps)
+          }
+        }
+      }, {
+        if (it is SHException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  override fun syncTodayHealthConnectStepsCount(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSync.getTodayStepsCount().fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectStepsCount", "Records Not Found")
+            }
+
+            is SyncStatusWithData.Synced -> {
+              val steps = it.data
+              promise.resolve(steps)
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun syncTodayCaloriesCount(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSync.getTodayCaloriesCount().fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("7", "The SDK could not find any health data related with calories")
+            }
+
+            is SyncStatusWithData.Synced -> {
+              val data = Arguments.createMap().apply {
+                putDouble("basal", it.data.basal ?: 0.0)
+                putDouble("active", it.data.active ?: 0.0)
+              }
+
+              promise.resolve(data)
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun syncSHTodayCaloriesCount(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSamsung.getTodayCaloriesCount().fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("7", "The SDK could not find any health data related with calories")
+            }
+
+            is SHSyncStatusWithData.Synced -> {
+              val data = Arguments.createMap().apply {
+                putDouble("basal", it.data.basal ?: 0.0)
+                putDouble("active", it.data.active ?: 0.0)
+              }
+
+              promise.resolve(data)
+            }
+          }
+        },
+        {
+          if (it is SHException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        }
+      )
+    }
+  }
+
+  override fun getTodayHeartRate(promise: Promise?) {
+    if (promise == null) return
+
+    scope.launch {
+      rookSync.getTodayHeartRate().fold(
+        { syncStatus ->
+          when (syncStatus) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("7", "The SDK could not find any health data related with calories")
+            }
+
+            is SyncStatusWithData.Synced -> {
+              promise.resolve(gsonBuilder.toJson(syncStatus.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun getSHTodayHeartRate(promise: Promise?) {
+    if (promise == null) return
+    scope.launch {
+      rookSamsung.getTodayHeartRate().fold(
+        { syncStatus ->
+          when (syncStatus) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("7", "The SDK could not find any health data related with calories")
+            }
+
+            is SHSyncStatusWithData.Synced -> {
+              promise.resolve(gsonBuilder.toJson(syncStatus.data))
+            }
+          }
+        },
+        {
+          if (it is HCException) {
+            promise.reject(it.code.toString(), it.message, it)
+          } else {
+            promise.reject("1001", it.message, it)
+          }
+        },
+      )
+    }
+  }
+
+  override fun sync(cb: Callback?) {
+    if (cb == null) return
+
+    scope.launch {
+      rookSync.sync(true).fold({ result ->
+        cb.invoke(null, result)
+      }, {
+        val params = Arguments.createMap().apply {
+          if (it is HCException) {
+            putString(it.code.toString(), it.message)
+          } else {
+            putString("1001", it.localizedMessage ?: it.message)
+          }
+        }
+
+        cb.invoke(params, false)
+      })
+    }
+  }
+
+  override fun syncByDate(date: String?, cb: Callback?) {
+    if(cb == null ) return
+
+    if (date == null || date == "") {
+      cb.invoke(null, false)
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      val result = rookSync.sync(localDate)
+
+      try {
+        val sleepSummaryStatus = result.sleepSummary.getOrThrow()
+        val physicalSummaryStatus = result.physicalSummary.getOrThrow()
+        val bodySummaryStatus = result.bodySummary.getOrThrow()
+
+        val noSleepData = sleepSummaryStatus == SyncStatus.RECORDS_NOT_FOUND
+        val noPhysicalData = physicalSummaryStatus == SyncStatus.RECORDS_NOT_FOUND
+        val noBodyData = bodySummaryStatus == SyncStatus.RECORDS_NOT_FOUND
+
+        if (noSleepData && noPhysicalData && noBodyData) {
+          val throwable = HCRecordsNotFoundException("Sleep, Physical and Body summary")
+
+          val params = Arguments.createMap().apply {
+            putString(throwable.code.toString(), throwable.message)
+          }
+
+          cb.invoke(params, false)
+        } else {
+          cb.invoke(null, true)
+        }
+      } catch (e: Exception) {
+        val params = Arguments.createMap().apply {
+          if (e is HCException){
+            putString(e.code.toString(), e.message)
+          } else {
+            putString("1001", e.message ?: "Unknown error")
+          }
+        }
+
+        cb.invoke(params, false)
+      }
+    }
+  }
+
+  override fun syncByDefinition(
+    summary: String?,
+    date: String?,
+    cb: Callback?
+  ) {
+    if(cb == null ) return
+
+    if (date == null || date == "" || summary == null || summary == "") {
+      cb.invoke(null, false)
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    val type = StringToSyncType.stringToSummary(summary)
+
+    scope.launch {
+      val result = rookSync.sync(localDate, type)
+      result.onSuccess {
+        when (it) {
+          SyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            val params = Arguments.createMap().apply {
+              putString(throwable.code.toString(), throwable.message)
+            }
+
+            cb.invoke(params, false)
+          }
+          SyncStatus.SYNCED -> cb.invoke(null, true)
+        }
+      }
+
+      result.onFailure {
+        val params = Arguments.createMap().apply {
+          if (it is HCException) {
+            putString(it.code.toString(), it.message)
+          } else {
+            putString("1001", it.localizedMessage ?: it.message)
+          }
+        }
+
+        cb.invoke(params, false)
+      }
+    }
+  }
+
+  override fun syncEvent(
+    date: String?,
+    event: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    if (event == null || event == "" || date == null || date == "") {
+      promise.reject(code = "1001", message = "Missing parameters")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToEvent(event)
+
+    scope.launch {
+      rookSync.syncEvents(localDate, type).fold({ result ->
+        when(result) {
+          SyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            promise.reject(throwable.code.toString(), throwable.message, throwable)
+          }
+          SyncStatus.SYNCED -> promise.resolve(true)
+        }
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  override fun shSync(enableLogs: Boolean, cb: Callback?) {
+    if (cb == null) return
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("5", "Samsung health is not available")
+        }
+
+        cb.invoke(params, false)
+        return@launch
+      }
+
+      rookSamsung.sync(enableLogs).fold(
+        {
+          cb(null, true)
+        }, {
+          val params = Arguments.createMap().apply {
+            if (it is SHException) {
+              putString(it.code.toString(), it.message)
+            } else {
+              putString("1001", it.localizedMessage ?: it.message)
+            }
+          }
+
+          cb.invoke(params, false)
+        }
+      )
+    }
+  }
+
+  override fun shSyncByDate(date: String?, cb: Callback?) {
+    if (cb == null) return
+
+    val localDate = RookDateTime.stringToLocalDate(date ?: "")
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("5", "Samsung health is not available")
+        }
+
+        cb.invoke(params, false)
+        return@launch
+      }
+
+      val result = rookSamsung.sync(localDate)
+
+      try {
+        val sleepSummaryStatus = result.sleepSummary.getOrThrow()
+        val physicalSummaryStatus = result.physicalSummary.getOrThrow()
+        val bodySummaryStatus = result.bodySummary.getOrThrow()
+
+        val noSleepData = sleepSummaryStatus == SHSyncStatus.RECORDS_NOT_FOUND
+        val noPhysicalData = physicalSummaryStatus == SHSyncStatus.RECORDS_NOT_FOUND
+        val noBodyData = bodySummaryStatus == SHSyncStatus.RECORDS_NOT_FOUND
+
+        if (noSleepData && noPhysicalData && noBodyData) {
+          val throwable = HCRecordsNotFoundException("Sleep, Physical and Body summary")
+
+          val params = Arguments.createMap().apply {
+            putString(throwable.code.toString(), throwable.message)
+          }
+
+          cb.invoke(params, false)
+        } else {
+          cb.invoke(null, true)
+        }
+      } catch (e: Exception) {
+        val params = Arguments.createMap().apply {
+          if (e is HCException){
+            putString(e.code.toString(), e.message)
+          } else {
+            putString("1001", e.message ?: "Unknown error")
+          }
+        }
+
+        cb.invoke(params, false)
+      }
+    }
+  }
+
+  override fun shSyncByDefinition(
+    summary: String?,
+    date: String?,
+    cb: Callback?
+  ) {
+    if (cb == null) return
+    if (summary == null || date == null) {
+      cb.invoke(null, false)
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToSamsungPillar(summary)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("5", "Samsung health is not available")
+        }
+
+        cb.invoke(params, false)
+        return@launch
+      }
+
+      val result = rookSamsung.sync(localDate, type)
+      result.onSuccess {
+        when (it) {
+          SHSyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            val params = Arguments.createMap().apply {
+              putString(throwable.code.toString(), throwable.message)
+            }
+
+            cb.invoke(params, false)
+          }
+          SHSyncStatus.SYNCED -> cb.invoke(null, true)
+        }
+      }
+
+      result.onFailure {
+        val params = Arguments.createMap().apply {
+          if (it is HCException) {
+            putString(it.code.toString(), it.message)
+          } else {
+            putString("1001", it.localizedMessage ?: it.message)
+          }
+        }
+
+        cb.invoke(params, false)
+      }
+    }
+  }
+
+  override fun shSyncEvent(
+    date: String?,
+    event: String?,
+    promise: Promise?
+  ) {
+    if(promise == null) return
+    if (event == null || date == null){
+      promise.reject(code = "1001", message = "Missing parameters")
+      return
+    }
+
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToSamsungEvent(event)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        promise.reject(
+          "5",
+          "Samsung health is not available",
+          Throwable("Samsung health is not available")
+        )
+        return@launch
+      }
+
+      rookSamsung.syncEvents(localDate, type).fold({ result ->
+        when(result) {
+          SHSyncStatus.RECORDS_NOT_FOUND -> {
+            val throwable = HCRecordsNotFoundException(type.toString())
+
+            promise.reject(throwable.code.toString(), throwable.message, throwable)
+          }
+          SHSyncStatus.SYNCED -> promise.resolve(true)
+        }
+      }, {
+        if (it is HCException) {
+          promise.reject(it.code.toString(), it.message, it)
+        } else {
+          promise.reject("1001", it.message, it)
+        }
+      })
+    }
+  }
+
+  override fun sendMessage(
+    message: ReadableMap?,
+    promise: Promise?
+  ) {
+    if (message == null || promise == null || !reactApplicationContext.hasActiveReactInstance())
+      return
+
+    val hash = ReadableToWritable.readableMapToHashMap(message)
+    val writable = ReadableToWritable.hashMapToWritableMap(hash)
+
+    emitOnRookMessage(writable)
+    promise.resolve(true)
+  }
+
+
+  // ios methods
+  private fun rejectFunction(promise: Promise) {
+    promise.reject("1001", "This method is only available in android")
+  }
+
+  override fun getDiagnosticState(promise: Promise?) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun enableBackGroundUpdates(promise: Promise?) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun disableBackGroundUpdates(promise: Promise?) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun isBackgroundUpdatesEnabled(promise: Promise?) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun appleHealthHasPermissions(
+    param: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun openAppleHealthSettings(promise: Promise?) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun requestAppleHealthPermissions(
+    permissions: ReadableArray?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun requestAppleWriteNutritionPermission(promise: Promise?) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun getAppleHealthSleepSummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun getAppleHealthBodySummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun getAppleHealthPhysicalSummary(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun getAppleHealthActivityEvents(
+    date: String?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun writeAppleHealthMealData(
+    meal: ReadableMap?,
+    promise: Promise?
+  ) {
+    if (promise == null) return
+    rejectFunction(promise)
+  }
+
+  override fun getTodayAppleHealthSteps(promise: Promise?) {
+    if (promise == null) return
+    rejectFunction(promise)
   }
 
   companion object {
-    const val NAME = "RookSdk"
+    const val NAME = "RNRookSdk"
   }
 }