react-native-spike-sdk 4.3.173 → 4.3.193

package/android/build.gradle

@@ -76,7 +76,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-android:0.71.3"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'com.spikeapi.sdk:spike-sdk:4.3.102'
+  implementation 'com.spikeapi.sdk:spike-sdk:4.3.122'
   implementation 'androidx.core:core-ktx:1.9.0'
   implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.5.1'
   implementation 'com.google.code.gson:gson:2.10.1'

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

@@ -19,11 +19,18 @@ import com.spikeapi.apiv3.datamodels.MetricType
 import com.spikeapi.apiv3.datamodels.ActivityConfig
 import com.spikeapi.apiv3.datamodels.SleepConfig
 import com.spikeapi.apiv3.datamodels.StatisticsType
+import com.spikeapi.apiv3.datamodels.NutritionRecord
+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
 import com.spikeapi.apiv3.datamodels.utils.StatisticsIntervalUtils
 import com.spikeapi.apiv3.datamodels.utils.MetricTypeUtils
+import com.spikeapi.apiv3.datamodels.utils.NutritionFactsLabelRecognitionConfigUtils
+import com.spikeapi.apiv3.datamodels.utils.NutritionRecordUtils
 import com.spikeapi.apiv3.datamodels.StatisticsInterval
 import com.spikeapi.apiv3.datamodels.StatisticsFilter
 import com.spikeapi.apiv3.datamodels.Provider
@@ -1388,7 +1395,202 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
 
 
 
