react-native-rook-sdk 2.0.2 → 2.1.0-rc.0

package/android/build.gradle

@@ -93,6 +93,6 @@ dependencies {
   implementation 'com.google.code.gson:gson:2.13.0'
 
   implementation("io.tryrook.android:rook-sdk-samsung:1.0.0-beta01")
-  implementation 'com.rookmotion.android:rook-sdk:2.2.1'
+  implementation 'com.rookmotion.android:rook-sdk:2.3.1'
 }
 

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

@@ -8,6 +8,7 @@ import com.facebook.react.uimanager.ViewManager
 import com.rookmotion.rook.sdk.RookConfigurationManager
 import com.rooksdk.modules.RookBackgroundSyncModule
 import com.rooksdk.modules.RookConfigurationModule
+import com.rooksdk.modules.RookLocalData
 import com.rooksdk.modules.RookPermissionsModule
 import com.rooksdk.modules.RookStepsModule
 import io.tryrook.sdk.samsung.RookSamsung
@@ -30,7 +31,8 @@ class RookSdkPackage : ReactPackage {
       RookConfigurationModule(reactContext, rookConfigurationManager!!, rookSamsung!!),
       RookSyncModule(reactContext, rookSamsung!!),
       RookBackgroundSyncModule(reactContext),
-      RookStepsModule(reactContext)
+      RookStepsModule(reactContext),
+      RookLocalData(reactContext, rookSamsung!!)
     )
   }
 

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

@@ -68,4 +68,18 @@ class RookBackgroundSyncModule (reactContext: ReactApplicationContext) : ReactCo
       }
     }
   }
+
+@ReactMethod
+  fun isBackgroundSyncEnabled(promise: Promise) {
+    scope.launch {
+      backgroundSyncManager.isScheduled().fold(
+        {
+          promise.resolve(it)
+        },
+        {
+          promise.reject(it)
+        }
+      )
+    }
+  }
 }

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

@@ -0,0 +1,247 @@
+package com.rooksdk.modules
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.rookmotion.rook.sdk.RookSyncManager
+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.SyncStatusWithData
+import com.rooksdk.utils.serializers.InstantSerializer
+import com.rooksdk.utils.RookDateTime
+import com.rooksdk.utils.serializers.LocalDateSerializer
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.model.SHActivityEvent
+import io.tryrook.sdk.samsung.domain.model.SHBodySummary
+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.launch
+import java.time.Instant
+import java.time.LocalDate
+
+class RookLocalData (
+  reactContext: ReactApplicationContext,
+  private val rookSamsung: RookSamsung,
+): ReactContextBaseJavaModule(reactContext){
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  private val rookHealthConnect by lazy {
+    RookSyncManager(reactContext)
+  }
+
+  private val gsonBuilder: Gson by lazy {
+    GsonBuilder()
+      .registerTypeAdapter(Instant::class.java, InstantSerializer())
+      .registerTypeAdapter(LocalDate::class.java, LocalDateSerializer())
+      .create()
+  }
+
+  @ReactMethod
+  fun getSamsungSleepSummary(date: String, promise: Promise) {
+    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))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getSamsungPhysicalSummary(date: String, promise: Promise) {
+    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))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getSamsungBodySummary(date: String, promise: Promise) {
+    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))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getSamsungActivityEvents(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookSamsung.getActivityEvents(localDate).fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("SamsungBodySummary", "Records Not Found For Date: $date")
+            }
+
+            is SHSyncStatusWithData.Synced<List<SHActivityEvent>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  // Health Connect
+  @ReactMethod
+  fun getHealthConnectSleepSummary(date: String, promise: Promise) {
+    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>> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getHealthConnectPhysicalSummary(date: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      rookHealthConnect.getPhysicalSummary(localDate).fold(
+        {
+          when (it) {
+            SyncStatusWithData.RecordsNotFound -> {
+              promise.reject("HealthConnectSleepSummary", "Records Not Found For Date: $date")
+            }
+
+            is SyncStatusWithData.Synced<HCPhysicalSummary> -> {
+              promise.resolve(gsonBuilder.toJson(it.data))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getHealthConnectBodySummary(date: String, promise: Promise) {
+    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))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getHealthConnectActivityEvents(date: String, promise: Promise) {
+    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))
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        },
+      )
+    }
+  }
+
+  override fun getName(): String {
+    return "RookLocalData"
+  }
+}

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

