react-native-spike-sdk 4.5.23 → 4.7.13

package/ios/SpikeSdk.swift

@@ -1,5 +1,7 @@
 import Foundation
+import BackgroundTasks
 import SpikeSDK
+import SwiftUI
 import React
 
 @objc(SpikeSdk)
@@ -13,79 +15,9 @@ class SpikeSdk: RCTEventEmitter {
         super.init()
     }
     
-    // MARK: - Connections dictionary
-    
-    /// Do not use this directly, use `addConnection` and `getConnection` instead
-    private var _connections: [String: SpikeConnection] = [:]
-    private let queue = DispatchQueue(label: "com.spike.rn.SpikeSdk.connections")
-    
-    /// Add new connection to the dictionary in a thread-safe manner
-    private func addConnection(_ connection: SpikeConnection, withUUID uuid: String) {
-        queue.sync {
-            _connections[uuid] = connection
-        }
-    }
-    
-    /// Synchronised read for safe multithreaded usage
-    private func getConnection(withUUID uuid: String) -> SpikeConnection? {
-        queue.sync {
-            _connections[uuid]
-        }
-    }
-    
     // MARK: - Spike SDK level
-        
-    @objc(createConnection:
-            withAppId:
-            withAuthToken:
-            withCustomerEndUserId:
-            withCallbackUrl:
-            withUseLogger:
-            withResolver:withRejecter:)
-    func createConnection(uuid: String,
-                          appId: String,
-                          authToken: String,
-                          customerEndUserId: String,
-                          callbackUrl: String?,
-                          useLogger: Bool,
-                          resolve: @escaping RCTPromiseResolveBlock,
-                          reject: @escaping RCTPromiseRejectBlock) {
-        Task {
-            do {
-                let logger = useLogger ? self.createLogger(connectionUUID: uuid) : nil
-                let spikeConnection = try await Spike.createConnection(
-                    appId: appId,
-                    authToken: authToken,
-                    customerEndUserId: customerEndUserId,
-                    callbackUrl: callbackUrl != nil ? URL(string: callbackUrl!) : nil,
-                    logger: logger)
-                addConnection(spikeConnection, withUUID: uuid)
-                resolve(Void())
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(getBackgroundConnections:
-            withRejecter:)
-    func getBackgroundConnections(resolve: @escaping RCTPromiseResolveBlock,
-                                  reject: @escaping RCTPromiseRejectBlock) {
-        Task {
-            do {
-                let spikeConnections = try await Spike.getBackgroundConnections()
-                var connectionsUUIDs: [String] = []
-                for connection in spikeConnections {
-                    let uuid = UUID().uuidString
-                    addConnection(connection, withUUID: uuid)
-                    connectionsUUIDs.append(uuid)
-                }
-                resolve(connectionsUUIDs)
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
+
+    private let queue = DispatchQueue(label: "com.spike.rn.SpikeSdk.connections")
 
     @objc(isHealthDataAvailable:
             withRejecter:)
@@ -96,359 +28,17 @@ class SpikeSdk: RCTEventEmitter {
             resolve(isAvailable)
         }
     }
-    
-    @objc(ensurePermissionsAreGranted:
-            withResolver:
-            withRejecter:)
-    func ensurePermissionsAreGranted(permissions: [String],
-                                     resolve: @escaping RCTPromiseResolveBlock,
-                                     reject: @escaping RCTPromiseRejectBlock) {
-        Task {
-            do {
-                let dataTypes = permissions.map { SpikeDataTypeMapper.mapDataType($0) }
-                try await Spike.ensurePermissionsAreGranted(permissions: dataTypes)
-                resolve(Void())
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    // MARK: SpikeConnection level
-    
-    @objc(getAppId:
-            withResolver:
-            withRejecter:)
-    func getAppId(connectionUUID: String,
-                  resolve: @escaping RCTPromiseResolveBlock,
-                  reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getAppId()
-            resolve(value)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(getSpikeEndUserId:
-            withResolver:
-            withRejecter:)
-    func getSpikeEndUserId(connectionUUID: String,
-                           resolve: @escaping RCTPromiseResolveBlock,
-                           reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getSpikeEndUserId()
-            resolve(value)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(getCustomerEndUserId:
-            withResolver:
-            withRejecter:)
-    func getCustomerEndUserId(connectionUUID: String,
-                              resolve: @escaping RCTPromiseResolveBlock,
-                              reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getCustomerEndUserId()
-            resolve(value)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(close:
-            withResolver:
-            withRejecter:)
-    func close(connectionUUID: String,
-               resolve: @escaping RCTPromiseResolveBlock,
-               reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            try connection.close()
-            resolve(Void())
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(extractData:
-            withDataType:
-            withResolver:
-            withRejecter:)
-    func extractData(connectionUUID: String,
-                     dataType: String,
-                     resolve: @escaping RCTPromiseResolveBlock,
-                     reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let result = try await SpikeDataTypeMapper.extractData(dataType,
-                                                                       connection: connection)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(extractDataInRange:
-            withDataType:
-            withFromDateMillis:
-            withToDateMillis:
-            withResolver:
-            withRejecter:)
-    func extractDataInRange(connectionUUID: String,
-                            dataType: String,
-                            fromDateMillis: Double,
-                            toDateMillis: Double,
-                            resolve: @escaping RCTPromiseResolveBlock,
-                            reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let fromDate = Date(timeIntervalSince1970: fromDateMillis/1000)
-                let toDate = Date(timeIntervalSince1970: toDateMillis/1000)
-                let result = try await SpikeDataTypeMapper.extractDataInRange(dataType,
-                                                                              connection: connection,
-                                                                              from: fromDate,
-                                                                              to: toDate)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    // MARK: SpikeWebhookConnection level
-    
-    @objc(getCallbackUrl:
-            withResolver:
-            withRejecter:)
-    func getCallbackUrl(connectionUUID: String,
-                        resolve: @escaping RCTPromiseResolveBlock,
-                        reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getCallbackUrl()
-            resolve(value.absoluteString)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(extractAndPostData:
-            withDataType:
-            withResolver:
-            withRejecter:)
-    func extractAndPostData(connectionUUID: String,
-                            dataType: String,
-                            resolve: @escaping RCTPromiseResolveBlock,
-                            reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let result = try await SpikeDataTypeMapper.extractAndPostData(dataType,
-                                                                              connection: connection)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(extractAndPostDataInRange:
-            withDataType:
-            withFromDateMillis:
-            withToDateMillis:
-            withResolver:
-            withRejecter:)
-    func extractAndPostDataInRange(connectionUUID: String,
-                                   dataType: String,
-                                   fromDateMillis: Double,
-                                   toDateMillis: Double,
-                                   resolve: @escaping RCTPromiseResolveBlock,
-                                   reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let fromDate = Date(timeIntervalSince1970: fromDateMillis/1000)
-                let toDate = Date(timeIntervalSince1970: toDateMillis/1000)
-                let result = try await SpikeDataTypeMapper.extractAndPostDataInRange(dataType,
-                                                                                     connection: connection,
-                                                                                     from: fromDate,
-                                                                                     to: toDate)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(enableBackgroundDelivery:
-            withDataTypes:
-            withResolver:
-            withRejecter:)
-    func enableBackgroundDelivery(connectionUUID: String,
-                                  dataTypes: [String],
-                                  resolve: @escaping RCTPromiseResolveBlock,
-                                  reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let types = dataTypes.map { SpikeDataTypeMapper.mapDataType($0) }
-                try await connection.enableBackgroundDelivery(dataTypes: types)
-                resolve(Void())
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(getBackgroundDeliveryDataTypes:
-            withResolver:
-            withRejecter:)
-    func getBackgroundDeliveryDataTypes(connectionUUID: String,
-                                        resolve: @escaping RCTPromiseResolveBlock,
-                                        reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let dataTypes = try await connection.getBackgroundDeliveryDataTypes()
-                let dataTypesString = dataTypes.map { SpikeDataTypeMapper.mapDataTypeToString($0) }
-                resolve(dataTypesString)
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(setListener:
-            withResolver:
-            withRejecter:)
-    func setListener(connectionUUID: String,
-                     resolve: @escaping RCTPromiseResolveBlock,
-                     reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let listener = createListener(connectionUUID: connectionUUID)
-            try connection.setListener(listener: listener)
-            resolve(Void())
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
+
     // MARK: Supported events
-    
+
     override func supportedEvents() -> [String]! {
         return [
-            "onDebug",
-            "onInfo",
-            "onError",
-            "onBackgroundLog",
             "onSdkLog",
         ]
     }
-    
-    // MARK: Private methods
-    
-    private func createLogger(connectionUUID: String) -> SpikeLogger {
-        return SpikeConnectionLogger(connectionUUID: connectionUUID) { [weak self] connectionUUID, level, message in
-            let body = [
-                "connectionUUID": connectionUUID,
-                "message": message
-            ]
-            switch level {
-            case .debug:
-                self?.sendEvent(withName: "onDebug", body: body)
-            case .info:
-                self?.sendEvent(withName: "onInfo", body: body)
-            case .error:
-                self?.sendEvent(withName: "onError", body: body)
-            }
-        }
-    }
 
-    private func createListener(connectionUUID: String) -> SpikeBackgroundDeliveriesLogger {
-        return SpikeConnectionListener(connectionUUID: connectionUUID) { [weak self] connectionUUID, log in
-            let body = [
-                "connectionUUID": connectionUUID,
-                "log": log
-            ]
-            self?.sendEvent(withName: "onBackgroundLog", body: body)
-        }
-    }
+    // MARK: Private methods
 
-    
     private func spikeReject(with error: Error, reject: RCTPromiseRejectBlock) {
         let message = (error as? SpikeException)?.description
         reject(
@@ -476,6 +66,12 @@ class SpikeSdk: RCTEventEmitter {
             _connectionsV3[uuid]
         }
     }
+    
+    private func removeConnectionV3(withUUID uuid: String) {
+        queue.sync {
+            _connectionsV3.removeValue(forKey: uuid)
+        }
+    }
 
     // SpikeSDK level
         
@@ -505,6 +101,29 @@ class SpikeSdk: RCTEventEmitter {
             }
         }
     }
+    
+    @objc(closeV3:
+            withResolver:
+            withRejecter:)
+    func closeV3(
+        connectionUUID: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                try await connection.close()
+                removeConnectionV3(withUUID: connectionUUID)
+                resolve(Void())
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
         
     @objc(createConnectionAPIv3Legacy:
             withAppId:
@@ -567,6 +186,7 @@ class SpikeSdk: RCTEventEmitter {
         metrics:
         activityConfigs:
         sleepConfigs:
+        nutritionalFields:
         withResolver:
         withRejecter:)
     func requestPermissionsFromHealthKit(
@@ -575,6 +195,7 @@ class SpikeSdk: RCTEventEmitter {
         forMetrics metrics: [String],
         forActivityConfigs activityConfigs: [String],
         forSleepConfigs sleepConfigs: [String],
+        nutritionalFields: [String],
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
@@ -596,12 +217,16 @@ class SpikeSdk: RCTEventEmitter {
                 let sleepConfigsObjects = sleepConfigs.compactMap {
                      try? makeSleepConfig(fromString: $0)
                  }
+                let nutritionFieldsObjects = nutritionalFields.compactMap {
+                    NutritionalField(rawValue: $0)
+                }
                 
                 try await connection.requestPermissionsFromHealthKit(
                     forStatistics: stats,
                     forMetrics: metricsObjects,
                     forActivities: activityConfigsObjects,
-                    forSleep: sleepConfigsObjects
+                    forSleep: sleepConfigsObjects,
+                    forNutrition: nutritionFieldsObjects
                 )
                 
                 resolve(Void())
@@ -616,6 +241,7 @@ class SpikeSdk: RCTEventEmitter {
         metrics:
         activityConfigs:
         sleepConfigs:
+        nutritionalFields:
         days:
         withResolver:
         withRejecter:)
@@ -625,6 +251,7 @@ class SpikeSdk: RCTEventEmitter {
         metrics: [String],
         activityConfigs: [String],
         sleepConfigs: [String],
+        nutritionalFields: [String],
         days: String?,
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
@@ -647,6 +274,9 @@ class SpikeSdk: RCTEventEmitter {
                 let sleepConfigsObjects = sleepConfigs.compactMap {
                     try? makeSleepConfig(fromString: $0)
                 }
+                let nutritionFieldsObjects = nutritionalFields.compactMap {
+                    NutritionalField(rawValue: $0)
+                }
                 
                 let daysValue: Int? = days != nil ? Int(days!) : nil
                 try await connection.requestPermissionsFromHealthKitAndBackfill(
@@ -654,6 +284,7 @@ class SpikeSdk: RCTEventEmitter {
                     forMetrics: metricsObjects,
                     forActivities: activityConfigsObjects,
                     forSleep: sleepConfigsObjects,
+                    forNutrition: nutritionFieldsObjects,
                     backfillDays: daysValue
                 )
                 
@@ -916,6 +547,7 @@ class SpikeSdk: RCTEventEmitter {
             metrics:
             activityConfigs:
             sleepConfigs:
+            nutritionalFields:
             withResolver:
             withRejecter:)
     func enableBackgroundDeliveryV3(
@@ -924,6 +556,7 @@ class SpikeSdk: RCTEventEmitter {
         metrics: [String],
         activityConfigs: [String],
         sleepConfigs: [String],
+        nutritionalFields: [String],
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
@@ -946,12 +579,16 @@ class SpikeSdk: RCTEventEmitter {
                 let sleepConfigsObjects = sleepConfigs.compactMap {
                     try? makeSleepConfig(fromString: $0)
                 }
+                let nutritionFieldsObjects = nutritionalFields.compactMap {
+                    NutritionalField(rawValue: $0)
+                }
                 
                 try await connection.enableBackgroundDelivery(
                     forStatistics: stats,
                     forMetrics: metricsObjects,
                     forActivities: activityConfigsObjects,
-                    forSleep: sleepConfigsObjects
+                    forSleep: sleepConfigsObjects,
+                    forNutrition: nutritionFieldsObjects
                 )
                 
                 resolve(true)
@@ -966,6 +603,7 @@ class SpikeSdk: RCTEventEmitter {
             metrics:
             activityConfigs:
             sleepConfigs:
+            nutritionalFields:
             days:
             withResolver:
             withRejecter:)
@@ -975,6 +613,7 @@ class SpikeSdk: RCTEventEmitter {
         metrics: [String],
         activityConfigs: [String],
         sleepConfigs: [String],
+        nutritionalFields: [String],
         days: String?,
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
@@ -997,6 +636,9 @@ class SpikeSdk: RCTEventEmitter {
                 let sleepConfigsObjects = sleepConfigs.compactMap {
                     try? makeSleepConfig(fromString: $0)
                 }
+                let nutritionFieldsObjects = nutritionalFields.compactMap {
+                    NutritionalField(rawValue: $0)
+                }
                 
                 let daysValue: Int? = days != nil ? Int(days!) : nil
                 try await connection.backfill(
@@ -1004,6 +646,7 @@ class SpikeSdk: RCTEventEmitter {
                     forMetrics: metricsObjects,
                     forActivities: activityConfigsObjects,
                     forSleep: sleepConfigsObjects,
+                    forNutrition: nutritionFieldsObjects,
                     days: daysValue
                 )
                 

package/lib/commonjs/Spike.js

@@ -3,9 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.setLogCallback = exports.isPackageInstalled = exports.isHealthDataAvailable = exports.getBackgroundConnections = exports.ensurePermissionsAreGranted = exports.createConnectionAPIv3Legacy = exports.createConnectionAPIv3 = exports.createConnection = void 0;
+exports.setLogCallback = exports.isPackageInstalled = exports.isHealthDataAvailable = exports.createConnectionAPIv3Legacy = exports.createConnectionAPIv3 = void 0;
 var _reactNative = require("react-native");
-var _SpikeConnection = require("./SpikeConnection");
 var _SpikeException = require("./SpikeException");
 var _SpikeSdk = require("./SpikeSdk");
 var _SpikeRNConnectionAPIv = require("./v3/SpikeRNConnectionAPIv3");
@@ -13,58 +12,6 @@ var _version = require("./version");
 /**
  * @ignore
  */
-
-/**
- * @deprecated Use createConnectionAPIv3 instead. See https://docs.spikeapi.com/sdk-docs/react-native/usage-guide
- * @ignore
- */
-const createConnection = async (config, logger) => {
-  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
-  try {
-    const connectionUUID = generateUUID();
-    const spikeConnection = new _SpikeConnection.SpikeConnection(connectionUUID, logger);
-    await _SpikeSdk.SpikeSdk.createConnection(connectionUUID, config.appId, config.authToken, config.customerEndUserId, config.callbackUrl ?? null, !!logger);
-    return spikeConnection;
-  } catch (error) {
-    throw (0, _SpikeException.unwrapSpikeException)(error);
-  }
-};
-
-/**
- * @deprecated Deprecated
- * @ignore
- */
-exports.createConnection = createConnection;
-const getBackgroundConnections = async () => {
-  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
-  try {
-    const connectionUUIDs = await _SpikeSdk.SpikeSdk.getBackgroundConnections();
-    const connections = connectionUUIDs.map(uuid => new _SpikeConnection.SpikeConnection(uuid));
-    return connections;
-  } catch (error) {
-    throw (0, _SpikeException.unwrapSpikeException)(error);
-  }
-};
-
-/**
- * @deprecated Deprecated
- * @ignore
- */
-exports.getBackgroundConnections = getBackgroundConnections;
-const ensurePermissionsAreGranted = async permissions => {
-  if (_reactNative.Platform.OS !== 'ios') return;
-  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
-  try {
-    await _SpikeSdk.SpikeSdk.ensurePermissionsAreGranted(permissions.map(permissionType => permissionType.rawValue));
-  } catch (error) {
-    throw (0, _SpikeException.unwrapSpikeException)(error);
-  }
-};
-
-/**
- * @ignore
- */
-exports.ensurePermissionsAreGranted = ensurePermissionsAreGranted;
 const isPackageInstalled = async () => {
   if (_reactNative.Platform.OS !== 'android') return true;
   if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
@@ -196,13 +143,10 @@ exports.createConnectionAPIv3Legacy = createConnectionAPIv3Legacy;
 const setLogCallback = async callback => {
   if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException("No SpikeSDK found");
   try {
-    // Set up event listener for both iOS and Android
     const eventEmitter = new _reactNative.NativeEventEmitter(_SpikeSdk.SpikeSdk);
     const subscription = eventEmitter.addListener('onSdkLog', event => {
       callback(event.level, event.message);
     });
-
-    // Store subscription for potential cleanup
     _SpikeSdk.SpikeSdk._logSubscription = subscription;
     await _SpikeSdk.SpikeSdk.setLogCallback(callback);
   } catch (error) {