react-native-rook-sdk 4.0.0-beta.2 → 5.0.0-beta.0

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

@@ -0,0 +1,62 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.rookmotion.rook.sdk.RookPermissionsManager
+
+/**
+ * AndroidPermissionsReceiverTransmitter is a custom BroadcastReceiver used to listen for updates
+ * on Android permission changes and transmit them back to the React Native layer.
+ * It listens for a broadcast containing permission status, then emits a corresponding event to JavaScript.
+ */
+class AndroidPermissionsReceiverTransmitter: BroadcastReceiver() {
+  var onActionReceived: ((ReadableMap) -> Unit)? = null
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  /**
+   * This method is called when a broadcast is received.
+   * It checks whether the broadcast includes the permission status and emits an event to the React Native
+   * JavaScript layer with the results.
+   *
+   * @param context The context in which the receiver is running.
+   * @param intent The intent containing permission-related data.
+   */
+  override fun onReceive(context: Context?, intent: Intent?) {
+    val permissionsGranted = intent?.getBooleanExtra(
+      /* name = */ RookPermissionsManager.EXTRA_ANDROID_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    val dialogDisplayed = intent?.getBooleanExtra(
+      RookPermissionsManager.EXTRA_ANDROID_PERMISSIONS_DIALOG_DISPLAYED,
+      false
+    ) ?: false
+
+    if (reactApplicationContext == null || reactApplicationContext?.hasReactInstance() == false)
+      return
+
+    val events = listOf(
+      "ROOK_BACKGROUND_ANDROID_PERMISSIONS" to permissionsGranted,
+      "ROOK_BACKGROUND_ANDROID_PERMISSIONS_DIALOG_DISPLAYED" to dialogDisplayed
+    )
+
+    events.forEach { (type, value) ->
+      Arguments.createMap().apply {
+        putString("type", type)
+        putBoolean("value", value)
+        onActionReceived?.invoke(this)
+      }
+    }
+  }
+
+  fun setConfig(ctx: ReactApplicationContext, emit: (ReadableMap) -> Unit) {
+    this.reactApplicationContext = ctx
+    this.onActionReceived = emit
+  }
+
+}
+

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

@@ -0,0 +1,64 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.rookmotion.rook.sdk.RookPermissionsManager
+
+/**
+ * HealthConnectPermissionsReceiverTransmitter is a custom BroadcastReceiver used to listen for updates
+ * on Android permission changes and transmit them back to the React Native layer.
+ * It listens for a broadcast containing permission status, then emits a corresponding event to JavaScript.
+ */
+class HealthConnectPermissionsReceiverTransmitter: BroadcastReceiver() {
+  var onActionReceived: ((ReadableMap) -> Unit)? = null
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  /**
+   * This method is called when a broadcast is received.
+   * It checks whether the broadcast includes the permission status and emits an event to the React Native
+   * JavaScript layer with the results.
+   *
+   * @param context The context in which the receiver is running.
+   * @param intent The intent containing permission-related data.
+   */
+  override fun onReceive(context: Context?, intent: Intent?) {
+    val permissionsGranted = intent?.getBooleanExtra(
+      /* name = */ RookPermissionsManager.EXTRA_HEALTH_CONNECT_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    val partiallyGranted = intent?.getBooleanExtra(
+      RookPermissionsManager.EXTRA_HEALTH_CONNECT_PERMISSIONS_PARTIALLY_GRANTED,
+      false
+    ) ?: false
+
+    val backgroundReadStatus = intent?.getBooleanExtra(
+      RookPermissionsManager.EXTRA_HEALTH_CONNECT_BACKGROUND_PERMISSION_GRANTED,
+      false
+    ) ?: false
+
+      val events = listOf(
+        "ROOK_HEALTH_CONNECT_PERMISSIONS" to permissionsGranted,
+        "ROOK_HEALTH_CONNECT_PERMISSIONS_PARTIALLY_GRANTED" to partiallyGranted,
+        "ROOK_HEALTH_CONNECT_BACKGROUND_PERMISSIONS" to backgroundReadStatus,
+      )
+
+      events.forEach { (type, value) ->
+        Arguments.createMap().apply {
+          putString("type", type)
+          putBoolean("value", value)
+          onActionReceived?.invoke(this)
+        }
+      }
+    }
+
+    fun setConfig(ctx: ReactApplicationContext,emit: (ReadableMap) -> Unit) {
+      this.reactApplicationContext = ctx
+      this.onActionReceived = emit
+    }
+  }
+

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

@@ -0,0 +1,44 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+class SamsungHealthPermissionsReceiverTransmitter: BroadcastReceiver() {
+  var onActionReceived: ((ReadableMap) -> Unit)? = null
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+  override fun onReceive(conext: Context?, intent: Intent?) {
+    val allPermissionsGranted = intent?.getBooleanExtra(
+      /* name = */ SamsungHealthPermission.EXTRA_SAMSUNG_HEALTH_PERMISSIONS_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+    val permissionsPartiallyGranted = intent?.getBooleanExtra(
+      /* name = */ SamsungHealthPermission.EXTRA_SAMSUNG_HEALTH_PERMISSIONS_PARTIALLY_GRANTED,
+      /* defaultValue = */ false
+    ) ?: false
+
+      val events = listOf(
+        "ROOK_SAMSUNG_HEALTH_PERMISSIONS" to allPermissionsGranted,
+        "ROOK_SAMSUNG_HEALTH_PERMISSIONS_PARTIALLY_GRANTED" to permissionsPartiallyGranted,
+      )
+
+      events.forEach { (type, value) ->
+        Arguments.createMap().apply {
+          putString("type", type)
+          putBoolean("value", value)
+          onActionReceived?.invoke(this)
+        }
+      }
+  }
+
+  fun setConfig(ctx: ReactApplicationContext, emit: (ReadableMap) -> Unit) {
+    this.reactApplicationContext = ctx
+    this.onActionReceived = emit
+  }
+}
+

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

@@ -0,0 +1,35 @@
+package com.rooksdk.utils
+
+import com.facebook.react.bridge.ReadableArray
+import io.tryrook.api.sources.domain.enums.DataSourceType
+
+object DatasourceUtils {
+
+  /**
+   * Maps a data source string to its corresponding DataSourceType enum.
+   * @param source 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(source: String): DataSourceType? {
+    return try {
+      DataSourceType.valueOf(source.uppercase())
+    } catch (e: IllegalArgumentException) {
+      null
+    }
+  }
+
+  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/PermissionConvertions.kt

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,144 @@
+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
+import com.rookmotion.rook.sdk.domain.enums.HCNutritionInsertionEventType
+import com.rookmotion.rook.sdk.domain.model.HCNutritionInsertionEvent
+import java.time.ZonedDateTime
+
+/**
+ * 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
+  }
+
+  fun mapReadableMapToHCMealData(map: ReadableMap): HCNutritionInsertionEvent {
+    // Helper for micro-nutrients: range [0.0, 100.0]
+    fun getGramValue(key: String): Double? {
+      return if (map.hasKey(key) && !map.isNull(key)) {
+        map.getDouble(key).takeIf { it in 0.0..100.0 }
+      } else null
+    }
+
+    // Helper for energy and macronutrients: range [0.0, 100,000.0]
+    fun getLargeValue(key: String): Double? {
+      return if (map.hasKey(key) && !map.isNull(key)) {
+        map.getDouble(key).takeIf { it in 0.0..100000.0 }
+      } else null
+    }
+
+    val typeString = if (map.hasKey("type")) map.getString("type") else null
+    val mealType = when (typeString?.uppercase()) {
+      "BREAKFAST" -> HCNutritionInsertionEventType.BREAKFAST
+      "LUNCH"     -> HCNutritionInsertionEventType.LUNCH
+      "DINNER"    -> HCNutritionInsertionEventType.DINNER
+      "SNACK"     -> HCNutritionInsertionEventType.SNACK
+      else        -> HCNutritionInsertionEventType.SNACK // Default fallback
+    }
+
+    return HCNutritionInsertionEvent(
+      startDateTime = ZonedDateTime.parse(map.getString("startDateTime")),
+      endDateTime = ZonedDateTime.parse(map.getString("endDateTime")),
+      name = map.getString("name") ?: "Meal",
+      type = mealType,
+
+      // Energy & Macros (0 to 100,000 range)
+      energyKcal = getLargeValue("energyKcal"),
+      energyFromFatKcal = getLargeValue("energyFromFatKcal"),
+      dietaryFiberGrams = getLargeValue("dietaryFiberGrams"),
+      monounsaturatedFatGrams = getLargeValue("monounsaturatedFatGrams"),
+      polyunsaturatedFatGrams = getLargeValue("polyunsaturatedFatGrams"),
+      proteinGrams = getLargeValue("proteinGrams"),
+      saturatedFatGrams = getLargeValue("saturatedFatGrams"),
+      sugarGrams = getLargeValue("sugarGrams"),
+      totalCarbohydrateGrams = getLargeValue("totalCarbohydrateGrams"),
+      totalFatGrams = getLargeValue("totalFatGrams"),
+      transFatGrams = getLargeValue("transFatGrams"),
+      unsaturatedFatGrams = getLargeValue("unsaturatedFatGrams"),
+
+      // Micro-nutrients & Minerals (0 to 100 range)
+      biotinGrams = getGramValue("biotinGrams"),
+      caffeineGrams = getGramValue("caffeineGrams"),
+      calciumGrams = getGramValue("calciumGrams"),
+      chlorideGrams = getGramValue("chlorideGrams"),
+      cholesterolGrams = getGramValue("cholesterolGrams"),
+      chromiumGrams = getGramValue("chromiumGrams"),
+      copperGrams = getGramValue("copperGrams"),
+      folateGrams = getGramValue("folateGrams"),
+      folicAcidGrams = getGramValue("folicAcidGrams"),
+      iodineGrams = getGramValue("iodineGrams"),
+      ironGrams = getGramValue("ironGrams"),
+      magnesiumGrams = getGramValue("magnesiumGrams"),
+      manganeseGrams = getGramValue("manganeseGrams"),
+      molybdenumGrams = getGramValue("molybdenumGrams"),
+      niacinGrams = getGramValue("niacinGrams"),
+      pantothenicAcidGrams = getGramValue("pantothenicAcidGrams"),
+      phosphorusGrams = getGramValue("phosphorusGrams"),
+      potassiumGrams = getGramValue("potassiumGrams"),
+      riboflavinGrams = getGramValue("riboflavinGrams"),
+      seleniumGrams = getGramValue("seleniumGrams"),
+      sodiumGrams = getGramValue("sodiumGrams"),
+      thiaminGrams = getGramValue("thiaminGrams"),
+      vitaminAGrams = getGramValue("vitaminAGrams"),
+      vitaminB12Grams = getGramValue("vitaminB12Grams"),
+      vitaminB6Grams = getGramValue("vitaminB6Grams"),
+      vitaminCGrams = getGramValue("vitaminCGrams"),
+      vitaminDGrams = getGramValue("vitaminDGrams"),
+      vitaminEGrams = getGramValue("vitaminEGrams"),
+      vitaminKGrams = getGramValue("vitaminKGrams"),
+      zincGrams = getGramValue("zincGrams")
+    )
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.rooksdk.utils
+
+import java.time.LocalDate
+import java.time.ZonedDateTime
+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
+  private val rookZonedDateTimeFormatter = DateTimeFormatter.ISO_ZONED_DATE_TIME
+
+  /**
+   * 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)
+  }
+
+  fun stringToZonedDateTime(string: String): ZonedDateTime {
+    return ZonedDateTime.parse(string, rookZonedDateTimeFormatter)
+  }
+}

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

@@ -0,0 +1,20 @@
+package com.rooksdk.utils
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.rooksdk.utils.serializers.InstantSerializer
+import com.rooksdk.utils.serializers.LocalDateSerializer
+import com.rooksdk.utils.serializers.ZonedDateTimeAdapter
+import java.time.Instant
+import java.time.LocalDate
+import java.time.ZonedDateTime
+
+object RookGsonBuilder {
+  fun getGsonBuilder(): Gson {
+    return GsonBuilder()
+      .registerTypeAdapter(Instant::class.java, InstantSerializer())
+      .registerTypeAdapter(LocalDate::class.java, LocalDateSerializer())
+      .registerTypeAdapter(ZonedDateTime::class.java, ZonedDateTimeAdapter())
+      .create()
+  }
+}

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

@@ -0,0 +1,22 @@
+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

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

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

@@ -0,0 +1,41 @@
+package com.rooksdk.utils
+
+import com.rookmotion.rook.sdk.domain.model.SyncType
+import io.tryrook.sdk.samsung.domain.model.SHSyncType
+
+object StringToSyncType {
+
+  fun stringToSummary(type: String): SyncType.Summary {
+    return when(type.lowercase()) {
+      "sleep" -> SyncType.Summary.SLEEP
+      "body" -> SyncType.Summary.BODY
+      "physical" -> SyncType.Summary.PHYSICAL
+      else -> SyncType.Summary.BODY
+    }
+  }
+
+  fun stringToEvent(value: String): SyncType.Event {
+    return try {
+      SyncType.Event.valueOf(value)
+    } catch (e: IllegalArgumentException) {
+      SyncType.Event.STEPS
+    }
+  }
+
+  fun stringToSamsungPillar(value: String): SHSyncType.Summary {
+    return when(value.lowercase()) {
+      "sleep" -> SHSyncType.Summary.SLEEP
+      "body" -> SHSyncType.Summary.BODY
+      "physical" -> SHSyncType.Summary.PHYSICAL
+      else -> SHSyncType.Summary.BODY
+    }
+  }
+
+  fun stringToSamsungEvent(value: String): SHSyncType.Event {
+    return try {
+      SHSyncType.Event.valueOf(value)
+    } catch (e: IllegalArgumentException) {
+      SHSyncType.Event.STEPS
+    }
+  }
+}

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

@@ -0,0 +1,18 @@
+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/android/src/main/java/com/rooksdk/utils/serializers/ZoneDateTimeSerializer.kt

@@ -0,0 +1,18 @@
+package com.rooksdk.utils.serializers
+
+import com.google.gson.*
+import java.lang.reflect.Type
+import java.time.ZonedDateTime
+import java.time.format.DateTimeFormatter
+
+class ZonedDateTimeAdapter : JsonSerializer<ZonedDateTime>, JsonDeserializer<ZonedDateTime> {
+  private val formatter = DateTimeFormatter.ISO_ZONED_DATE_TIME
+
+  override fun serialize(src: ZonedDateTime, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
+    return JsonPrimitive(formatter.format(src))
+  }
+
+  override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): ZonedDateTime {
+    return ZonedDateTime.parse(json.asString, formatter)
+  }
+}

package/ios/EncodableSDKState.swift

@@ -0,0 +1,95 @@
+//
+//  EncodableSDKState.swift
+//  RNRookSdk
+//
+//  Created by Javier Villanueva on 07/04/26.
+//
+
+import Foundation
+import RookSDK
+
+private struct DateTransformer {
+    static let localFormatter: DateFormatter = {
+        let formatter = DateFormatter()
+        // Use a standard ISO-like format or customize as needed
+        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"
+        formatter.timeZone = .current // Explicitly set to the device's local timezone
+        return formatter
+    }()
+    
+    static func string(from date: Date?) -> String? {
+        guard let date = date else { return nil }
+        return localFormatter.string(from: date)
+    }
+}
+
+public struct EncodableSDKState: Encodable {
+    
+  private let state: RookSDK.SDKState
+
+  public init(_ state: RookSDK.SDKState) {
+        self.state = state
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case isConfigured
+        case userIdentified
+        case permissions
+        case backgroundSync
+        case manualSync
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        try container.encode(state.isConfigured, forKey: .isConfigured)
+        try container.encode(state.userIdentified, forKey: .userIdentified)
+        try container.encode(state.permissions, forKey: .permissions)
+        
+        // Wrap nested structs to ensure they use their own encoding logic
+        try container.encode(EncodableSDKBackgroundState(state.backgroundSync), forKey: .backgroundSync)
+        try container.encode(EncodableSDKManualSyncState(state.manualSync), forKey: .manualSync)
+    }
+}
+
+// MARK: - Nested Wrappers
+
+struct EncodableSDKBackgroundState: Encodable {
+  private let backgroundState: RookSDK.SDKBackgroundState
+  private let formatter = ISO8601DateFormatter()
+    
+  init(_ backgroundState: RookSDK.SDKBackgroundState) {
+        self.backgroundState = backgroundState
+    }
+    
+    private enum CodingKeys: String, CodingKey {
+        case enabled, lastSync
+    }
+    
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(backgroundState.enabled, forKey: .enabled)
+    
+    try container.encode(DateTransformer.string(from: backgroundState.lastSync), forKey: .lastSync)
+  }
+}
+
+struct EncodableSDKManualSyncState: Encodable {
+  private let manualState: RookSDK.SDKManualSyncState
+  private let formatter = ISO8601DateFormatter()
+    
+  init(_ manualState: RookSDK.SDKManualSyncState) {
+        self.manualState = manualState
+    }
+    
+    private enum CodingKeys: String, CodingKey {
+        case enabled, lastSync
+    }
+    
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(manualState.enabled, forKey: .enabled)
+    
+    try container.encode(DateTransformer.string(from: manualState.lastSync), forKey: .lastSync)
+  }
+}