@infilectorg/infiviz-shots-react-sdk 1.0.52 → 1.0.53

package/ios/InfivizShotsReactSdk.swift

@@ -12,339 +12,313 @@ import React
 
 @objc(InfivizShotsReactSdk)
 class InfivizShotsReactSdk:  RCTEventEmitter {
-    @objc
-    override static func moduleName() -> String! {
-        return "InfivizShotsReactSdk"
-    }
-    
-    @objc
-    override static func requiresMainQueueSetup() -> Bool {
-        return false
-    }
-    
-    // MARK: – RCTEventEmitter Boilerplate
-    
-    private var hasListeners = false
-    
-    // 3. List of events that JS can subscribe to:
-    override func supportedEvents() -> [String]! {
-        return [
-            "SyncEvent",
-            "ActionsGeneratedEvent",
-            "SessionRealTimeResultEvent"]
-    }
-    
-    // 4. Only send events if JS has at least one listener:
-    override func startObserving() {
-        hasListeners = true
-        
-        NotificationCenter.default.addObserver(self,
-                                               selector: #selector(handleActionsGeneratedEvent(_:)),
-                                               name: NSNotification.Name("ActionsGeneratedEvent"),
-                                               object: nil)
+ @objc
+     override static func moduleName() -> String! {
+         return "InfivizShotsReactSdk"
+     }
+
+     @objc
+     override static func requiresMainQueueSetup() -> Bool {
+         return false
+       }
+
+       // MARK: – RCTEventEmitter Boilerplate
+
+       private var hasListeners = false
+
+       // 3. List of events that JS can subscribe to:
+       override func supportedEvents() -> [String]! {
+         return [
+           "SyncEvent",
+           "ActionsGeneratedEvent",
+           "SessionRealTimeResultEvent"]
+       }
+
+        // 4. Only send events if JS has at least one listener:
+       override func startObserving() {
+         hasListeners = true
+
         NotificationCenter.default.addObserver(self,
-                                               selector: #selector(handleSessionRealTimeResultEvent(_:)),
-                                               name: NSNotification.Name("SessionRealTimeResultEvent"),
-                                               object: nil)
-        
-    }
-    
-    override func stopObserving() {
-        hasListeners = false
-        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("ActionsGeneratedEvent"), object: nil)
-        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("SessionRealTimeResultEvent"), object: nil)
-    }
-    
-    // 5. If you have no constants to export, just return empty:
-    override func constantsToExport() -> [AnyHashable: Any]! {
-        return [:]
-    }
-    
-    
-    var activity: InfivizShotsActivity?
-    
-    // MARK: –––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
-    // MARK: – Helper Methods (not directly exposed to JS)
-    
-    
-    // MARK: - Universal Session ID
-    @objc
-    func fetchUniversalSessionId(_ tempID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        InfivizShotsSDK.shared.fetchUniversalSessionId(temporarySessionID: tempID as String, completion: { sessionID, error in
-            if let id = sessionID {
-                resolve(id)
-            } else {
-                reject("FETCH_SESSION_ID_ERROR", "Session not found", nil)
-            }
-        })
-    }
-    
-    @objc
-    func syncSession(_ sessionId: NSString) {
-        // Kick off the upload. No resolver/rejecter—just emit events once it’s done.
-        InfivizShotsSDK.shared.uploadSession(temporarySessionID: sessionId as String) { result in
-            switch result {
-            case .success(let response):
-                if self.hasListeners {
-                    let payload: [String: Any] = [
-                        "status": "200",
-                        "universalSessionID": response,
-                        "temporarySessionID": sessionId as String
-                    ]
-                    self.sendEvent(withName: "SyncEvent", body: payload)
-                }
-            case .failure(let error):
-                if self.hasListeners {
-                    let payload: [String: Any] = [
-                        "status": "400",
-                        "message": error.localizedDescription,
-                        "temporarySessionID": sessionId as String
-                    ]
-                    self.sendEvent(withName: "SyncEvent", body: payload)
-                }
-            }
-        }
-    }
-    
-    // MARK: - Sync Multiple Sessions
-    /// Bridge to InfivizShotsSDK.shared.syncSessions(temporarySessionIDs:completionHandler:)
-    
-    @objc
-    func uploadSession(temporarySessionIDs: NSArray) {
+                     selector: #selector(handleActionsGeneratedEvent(_:)),
+                     name: NSNotification.Name("ActionsGeneratedEvent"),
+                     object: nil)
+         NotificationCenter.default.addObserver(self,
+                     selector: #selector(handleSessionRealTimeResultEvent(_:)),
+                     name: NSNotification.Name("SessionRealTimeResultEvent"),
+                     object: nil)
+
+       }
+
+       override func stopObserving() {
+         hasListeners = false
+         NotificationCenter.default.removeObserver(self, name: NSNotification.Name("ActionsGeneratedEvent"), object: nil)
+         NotificationCenter.default.removeObserver(self, name: NSNotification.Name("SessionRealTimeResultEvent"), object: nil)
+       }
+
+       // 5. If you have no constants to export, just return empty:
+       override func constantsToExport() -> [AnyHashable: Any]! {
+         return [:]
+       }
+
+
+     var activity: InfivizShotsActivity?
+
+      // MARK: –––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
+       // MARK: – Helper Methods (not directly exposed to JS)
+
+
+       // MARK: - Universal Session ID
+       @objc
+       func fetchUniversalSessionId(_ tempID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+         InfivizShotsSDK.shared.fetchUniversalSessionId(temporarySessionID: tempID as String, completion: { sessionID, error in
+           if let id = sessionID {
+             resolve(id)
+           } else {
+             reject("FETCH_SESSION_ID_ERROR", "Session not found", nil)
+           }
+         })
+       }
+
+     @objc
+       func syncSession(_ sessionId: NSString) {
+         // Kick off the upload. No resolver/rejecter—just emit events once it’s done.
+         InfivizShotsSDK.shared.uploadSession(temporarySessionID: sessionId as String) { result in
+           switch result {
+           case .success(let response):
+             if self.hasListeners {
+               let payload: [String: Any] = [
+                 "status": "200",
+                 "universalSessionID": response,
+                 "temporarySessionID": sessionId as String
+               ]
+               self.sendEvent(withName: "SyncEvent", body: payload)
+             }
+           case .failure(let error):
+             if self.hasListeners {
+               let payload: [String: Any] = [
+                 "status": "400",
+                 "message": error.localizedDescription,
+                 "temporarySessionID": sessionId as String
+               ]
+               self.sendEvent(withName: "SyncEvent", body: payload)
+             }
+           }
+         }
+       }
+
+      // MARK: - Sync Multiple Sessions
+      /// Bridge to InfivizShotsSDK.shared.syncSessions(temporarySessionIDs:completionHandler:)
+
+      @objc
+      func uploadSession(temporarySessionIDs: NSArray) {
         var ids: [String] = []
         if let arr = temporarySessionIDs as? [String] {
-            ids = arr
+          ids = arr
         } else if let arr = temporarySessionIDs as? [NSString] {
-            ids = arr.map { $0 as String }
+          ids = arr.map { $0 as String }
         }
-        
+
         guard !ids.isEmpty else { return }
-        
+
         InfivizShotsSDK.shared.syncSessions(temporarySessionIDs: ids) { sessionId, result in
-            switch result {
-            case .success(let message):
-                if self.hasListeners {
-                    let payload: [String: Any] = [
-                        "status": "200",
-                        "universalSessionID": message,
-                        "temporarySessionID": sessionId
-                    ]
-                    self.sendEvent(withName: "SyncEvent", body: payload)
-                }
-            case .failure(let error):
-                if self.hasListeners {
-                    let payload: [String: Any] = [
-                        "status": "400",
-                        "universalSessionID": error,
-                        "temporarySessionID": sessionId
-                    ]
-                    self.sendEvent(withName: "SyncEvent", body: payload)
-                }
+          switch result {
+          case .success(let message):
+            if self.hasListeners {
+              let payload: [String: Any] = [
+                "status": "200",
+                "universalSessionID": message,
+                "temporarySessionID": sessionId
+              ]
+              self.sendEvent(withName: "SyncEvent", body: payload)
             }
+          case .failure(let error):
+            if self.hasListeners {
+              let payload: [String: Any] = [
+                "status": "400",
+                "universalSessionID": error,
+                "temporarySessionID": sessionId
+              ]
+              self.sendEvent(withName: "SyncEvent", body: payload)
+            }
+          }
         }
-    }
-    
-    // MARK: - Get Session Result
-    
+      }
+       
+       // MARK: - Get Session Result
+
     @objc
     func getSessionStatus(
-        _ temporarySessionID: NSString,
-        resolver resolve: @escaping RCTPromiseResolveBlock,
-        rejecter reject: @escaping RCTPromiseRejectBlock
+      _ temporarySessionID: NSString,
+      resolver resolve: @escaping RCTPromiseResolveBlock,
+      rejecter reject: @escaping RCTPromiseRejectBlock
     ) {
-        InfivizShotsSDK.shared.checkState(sessionID: temporarySessionID as String) { result in
-            switch result {
-            case .success(let response):
-                let json = ["sessionId": temporarySessionID,
-                            "status": response]
-                
-                if let jsonData = try? JSONSerialization.data(withJSONObject: json, options: []) {
-                    let jsonString = String(data: jsonData, encoding: .utf8)
-                    resolve(jsonString)
-                }
-                
-            case .failure(let error):
-                reject(
-                    "RESULT_FAILED",
-                    "Failed to get result for \(temporarySessionID): \(error.localizedDescription)",
-                    nil
-                )
-            }
-        }
-    }
-    
-    // MARK: - Sync All Data
-    @objc
-    func syncAllData(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        InfivizShotsSDK.shared.syncAllData { result in
-            switch result {
-            case .success(let message):
-                resolve(message)
-            case .failure(let error):
-                reject("SYNC_FAILED", "Sync failed: \(error)", nil)
-            }
-        }
-    }
-    
-    // MARK: - Fetch Session Details
-    @objc
-    func fetchSessionDetails(_ temporarySessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        InfivizShotsSDK.shared.fetchSessionDetails(temporarySessionID: temporarySessionID as String) {  result in
-            switch result {
-            case .success(let value):
-                // Convert any value to a clean dictionary that handles Optionals properly
-                let cleanDict = self.convertToCleanDictionary(value)
-                print(value)
-                // Return the dictionary directly instead of JSON string
-                resolve(cleanDict)
-            case .failure(let error):
-                reject("RESULT_FAILED", "Failed to get result: \(error)", nil)
-            }
-        }
-    }
-    
-    // MARK: - Convert Any to Clean Dictionary
-    private func convertToCleanDictionary(_ value: Any) -> [String: Any] {
-        if let dict = value as? [String: Any] {
-            return cleanDictionary(dict)
-        } else {
-            let mirror = Mirror(reflecting: value)
-            var result: [String: Any] = [:]
-            
-            for child in mirror.children {
-                if let label = child.label {
-                    result[label] = unwrapOptional(child.value)
-                }
-            }
-            return result
-        }
-    }
-
-    // MARK: - Recursively Clean Dictionary
-    private func cleanDictionary(_ dict: [String: Any]) -> [String: Any] {
-        var cleaned: [String: Any] = [:]
-        for (key, value) in dict {
-            cleaned[key] = unwrapOptional(value)
-        }
-        return cleaned
-    }
-
-    // MARK: - Unwrap Optionals and Flatten SDK Values
-    private func unwrapOptional(_ value: Any) -> Any {
-        // 1. Handle Optional
-        let mirror = Mirror(reflecting: value)
-        if mirror.displayStyle == .optional {
-            if let unwrapped = mirror.children.first?.value {
-                return unwrapOptional(unwrapped)
-            } else {
-                return NSNull()
-            }
-        }
+      InfivizShotsSDK.shared.checkState(sessionID: temporarySessionID as String) { result in
+        switch result {
+        case .success(let response):
+            let json = ["sessionId": temporarySessionID,
+                        "status": response]
 
-        // 2. Handle JSONValue directly
-        if let jsonValue = value as? InfivizShotSDK.JSONValue {
-            switch jsonValue {
-            case .string(let str): return str
-            case .bool(let b): return b
-            case .int(let i): return i
-            case .double(let d): return d
-            case .dictionary(let dict):
-                var cleaned: [String: Any] = [:]
-                for (k, v) in dict {
-                    cleaned[k] = unwrapOptional(v)
-                }
-                return cleaned
-            case .array(let arr):
-                return arr.map { unwrapOptional($0) }
-            case .null:
-                return NSNull()
-            @unknown default:
-                return NSNull()
+            if let jsonData = try? JSONSerialization.data(withJSONObject: json, options: []) {
+                let jsonString = String(data: jsonData, encoding: .utf8)
+                resolve(jsonString)
             }
-        }
 
-        // 3. Arrays
-        if let array = value as? [Any] {
-            return array.map { unwrapOptional($0) }
+        case .failure(let error):
+          reject(
+            "RESULT_FAILED",
+            "Failed to get result for \(temporarySessionID): \(error.localizedDescription)",
+            nil
+          )
         }
+      }
+    }
 
-        // 4. Dictionaries
-        if let dict = value as? [String: Any] {
-            var cleaned: [String: Any] = [:]
-            for (k, v) in dict {
-                cleaned[k] = unwrapOptional(v)
-            }
-            return cleaned
-        }
+       // MARK: - Sync All Data
+       @objc
+       func syncAllData(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+         InfivizShotsSDK.shared.syncAllData { result in
+           switch result {
+           case .success(let message):
+             resolve(message)
+           case .failure(let error):
+             reject("SYNC_FAILED", "Sync failed: \(error)", nil)
+           }
+         }
+       }
 
-        // 5. Enum like SessionSyncStateEnum
-        let typeName = String(describing: type(of: value))
-        if typeName.contains("InfivizShotSDK.SessionSyncStateEnum") {
-            return String(describing: value)
-        }
+              // MARK: - Fetch Session Details
+       @objc
+         func fetchSessionDetails(_ temporarySessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+             InfivizShotsSDK.shared.fetchSessionDetails(temporarySessionID: temporarySessionID as String) {  result in
+                 switch result {
+                 case .success(let value):
+                     // Convert any value to a clean dictionary that handles Optionals properly
+                     let cleanDict = self.convertToCleanDictionary(value)
+                     // Return the dictionary directly instead of JSON string
+                     resolve(cleanDict)
+                 case .failure(let error):
+                     reject("RESULT_FAILED", "Failed to get result: \(error)", nil)
+                 }
+             }
+         }
+         
+         // Helper method to convert any value to a clean dictionary that handles Optionals
+         private func convertToCleanDictionary(_ value: Any) -> [String: Any] {
+             if let dict = value as? [String: Any] {
+                 return cleanDictionary(dict)
+             } else {
+                 // Try to convert to dictionary using Mirror reflection
+                 let mirror = Mirror(reflecting: value)
+                 var result: [String: Any] = [:]
+                 
+                 for child in mirror.children {
+                     if let label = child.label {
+                         result[label] = unwrapOptional(child.value)
+                     }
+                 }
+                 return result
+             }
+         }
+         
+         // Recursively clean a dictionary to handle Optionals
+         private func cleanDictionary(_ dict: [String: Any]) -> [String: Any] {
+             var cleaned: [String: Any] = [:]
+             
+             for (key, value) in dict {
+                 cleaned[key] = unwrapOptional(value)
+             }
+             
+             return cleaned
+         }
+         
+         // Unwrap Optional values and clean nested structures
+         private func unwrapOptional(_ value: Any) -> Any {
+             let mirror = Mirror(reflecting: value)
+             
+             // Check if it's an Optional by checking the type name
+             let typeName = String(describing: type(of: value))
+             if typeName.hasPrefix("Optional<") {
+                 if let unwrapped = mirror.children.first?.value {
+                     return unwrapOptional(unwrapped)
+                 } else {
+                     return NSNull() // nil value
+                 }
+             }
+             
+             // Handle arrays
+             if let array = value as? [Any] {
+                 return array.map { unwrapOptional($0) }
+             }
+             
+             // Handle dictionaries
+             if let dict = value as? [String: Any] {
+                 return cleanDictionary(dict)
+             }
+             
+             // Handle Date objects
+             if let date = value as? Date {
+                 let formatter = DateFormatter()
+                 formatter.dateFormat = "yyyy-MM-dd HH:mm:ss Z"
+                 return formatter.string(from: date)
+             }
+             
+             // Handle custom objects (like ImageMetaData) using Mirror reflection
+             // This ensures that objects with optional properties are properly serialized
+             let objectMirror = Mirror(reflecting: value)
+             if !objectMirror.children.isEmpty {
+                 var result: [String: Any] = [:]
+                 for child in objectMirror.children {
+                     if let label = child.label {
+                         result[label] = unwrapOptional(child.value)
+                     }
+                 }
+                 return result
+             }
+             
+             // Return the value as-is if it's a basic type
+             return value
+         }
 
-        // 6. Date
-        if let date = value as? Date {
-            let formatter = DateFormatter()
-            formatter.dateFormat = "yyyy-MM-dd HH:mm:ss Z"
-            return formatter.string(from: date)
-        }
+       // MARK: - Logout
+       @objc
+       func logout(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+         InfivizShotsSDK.shared.callLogoutAPI { result in
+           switch result {
+           case .success(let success):
+             resolve(success)
+           case .failure(let error):
+             reject("LOGOUT_FAILED", "Logout error: \(error)", nil)
+           }
+         }
+       }
 
-        // 7. Custom objects
-        if !mirror.children.isEmpty {
-            var result: [String: Any] = [:]
-            for child in mirror.children {
-                if let label = child.label {
-                    result[label] = unwrapOptional(child.value)
-                }
-            }
-            return result
-        }
+       // MARK: - Reprocessing Enable Time
+       @objc
+       func getReprocessingButtonEnableTime(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+         InfivizShotsSDK.shared.getReprocessingButtonEnableTime(sessionID: sessionID as String) { result in
+           switch result {
+           case .success(let time):
+             resolve(time)
+           case .failure(let error):
+             reject("REPROCESS_TIME_ERROR", "Error fetching reprocessing time: \(error)", nil)
+           }
+         }
+       }
 
-        // 8. Primitive
-        return value
-    }
+       // MARK: - Start Reprocessing Workflow
+       @objc
+       func startReprocessingWorkflow(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+         InfivizShotsSDK.shared.startReprocessingWorkflow(sessionID: sessionID as String) { result in
+           switch result {
+           case .success(let time):
+             resolve(time)
+           case .failure(let error):
+             reject("REPROCESS_WORKFLOW_ERROR", "Reprocessing workflow error: \(error)", nil)
+           }
+         }
+       }
 
-    // MARK: - Logout
-    @objc
-    func logout(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        InfivizShotsSDK.shared.callLogoutAPI { result in
-            switch result {
-            case .success(let success):
-                resolve(success)
-            case .failure(let error):
-                reject("LOGOUT_FAILED", "Logout error: \(error)", nil)
-            }
-        }
-    }
-    
-    // MARK: - Reprocessing Enable Time
-    @objc
-    func getReprocessingButtonEnableTime(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        InfivizShotsSDK.shared.getReprocessingButtonEnableTime(sessionID: sessionID as String) { result in
-            switch result {
-            case .success(let time):
-                resolve(time)
-            case .failure(let error):
-                reject("REPROCESS_TIME_ERROR", "Error fetching reprocessing time: \(error)", nil)
-            }
-        }
-    }
-    
-    // MARK: - Start Reprocessing Workflow
-    @objc
-    func startReprocessingWorkflow(_ sessionID: NSString, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        InfivizShotsSDK.shared.startReprocessingWorkflow(sessionID: sessionID as String) { result in
-            switch result {
-            case .success(let time):
-                resolve(time)
-            case .failure(let error):
-                reject("REPROCESS_WORKFLOW_ERROR", "Reprocessing workflow error: \(error)", nil)
-            }
-        }
-    }
-    
-    // MARK: - Start Camera
+       // MARK: - Start Camera
     @objc(startCamera:storeTitle:storeId:photoType:category:maxPhoto:maxPhotoOneGo:metaData:resolver:rejecter:)
     func startCamera(_ taskName: NSString,
                      storeTitle: NSString,
@@ -356,229 +330,229 @@ class InfivizShotsReactSdk:  RCTEventEmitter {
                      metaData: NSDictionary,
                      resolver resolve: @escaping RCTPromiseResolveBlock,
                      rejecter reject: @escaping RCTPromiseRejectBlock) {
-        
-        DispatchQueue.main.async {
-            // 1️⃣ Build the CameraContext just like before
-            let metadataDict: [String: Any]? = metaData as? [String: Any]
-            let context = CameraContext(
-                taskName:     taskName as String,
-                storeTitle:   storeTitle as String,
-                storeId:      storeId as String,
-                photoType:    photoType as String,
-                category:     category as String,
-                maxPhoto:     maxPhoto.intValue,
-                maxPhotoOneGo: maxPhotoOneGo.intValue,
-                tempSessionId: nil,
-                imageURI:      nil,
-                navigationController: nil,
-                retake: false,
-                metaData: metadataDict
-            )
-            
-            // 2️⃣ Instantiate the SDK activity
-            let activity = InfilectSDKCameraActivityForResult(cameraContext: context)
-            
-            // 3️⃣ Call its existing `start(completion:)` which will handle validation,
-            activity.start { result in
-                switch result {
-                case .success(let sessionID):
-                    resolve(sessionID)
-                case .failure(let apiError):
-                    reject("CAMERA_ERROR", apiError.localizedDescription, nil)
-                }
-            }
-        }
-    }
-    
-    @objc
-    func initialize(_ appID: NSString,
-                    authSecret: NSString,
-                    accountKey: NSString,
-                    userID: NSString,
-                    clientID: NSString,
-                    apiToken: NSString,
-                    env: NSString,
-                    resolver resolve: @escaping RCTPromiseResolveBlock,
-                    rejecter reject: @escaping RCTPromiseRejectBlock) {
-        
-        let model = InfivizUserLoginContext(
-            appID: appID as String,
-            authSecret: authSecret as String,
-            accountKey: accountKey as String,
-            userID: userID as String,
-            clientID: clientID as String,
-            apiToken: apiToken as String
+
+      DispatchQueue.main.async {
+        // 1️⃣ Build the CameraContext just like before
+        let metadataDict: [String: Any]? = metaData as? [String: Any]
+        let context = CameraContext(
+          taskName:     taskName as String,
+          storeTitle:   storeTitle as String,
+          storeId:      storeId as String,
+          photoType:    photoType as String,
+          category:     category as String,
+          maxPhoto:     maxPhoto.intValue,
+          maxPhotoOneGo: maxPhotoOneGo.intValue,
+          tempSessionId: nil,
+          imageURI:      nil,
+          navigationController: nil,
+          retake: false,
+          metaData: metadataDict
         )
-        
-        let environment =  APIEnvironment(rawValue: env as String) ?? .production
-        InfivizShotsSDK.shared.initializeEnvironent(environment)
-        activity = InfivizShotsActivity(model: model)
-        activity?.initialize { result in
-            switch result {
-            case .success(let success):
-                resolve(success)
-            case .failure(let error):
-                reject("LOGIN_FAILED", error.localizedDescription, nil)
-            }
-        }
-    }
-    
-    @objc
-    func fetchSessionID(_ taskCategory: NSString,
-                        storeID: NSString,
-                        taskPhotoType: NSString,
-                        resolver resolve: @escaping RCTPromiseResolveBlock,
-                        rejecter reject: @escaping RCTPromiseRejectBlock) {
-        
-        InfivizShotsSDK.shared.fetchSessionID(
-            taskCategory: taskCategory as String,
-            storeID: storeID as String,
-            taskPhotoType: taskPhotoType as String
-        ) { sessionID, error in
-            if let id = sessionID {
-                resolve(id)
-            } else {
-                reject("SESSION_NOT_FOUND", "Session not found", nil)
-            }
+
+        // 2️⃣ Instantiate the SDK activity
+        let activity = InfilectSDKCameraActivityForResult(cameraContext: context)
+
+        // 3️⃣ Call its existing `start(completion:)` which will handle validation,
+        activity.start { result in
+          switch result {
+          case .success(let sessionID):
+            resolve(sessionID)
+          case .failure(let apiError):
+            reject("CAMERA_ERROR", apiError.localizedDescription, nil)
+          }
         }
+      }
     }
-    
-    // MARK: - View IR Results via bridge
-    @objc(viewIRResults:resolver:rejecter:)
-    func viewIRResults(_ sessionID: NSString,
+
+       @objc
+         func initialize(_ appID: NSString,
+                       authSecret: NSString,
+                       accountKey: NSString,
+                       userID: NSString,
+                       clientID: NSString,
+                       apiToken: NSString,
+                       env: NSString,
                        resolver resolve: @escaping RCTPromiseResolveBlock,
-                       rejecter reject: @escaping RCTPromiseRejectBlock) {
-        DispatchQueue.main.async {
-            guard let navigationController = UIApplication.shared.connectedScenes
-                .compactMap({ $0 as? UIWindowScene })
-                .flatMap({ $0.windows })
-                .first(where: { $0.isKeyWindow })?
-                .rootViewController?.navigationController else {
-                reject("NAV_ERROR", "No navigation controller available", nil)
-                return
-            }
-            let realTimeView = InfivizRealTimeView(sessionID: sessionID as String,
-                                                   navigationController: navigationController)
-            realTimeView.viewIRResults(sessionID: sessionID as String) { result in
-                switch result {
-                case .success(let value): resolve(value)
-                case .failure(let error): reject("VIEW_IR_FAILED", error.localizedDescription, nil)
-                }
-            }
-        }
-    }
-    
-    // MARK: - Start Actions Workflow via bridge
-    @objc(startActionsWorkFlow:sessionId:latitude:longitude:dateTimeStamp:resolver:rejecter:)
-    func startActionsWorkFlow(_ storeId: NSString,
-                              sessionId: NSString,
-                              latitude: NSString,
-                              longitude: NSString,
-                              dateTimeStamp: NSString,
-                              resolver resolve: @escaping RCTPromiseResolveBlock,
-                              rejecter reject: @escaping RCTPromiseRejectBlock) {
-        DispatchQueue.main.async {
-            guard let navigationController = UIApplication.shared.connectedScenes
-                .compactMap({ $0 as? UIWindowScene })
-                .flatMap({ $0.windows })
-                .first(where: { $0.isKeyWindow })?
-                .rootViewController?.navigationController else {
-                reject("NAV_ERROR", "No navigation controller available", nil)
-                return
-            }
-            let realTimeView = InfivizRealTimeView(sessionID: sessionId as String,
-                                                   navigationController: navigationController)
-            realTimeView.startActionsWorkFlow(storeId: storeId as String,
-                                              sessionId: sessionId as String,
-                                              latitude: latitude as String,
-                                              longitude: longitude as String,
-                                              dateTimeStamp: dateTimeStamp as String) { result in
-                switch result {
-                case .success(let value): resolve(value)
-                case .failure(let error): reject("ACTIONS_WORKFLOW_FAILED", error.localizedDescription, nil)
-                }
-            }
-        }
-    }
-    
-    @objc(resumeCamera:metaData:resolver:rejecter:)
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+             
+             let model = InfivizUserLoginContext(
+                appID: appID as String,
+                authSecret: authSecret as String,
+                accountKey: accountKey as String,
+                userID: userID as String,
+                clientID: clientID as String,
+                apiToken: apiToken as String
+             )
+             
+             let environment =  APIEnvironment(rawValue: env as String) ?? .production
+             InfivizShotsSDK.shared.initializeEnvironent(environment)
+             activity = InfivizShotsActivity(model: model)
+             activity?.initialize { result in
+                 switch result {
+                 case .success(let success):
+                     resolve(success)
+                 case .failure(let error):
+                     reject("LOGIN_FAILED", error.localizedDescription, nil)
+                 }
+             }
+         }
+
+     @objc
+     func fetchSessionID(_ taskCategory: NSString,
+                         storeID: NSString,
+                         taskPhotoType: NSString,
+                         resolver resolve: @escaping RCTPromiseResolveBlock,
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+
+         InfivizShotsSDK.shared.fetchSessionID(
+             taskCategory: taskCategory as String,
+             storeID: storeID as String,
+             taskPhotoType: taskPhotoType as String
+         ) { sessionID, error in
+             if let id = sessionID {
+                 resolve(id)
+             } else {
+                 reject("SESSION_NOT_FOUND", "Session not found", nil)
+             }
+         }
+     }
+
+     // MARK: - View IR Results via bridge
+       @objc(viewIRResults:resolver:rejecter:)
+       func viewIRResults(_ sessionID: NSString,
+                          resolver resolve: @escaping RCTPromiseResolveBlock,
+                          rejecter reject: @escaping RCTPromiseRejectBlock) {
+         DispatchQueue.main.async {
+           guard let navigationController = UIApplication.shared.connectedScenes
+                   .compactMap({ $0 as? UIWindowScene })
+                   .flatMap({ $0.windows })
+                   .first(where: { $0.isKeyWindow })?
+                   .rootViewController?.navigationController else {
+             reject("NAV_ERROR", "No navigation controller available", nil)
+             return
+           }
+           let realTimeView = InfivizRealTimeView(sessionID: sessionID as String,
+                                                  navigationController: navigationController)
+           realTimeView.viewIRResults(sessionID: sessionID as String) { result in
+             switch result {
+             case .success(let value): resolve(value)
+             case .failure(let error): reject("VIEW_IR_FAILED", error.localizedDescription, nil)
+             }
+           }
+         }
+       }
+
+       // MARK: - Start Actions Workflow via bridge
+       @objc(startActionsWorkFlow:sessionId:latitude:longitude:dateTimeStamp:resolver:rejecter:)
+       func startActionsWorkFlow(_ storeId: NSString,
+                                 sessionId: NSString,
+                                 latitude: NSString,
+                                 longitude: NSString,
+                                 dateTimeStamp: NSString,
+                                 resolver resolve: @escaping RCTPromiseResolveBlock,
+                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+         DispatchQueue.main.async {
+           guard let navigationController = UIApplication.shared.connectedScenes
+                   .compactMap({ $0 as? UIWindowScene })
+                   .flatMap({ $0.windows })
+                   .first(where: { $0.isKeyWindow })?
+                   .rootViewController?.navigationController else {
+             reject("NAV_ERROR", "No navigation controller available", nil)
+             return
+           }
+           let realTimeView = InfivizRealTimeView(sessionID: sessionId as String,
+                                                  navigationController: navigationController)
+           realTimeView.startActionsWorkFlow(storeId: storeId as String,
+                                             sessionId: sessionId as String,
+                                             latitude: latitude as String,
+                                             longitude: longitude as String,
+                                             dateTimeStamp: dateTimeStamp as String) { result in
+             switch result {
+             case .success(let value): resolve(value)
+             case .failure(let error): reject("ACTIONS_WORKFLOW_FAILED", error.localizedDescription, nil)
+             }
+           }
+         }
+       }
+
+       @objc(resumeCamera:metaData:resolver:rejecter:)
     func resumeCamera(
-        _ temporarySessionID: NSString,
-        metaData: NSDictionary?,
-        resolver resolve: @escaping RCTPromiseResolveBlock,
-        rejecter reject: @escaping RCTPromiseRejectBlock
+      _ temporarySessionID: NSString,
+      metaData: NSDictionary?,
+      resolver resolve: @escaping RCTPromiseResolveBlock,
+      rejecter reject: @escaping RCTPromiseRejectBlock
     ) {
-        // Build whatever CameraContext your SDK needs. In your original UI code,
-        // you were reading from text fields (e.g. shelfTextField.text, traderTextField.text, etc.).
-        // In a module method you typically won't have those outlets available, so you'll
-        // need to pass any required "taskName", "storeTitle" etc. from JS into this call
-        // or hard‐code defaults here. For now, I'll show a minimal example:
-        
-        let context = CameraContext(
-            taskName: "",                       // ← pass in from JS if you really need it
-            storeTitle: "",
-            storeId: "",
-            photoType: "",
-            category: "",
-            maxPhoto: 0,
-            maxPhotoOneGo: 0,
-            navigationController: nil           // ← no UIKit nav controller in RN module
-        )
-        
-        // Instantiate your SDK's camera controller just like before:
-        let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
-        
-        // Convert NSDictionary to [String: Any]
-        let metadataDict: [String: Any]? = metaData as? [String: Any]
-        
-        // Call the updated `resumeCamera(sessionID:metaData:completion:)` API with metadata
-        controller.resumeCamera(sessionID: temporarySessionID as String, metaData: metadataDict) { result in
-            switch result {
-            case .success(let successString):
-                // fulfill the JS promise with the returned string
-                resolve(successString)
-                
-            case .failure(let sdkError):
-                // reject the JS promise
-                let nsError = sdkError as NSError
-                reject(
-                    "ResumeCameraError",
-                    "Failed to resume camera: \(nsError.localizedDescription)",
-                    nsError
-                )
-            }
-        }
-    }
-    
-    @objc
-    func deletePhoto(
-        _ imageURI: NSString,
-        temporarySessionId: NSString,
-        resolver resolve: @escaping RCTPromiseResolveBlock,
-        rejecter reject: @escaping RCTPromiseRejectBlock
-    ) {
-        let context = CameraContext(
-            taskName: "",
-            storeTitle: "",
-            storeId: "",
-            photoType: "",
-            
-            category: "",
-            maxPhoto: 0,
-            maxPhotoOneGo: 0,
-            navigationController: nil
-        )
-        let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
-        controller.deleteImage(imageID: imageURI as String, sessionID: temporarySessionId as String) { result in
-            switch result {
-            case .success(let successMessage):
-                resolve(successMessage)
-            case .failure(let error):
-                reject("DELETE_IMAGE_ERROR", "Failed to delete image: \(error.localizedDescription)", error)
-            }
+      // Build whatever CameraContext your SDK needs. In your original UI code,
+      // you were reading from text fields (e.g. shelfTextField.text, traderTextField.text, etc.).
+      // In a module method you typically won't have those outlets available, so you'll
+      // need to pass any required "taskName", "storeTitle" etc. from JS into this call
+      // or hard‐code defaults here. For now, I'll show a minimal example:
+
+      let context = CameraContext(
+        taskName: "",                       // ← pass in from JS if you really need it
+        storeTitle: "",
+        storeId: "",
+        photoType: "",
+        category: "",
+        maxPhoto: 0,
+        maxPhotoOneGo: 0,
+        navigationController: nil           // ← no UIKit nav controller in RN module
+      )
+
+      // Instantiate your SDK's camera controller just like before:
+      let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
+
+      // Convert NSDictionary to [String: Any]
+      let metadataDict: [String: Any]? = metaData as? [String: Any]
+
+      // Call the updated `resumeCamera(sessionID:metaData:completion:)` API with metadata
+      controller.resumeCamera(sessionID: temporarySessionID as String, metaData: metadataDict) { result in
+        switch result {
+        case .success(let successString):
+          // fulfill the JS promise with the returned string
+          resolve(successString)
+
+        case .failure(let sdkError):
+          // reject the JS promise
+          let nsError = sdkError as NSError
+          reject(
+            "ResumeCameraError",
+            "Failed to resume camera: \(nsError.localizedDescription)",
+            nsError
+          )
         }
+      }
     }
-    
+
+     @objc
+     func deletePhoto(
+       _ imageURI: NSString,
+       temporarySessionId: NSString,
+       resolver resolve: @escaping RCTPromiseResolveBlock,
+       rejecter reject: @escaping RCTPromiseRejectBlock
+     ) {
+       let context = CameraContext(
+         taskName: "",
+         storeTitle: "",
+         storeId: "",
+         photoType: "",
+         
+         category: "",
+         maxPhoto: 0,
+         maxPhotoOneGo: 0,
+         navigationController: nil
+       )
+       let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
+       controller.deleteImage(imageID: imageURI as String, sessionID: temporarySessionId as String) { result in
+         switch result {
+         case .success(let successMessage):
+           resolve(successMessage)
+         case .failure(let error):
+           reject("DELETE_IMAGE_ERROR", "Failed to delete image: \(error.localizedDescription)", error)
+         }
+       }
+     }
+
     @objc(retakeImage:imageURL:metaData:resolver:rejecter:)
     func retakeImage(
         _ temporarySessionId: NSString,
@@ -619,70 +593,70 @@ class InfivizShotsReactSdk:  RCTEventEmitter {
             }
         }
     }
-    
-    // MARK: – React Native Promise Exposures for OutputAPI
-    /// Expose `getIRResult(sessionID:completion:)` to JavaScript as:
-    ///   InfiBridge.getIRResult("session-123").then(...).catch(...)
-    @objc
-    func getIrResult(
-        _ sessionId: NSString,
-        resolver resolve: @escaping RCTPromiseResolveBlock,
-        rejecter reject: @escaping RCTPromiseRejectBlock
-    ) {
-        print("Inside GetIrResult sessionId -> \(sessionId)")
-        // Call the Swift helper (which calls outputAPI.getIRResult)
-        InfivizShotsSDK.shared.getIrResult(sessionID: sessionId as String) { (dataAny, error) in
-            if let err = error {
-                // If the SDK returned an error, reject the JS promise
-                print("err", err)
-                reject(
-                    "IR_RESULT_ERROR",                // error code (custom identifier)
-                    err as? String,                      // error message
-                    nil                               // optional NSError (can be nil)
-                )
-            } else if let output = dataAny {
-                // If the SDK returned data (Any), pass it back to JS.
-                resolve(output)
-            } else {
-                // Neither data nor error? Just resolve with `nil`.
-                resolve(nil)
-            }
-        }
-    }
-    
-    /// Expose `getActionsResult(sessionID:completion:)` to JavaScript as:
-    ///   InfiBridge.getActionsResult("session-123").then(...).catch(...)
-    @objc
-    func getActionsResult(
-        _ sessionId: NSString,
-        resolver resolve: @escaping RCTPromiseResolveBlock,
-        rejecter reject: @escaping RCTPromiseRejectBlock
-    ) {
-        // Call the Swift helper (which calls outputAPI.getActionsResult)
-        InfivizShotsSDK.shared.getActionsResult(sessionID: sessionId as String) { (dataAny, error) in
-            if let err = error {
-                reject("ACTIONS_FAILED", err as? String, nil)
-            } else if let output = dataAny {
-                resolve(output)
-            } else {
-                resolve(nil)
-            }
+
+      // MARK: – React Native Promise Exposures for OutputAPI
+       /// Expose `getIRResult(sessionID:completion:)` to JavaScript as:
+       ///   InfiBridge.getIRResult("session-123").then(...).catch(...)
+       @objc
+       func getIrResult(
+         _ sessionId: NSString,
+         resolver resolve: @escaping RCTPromiseResolveBlock,
+         rejecter reject: @escaping RCTPromiseRejectBlock
+       ) {
+           print("Inside GetIrResult sessionId -> \(sessionId)")
+         // Call the Swift helper (which calls outputAPI.getIRResult)
+           InfivizShotsSDK.shared.getIrResult(sessionID: sessionId as String) { (dataAny, error) in
+           if let err = error {
+             // If the SDK returned an error, reject the JS promise
+               print("err", err)
+               reject(
+                 "IR_RESULT_ERROR",                // error code (custom identifier)
+                 err as? String,                      // error message
+                 nil                               // optional NSError (can be nil)
+               )
+           } else if let output = dataAny {
+             // If the SDK returned data (Any), pass it back to JS.
+             resolve(output)
+           } else {
+             // Neither data nor error? Just resolve with `nil`.
+             resolve(nil)
+           }
+         }
+       }
+
+       /// Expose `getActionsResult(sessionID:completion:)` to JavaScript as:
+       ///   InfiBridge.getActionsResult("session-123").then(...).catch(...)
+       @objc
+       func getActionsResult(
+         _ sessionId: NSString,
+         resolver resolve: @escaping RCTPromiseResolveBlock,
+         rejecter reject: @escaping RCTPromiseRejectBlock
+       ) {
+         // Call the Swift helper (which calls outputAPI.getActionsResult)
+           InfivizShotsSDK.shared.getActionsResult(sessionID: sessionId as String) { (dataAny, error) in
+           if let err = error {
+             reject("ACTIONS_FAILED", err as? String, nil)
+           } else if let output = dataAny {
+             resolve(output)
+           } else {
+             resolve(nil)
+           }
+         }
+       }
+
+       @objc
+        private func handleActionsGeneratedEvent(_ notification: Notification) {
+          guard hasListeners else { return }
+
+          let payload = notification.userInfo ?? [:]
+          sendEvent(withName: "ActionsGeneratedEvent", body: payload)
         }
-    }
-    
-    @objc
-    private func handleActionsGeneratedEvent(_ notification: Notification) {
-        guard hasListeners else { return }
         
-        let payload = notification.userInfo ?? [:]
-        sendEvent(withName: "ActionsGeneratedEvent", body: payload)
-    }
-    
-    @objc
-    private func handleSessionRealTimeResultEvent(_ notification: Notification) {
-        guard hasListeners else { return }
-        
-        let payload = notification.userInfo ?? [:]
-        sendEvent(withName: "SessionRealTimeResultEvent", body: payload)
-    }
+       @objc
+        private func handleSessionRealTimeResultEvent(_ notification: Notification) {
+          guard hasListeners else { return }
+
+          let payload = notification.userInfo ?? [:]
+          sendEvent(withName: "SessionRealTimeResultEvent", body: payload)
+        }
 }