react-native-rook-sdk 2.0.3 → 2.1.0-rc.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/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

package/ios/RookLocalData.swift

@@ -0,0 +1,152 @@
+//
+//  RookLocalData.swift
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 10/09/25.
+//
+
+import RookSDK
+
+@objc(RookLocalData)
+public class RookLocalData: NSObject {
+  
+  lazy var summaryManager: RookSummaryManager = {
+    return RookSummaryManager()
+  }()
+  
+  lazy var eventManager: RookEventsManager = {
+    return RookEventsManager()
+  }()
+  
+  func parseStringToDate(_ input: String) -> Date? {
+    let dateFormatter = DateFormatter()
+    dateFormatter.dateFormat = "yyyy-MM-dd"
+    return dateFormatter.date(from: input)
+  }
+  
+  @objc(getAppleHealthSleepSummary:resolve:reject:)
+  public func getAppleHealthSleepSummary(
+    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task {
+      do {
+        guard let parsed = parseStringToDate(date) else {
+          reject("AppleHealthGetSleepSummaryError", "Invalid date format", nil)
+          return
+        }
+        
+        let sleepSummaries = try await summaryManager.getSleepSummary(date: parsed)
+        let dic = sleepSummaries.map { $0.toDictionary() }
+        
+        DispatchQueue.main.async {
+          resolve(dic)
+        }
+      } catch {
+        
+        DispatchQueue.main.async {
+          reject("AppleHealthGetSleepSummaryError", error.localizedDescription, error as NSError)
+        }
+      }
+    }
+  }
+  
+  @objc(getAppleHealthPhysicalSummary:resolve:reject:)
+  public func getAppleHealthPhysicalSummary(
+    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task {
+      do {
+        guard let parsed = parseStringToDate(date) else {
+          reject("AppleHealthGetPhysicalSummaryError", "Invalid date format", nil)
+          return
+        }
+        
+        let physicalSummaries = try await summaryManager.getPhysicalSummary(date: parsed)
+        let dic = physicalSummaries.toDictionary()
+        
+        DispatchQueue.main.async {
+          resolve(dic)
+        }
+        
+      } catch {
+        
+        DispatchQueue.main.async {
+          reject("AppleHealthGetBodySummaryError", error.localizedDescription, error as NSError)
+        }
+      }
+    }
+  }
+  
+  @objc(getAppleHealthBodySummary:resolve:reject:)
+  public func getAppleHealthBodySummary(
+    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task {
+      do {
+        guard let parsed = parseStringToDate(date) else {
+          reject("AppleHealthGetBodySummaryError", "Invalid date format", nil)
+          return
+        }
+        let bodySummaries = try await summaryManager.getBodySummary(date: parsed)
+        let dic = bodySummaries.toDictionary()
+        
+        DispatchQueue.main.async {
+          resolve(dic)
+        }
+        
+      } catch {
+        
+        DispatchQueue.main.async {
+          reject("AppleHealthGetBodySummaryError", error.localizedDescription, error as NSError)
+        }
+      }
+    }
+  }
+  
+  @objc(getAppleHealthActivityEvents:resolve:reject:)
+  public func getAppleHealthActivityEvents(
+    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task {
+      do {
+        guard let parsed = parseStringToDate(date) else {
+          reject("AppleHealthGetActivityEventsError", "Invalid date format", nil)
+          return
+        }
+        
+        let activityEvents = try await eventManager.getActivityEvents(date: parsed)
+        let dic = activityEvents.map { $0.toDictionary() }
+        
+        DispatchQueue.main.async {
+          resolve(dic)
+        }
+        
+      } catch {
+        
+        DispatchQueue.main.async {
+          reject("AppleHealthGetActivityEvents", error.localizedDescription, error as NSError)
+        }
+      }
+    }
+  }
+  
+}
+
+extension Encodable {
+  func toDictionary() -> [String: Any] {
+      let encoder = JSONEncoder()
+      
+      let dateFormatter = DateFormatter()
+      dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZ"
+      
+      encoder.dateEncodingStrategy = .formatted(dateFormatter)
+
+      guard let data = try? encoder.encode(self),
+            let dictionary = try? JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any]
+      else {
+          return [:]
+      }
+      
+      return dictionary
+  }
+}

package/ios/RookSdk.mm

@@ -1,4 +1,5 @@
 #import "RookSdk.h"
+#import <React/RCTLog.h>
 #import "RookSDK/RookSDK-Swift.h"
 #import "RCTConvert.h"