react-native-spike-sdk 4.5.23 → 4.7.13

package/android/src/main/java/com/spikesdk/SpikeSdkModule.kt

@@ -8,12 +8,8 @@ import androidx.activity.result.contract.ActivityResultContract
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.google.gson.GsonBuilder
-import com.spikeapi.SpikeConnection
-import com.spikeapi.SpikeEnvironment
 import com.spikeapi.SpikeExceptions
-import com.spikeapi.SpikeLogger
 import com.spikeapi.SpikePackageChecker
-import com.spikeapi.healthconnect.HealthConnectAvailability
 import com.spikeapi.apiv3.SpikeConnectionAPIv3
 import com.spikeapi.apiv3.datamodels.MetricType
 import com.spikeapi.apiv3.datamodels.ActivityConfig
@@ -21,10 +17,10 @@ import com.spikeapi.apiv3.datamodels.RecordConfig
 import com.spikeapi.apiv3.datamodels.SleepConfig
 import com.spikeapi.apiv3.datamodels.StatisticsType
 import com.spikeapi.apiv3.datamodels.NutritionRecord
+import com.spikeapi.apiv3.datamodels.NutritionalField
 import com.spikeapi.apiv3.datamodels.NutritionalAnalysisConfig
 import com.spikeapi.apiv3.datamodels.NutritionFactsLabelRecognitionConfig
 import com.spikeapi.apiv3.datamodels.NutritionRecordAnalysisMode
-import com.spikeapi.apiv3.datamodels.NutritionalField
 import com.spikeapi.apiv3.datamodels.utils.ActivityConfigUtils
 import com.spikeapi.apiv3.datamodels.utils.SleepConfigUtils
 import com.spikeapi.apiv3.datamodels.utils.StatisticsTypeUtils
@@ -62,9 +58,6 @@ fun <I, O> ComponentActivity.registerActivityResultLauncher(
 class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
 
-    // Do not use this directly, use `addConnection` and `getConnection` instead
-    private val _connections = mutableMapOf<String, SpikeConnection>()
-
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
 
     private val gson = GsonBuilder()
@@ -73,8 +66,6 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             OffsetDateTime::class.java,
             OffsetDateTimeSerializer()
         ).create()
-    private var checkPermissionsFor: Triple<String, Set<String>, Promise>? = null
-
     override fun getName(): String {
         return NAME
     }