-    /// --- 
+    /// --- Nutrition AI ---
+
+    @ReactMethod
+    fun analyzeNutrition(
+        connectionUUID: String,
+        imageBase64: String,
+        consumedAt: String?,
+        config: String?,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("analyzeNutrition", connectionUUID, promise) { connection ->
+            val consumedAtInstant = consumedAt?.let { convertIsoStringToInstant(it) }
+            val configObject = config?.let { parseNutritionalAnalysisConfig(it) }
+
+            val result = connection.analyzeNutrition(
+                imageBase64 = imageBase64,
+                consumedAt = consumedAtInstant,
+                config = configObject
+            )
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    @ReactMethod
+    fun submitNutritionForAnalysis(
+        connectionUUID: String,
+        imageBase64: String,
+        consumedAt: String?,
+        config: String?,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("submitNutritionForAnalysis", connectionUUID, promise) { connection ->
+            val consumedAtInstant = consumedAt?.let { convertIsoStringToInstant(it) }
+            val configObject = config?.let { parseNutritionalAnalysisConfig(it) }
+
+            val result = connection.submitNutritionForAnalysis(
+                imageBase64 = imageBase64,
+                consumedAt = consumedAtInstant,
+                config = configObject
+            )
+
+            promise.resolve(result.toString())
+        }
+    }
+    
+    private fun parseNutritionalAnalysisConfig(json: String): NutritionalAnalysisConfig? {
+        return try {
+            NutritionalAnalysisConfigUtils.fromValue(json)
+        } catch (e: Exception) {
+            Log.e("SpikeSdkModule", "Error parsing NutritionalAnalysisConfig: ${e.message}")
+            null
+        }
+    }
+
+    @ReactMethod
+    fun getNutritionRecords(
+        connectionUUID: String,
+        from: String,
+        to: String,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("getNutritionRecords", connectionUUID, promise) { connection ->
+            val dateFrom = convertIsoStringToInstant(from)
+            val dateTo = convertIsoStringToInstant(to)
+
+            val result = connection.getNutritionRecords(
+                from = dateFrom,
+                to = dateTo
+            )
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    @ReactMethod
+    fun getNutritionRecord(
+        connectionUUID: String,
+        recordId: String,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("getNutritionRecord", connectionUUID, promise) { connection ->
+            val uuid = UUID.fromString(recordId)
+
+            val result = connection.getNutritionRecord(id = uuid)
+
+            if (result != null) {
+                promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+            } else {
+                promise.resolve(null)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun deleteNutritionRecord(
+        connectionUUID: String,
+        recordId: String,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("deleteNutritionRecord", connectionUUID, promise) { connection ->
+            val uuid = UUID.fromString(recordId)
+
+            connection.deleteNutritionRecord(id = uuid)
+
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun updateNutritionRecordServingSize(
+        connectionUUID: String,
+        recordId: String,
+        servingSize: Double,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("updateNutritionRecordServingSize", connectionUUID, promise) { connection ->
+            val uuid = UUID.fromString(recordId)
+
+            val result = connection.updateNutritionRecordServingSize(
+                id = uuid,
+                servingSize = servingSize
+            )
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    @ReactMethod
+    fun recognizeNutritionFactsLabel(
+        connectionUUID: String,
+        imageBase64: String,
+        config: String?,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("recognizeNutritionFactsLabel", connectionUUID, promise) { connection ->
+            val configObject = config?.let { parseNutritionFactsLabelRecognitionConfig(it) }
+
+            val result = connection.recognizeNutritionFactsLabel(
+                imageBase64 = imageBase64,
+                config = configObject
+            )
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    private fun parseNutritionFactsLabelRecognitionConfig(json: String): NutritionFactsLabelRecognitionConfig? {
+        return try {
+            NutritionFactsLabelRecognitionConfigUtils.fromValue(json)
+        } catch (e: Exception) {
+            Log.e("SpikeSdkModule", "Error parsing NutritionFactsLabelRecognitionConfig: ${e.message}")
+            null
+        }
+    }
+
+    @ReactMethod
+    fun createNutritionRecord(
+        connectionUUID: String,
+        nutritionRecord: String,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("createNutritionRecord", connectionUUID, promise) { connection ->
+            val recordObject = parseNutritionRecord(nutritionRecord)
+                ?: throw SpikeExceptions.SpikeException("Failed to parse nutrition record")
+
+            val result = connection.createNutritionRecord(recordObject)
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    @ReactMethod
+    fun replaceNutritionRecord(
+        connectionUUID: String,
+        nutritionRecord: String,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("replaceNutritionRecord", connectionUUID, promise) { connection ->
+            val recordObject = parseNutritionRecord(nutritionRecord)
+                ?: throw SpikeExceptions.SpikeException("Failed to parse nutrition record")
+
+            val result = connection.replaceNutritionRecord(recordObject)
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    private fun parseNutritionRecord(json: String): NutritionRecord? {
+        return try {
+            NutritionRecordUtils.fromValue(json)
+        } catch (e: Exception) {
+            Log.e("SpikeSdkModule", "Error parsing NutritionRecord: ${e.message}")
+            null
+        }
+    }
 
 }
 

package/ios/SpikeSdk.m

@@ -196,4 +196,58 @@ RCT_EXTERN_METHOD(isHealthKitIntegrationEnabled: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
+// MARK: Nutrition AI
+
+RCT_EXTERN_METHOD(analyzeNutrition: (NSString)connectionUUID
+                  imageBase64: (NSString)imageBase64
+                  consumedAt: (NSString)consumedAt
+                  config: (NSString)config
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(submitNutritionForAnalysis: (NSString)connectionUUID
+                  imageBase64: (NSString)imageBase64
+                  consumedAt: (NSString)consumedAt
+                  config: (NSString)config
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getNutritionRecords: (NSString)connectionUUID
+                  from: (NSString)from
+                  to: (NSString)to
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getNutritionRecord: (NSString)connectionUUID
+                  recordId: (NSString)recordId
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(deleteNutritionRecord: (NSString)connectionUUID
+                  recordId: (NSString)recordId
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(updateNutritionRecordServingSize: (NSString)connectionUUID
+                  recordId: (NSString)recordId
+                  servingSize: (double)servingSize
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(recognizeNutritionFactsLabel: (NSString)connectionUUID
+                  imageBase64: (NSString)imageBase64
+                  config: (NSString)config
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(createNutritionRecord: (NSString)connectionUUID
+                  nutritionRecord: (NSString)nutritionRecord
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(replaceNutritionRecord: (NSString)connectionUUID
+                  nutritionRecord: (NSString)nutritionRecord
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
 @end

package/ios/SpikeSdk.swift

@@ -1023,6 +1023,19 @@ class SpikeSdk: RCTEventEmitter {
         return config
     }
     
+    private func makeNutritionalAnalysisConfig(fromString string: String?) throws -> NutritionalAnalysisConfig? {
+        guard let string else {
+            return nil
+        }
+        guard let data = string.data(using: .utf8) else {
+            throw SpikeDataDecodingException()
+        }
+        let decoder = SpikeSDK.JSONDecoder.spikeDefaultJsonDecoder
+        let config = try decoder.decode(NutritionalAnalysisConfig.self, from: data)
+        
+        return config
+    }
+    
     @objc(getUserProperties:withMetrics:withResolver:withRejecter:)
     func getUserProperties(
         connectionUUID: String,
@@ -1099,4 +1112,359 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
     
+    // MARK: - Nutrition AI
+    
+    @objc(analyzeNutrition:
+            imageBase64:
+            consumedAt:
+            config:
+            withResolver:
+            withRejecter:)
+    func analyzeNutrition(
+        connectionUUID: String,
+        imageBase64: String,
+        consumedAt: String?,
+        config: String?,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                let consumedAtDate = try consumedAt != nil ? makeDate(fromString: consumedAt!) : nil
+                let configObject = try makeNutritionalAnalysisConfig(fromString: config)
+                
+                let result = try await connection.analyzeNutrition(
+                    imageBase64: imageBase64,
+                    consumedAt: consumedAtDate,
+                    config: configObject
+                )
+                
+                let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
+                let jsonResult = try encoder.encode(result)
+                let stringResult = String(data: jsonResult, encoding: .utf8)
+                
+                resolve(stringResult)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(submitNutritionForAnalysis:
+            imageBase64:
+            consumedAt:
+            config:
+            withResolver:
+            withRejecter:)
+    func submitNutritionForAnalysis(
+        connectionUUID: String,
+        imageBase64: String,
+        consumedAt: String?,
+        config: String?,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                let consumedAtDate = try consumedAt != nil ? makeDate(fromString: consumedAt!) : nil
+                let configObject = try makeNutritionalAnalysisConfig(fromString: config)
+                
+                let result = try await connection.submitNutritionForAnalysis(
+                    imageBase64: imageBase64,
+                    consumedAt: consumedAtDate,
+                    config: configObject
+                )
+                
+                resolve(result.uuidString)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(getNutritionRecords:
+            from:
+            to:
+            withResolver:
+            withRejecter:)
+    func getNutritionRecords(
+        connectionUUID: String,
+        from: String,
+        to: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                let dateFrom = try makeDate(fromString: from)
+                let dateTo = try makeDate(fromString: to)
+                
+                let result = try await connection.getNutritionRecords(
+                    from: dateFrom,
+                    to: dateTo
+                )
+                
+                let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
+                let jsonResult = try encoder.encode(result)
+                let stringResult = String(data: jsonResult, encoding: .utf8)
+                
+                resolve(stringResult)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(getNutritionRecord:
+            recordId:
+            withResolver:
+            withRejecter:)
+    func getNutritionRecord(
+        connectionUUID: String,
+        recordId: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                guard let uuid = UUID(uuidString: recordId) else {
+                    throw SpikeDataDecodingException()
+                }
+                
+                let result = try await connection.getNutritionRecord(id: uuid)
+                
+                if let result = result {
+                    let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
+                    let jsonResult = try encoder.encode(result)
+                    let stringResult = String(data: jsonResult, encoding: .utf8)
+                    resolve(stringResult)
+                } else {
+                    resolve(nil)
+                }
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(deleteNutritionRecord:
+            recordId:
+            withResolver:
+            withRejecter:)
+    func deleteNutritionRecord(
+        connectionUUID: String,
+        recordId: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                guard let uuid = UUID(uuidString: recordId) else {
+                    throw SpikeDataDecodingException()
+                }
+                
+                try await connection.deleteNutritionRecord(id: uuid)
+                
+                resolve(Void())
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(updateNutritionRecordServingSize:
+            recordId:
+            servingSize:
+            withResolver:
+            withRejecter:)
+    func updateNutritionRecordServingSize(
+        connectionUUID: String,
+        recordId: String,
+        servingSize: Double,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                guard let uuid = UUID(uuidString: recordId) else {
+                    throw SpikeDataDecodingException()
+                }
+                
+                let result = try await connection.updateNutritionRecordServingSize(
+                    id: uuid,
+                    servingSize: servingSize
+                )
+                
+                let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
+                let jsonResult = try encoder.encode(result)
+                let stringResult = String(data: jsonResult, encoding: .utf8)
+                
+                resolve(stringResult)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(recognizeNutritionFactsLabel:
+            imageBase64:
+            config:
+            withResolver:
+            withRejecter:)
+    func recognizeNutritionFactsLabel(
+        connectionUUID: String,
+        imageBase64: String,
+        config: String?,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                let configObject = try makeNutritionFactsLabelRecognitionConfig(fromString: config)
+                
+                let result = try await connection.recognizeNutritionFactsLabel(
+                    imageBase64: imageBase64,
+                    config: configObject
+                )
+                
+                let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
+                let jsonResult = try encoder.encode(result)
+                let stringResult = String(data: jsonResult, encoding: .utf8)
+                
+                resolve(stringResult)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(createNutritionRecord:
+            nutritionRecord:
+            withResolver:
+            withRejecter:)
+    func createNutritionRecord(
+        connectionUUID: String,
+        nutritionRecord: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                guard let recordObject = try makeNutritionRecord(fromString: nutritionRecord) else {
+                    throw SpikeDataDecodingException()
+                }
+                
+                let result = try await connection.createNutritionRecord(recordObject)
+                
+                let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
+                let jsonResult = try encoder.encode(result)
+                let stringResult = String(data: jsonResult, encoding: .utf8)
+                
+                resolve(stringResult)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    @objc(replaceNutritionRecord:
+            nutritionRecord:
+            withResolver:
+            withRejecter:)
+    func replaceNutritionRecord(
+        connectionUUID: String,
+        nutritionRecord: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                
+                guard let recordObject = try makeNutritionRecord(fromString: nutritionRecord) else {
+                    throw SpikeDataDecodingException()
+                }
+                
+                let result = try await connection.replaceNutritionRecord(recordObject)
+                
+                let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
+                let jsonResult = try encoder.encode(result)
+                let stringResult = String(data: jsonResult, encoding: .utf8)
+                
+                resolve(stringResult)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
+    private func makeNutritionFactsLabelRecognitionConfig(fromString string: String?) throws -> NutritionFactsLabelRecognitionConfig? {
+        guard let string else {
+            return nil
+        }
+        guard let data = string.data(using: .utf8) else {
+            throw SpikeDataDecodingException()
+        }
+        let decoder = SpikeSDK.JSONDecoder.spikeDefaultJsonDecoder
+        let config = try decoder.decode(NutritionFactsLabelRecognitionConfig.self, from: data)
+        
+        return config
+    }
+    
+    private func makeNutritionRecord(fromString string: String?) throws -> NutritionRecord? {
+        guard let string else {
+            return nil
+        }
+        guard let data = string.data(using: .utf8) else {
+            throw SpikeDataDecodingException()
+        }
+        let decoder = SpikeSDK.JSONDecoder.spikeDefaultJsonDecoder
+        let record = try decoder.decode(NutritionRecord.self, from: data)
+        
+        return record
+    }
+    
 }