@infilect-sdk/infiviz-shots-react-sdk 1.2.14

package/ios/InfivizShotsReactSdk.swift

@@ -0,0 +1,913 @@
+//
+//  InfivizShotsReactSdk.swift
+//
+//
+//  Created by Aakash Sinha on 10/04/25.
+//
+
+import Foundation
+import InfivizShotSDK
+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",
+            "IMAGE_SLOW_UPLOAD",
+            "SESSION_PROCESSING_SLA_BREACHED",
+            "IMAGE_UPLOAD_FAILED",
+            "SESSION_UPLOAD_FAILED",
+            "HIGH_CPU_USAGE",
+            "HIGH_DEVICE_TEMPERATURE",
+            "LOW_DEVICE_STORAGE",
+            "LOW_BATTERY"
+            ]
+    }
+    
+    // 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)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleSessionRealTimeResultEvent(_:)),
+                                               name: NSNotification.Name("SessionRealTimeResultEvent"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleImageSlowUploadEvent(_:)),
+                                               name: NSNotification.Name("IMAGE_SLOW_UPLOAD"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleSessionProcessingSlaBreachedEvent(_:)),
+                                               name: NSNotification.Name("SESSION_PROCESSING_SLA_BREACHED"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleImageUploadFailedEvent(_:)),
+                                               name: NSNotification.Name("IMAGE_UPLOAD_FAILED"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleSessionUploadFailedEvent(_:)),
+                                               name: NSNotification.Name("SESSION_UPLOAD_FAILED"),
+                                               object: nil)
+        
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleHighCpuUsageEvent(_:)),
+                                               name: NSNotification.Name("HIGH_CPU_USAGE"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleHighDeviceTemperatureEvent(_:)),
+                                               name: NSNotification.Name("HIGH_DEVICE_TEMPERATURE"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleLowDeviceStorageEvent(_:)),
+                                               name: NSNotification.Name("LOW_DEVICE_STORAGE"),
+                                               object: nil)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(handleLowBatteryEvent(_:)),
+                                               name: NSNotification.Name("LOW_BATTERY"),
+                                               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)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("IMAGE_SLOW_UPLOAD"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("SESSION_PROCESSING_SLA_BREACHED"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("IMAGE_UPLOAD_FAILED"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("SESSION_UPLOAD_FAILED"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("HIGH_CPU_USAGE"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("HIGH_DEVICE_TEMPERATURE"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("LOW_DEVICE_STORAGE"), object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("LOW_BATTERY"), 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
+        } else if let arr = temporarySessionIDs as? [NSString] {
+            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)
+                }
+            }
+        }
+    }
+    
+    // MARK: - Get Session Result
+    
+    @objc
+    func getSessionStatus(
+        _ 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)
+                
+                // Ensure status field is properly handled
+                var finalDict = cleanDict
+                if let statusValue = cleanDict["status"] {
+                    // If status is NSNull, try to get a default value
+                    if statusValue is NSNull {
+                        finalDict["status"] = InfivizShotSDK.SessionSyncStateEnum.NOT_SYNCED.rawValue // Default fallback
+                    }
+                } else {
+                    finalDict["status"] = InfivizShotSDK.SessionSyncStateEnum.NOT_SYNCED.rawValue // Default fallback
+                }
+                
+                // Return the dictionary directly instead of JSON string
+                resolve(finalDict)
+            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()
+            }
+        }
+
+        // 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()
+            }
+        }
+
+        // 3. Arrays
+        if let array = value as? [Any] {
+            return array.map { unwrapOptional($0) }
+        }
+
+        // 4. Dictionaries
+        if let dict = value as? [String: Any] {
+            var cleaned: [String: Any] = [:]
+            for (k, v) in dict {
+                cleaned[k] = unwrapOptional(v)
+            }
+            return cleaned
+        }
+
+        // 5. Enum like SessionSyncStateEnum
+        let typeName = String(describing: type(of: value))
+        if typeName.contains("InfivizShotSDK.SessionSyncStateEnum") {
+            return String(describing: value)
+        }
+        
+        // 5a. Handle SessionSyncStateEnum directly if it's the actual enum type
+        if let sessionState = value as? InfivizShotSDK.SessionSyncStateEnum {
+            return sessionState.rawValue
+        }
+
+        // 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)
+        }
+
+        // 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
+        }
+
+        // 8. Primitive
+        return value
+    }
+
+    // MARK: - Logout
+    @objc
+    func logout(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.callLogoutAPI { result in
+            switch result {
+            case .success(let success):
+                resolve("From Callback: SDK Logout success")
+            case .failure(let error):
+                reject("LOGOUT_ERROR", error.localizedDescription, 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
+    @objc(startCamera:storeTitle:storeId:photoType:category:maxPhoto:maxPhotoOneGo:metaData:resolver:rejecter:)
+    func startCamera(_ taskName: NSString,
+                     storeTitle: NSString,
+                     storeId: NSString,
+                     photoType: NSString,
+                     category: NSString,
+                     maxPhoto: NSNumber,
+                     maxPhotoOneGo: NSNumber,
+                     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:     0,
+                maxPhotoOneGo: 0,
+                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 successRes):
+                    switch successRes {
+                    case .cameraStarted(let msg):
+                        print(msg)
+                    case .sessionCompleted(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
+        )
+        
+        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("SDK Initialized successfully!!")
+            case .failure(let error):
+                reject("SDK_INIT_ERROR", "SDK Initialized 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)
+            }
+        }
+    }
+
+    static func topMostViewController() -> UIViewController? {
+        guard let keyWindow = UIApplication.shared.connectedScenes
+            .compactMap({ $0 as? UIWindowScene })
+            .flatMap({ $0.windows })
+            .first(where: { $0.isKeyWindow }) else {
+            return nil
+        }
+        
+        var top = keyWindow.rootViewController
+        while let presented = top?.presentedViewController {
+            top = presented
+        }
+        return top
+    }
+    
+    // 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
+            // }
+            guard let topVC = InfivizShotsReactSdk.topMostViewController() else {
+              reject("NAV_ERROR", "No view controller available", nil)
+              return
+            }
+            
+            // Create a navigation controller for the SDK to use
+                    let navController: UINavigationController
+                    
+                    if let existingNav = topVC as? UINavigationController {
+                        // TopVC is already a navigation controller
+                        navController = existingNav
+                    } else if let existingNav = topVC.navigationController {
+                        // TopVC is inside a navigation controller
+                        navController = existingNav
+                    } else {
+                        // React Native doesn't have a nav controller, create a temporary one
+                        // We'll pass this to the SDK, and the SDK will handle presenting its views
+                        navController = UINavigationController()
+                        navController.setViewControllers([], animated: false)
+                    }
+
+            let realTimeView = InfivizRealTimeView(sessionID: sessionID as String,
+                                                   navigationController: navController)
+            realTimeView.viewIRResults(sessionID: sessionID as String) { result in
+                switch result {
+                case .success(let value):
+                 print("View IR Results success: \(value)")
+                 resolve(value)
+                case .failure(let error): 
+                 print("View IR Results error: \(error.localizedDescription)")
+                 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
+    ) {
+        // 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 successRes):
+                // fulfill the JS promise with the returned string
+                switch successRes {
+                case .cameraStarted(let msg):
+                    resolve(msg)
+                case .sessionCompleted(let sessionID):
+                    print(sessionID)
+                }
+                
+            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(imageURL: 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,
+        imageURL: String,
+        metaData: NSDictionary?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let context = CameraContext(
+            taskName: "",
+            storeTitle: "",
+            storeId: "",
+            photoType: "",
+            category: "",
+            maxPhoto: 0,
+            maxPhotoOneGo: 0,
+            navigationController: nil,
+            metaData: metaData as? [String: Any]
+        )
+        
+        let imageURL = imageURL.components(separatedBy: "/").last ?? ""
+        
+        let controller = InfilectSDKCameraActivityForResult(cameraContext: context)
+        controller.retakeImage(
+            imageURL: imageURL,
+            sessionID: temporarySessionId as String,
+            metaData: [:] as? [String: Any]
+        ) { result in
+            switch result {
+            case .success(let newImageId):
+                resolve(newImageId)
+            case .failure(let sdkError):
+                reject(
+                    "RetakeImageError",
+                    "Failed to retake image: \((sdkError as NSError).localizedDescription)",
+                    sdkError as NSError
+                )
+            }
+        }
+    }
+    
+    // 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 output = dataAny {
+            resolve(output)
+        } else {
+                reject(
+                    "IR_RESULT_ERROR",                // error code (custom identifier)
+                    error.debugDescription,
+                    error as? NSError                    // error message
+                )
+        }
+        }
+    }
+    
+    /// 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 output = dataAny {
+            resolve(output)
+            } else {
+                reject(
+                    "ACTIONS_FAILED",                // error code (custom identifier)
+                    error.debugDescription,
+                    error as? NSError                    // error message
+                )
+            }
+        }
+    }
+    
+    @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 handleSessionProcessingSlaBreachedEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "SESSION_PROCESSING_SLA_BREACHED", body: payload)
+    }
+
+    @objc
+    private func handleImageSlowUploadEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "IMAGE_SLOW_UPLOAD", body: payload)
+    }
+
+    @objc
+    private func handleImageUploadFailedEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "IMAGE_UPLOAD_FAILED", body: payload)
+    }
+    
+    @objc
+    private func handleSessionUploadFailedEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "SESSION_UPLOAD_FAILED", body: payload)
+    }
+    
+    @objc
+    private func handleHighCpuUsageEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "HIGH_CPU_USAGE", body: payload)
+    }
+    
+    @objc
+    private func handleHighDeviceTemperatureEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "HIGH_DEVICE_TEMPERATURE", body: payload)
+    }
+    
+    @objc
+    private func handleLowDeviceStorageEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "LOW_DEVICE_STORAGE", body: payload)
+    }
+    
+    @objc
+    private func handleLowBatteryEvent(_ notification: Notification) {
+        guard hasListeners else { return }
+        
+        let payload = notification.userInfo ?? [:]
+        sendEvent(withName: "LOW_BATTERY", body: payload)
+    }
+    
+    @objc(checkTokenValidity:userID:resolver:rejecter:)
+    func checkTokenValidity(_ clientID: NSString,
+                            userID: NSString,
+                            resolver resolve: @escaping RCTPromiseResolveBlock,
+                            rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.checkTokenValidity(clientID: clientID as String, userID: userID as String) { result in
+            switch result {
+            case .success(let isValid):
+                resolve(isValid)
+            case .failure(let error):
+                reject("TOKEN_VALIDITY_ERROR", error.localizedDescription, nil)
+            }
+        }
+    }
+
+    @objc
+    func fetchLatestSdkStatus(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.fetchLatestSdkStatus { [weak self] result in
+                    guard let self = self else {
+                        reject("FETCH_LATEST_SDK_STATUS_ERROR", "No data found", nil)
+                         return }
+                    
+                    if let sdkStatus = result {
+                    // Convert any value to a clean dictionary that handles Optionals properly
+                        resolve(sdkStatus.toDictionary())
+                    }
+                    else {
+                        reject("FETCH_LATEST_SDK_STATUS_ERROR", "No data found", nil)
+                    }
+                }
+    }
+    
+    @objc(fetchSdkStatusLogs:resolver:rejecter:)
+    func fetchSdkStatusLogs(_ days: NSNumber,
+                           resolver resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        InfivizShotsSDK.shared.fetchSdkStatusLogs(days: days.intValue) { sdkStatusArray in
+            if let statusArray = sdkStatusArray {
+                // Convert SDKStatus array to JSON-serializable format using existing method
+                let jsonArray = statusArray.map { sdkStatus -> [String: Any] in
+                    return self.convertToCleanDictionary(sdkStatus)
+                }
+                resolve(jsonArray)
+            } else {
+                reject("FETCH_SDK_STATUS_LOGS_ERROR", "Failed to fetch SDK status logs", nil)
+            }
+        }
+    }
+}