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

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

@@ -1,496 +0,0 @@
-import android.annotation.SuppressLint
-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.ReadableMap
-import com.google.gson.Gson
-import com.rookmotion.rook.sdk.RookContinuousUploadManager
-import com.rookmotion.rook.sdk.RookDataSources
-import com.rookmotion.rook.sdk.RookSyncManager
-import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
-import com.rooksdk.utils.DatasourcesUtils.dataSourcesToWritableArray
-import com.rooksdk.utils.DatasourcesUtils.mapToDataSourceType
-import com.rooksdk.utils.RookDateTime
-import com.rooksdk.utils.SamsungAvailability
-import com.rooksdk.utils.StringToSyncType
-import io.tryrook.sdk.samsung.RookSamsung
-import io.tryrook.sdk.samsung.domain.model.SHSyncStatusWithData
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import org.jetbrains.annotations.Debug
-
-class RookSyncModule(
-  reactContext: ReactApplicationContext,
-  private val rookSamsung: RookSamsung
-): ReactContextBaseJavaModule(reactContext) {
-
-  private val rookContinuousUploadManager by lazy {
-    RookContinuousUploadManager(reactContext)
-  }
-
-  private val rookSync by lazy {
-    RookSyncManager(reactContext)
-  }
-
-  private val scope: CoroutineScope by lazy {
-    CoroutineScope(SupervisorJob() + Dispatchers.Main)
-  }
-
-  private val rookDataSources: RookDataSources by lazy {
-    RookDataSources(reactApplicationContext)
-  }
-
-  /**
-   * Schedules a background sync for yesterday's data, which automatically retrieves and processes data
-   * from connected devices or platforms.
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @SuppressLint("MissingPermission")
-  @ReactMethod
-  fun scheduleYesterdaySync(promise: Promise) {
-    scope.launch {
-      rookContinuousUploadManager.launchInForegroundService(true)
-        .fold({
-          promise.resolve(true)
-        },{
-          promise.reject(it)
-        })
-    }
-  }
-
-  @ReactMethod
-  fun enableSamsungSync(promise: Promise) {
-     scope.launch {
-       rookSamsung.schedule(true)
-       promise.resolve(true)
-     }
-  }
-
-  @ReactMethod
-  fun isSamsungSyncEnabled(promise: Promise) {
-    scope.launch {
-      rookSamsung.isScheduled().fold(
-        {
-          promise.resolve(it)
-        },
-        {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-
-  @ReactMethod
-  fun disableSamsungSync(promise: Promise) {
-    scope.launch {
-      rookSamsung.cancel()
-      promise.resolve(true)
-    }
-  }
-
-  @ReactMethod
-  fun syncTodaySamsungHealthStepsCount(promise: Promise) {
-    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)
-          }
-        }
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the step count for the current day from Health Connect.
-   * This method queries the Health Connect platform via the Rook SDK to retrieve
-   * the step count for today. If no records are found, it rejects the promise with an error message.
-   *
-   * @param promise A promise object that resolves with the step count if data is found,
-   *                or rejects with an error if records are not found or synchronization fails.
-   */
-  @ReactMethod
-  fun syncTodayHealthConnectStepsCount(promise: Promise) {
-    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)
-            }
-          }
-        },
-        {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-
-
-  /**
-   * @deprecated
-   * Retrieves the available data sources that can be connected to the app.
-   * This method fetches data sources such as Garmin, Fitbit, Oura, etc.,
-   * that the user can authorize to sync their health data.
-   *
-   * @param options Optional parameters that may include a redirect URL to be used during authorization.
-   * @param promise A promise object that resolves with a list of available data sources
-   *                or rejects with an error if the operation fails.
-   */
-  @ReactMethod
-  fun getAvailableDataSources(options: ReadableMap?, promise: Promise) {
-    var redirectURL: String? = null
-
-    if (options !== null) redirectURL = options.getString("redirectURL")
-
-    scope.launch {
-      rookDataSources.getAvailableDataSources(redirectURL).fold(
-        { dataSources ->
-          promise.resolve(dataSourcesToWritableArray(dataSources))
-        },
-        {
-          promise.reject(it)
-        },
-      )
-    }
-  }
-
-  /**
-   * Presents a view to the user where they can authorize and connect a specific data source.
-   * This method initiates the user interface for connecting a health data source (e.g., Garmin, Fitbit).
-   *
-   * @param options Optional parameters that may include a redirect URL for the authorization flow.
-   * @param promise A promise object that resolves with true if the data source view was presented successfully,
-   *                or rejects with an error if the operation fails.
-   */
-  @ReactMethod
-  fun presentDataSourceView(options: ReadableMap?, promise: Promise) {
-    var redirectURL: String? = null
-
-    if (options !== null) redirectURL = options.getString("redirectURL")
-
-    rookDataSources.presentDataSourceView(redirectURL).fold({
-      promise.resolve(true)
-    }, {
-      promise.reject(it)
-    })
-  }
-
-  /**
-   * Revokes authorization for a specific data source, disconnecting it from the app.
-   * This method allows the user to revoke a previously authorized data source,
-   * such as Garmin, Fitbit, or Oura, preventing further data synchronization.
-   *
-   * @param source The name of the data source to revoke (e.g., "Garmin", "Fitbit").
-   * @param promise A promise object that resolves with true if the data source was revoked successfully,
-   *                or rejects with an error if the operation fails or if the source is invalid.
-   */
-  @ReactMethod
-  fun revokeDataSource(source: String, promise: Promise) {
-    val type = mapToDataSourceType(source)
-
-    if (type == null) {
-      promise.reject("Invalid", "Enter a valid data source")
-      return
-    }
-
-    scope.launch {
-      rookDataSources.revokeDataSource(type).fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun getAuthorizedDataSources(promise: Promise) {
-    scope.launch {
-      rookDataSources.getAuthorizedDataSources().fold(
-        {
-          val gson = Gson()
-          promise.resolve(gson.toJson(it))
-        }, {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-
-  @ReactMethod
-  fun getAuthorizedDataSourcesV2(promise: Promise) {
-    scope.launch {
-      rookDataSources.getAuthorizedDataSourcesV2().fold(
-        {
-          val gson = Gson()
-          promise.resolve(gson.toJson(it))
-        }, {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-
-  @ReactMethod
-  fun getDataSourceAuthorizer(options: ReadableMap, promise: Promise) {
-
-    val source = options.getString("dataSource") ?: ""
-    val redirect = options.getString("redirectURL")
-
-    scope.launch {
-      rookDataSources.getDataSourceAuthorizer(dataSource = source, redirectUrl = redirect)
-        .fold({ value ->
-          val gson = Gson()
-          promise.resolve(gson.toJson(value))
-        }, {
-          promise.reject(it)
-        })
-    }
-  }
-
-  @ReactMethod
-  fun syncSHTodayCaloriesCount(promise: Promise) {
-    scope.launch {
-      rookSamsung.getTodayCaloriesCount().fold(
-        {
-          when (it) {
-            SHSyncStatusWithData.RecordsNotFound -> {
-              promise.reject("syncTodayHealthConnect", "Records Not Found")
-            }
-
-            is SHSyncStatusWithData.Synced -> {
-              val data = Arguments.createMap().apply {
-                putDouble("basal", it.data.basal)
-                putDouble("active", it.data.active)
-              }
-
-              promise.resolve(data)
-            }
-          }
-        },
-        {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-
-  /**
-   * Synchronizes the calories count for the current day from Health Connect.
-   * This method queries the Health Connect platform via the Rook SDK to retrieve
-   * the calories count for today. If no records are found, it rejects the promise with an error message.
-   *
-   * @param promise A promise object that resolves with the step count if data is found,
-   *                or rejects with an error if records are not found or synchronization fails.
-   */
-  @ReactMethod
-  fun syncTodayCaloriesCount(promise: Promise) {
-    scope.launch {
-      rookSync.getTodayCaloriesCount().fold(
-        {
-          when (it) {
-            SyncStatusWithData.RecordsNotFound -> {
-              promise.reject("syncTodayHealthConnect", "Records Not Found")
-            }
-
-            is SyncStatusWithData.Synced -> {
-              val data = Arguments.createMap().apply {
-                putDouble("basal", it.data.basal)
-                putDouble("active", it.data.active)
-              }
-
-              promise.resolve(data)
-            }
-          }
-        },
-        {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-
-  @ReactMethod
-  fun sync(enableLogs: Boolean, callback: Callback) {
-    scope.launch {
-      rookSync.sync(enableLogs).fold({ result ->
-        callback.invoke(null, result)
-      }, {
-        val params = Arguments.createMap().apply {
-          putString("domain", it.localizedMessage ?: it.message)
-        }
-
-        callback.invoke(params, false)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncByDate(date: String, callback: Callback) {
-    val localDate = RookDateTime.stringToLocalDate(date)
-
-    scope.launch {
-      rookSync.sync(localDate).fold({ result ->
-        callback.invoke(null, result)
-      }, {
-        val params = Arguments.createMap().apply {
-          putString("domain", it.localizedMessage ?: it.message)
-        }
-
-        callback.invoke(params, false)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncByDefinition(summary: String, date: String, callback: Callback) {
-    val localDate = RookDateTime.stringToLocalDate(date)
-    val type = StringToSyncType.stringToSummary(summary)
-
-    scope.launch {
-      rookSync.sync(localDate, type).fold({ result ->
-        callback.invoke(null, result)
-      }, {
-        val params = Arguments.createMap().apply {
-          putString("domain", it.localizedMessage ?: it.message)
-        }
-
-        callback.invoke(params, false)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncEvent(date: String, event: String, promise: Promise) {
-    val localDate = RookDateTime.stringToLocalDate(date)
-    val type = StringToSyncType.stringToEvent(event)
-
-    scope.launch {
-      rookSync.syncEvents(localDate, type).fold({ result ->
-        promise.resolve(result)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun shSync(enableLogs: Boolean, callback: Callback) {
-    scope.launch {
-      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
-        val params = Arguments.createMap().apply {
-          putString("domain", "Samsung health is not available")
-        }
-
-        callback.invoke(params, false)
-        return@launch
-      }
-
-      rookSamsung.sync(enableLogs).fold(
-        {
-          callback(null, true)
-        }, {
-          val params = Arguments.createMap().apply {
-            putString("domain", it.localizedMessage ?: it.message)
-          }
-
-          callback.invoke(params, false)
-        }
-      )
-    }
-  }
-
-  @ReactMethod
-  fun shSyncByDate(date: String, callback: Callback) {
-    val localDate = RookDateTime.stringToLocalDate(date)
-
-    scope.launch {
-      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
-        val params = Arguments.createMap().apply {
-          putString("domain", "Samsung health is not available")
-        }
-
-        callback.invoke(params, false)
-        return@launch
-      }
-
-      rookSamsung.sync(localDate).fold({ result ->
-        callback.invoke(null, result)
-      }, {
-        val params = Arguments.createMap().apply {
-          putString("domain", it.localizedMessage ?: it.message)
-        }
-
-        callback.invoke(params, false)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun shSyncByDefinition(summary: String, date: String, callback: Callback) {
-    val localDate = RookDateTime.stringToLocalDate(date)
-    val type = StringToSyncType.stringToSamsungPillar(summary)
-
-    scope.launch {
-      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
-        val params = Arguments.createMap().apply {
-          putString("domain", "Samsung health is not available")
-        }
-
-        callback.invoke(params, false)
-        return@launch
-      }
-
-      rookSamsung.sync(localDate, type).fold({ result ->
-        callback.invoke(null, result)
-      }, {
-        val params = Arguments.createMap().apply {
-          putString("domain", it.localizedMessage ?: it.message)
-        }
-
-        callback.invoke(params, false)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun shSyncEvent(date: String, event: String, promise: Promise) {
-    val localDate = RookDateTime.stringToLocalDate(date)
-    val type = StringToSyncType.stringToSamsungEvent(event)
-
-    scope.launch {
-      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
-        promise.reject(Throwable("Samsung health is not available"))
-        return@launch
-      }
-
-      rookSamsung.syncEvents(localDate, type).fold({ result ->
-        promise.resolve(result)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-  override fun getName(): String {
-    return "RookSyncModule"
-  }
-
-}

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

@@ -1,63 +0,0 @@
-package com.rooksdk.utils
-
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.WritableArray
-import com.rookmotion.rook.sdk.domain.enums.DataSourceType
-import com.rookmotion.rook.sdk.domain.model.DataSource
-
-object DatasourcesUtils {
-
-  /**
-   * Maps a data source string to its corresponding DataSourceType enum.
-   * @param string The data source name as a string (e.g., "Garmin", "Fitbit").
-   * @return The corresponding DataSourceType enum or null if the string does not match.
-   */
-  fun mapToDataSourceType(string: String): DataSourceType? {
-    return when (string) {
-      "Garmin" -> DataSourceType.GARMIN
-      "Oura" -> DataSourceType.OURA
-      "Polar" -> DataSourceType.POLAR
-      "Fitbit" -> DataSourceType.FITBIT
-      "Withings" -> DataSourceType.WITHINGS
-      "Whoop" -> DataSourceType.WHOOP
-      else -> null
-    }
-  }
-
-  /**
-   * Converts a list of DataSource objects to a WritableArray to be sent to the React Native layer.
-   * Each DataSource object contains information such as name, description, image URL, and connection status.
-   * @param dataSources A list of DataSource objects.
-   * @return A WritableArray to be sent to the React Native layer.
-   */
-  fun dataSourcesToWritableArray(dataSources: List<DataSource>): WritableArray {
-    val array = Arguments.createArray()
-    for (dataSource in dataSources) {
-      val map = Arguments.createMap()
-      map.putString("name", dataSource.name)
-      map.putString("description", dataSource.description)
-      map.putString("imageUrl", dataSource.imageUrl)
-      map.putBoolean("connected", dataSource.connected)
-      dataSource.authorizationUrl?.let {
-        map.putString("authorizationURL", it)
-      }
-      array.pushMap(map)
-    }
-    return array
-  }
-
-  fun readableArrayToSourceList(sources: ReadableArray): List<Source> {
-    val rawList = sources.toArrayList()
-
-    return rawList
-        .mapNotNull { it as? String }
-        .mapNotNull {
-          try {
-            Source.valueOf(it)
-          } catch (e: IllegalArgumentException) {
-            null
-          }
-        }
-  }
-}

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

@@ -1,21 +0,0 @@
-package com.rooksdk.utils
-
-import com.facebook.react.bridge.ReadableArray
-import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
-
-object PermissionConversion {
-
-fun parseSamsungPermissions(rawPermissions: ReadableArray): Set<SamsungHealthPermission> {
-    val rawList = rawPermissions.toArrayList()
-
-    return rawList
-      .mapNotNull { it as? String }
-      .mapNotNull {
-        try {
-          SamsungHealthPermission.valueOf(it)
-        } catch (e: IllegalArgumentException) {
-          null
-        }
-      }.toSet()
-  }
-}

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

@@ -1,64 +0,0 @@
-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
-
-/**
- * ReadableToWritable is a utility object that provides methods to convert between
- * React Native's ReadableMap and WritableMap, and Kotlin's HashMap.
- * This is useful when you need to transform data between JavaScript and native code.
- */
-object ReadableToWritable {
-
-  /**
-   * Converts a ReadableMap (from JavaScript/React Native) to a HashMap (native Kotlin data structure).
-   * It iterates through all the keys in the ReadableMap and converts its values based on their type.
-   *
-   * @param readableMap The ReadableMap to convert.
-   * @return A HashMap<String, Any> with equivalent values.
-   */
-  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
-  }
-
-  /**
-   * Converts a HashMap (native Kotlin data structure) to a WritableMap (to be sent to JavaScript/React Native).
-   * It iterates through all the entries in the HashMap and converts its values based on their type.
-   *
-   * @param hashMap The HashMap<String, Any> to convert.
-   * @return A WritableMap with equivalent values.
-   */
-  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/utils/RookDateTime.kt

@@ -1,20 +0,0 @@
-package com.rooksdk.utils
-
-import java.time.LocalDate
-import java.time.format.DateTimeFormatter
-
-/**
- * RookDateTime is a utility object for handling date-related operations.
- * It provides methods to format and parse dates using the ISO_LOCAL_DATE format.
- */
-object RookDateTime {
-  private val rookDateFormatter: DateTimeFormatter get() = DateTimeFormatter.ISO_LOCAL_DATE
-
-  /**
-   * A DateTimeFormatter using the ISO_LOCAL_DATE pattern (e.g., "YYYY-MM-DD").
-   * It formats or parses dates in the standard ISO 8601 format.
-   */
-  fun stringToLocalDate(string: String): LocalDate {
-    return LocalDate.parse(string, rookDateFormatter)
-  }
-}

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

@@ -1,21 +0,0 @@
-package com.rooksdk.utils
-
-import io.tryrook.sdk.samsung.RookSamsung
-import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
-
-object SamsungAvailability {
-  suspend fun getSamsungHealthAvailabilityOrDefault(rookSamsung: RookSamsung): SamsungHealthAvailability {
-    val result = rookSamsung.checkSamsungHealthAvailability()
-    val defaultValue = SamsungHealthAvailability.NOT_INSTALLED
-
-    return result.getOrDefault(defaultValue)
-  }
-  suspend fun isSamsungAvailable(rookSamsung: RookSamsung): Boolean {
-    val result = rookSamsung.checkSamsungHealthAvailability()
-    val defaultValue = SamsungHealthAvailability.NOT_INSTALLED
-
-    val availability = result.getOrDefault(defaultValue)
-
-    return availability == SamsungHealthAvailability.INSTALLED
-  }
-}

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

@@ -1,6 +0,0 @@
-package com.rooksdk.utils
-
-enum class Source{
-  HEALTH_CONNECT,
-  SAMSUNG_HEALTH
-}