@@ -22,6 +22,7 @@ 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,
@@ -145,6 +146,7 @@ class RookSyncModule(
 
 
   /**
+   * @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.
@@ -233,7 +235,21 @@ class RookSyncModule(
     }
   }
 
-@ReactMethod
+  @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") ?: ""

package/android/src/main/java/com/rooksdk/utils/serializers/InstantSerializer.kt

@@ -0,0 +1,19 @@
+package com.rooksdk.utils.serializers
+
+import com.google.gson.JsonElement
+import com.google.gson.JsonPrimitive
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
+import java.time.Instant
+import java.lang.reflect.Type
+
+class InstantSerializer : JsonSerializer<Instant> {
+  override fun serialize(
+    src: Instant?,
+    typeOfSrc: Type?,
+    context: JsonSerializationContext?
+  ): JsonElement {
+    return JsonPrimitive(src?.toString())
+  }
+}
+

package/android/src/main/java/com/rooksdk/utils/serializers/LocalDateSerializer.kt

@@ -0,0 +1,21 @@
+package com.rooksdk.utils.serializers
+
+import com.google.gson.JsonElement
+import com.google.gson.JsonPrimitive
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
+import java.lang.reflect.Type
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+class LocalDateSerializer : JsonSerializer<LocalDate> {
+  private val formatter: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd")
+
+  override fun serialize(
+    src: LocalDate?,
+    typeOfSrc: Type?,
+    context: JsonSerializationContext?
+  ): JsonElement {
+    return JsonPrimitive(src?.format(formatter))
+  }
+}

package/ios/EncodableDataSource.swift

@@ -0,0 +1,32 @@
+//
+//  EncodableDataSource.swift
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 09/10/25.
+//
+
+import Foundation
+import RookSDK
+
+struct EncodableDataSource: Encodable {
+    
+    private let dataSource: RookSDK.DataSourceStatus
+
+    init(_ dataSource: RookSDK.DataSourceStatus) {
+        self.dataSource = dataSource
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case source
+        case status
+        case imageURL
+    }
+  
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        try container.encode(dataSource.source, forKey: .source)
+        try container.encode(dataSource.status, forKey: .status)
+        try container.encode(dataSource.imageURL, forKey: .imageURL)
+    }
+}

package/ios/EncodableDataSourceAuthorizer.swift

@@ -0,0 +1,32 @@
+//
+//  EncodableDataSourceAuthorizer.swift
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 08/10/25.
+//
+
+import RookSDK
+import Foundation
+
+struct EncodableDataSourceAuthorizer: Encodable {
+    
+    private let authorizer: RookSDK.DataSourceAuthorizer
+
+    init(_ authorizer: RookSDK.DataSourceAuthorizer) {
+        self.authorizer = authorizer
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case dataSource
+        case authorized
+        case authorizationURL
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        try container.encode(authorizer.dataSource, forKey: .dataSource)
+        try container.encode(authorizer.authorized, forKey: .authorized)
+        try container.encode(authorizer.authorizationURL, forKey: .authorizationURL)
+    }
+}

package/ios/EncodableRookDataSource.swift

@@ -0,0 +1,36 @@
+//
+//  EncodableRookDataSource.swift
+//  Pods
+//
+//  Created by Javier Villanueva on 08/10/25.
+//
+
+import Foundation
+import RookSDK
+
+struct EncodableRookDataSource: Encodable {
+
+    private let dataSource: RookSDK.RookDataSource
+
+    init(_ dataSource: RookSDK.RookDataSource) {
+        self.dataSource = dataSource
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case name
+        case description
+        case imageUrl
+        case connected
+        case authorizationURL
+    }
+  
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        
+        try container.encode(dataSource.name, forKey: .name)
+        try container.encode(dataSource.description, forKey: .description)
+        try container.encode(dataSource.imageUrl, forKey: .imageUrl)
+        try container.encode(dataSource.connected, forKey: .connected)
+        try container.encode(dataSource.authorizationURL, forKey: .authorizationURL)
+    }
+}

package/ios/EncodableStatusDataSources.swift

@@ -0,0 +1,47 @@
+//
+//  EncodableStatusDataSources.swift
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 08/10/25.
+//
+
+import Foundation
+import RookSDK
+
+struct EncodableStatusDataSources: Encodable {
+    private let status: RookSDK.StatusDataSources
+
+    init(_ status: RookSDK.StatusDataSources) {
+        self.status = status
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case oura
+        case polar
+        case whoop
+        case fitbit
+        case garmin
+        case withings
+        case googleFit
+        case appleHealth
+        case healthConnect
+        case android
+        case dexcom
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        try container.encode(status.oura, forKey: .oura)
+        try container.encode(status.polar, forKey: .polar)
+        try container.encode(status.whoop, forKey: .whoop)
+        try container.encode(status.fitbit, forKey: .fitbit)
+        try container.encode(status.garmin, forKey: .garmin)
+        try container.encode(status.withings, forKey: .withings)
+        try container.encode(status.googleFit, forKey: .googleFit)
+        try container.encode(status.appleHealth, forKey: .appleHealth)
+        try container.encode(status.healthConnect, forKey: .healthConnect)
+        try container.encode(status.android, forKey: .android)
+        try container.encode(status.dexcom, forKey: .dexcom)
+    }
+}

package/ios/RookExternalModule.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RookExternalModule: NSObject<RCTBridgeModule>
+
+@end

package/ios/RookExternalModule.m

@@ -0,0 +1,27 @@
+//
+//  RookExternalModule.m
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 10/09/25.
+//
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(RookLocalData, NSObject)
+
+RCT_EXTERN_METHOD(getAppleHealthSleepSummary: (NSString *) date
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getAppleHealthPhysicalSummary: (NSString *) date
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getAppleHealthBodySummary: (NSString *) date
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getAppleHealthActivityEvents: (NSString *) date
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+@end