@@ -99,443 +90,6 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    @ReactMethod
-    fun createConnection(
-        uuid: String,
-        appId: String,
-        authToken: String,
-        customerEndUserId: String,
-        callbackUrl: String?,
-        useLogger: Boolean,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val logger = if (useLogger) {
-                    createLogger(uuid)
-                } else {
-                    null
-                }
-                addConnection(connection = SpikeConnection.createConnection(
-                    context = reactApplicationContext,
-                    authToken = authToken,
-                    customerEndUserId = customerEndUserId,
-                    appId = appId,
-                    callbackUrl = callbackUrl,
-                    env = SpikeEnvironment.PROD,
-                    logger = logger,
-                ), uuid = uuid)
-                promise.resolve(uuid)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getAppId(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val appId = connection.getAppId()
-                promise.resolve(appId)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getSpikeEndUserId(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val spikeEndUserId = connection.getSpikeUserId()
-                promise.resolve(spikeEndUserId)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getCustomerEndUserId(uuid: String, promise: Promise) {
-        scope.launch {
-        try {
-            val connection = getConnection(uuid) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-            val customerEndUserId = connection.getCustomerUserId()
-            promise.resolve(customerEndUserId)
-        } catch (e: SpikeExceptions) {
-            promise.reject(e.mapException(), e.message)
-        }
-            }
-    }
-
-    @ReactMethod
-    fun getCallbackUrl(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val callbackUrl = connection.getPostbackUrl()
-                promise.resolve(callbackUrl)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-
-    @ReactMethod
-    fun close(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(uuid) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                connection.close()
-                promise.resolve(true)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractDataInRange(
-        connectionUUID: String,
-        dataType: String,
-        fromDateMillis: Double,
-        toDateMillis: Double,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractData(
-                    dataType = dataType.toSpikeDataType(),
-                    from = fromDateMillis.toLong().millisToOffsetDataTime(),
-                    to = toDateMillis.toLong().millisToOffsetDataTime()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractAndPostDataInRange(
-        connectionUUID: String,
-        dataType: String,
-        fromDateMillis: Double,
-        toDateMillis: Double,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractAndPostData(
-                    dataType = dataType.toSpikeDataType(),
-                    from = fromDateMillis.toLong().millisToOffsetDataTime(),
-                    to = toDateMillis.toLong().millisToOffsetDataTime()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractData(
-        connectionUUID: String,
-        dataType: String,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractData(
-                    dataType = dataType.toSpikeDataType()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun extractAndPostData(
-        connectionUUID: String,
-        dataType: String,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val result = connection.extractAndPostData(
-                    dataType = dataType.toSpikeDataType()
-                )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun manageHealthConnect(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                connection.manageHealthConnect()
-                promise.resolve(true)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun checkPermissionsGranted(connectionUUID: String, dataType: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val requiredPermissions = connection.getRequiredHealthPermissionsMetadata(
-                    dataType.toSpikeDataType()
-                )
-                val permissionsGranted: Boolean =
-                    connection.hasHealthPermissionsGranted(requiredPermissions)
-                promise.resolve(permissionsGranted)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getHealthConnectAvailability(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val availability = connection.getHealthConnectAvailability()
-                promise.resolve(availability.toStringType())
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun revokeAllPermissions(connectionUUID: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                connection.revokeAllPermissions()
-                promise.resolve(true)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun requestHealthPermissions(connectionUUID: String, dataType: String, promise: Promise) {
-        scope.launch {
-            val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-
-            val permissions =
-                connection.getRequiredHealthPermissionsMetadata(dataType.toSpikeDataType())
-
-            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-                val intent = SpikeConnection.requestReadAuthorization().createIntent(
-                    reactApplicationContext, permissions
-                )
-
-                val availability = connection.getHealthConnectAvailability()
-                if (availability == HealthConnectAvailability.INSTALLED) {
-                    reactApplicationContext.currentActivity?.startActivityForResult(
-                        intent,
-                        REQUEST_CODE
-                    )
-                    promise.resolve(true)
-                } else {
-                    promise.reject(
-                        SpikeExceptions.SpikeException().mapException(),
-                        SpikeExceptions.SpikeException().message
-                    )
-                }
-            } else {
-                val activity = reactApplicationContext.currentActivity
-                if (activity is ComponentActivity) {
-                    checkPermissionsFor = Triple(connectionUUID, setOf(dataType), promise)
-                    val launcher =
-                        activity.registerActivityResultLauncher(
-                            SpikeConnection.requestReadAuthorization()
-                        ) {
-
-                        }
-
-                    if (permissions.isNotEmpty()) {
-                        launcher.launch(permissions)
-                    } else {
-                        promise.resolve(false)
-                    }
-                } else {
-                    promise.resolve(false)
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun requestMultipleHealthPermissions(connectionUUID: String, dataTypes: ReadableArray, promise: Promise) {
-        scope.launch {
-            val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-
-            val permissions = mutableSetOf<String>()
-            dataTypes.toArrayList().forEach {
-                connection.getRequiredHealthPermissionsMetadata((it as String).toSpikeDataType())
-                    .forEach {
-                        permissions.add(it)
-                    }
-            }
-
-            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-                val availability = connection.getHealthConnectAvailability()
-                if (permissions.isNotEmpty() && availability == HealthConnectAvailability.INSTALLED) {
-                    val intent = SpikeConnection.requestReadAuthorization().createIntent(
-                        reactApplicationContext, permissions
-                    )
-
-                    reactApplicationContext.currentActivity?.startActivityForResult(
-                        intent,
-                        REQUEST_CODE
-                    )
-                    promise.resolve(true)
-                } else {
-                    promise.reject(
-                        SpikeExceptions.SpikeException().mapException(),
-                        SpikeExceptions.SpikeException().message
-                    )
-                }
-            } else {
-                val activity = reactApplicationContext.currentActivity
-                if (activity is ComponentActivity) {
-                    checkPermissionsFor = Triple(
-                        connectionUUID,
-                        dataTypes.toArrayList().toSet() as Set<String>,
-                        promise
-                    )
-                    val launcher =
-                        activity.registerActivityResultLauncher(
-                            SpikeConnection.requestReadAuthorization()
-                        ) {
-
-                        }
-                    if (permissions.isNotEmpty()) {
-                        launcher.launch(permissions)
-                    } else {
-                        promise.reject(
-                            SpikeExceptions.SpikeException().mapException(),
-                            SpikeExceptions.SpikeException().message
-                        )
-                    }
-                } else {
-                    promise.resolve(false)
-                }
-            }
-        }
-    }
-
-    private fun createLogger(connectionUUID: String): SpikeLogger {
-        return SpikeConnectionLogger(connectionUUID) { _, logLevel, message ->
-            val body = WritableNativeMap().apply {
-                putString("connectionUUID", connectionUUID)
-                putString("message", message)
-            }
-
-            when (logLevel) {
-                SpikeLogLevel.DEBUG -> sendEvent(
-                    reactContext = reactApplicationContext,
-                    eventName = logLevel.jsEventName,
-                    params = body
-                )
-
-                SpikeLogLevel.ERROR -> sendEvent(
-                    reactContext = reactApplicationContext,
-                    eventName = logLevel.jsEventName,
-                    params = body
-                )
-
-                SpikeLogLevel.INFO -> sendEvent(
-                    reactContext = reactApplicationContext,
-                    eventName = logLevel.jsEventName,
-                    params = body
-                )
-            }
-        }
-    }
-
     private fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap?) {
         reactContext
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
@@ -543,19 +97,6 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     }
 
     override fun onHostResume() {
-        // Old SDK
-        checkPermissionsFor?.let {
-            it.second.forEach { permission ->
-                checkPermissionsGranted(
-                    it.first,
-                    permission,
-                    it.third
-                )
-            }
-        }
-        checkPermissionsFor = null
-
-        // New SDK V3
         checkPermissionsForV3?.let {
             areAllPermissionsGranted(it.first, it.second, it.third)
         }
@@ -572,25 +113,9 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         const val REQUEST_CODE = 4200
     }
 
-    // Connections
+    // ------------------------- V3 -------------------------
 
     private val mutex = Mutex()
-
-    // Add new connection to the dictionary in a thread-safe manner
-    private suspend fun addConnection(connection: SpikeConnection, uuid: String) {
-        mutex.withLock {
-            _connections[uuid] = connection
-        }
-    }
-
-    // Synchronised read for safe multithreaded usage
-    private suspend fun getConnection(uuid: String): SpikeConnection? {
-        mutex.withLock {
-            return _connections[uuid]
-        }
-    }
-
-    // ------------------------- V3 -------------------------
     
     @ReactMethod
     fun setWrapper(type: String, version: String) {
@@ -675,6 +200,17 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun closeV3(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("closeV3", connectionUUID, promise) { connection ->
+            connection.close()
+            mutex.withLock {
+                _connectionsV3.remove(connectionUUID)
+            }
+            promise.resolve(true)
+        }
+    }
+
     /// --- Read user info ---
 
     @ReactMethod
@@ -915,6 +451,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         metricTypes: ReadableArray, 
         activityConfigs: ReadableArray, 
         sleepConfigs: ReadableArray, 
+        nutritionalFields: ReadableArray,
         includeEnhancedPermissions: Boolean,
         includeBackgroundDelivery: Boolean,
         promise: Promise
@@ -941,12 +478,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                 SleepConfigUtils.fromValue(it as String)
             }.toSet()
 
+            val nFields = makeNutritionalFields(nutritionalFields)
+
             val permissions = permissionManager
                 .getPermissions(
                     statisticsTypes = statTypes,
                     metricTypes = mTypes,
                     activityConfigs = aConfigs,
                     sleepConfigs = sConfigs,
+                    nutritionalFields = nFields,
                     includeEnhancedPermissions = includeEnhancedPermissions,
                     includeBackgroundDelivery = includeBackgroundDelivery
                 )
@@ -1090,6 +630,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         metricTypes: ReadableArray, 
         activityConfigs: ReadableArray, 
         sleepConfigs: ReadableArray, 
+        nutritionalFields: ReadableArray,
         promise: Promise
     ) {
         executeV3MethodWithConnection("enableBackgroundDelivery", connectionUUID, promise) { connection ->
@@ -1116,11 +657,14 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                 SleepConfigUtils.fromValue(it as String)
             }.toSet()
 
+            val nFields = makeNutritionalFields(nutritionalFields)
+
             connection.enableBackgroundDelivery(
                     statisticsTypes = statTypes,
                     metricTypes = mTypes,
                     activityConfigs = aConfigs,
-                    sleepConfigs = sConfigs
+                    sleepConfigs = sConfigs,
+                    nutritionalFields = nFields
                 )
 
             promise.resolve(true)
@@ -1134,6 +678,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         metricTypes: ReadableArray,
         activityConfigs: ReadableArray,
         sleepConfigs: ReadableArray,
+        nutritionalFields: ReadableArray,
         days: String?,
         promise: Promise
     ) {
@@ -1154,12 +699,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                 SleepConfigUtils.fromValue(it as String)
             }.toSet()
 
+            val nFields = makeNutritionalFields(nutritionalFields)
+
             connection.backfill(
                 days = days?.toIntOrNull(),
                 statisticsTypes = statTypes,
                 metricTypes = mTypes,
                 activityConfigs = aConfigs,
-                sleepConfigs = sConfigs
+                sleepConfigs = sConfigs,
+                nutritionalFields = nFields
             )
 
             promise.resolve(true)
@@ -1204,6 +752,13 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    private fun makeNutritionalFields(nutritionalFields: ReadableArray): Set<NutritionalField> {
+        return nutritionalFields.toArrayList().mapNotNull { item ->
+            val value = item as? String ?: return@mapNotNull null
+            NutritionalField.values().find { it.value == value }
+        }.toSet()
+    }
+
     /// --- Private stuff ---
 
     // Do not use this directly, use `addConnection` and `getConnection` instead
@@ -1336,6 +891,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         metricTypes: ReadableArray, 
         activityConfigs: ReadableArray, 
         sleepConfigs: ReadableArray, 
+        nutritionalFields: ReadableArray,
         promise: Promise
     ) {
         executeV3MethodWithConnection("getSamsungHealthDataPermissions", connectionUUID, promise) { connection ->
@@ -1360,12 +916,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                 SleepConfigUtils.fromValue(it as String)
             }.toSet()
 
+            val nFields = makeNutritionalFields(nutritionalFields)
+
             val permissions = permissionManager
                 .getPermissions(
                     statisticsTypes = statTypes,
                     metricTypes = mTypes,
                     activityConfigs = aConfigs,
-                    sleepConfigs = sConfigs
+                    sleepConfigs = sConfigs,
+                    nutritionalFields = nFields
                 )
 
             val result = Arguments.createArray()
@@ -1384,6 +943,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         metricTypes: ReadableArray, 
         activityConfigs: ReadableArray, 
         sleepConfigs: ReadableArray, 
+        nutritionalFields: ReadableArray,
         promise: Promise
     ) {
         executeV3MethodWithConnection("requestPermissionsFromSamsungHealthData", connectionUUID, promise) { connection ->
@@ -1408,8 +968,10 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             val sConfigs = sleepConfigs.toArrayList().mapNotNull {
                 SleepConfigUtils.fromValue(it as String)
             }.toSet()
-            
-            Log.d("SpikeSdkModule", "Will ask for Samsung Health Data permissions with: statTypes=$statTypes, metricTypes=$mTypes, activityConfigs=$aConfigs, sleepConfigs=$sConfigs")
+
+            val nFields = makeNutritionalFields(nutritionalFields)
+
+            Log.d("SpikeSdkModule", "Will ask for Samsung Health Data permissions with: statTypes=$statTypes, metricTypes=$mTypes, activityConfigs=$aConfigs, sleepConfigs=$sConfigs, nutritionalFields=$nFields")
 
             val activity = reactApplicationContext.currentActivity
             if (activity == null) {
@@ -1421,7 +983,8 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                     statisticsTypes = statTypes,
                     metricTypes = mTypes,
                     activityConfigs = aConfigs,
-                    sleepConfigs = sConfigs
+                    sleepConfigs = sConfigs,
+                    nutritionalFields = nFields
                 )
                 
                 val result = Arguments.createArray()
@@ -1443,6 +1006,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         metricTypes: ReadableArray,
         activityConfigs: ReadableArray,
         sleepConfigs: ReadableArray,
+        nutritionalFields: ReadableArray,
         days: String?,
         promise: Promise
     ) {
@@ -1468,12 +1032,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                 SleepConfigUtils.fromValue(it as String)
             }.toSet()
 
+            val nFields = makeNutritionalFields(nutritionalFields)
+
             connection.requestPermissionsFromSamsungHealthDataAndBackfill(
                 activity = activity,
                 statisticsTypes = statTypes,
                 metricTypes = mTypes,
                 activityConfigs = aConfigs,
                 sleepConfigs = sConfigs,
+                nutritionalFields = nFields,
                 backfillDays = days?.toIntOrNull()
             )