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

package/android/src/main/java/com/infilect/infivizshotsreactsdk/InfivizShotsReactSdkModule.kt

@@ -0,0 +1,813 @@
+package com.infilect.infivizshotsreactsdk
+
+import android.app.Activity
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.gson.Gson
+import org.json.JSONArray
+import org.json.JSONObject
+import com.infilect.actions.ACTION_TYPE
+import com.infilect.actions.IRResultAndActionsCallback
+import infilect.infiviz.InfiVizShotsSDK
+import infilect.infiviz.IntentConstants
+import infilect.infiviz.error.ErrorEnums
+import infilect.infiviz.error.SDKExceptions
+import infilect.infiviz.infilect_client.Info.InfivizShotsSDKSessionState.SessionStateListener
+import infilect.infiviz.infilect_client.SDKCallbacks.OnInfivizShotsSDKInitializationListener
+import infilect.infiviz.infilect_client.SDKCallbacks.OnInfivizShotsSDKLogoutListener
+import infilect.infiviz.infilect_client.model.ivyresponse.DeleteCallBack
+import infilect.infiviz.infilect_client.model.ivyresponse.InfiSession
+import infilect.infiviz.infilect_client.model.ivyresponse.SDKCallback
+import infilect.infiviz.infilect_client.model.ivyresponse.UploadCallback
+import infilect.infiviz.sdkEnvironment.InfivizshotsEnvironment
+import kotlin.jvm.java
+import android.util.Log
+
+@ReactModule(name = InfivizShotsReactSdkModule.NAME)
+class InfivizShotsReactSdkModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+    init {
+        reactContext.addActivityEventListener(this)
+    }
+
+    private lateinit var irResultCallback: IRResultAndActionsCallback
+    private var startCameraCallback: ((String) -> Unit)? = null
+
+    private val syncCallbackBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            val status = intent!!.getStringExtra(IntentConstants.STATUS)
+            val message = intent.getStringExtra(IntentConstants.MESSAGE)
+            val sessionId = intent.getStringExtra(IntentConstants.SESSION_ID)
+            val universalSessionId = intent.getStringExtra(IntentConstants.EXTERNAL_SESSION_ID)
+
+            Log.d(TAG, "Broadcast received: ${SDKEvent.SYNC_EVENT.name} | sessionId: $sessionId, status: $status")
+            sendEventToReact(SDKEvent.SYNC_EVENT, sessionId!!, status!!, message!!,universalSessionId)
+        }
+    }
+
+    private val imageUploadFailedBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putString("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                putString("imageUri", intent.getStringExtra(IntentConstants.IMAGE_URI))
+                putInt("statusCode", intent.getIntExtra(IntentConstants.STATUS_CODE, 0))
+                putString("errorType", intent.getStringExtra(IntentConstants.ERROR_TYPE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.IMAGE_UPLOAD_FAILED_EVENT, params)
+        }
+    }
+
+    private val sessionUploadFailedBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putString("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                putInt("statusCode", intent.getIntExtra(IntentConstants.STATUS_CODE, 0))
+                putString("errorType", intent.getStringExtra(IntentConstants.ERROR_TYPE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.SESSION_UPLOAD_FAILED_EVENT, params)
+        }
+    }
+
+    private val sessionProcessingSlaBreachedBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putString("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                putInt("imageCount", intent.getIntExtra("image_count", 0))
+                putInt("baseSlaSec", intent.getIntExtra("base_sla_sec", 0))
+                putInt("bufferSec", intent.getIntExtra("buffer_sec", 0))
+                putInt("effectiveSla", intent.getIntExtra("effective_sla", 0))
+                putDouble("elapsedTimeSec", intent.getLongExtra("elapsed_time_sec", 0L).toDouble())
+                putString("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.SESSION_PROCESSING_SLA_BREACHED_EVENT, params)
+        }
+    }
+
+    private val imageSlowUploadBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putString("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                putString("imageUri", intent.getStringExtra(IntentConstants.IMAGE_URI))
+                putDouble("uploadDurationSec", intent.getDoubleExtra(IntentConstants.UPLOAD_DURATION_SEC, 0.0))
+                putDouble("derivedUploadSpeedKbps", intent.getDoubleExtra(IntentConstants.DERIVED_UPLOAD_SPEED_KBPS, 0.0))
+                putInt("reasonCode", intent.getIntExtra(IntentConstants.REASON_CODE, 0))
+                putString("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.IMAGE_SLOW_UPLOAD_EVENT, params)
+        }
+    }
+
+    private val highCpuUsageBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putInt("cpuUsageThresholdPercent", intent.getIntExtra("cpu_usage_threshold_percent", 0))
+                putInt("currentCpuUsagePercent", intent.getIntExtra("current_cpu_usage_percent", 0))
+                putString("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.HIGH_CPU_USAGE_EVENT, params)
+        }
+    }
+
+    private val highDeviceTemperatureBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putDouble("deviceTemperatureThresholdCelsius", intent.getIntExtra("device_temperature_threshold_celsius", 0).toDouble())
+                putDouble("currentDeviceTemperatureCelsius", intent.getIntExtra("current_device_temperature_celsius", 0).toDouble())
+                putString("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.HIGH_DEVICE_TEMPERATURE_EVENT, params)
+        }
+    }
+
+    private val lowDeviceStorageBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putDouble("availableMb", intent.getLongExtra("available_mb", 0L).toDouble())
+                putDouble("usedMb", intent.getLongExtra("used_mb", 0L).toDouble())
+                putDouble("remainingMb", intent.getLongExtra("remaining_mb", 0L).toDouble())
+                putString("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.LOW_DEVICE_STORAGE_EVENT, params)
+        }
+    }
+
+    private val lowBatteryBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = Arguments.createMap().apply {
+                putString("event", intent.getStringExtra(IntentConstants.EVENT))
+                putInt("currentBatteryPercent", intent.getIntExtra("current_battery_percent", 0))
+                putString("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                putString("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                putDouble("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(SDKEvent.LOW_BATTERY_EVENT, params)
+        }
+    }
+
+    private fun emitBroadcastEvent(event: SDKEvent, params: WritableMap) {
+        Log.d(TAG, "Broadcast received: ${event.name} | params: $params")
+        if (reactContext.hasActiveReactInstance()) {
+            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(event.name, params)
+            Log.d(TAG, "Broadcast emitted to JS: ${event.name}")
+        } else {
+            Log.w(TAG, "Broadcast received but no active React instance: ${event.name}")
+        }
+    }
+
+    fun convertReadableMapToStringHashMap(readableMap: ReadableMap?): HashMap<String, String> {
+        val result = HashMap<String, String>()
+        if(readableMap!=null){
+        val iterator = readableMap.keySetIterator()
+
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            try {
+                result[key] = when (readableMap.getType(key)) {
+                    com.facebook.react.bridge.ReadableType.Null -> ""
+                    com.facebook.react.bridge.ReadableType.Boolean -> readableMap.getBoolean(key).toString()
+                    com.facebook.react.bridge.ReadableType.Number -> readableMap.getDouble(key).toString()
+                    com.facebook.react.bridge.ReadableType.String -> readableMap.getString(key) ?: ""
+                    else -> ""
+                }
+            } catch (e: Exception) {
+                result[key] = ""
+            }
+        }
+        }
+        return result
+    }
+
+    private fun sendEventToReact(
+        eventName: SDKEvent, sessionId: String, status: String, message: String, universalSessionId: String? = null
+    ) {
+        val params = Arguments.createMap().apply {
+            putString("temporarySessionID", sessionId)
+            putString("status", status)
+            putString("message", message)
+            putString("universalSessionID", universalSessionId)
+        }
+
+        if (reactContext.hasActiveReactInstance()) {
+            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName.name, params)
+        }
+    }
+
+    // Add this async function
+    private fun fetchUniversalSessionIdAsync(temporarySessionID: String, callback: (String?) -> Unit) {
+        InfiVizShotsSDK.fetchUniversalSessionId(
+            currentActivity,
+            temporarySessionID, object : SDKCallback<String> {
+                override fun onSuccess(sessionId: String) {
+                    callback(sessionId)
+                }
+
+                override fun onError(sdkExceptions: SDKExceptions) {
+                    Log.e("SDK", "Error fetching universal session ID", sdkExceptions)
+                    callback(null)
+                }
+            })
+    }
+
+    private fun sendEventToReact(eventName: SDKEvent, sessionId: String) {
+        if (reactContext.hasActiveReactInstance()) {
+            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName.name, sessionId)
+        }
+    }
+
+    private fun sendSessionRealTimeResultEvent(sessionId: String, message: String, sdkEvent: SDKEvent) {
+        val params = Arguments.createMap().apply {
+            putString("sessionId", sessionId)
+            putString("message", message)
+        }
+
+        if (reactContext.hasActiveReactInstance()) {
+            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(sdkEvent.name, params)
+        }
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod
+    fun initialize(
+        appID: String,
+        authSecret: String,
+        accountKey: String,
+        userID: String,
+        clientID: String,
+        apiToken: String,
+        env: String,
+        promise: Promise
+    ) {
+        val context = currentActivity ?: reactApplicationContext
+        val environment: InfivizshotsEnvironment = when (env) {
+            "staging" -> InfivizshotsEnvironment.UAT
+            "production" -> InfivizshotsEnvironment.PROD
+            else -> InfivizshotsEnvironment.PROD  // Asked last time for default config.
+        }
+        val platform: String = "REACT_NATIVE"
+        val isDebug: Boolean = false
+        InfiVizShotsSDK.init(
+            context.applicationContext, object : OnInfivizShotsSDKInitializationListener {
+                override fun onInfivizShotsSDKInitSuccess() {
+                    promise.resolve("SDK Initialized successfully!!")
+                }
+
+                override fun onInfivizShotsSDKInitFailed(p0: SDKExceptions) {
+                    promise.reject("SDK_INIT_ERROR", "SDK Initialized Failed -> ${p0.message}", p0)
+                }
+            }, appID, authSecret, accountKey, userID, clientID, apiToken, environment,isDebug,platform
+        )
+    }
+
+    @ReactMethod
+    fun syncSession(sessionId: String) {
+        InfiVizShotsSDK.uploadSession(
+            currentActivity!!, arrayListOf(sessionId), object : SDKCallback<String> {
+                override fun onSuccess(p0: String) {
+                    sendEventToReact(SDKEvent.SYNC_EVENT, p0, "200", p0)
+                }
+
+                override fun onError(p0: SDKExceptions) {
+                    sendEventToReact(
+                        SDKEvent.SYNC_EVENT,
+                        p0.sessionId,
+                        p0.status.toString(),
+                        p0.message.toString()
+                    )
+                }
+            })
+    }
+
+    @ReactMethod
+    fun startCamera(
+        taskName: String,
+        storeTitle: String,
+        storeId: String,
+        photoType: String,
+        category: String,
+        maxPhoto: Double,
+        maxPhotoOneGo: Double,
+        metaData: ReadableMap?,
+        promise: Promise
+    ) {
+        startCameraCallback = {
+            promise.resolve(it)
+        }
+
+        val metadataMap = convertReadableMapToStringHashMap(metaData)
+        
+        InfiVizShotsSDK.startCamera(
+            currentActivity!!,
+            taskName,
+            storeTitle,
+            storeId,
+            photoType,
+            category,
+            maxPhoto.toInt(),
+            maxPhotoOneGo.toInt(),
+            22,
+            metadataMap,
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    // No Op
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject("SDK_ERROR", e.message, e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun retakeImage(
+        temporarySessionId: String,
+        imageURI: String,
+        metaData: ReadableMap,
+        promise: Promise
+    ) {
+//        val metadataMap = metaData.toStringHashMap()
+        
+        InfiVizShotsSDK.retakeImage(
+            currentActivity!!,
+            temporarySessionId,
+            imageURI,
+//            metadataMap,
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject("SDK_ERROR", e.message, e)
+                }
+            }, 32
+        )
+    }
+
+    @ReactMethod
+    fun deletePhoto(
+        imageURI: String,
+        temporarySessionId: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.deleteImage(
+            currentActivity!!,
+            temporarySessionId,
+            imageURI, object : DeleteCallBack() {
+                override fun onSuccess(tempSessionId: String?, errorEnums: ErrorEnums?) {
+                    if (errorEnums != null) {
+                        promise.reject(errorEnums.status.toString(), errorEnums.message)
+                    }
+                    promise.resolve("Deleted file successfully")
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject("SDK_ERROR", e.message, e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun resumeCamera(
+        tempSessionId: String,
+        metaData: ReadableMap?,
+        promise: Promise
+    ) {
+        val metadataMap = convertReadableMapToStringHashMap(metaData)
+
+        InfiVizShotsSDK.resumeCamera(
+            currentActivity!!,
+            tempSessionId, 22, metadataMap, object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    Log.d("RESUME CAMERA",response + " Sample ")
+                    promise.resolve(response)
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject("SDK_ERROR", e.message, e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun uploadSession(
+        temporarySessionID: ReadableArray,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.uploadSession(
+            reactContext,
+            temporarySessionID.toStringList(), object : UploadCallback() {
+                override fun onError(sdkExceptions: SDKExceptions) {
+                    promise.reject("SDK_ERROR", sdkExceptions.message, sdkExceptions)
+                }
+
+                override fun onSuccess(tempId: String?) {
+                    promise.resolve(tempId)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun dataArchival(
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.dataArchival_v1(
+            currentActivity!!)
+            
+    }
+
+    private fun ReadableArray.toStringList(): ArrayList<String> {
+        val list = ArrayList<String>()
+        for (i in 0 until this.size()) {
+            list.add(this.getString(i) ?: "")
+        }
+        return list
+    }
+
+    private fun convertJsonToWritableMap(jsonObject: JSONObject): WritableMap {
+        val writableMap = Arguments.createMap()
+        
+        val keys = jsonObject.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            val value = jsonObject.get(key)
+            
+            when (value) {
+                is String -> writableMap.putString(key, value)
+                is Int -> writableMap.putInt(key, value)
+                is Long -> writableMap.putDouble(key, value.toDouble())
+                is Double -> writableMap.putDouble(key, value)
+                is Boolean -> writableMap.putBoolean(key, value)
+                is JSONObject -> writableMap.putMap(key, convertJsonToWritableMap(value))
+                is JSONArray -> writableMap.putArray(key, convertJsonArrayToWritableArray(value))
+                else -> writableMap.putString(key, value.toString())
+            }
+        }
+        
+        return writableMap
+    }
+
+    private fun convertJsonArrayToWritableArray(jsonArray: JSONArray): WritableArray {
+        val writableArray = Arguments.createArray()
+        
+        for (i in 0 until jsonArray.length()) {
+            val value = jsonArray.get(i)
+            
+            when (value) {
+                is String -> writableArray.pushString(value)
+                is Int -> writableArray.pushInt(value)
+                is Long -> writableArray.pushDouble(value.toDouble())
+                is Double -> writableArray.pushDouble(value)
+                is Boolean -> writableArray.pushBoolean(value)
+                is JSONObject -> writableArray.pushMap(convertJsonToWritableMap(value))
+                is JSONArray -> writableArray.pushArray(convertJsonArrayToWritableArray(value))
+                else -> writableArray.pushString(value.toString())
+            }
+        }
+        
+        return writableArray
+    }
+
+    @ReactMethod
+    fun fetchSessionDetails(
+        temporarySessionID: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.fetchSessionDetails(
+            currentActivity!!,
+            temporarySessionID, object : SDKCallback<InfiSession> {
+                override fun onSuccess(response: InfiSession) {
+                    val responseJson = Gson().toJson(response)
+                    promise.resolve(responseJson)
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject("SDK_ERROR", e.message, e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun fetchUniversalSessionId(
+        temporarySessionID: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.fetchUniversalSessionId(
+            currentActivity,
+            temporarySessionID, object : SDKCallback<String> {
+                override fun onSuccess(sessionId: String) {
+                    promise.resolve(sessionId)
+                }
+
+                override fun onError(sdkExceptions: SDKExceptions) {
+                    promise.reject("SDK_ERROR", sdkExceptions.message, sdkExceptions)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun viewIRResults(
+        sessionId: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.viewIRResults(
+            currentActivity, sessionId,
+            object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(exceptions: SDKExceptions) {
+                    promise.reject("SDK_ERROR", exceptions.message, exceptions)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun startActionsWorkFlow(
+        storeId: String,
+        sessionId: String,
+        latitude: String,
+        longitude: String,
+        dateTimeStamp: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.startActionsWorkFlow(
+            currentActivity,
+            storeId,
+            sessionId,
+            latitude.toLong(),
+            longitude.toLong(),
+            dateTimeStamp,
+            object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(exceptions: SDKExceptions) {
+                    promise.reject("SDK_ERROR", exceptions.message, exceptions)
+                }
+            })
+
+    }
+
+    @ReactMethod
+    fun logout(promise: Promise) {
+        InfiVizShotsSDK.logoutSDK(
+            reactContext,
+            object : OnInfivizShotsSDKLogoutListener {
+                override fun onInfivizShotsSDKLogoutSuccess() {
+                    promise.resolve("From Callback: SDK Logout success")
+                }
+
+                override fun onInfivizShotsSDKLogoutFailed(jsonObject: SDKExceptions) {
+                    promise.reject("LOGOUT_ERROR", jsonObject.message, jsonObject)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun getIrResult(sessionId: String, promise: Promise) {
+        InfiVizShotsSDK.getIRResult(
+            reactContext,
+            sessionId,
+            object : SDKCallback<String> {
+                override fun onSuccess(p0: String) {
+                    promise.resolve(p0)
+                }
+
+                override fun onError(p0: SDKExceptions) {
+                    promise.reject("SDK_ERROR", p0.message, p0)
+                }
+            }
+        )
+    }
+
+    @ReactMethod
+    fun getActionsResult(sessionId: String, promise: Promise) {
+        InfiVizShotsSDK.getActionsResult(
+            reactContext,
+            sessionId,
+            object : SDKCallback<String> {
+                override fun onSuccess(p0: String) {
+                    promise.resolve(p0)
+                }
+
+                override fun onError(p0: SDKExceptions) {
+                    promise.reject("SDK_ERROR", p0.message, p0)
+                }
+            }
+        )
+    }
+
+    @ReactMethod
+    fun getSessionStatus(sessionId: String, promise: Promise) {
+        InfiVizShotsSDK.getSessionStatus(reactContext, sessionId, object : SessionStateListener {
+            override fun sessionState(p0: Int, p1: String) {
+                promise.resolve(Gson().toJson(SessionStatus(p0, p1)))
+            }
+
+            override fun error(p0: SDKExceptions) {
+                promise.reject("SESSION_STATUS_ERROR", p0.message, p0)
+            }
+        })
+    }
+
+
+    @ReactMethod
+    fun checkTokenValidity(clientID: String, userID: String, promise: Promise) {
+        val context = reactApplicationContext
+        InfiVizShotsSDK.checkTokenValidity(
+            context,
+            clientID,
+            userID,
+            object : SDKCallback<Boolean> {
+                override fun onSuccess(result: Boolean) {
+                    promise.resolve(result)
+                }
+
+                override fun onError(sdkExceptions: SDKExceptions) {
+                    promise.reject(
+                        sdkExceptions.status.toString(),
+                        sdkExceptions.message,
+                        sdkExceptions
+                    )
+                }
+            }
+        )
+    }
+
+    @ReactMethod
+    fun fetchLatestSdkStatus(promise: Promise) {
+        val context = currentActivity ?: reactApplicationContext
+        InfiVizShotsSDK.fetchLatestSdkStatus(context, object : SDKCallback<infilect.infiviz.models.SDKStatus> {
+            override fun onSuccess(status: infilect.infiviz.models.SDKStatus) {
+                val jsonString = Gson().toJson(status)
+                val jsonObject = JSONObject(jsonString)
+                val writableMap = convertJsonToWritableMap(jsonObject)
+                promise.resolve(writableMap)
+            }
+
+            override fun onError(e: SDKExceptions) {
+                promise.reject("SDK_ERROR", e.message, e)
+            }
+        })
+    }
+
+    @ReactMethod
+    fun fetchSdkStatusLogs(days: Double, promise: Promise) {
+        val context = currentActivity ?: reactApplicationContext
+        InfiVizShotsSDK.fetchSdkStatusLogs(context, days.toInt(), object : SDKCallback<List<infilect.infiviz.models.SDKStatus>> {
+            override fun onSuccess(statusList: List<infilect.infiviz.models.SDKStatus>) {
+                val writableArray = Arguments.createArray()
+                for (status in statusList) {
+                    val jsonString = Gson().toJson(status)
+                    val jsonObject = JSONObject(jsonString)
+                    val writableMap = convertJsonToWritableMap(jsonObject)
+                    writableArray.pushMap(writableMap)
+                }
+                promise.resolve(writableArray)
+            }
+
+            override fun onError(e: SDKExceptions) {
+                promise.reject("SDK_ERROR", e.message, e)
+            }
+        })
+    }
+
+    override fun initialize() {
+        val lbm = LocalBroadcastManager.getInstance(reactContext)
+
+        // Sync callback broadcast
+        lbm.registerReceiver(syncCallbackBroadcast, IntentFilter("sync_callback_broadcast"))
+
+        // Image Upload failed broadcast
+        lbm.registerReceiver(imageUploadFailedBroadcast, IntentFilter(IntentConstants.IMAGE_UPLOAD_FAILED_BROADCAST))
+
+        // Session Upload failed broadcast
+        lbm.registerReceiver(sessionUploadFailedBroadcast, IntentFilter(IntentConstants.SESSION_UPLOAD_FAILED_BROADCAST))
+
+        // Session Processing SLA Breached broadcast
+        lbm.registerReceiver(sessionProcessingSlaBreachedBroadcast, IntentFilter(IntentConstants.SESSION_PROCESSING_SLA_BREACHED_BROADCAST))
+
+        // Image Slow Upload broadcast
+        lbm.registerReceiver(imageSlowUploadBroadcast, IntentFilter(IntentConstants.IMAGE_SLOW_UPLOAD_BROADCAST))
+
+        // High CPU Usage broadcast
+        lbm.registerReceiver(highCpuUsageBroadcast, IntentFilter(IntentConstants.HIGH_CPU_USAGE_BROADCAST))
+
+        // High Device Temperature broadcast
+        lbm.registerReceiver(highDeviceTemperatureBroadcast, IntentFilter(IntentConstants.HIGH_DEVICE_TEMPERATURE_BROADCAST))
+
+        // Low Device Storage broadcast
+        lbm.registerReceiver(lowDeviceStorageBroadcast, IntentFilter(IntentConstants.LOW_DEVICE_STORAGE_BROADCAST))
+
+        // Low Battery broadcast
+        lbm.registerReceiver(lowBatteryBroadcast, IntentFilter(IntentConstants.LOW_BATTERY_BROADCAST))
+
+        irResultCallback = object : IRResultAndActionsCallback {
+            override fun onCallback(
+                globalSessionId: String,
+                isSuccess: Boolean,
+                broadCastFor: ACTION_TYPE,
+                message: String
+            ) {
+                when(broadCastFor) {
+                    ACTION_TYPE.ACTION_GENERATED -> {
+                        sendSessionRealTimeResultEvent(globalSessionId, message, SDKEvent.ACTION_GENERATED_EVENT)
+                    }
+                    ACTION_TYPE.RESULTS_GENERATED -> {
+                        sendSessionRealTimeResultEvent(globalSessionId, message, SDKEvent.SESSION_RESULT_EVENT)
+                    }
+                }
+
+            }
+        }
+        InfiVizShotsSDK.setIRResultAndActionsCallback(irResultCallback)
+    }
+
+    override fun canOverrideExistingModule(): Boolean = true
+
+    override fun invalidate() {
+        val lbm = LocalBroadcastManager.getInstance(reactContext)
+        lbm.unregisterReceiver(syncCallbackBroadcast)
+        lbm.unregisterReceiver(imageUploadFailedBroadcast)
+        lbm.unregisterReceiver(sessionUploadFailedBroadcast)
+        lbm.unregisterReceiver(sessionProcessingSlaBreachedBroadcast)
+        lbm.unregisterReceiver(imageSlowUploadBroadcast)
+        lbm.unregisterReceiver(highCpuUsageBroadcast)
+        lbm.unregisterReceiver(highDeviceTemperatureBroadcast)
+        lbm.unregisterReceiver(lowDeviceStorageBroadcast)
+        lbm.unregisterReceiver(lowBatteryBroadcast)
+        InfiVizShotsSDK.removeIRResultAndActionsCallback(irResultCallback)
+    }
+
+    override fun onActivityResult(
+        activity: Activity, requestCode: Int, resultCode: Int, data: Intent?
+    ) {
+        if (requestCode == 22 && resultCode == Activity.RESULT_OK) {
+            val tempSessionId = data!!.getStringExtra(IntentConstants.TEMP_SESSION_ID)
+            startCameraCallback?.invoke(tempSessionId!!)
+            startCameraCallback = null
+        }
+    }
+
+    override fun onNewIntent(p0: Intent?) {
+    }
+
+    companion object {
+        const val NAME = "InfivizShotsReactSdk"
+        private const val TAG = "InfivizShotsRNBridge"
+    }
+}