@infilect-sdk/capacitor-infiviz-shots 1.0.2

package/android/src/main/java/com/infilectcapacitordev/capacitor/infivizshots/InfivizShotsPlugin.kt

@@ -0,0 +1,814 @@
+package com.infilectcapacitordev.capacitor.infivizshots
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.google.gson.Gson
+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 android.util.Log
+import org.json.JSONArray
+import org.json.JSONObject
+
+@CapacitorPlugin(name = "InfivizShotsPlugin")
+class InfivizShotsPlugin : Plugin() {
+
+    private var irResultCallback: IRResultAndActionsCallback? = null
+    private var startCameraCallbackSessionId: ((String) -> Unit)? = null
+
+    private lateinit var cameraLauncher: androidx.activity.result.ActivityResultLauncher<Intent>
+
+    // ── Broadcast Receivers ────────────────────────────────────────────
+
+    private val syncCallbackBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            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: ${InfivizShotsEvents.SYNC_EVENT.eventName} | sessionId: $sessionId, status: $status")
+            sendSyncEventToCapacitor(
+                InfivizShotsEvents.SYNC_EVENT.eventName,
+                sessionId,
+                status,
+                message,
+                universalSessionId
+            )
+        }
+    }
+
+    private val imageUploadFailedBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                put("imageUri", intent.getStringExtra(IntentConstants.IMAGE_URI))
+                put("statusCode", intent.getIntExtra(IntentConstants.STATUS_CODE, 0))
+                put("errorType", intent.getStringExtra(IntentConstants.ERROR_TYPE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.IMAGE_UPLOAD_FAILED_EVENT, params)
+        }
+    }
+
+    private val sessionUploadFailedBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                put("statusCode", intent.getIntExtra(IntentConstants.STATUS_CODE, 0))
+                put("errorType", intent.getStringExtra(IntentConstants.ERROR_TYPE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.SESSION_UPLOAD_FAILED_EVENT, params)
+        }
+    }
+
+    private val sessionProcessingSlaBreachedBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                put("imageCount", intent.getIntExtra("image_count", 0))
+                put("baseSlaSec", intent.getIntExtra("base_sla_sec", 0))
+                put("bufferSec", intent.getIntExtra("buffer_sec", 0))
+                put("effectiveSla", intent.getIntExtra("effective_sla", 0))
+                put("elapsedTimeSec", intent.getLongExtra("elapsed_time_sec", 0L).toDouble())
+                put("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.SESSION_PROCESSING_SLA_BREACHED_EVENT, params)
+        }
+    }
+
+    private val imageSlowUploadBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("sessionId", intent.getStringExtra(IntentConstants.SESSION_ID))
+                put("imageUri", intent.getStringExtra(IntentConstants.IMAGE_URI))
+                put("uploadDurationSec", intent.getDoubleExtra(IntentConstants.UPLOAD_DURATION_SEC, 0.0))
+                put("derivedUploadSpeedKbps", intent.getDoubleExtra(IntentConstants.DERIVED_UPLOAD_SPEED_KBPS, 0.0))
+                put("reasonCode", intent.getIntExtra(IntentConstants.REASON_CODE, 0))
+                put("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.IMAGE_SLOW_UPLOAD_EVENT, params)
+        }
+    }
+
+    private val highCpuUsageBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("cpuUsageThresholdPercent", intent.getIntExtra("cpu_usage_threshold_percent", 0))
+                put("currentCpuUsagePercent", intent.getIntExtra("current_cpu_usage_percent", 0))
+                put("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.HIGH_CPU_USAGE_EVENT, params)
+        }
+    }
+
+    private val highDeviceTemperatureBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("deviceTemperatureThresholdCelsius", intent.getIntExtra("device_temperature_threshold_celsius", 0).toDouble())
+                put("currentDeviceTemperatureCelsius", intent.getIntExtra("current_device_temperature_celsius", 0).toDouble())
+                put("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.HIGH_DEVICE_TEMPERATURE_EVENT, params)
+        }
+    }
+
+    private val lowDeviceStorageBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("availableMb", intent.getLongExtra("available_mb", 0L).toDouble())
+                put("usedMb", intent.getLongExtra("used_mb", 0L).toDouble())
+                put("remainingMb", intent.getLongExtra("remaining_mb", 0L).toDouble())
+                put("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.LOW_DEVICE_STORAGE_EVENT, params)
+        }
+    }
+
+    private val lowBatteryBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            intent ?: return
+            val params = JSObject().apply {
+                put("event", intent.getStringExtra(IntentConstants.EVENT))
+                put("currentBatteryPercent", intent.getIntExtra("current_battery_percent", 0))
+                put("statusCode", intent.getStringExtra(IntentConstants.STATUS_CODE))
+                put("message", intent.getStringExtra(IntentConstants.MESSAGE))
+                put("timestamp", intent.getLongExtra(IntentConstants.TIMESTAMP, 0L).toDouble())
+            }
+            emitBroadcastEvent(InfivizShotsEvents.LOW_BATTERY_EVENT, params)
+        }
+    }
+
+    // ── Helper methods ─────────────────────────────────────────────────
+
+    private fun emitBroadcastEvent(event: InfivizShotsEvents, params: JSObject) {
+        Log.d(TAG, "Broadcast received: ${event.eventName} | params: $params")
+        notifyListeners(event.eventName, params)
+    }
+
+    private fun sendSyncEventToCapacitor(
+        eventName: String?,
+        sessionId: String?,
+        status: String?,
+        message: String?,
+        universalSessionId: String? = null
+    ) {
+        val params = JSObject().apply {
+            put("temporarySessionID", sessionId)
+            put("status", status)
+            put("message", message)
+            put("universalSessionID", universalSessionId)
+        }
+        notifyListeners(eventName, params)
+    }
+
+    private fun sendSessionRealTimeResultEvent(
+        sessionId: String?,
+        message: String?,
+        sdkEvent: String?
+    ) {
+        val params = JSObject().apply {
+            put("sessionId", sessionId)
+            put("message", message)
+        }
+        notifyListeners(sdkEvent, params)
+    }
+
+    private fun convertJSObjectToStringHashMap(jsObject: JSObject?): HashMap<String, String> {
+        val result = HashMap<String, String>()
+        if (jsObject != null) {
+            val keys = jsObject.keys()
+            while (keys.hasNext()) {
+                val key = keys.next()
+                try {
+                    val value = jsObject.get(key)
+                    result[key] = value?.toString() ?: ""
+                } catch (e: Exception) {
+                    result[key] = ""
+                }
+            }
+        }
+        return result
+    }
+
+    // Method to handle camera result from MainActivity (if using activity result pattern)
+    fun onCameraResult(sessionId: String?, imageDetails: String?) {
+        if (sessionId != null) {
+            startCameraCallbackSessionId?.invoke(sessionId)
+        } else {
+            Log.e(TAG, "SessionId is null in onCameraResult")
+        }
+    }
+
+    // ── Lifecycle ──────────────────────────────────────────────────────
+
+    override fun load() {
+        super.load()
+
+        // Register camera activity result launcher
+        cameraLauncher = activity.registerForActivityResult(
+            ActivityResultContracts.StartActivityForResult()
+        ) { activityResult ->
+            if (activityResult.resultCode == android.app.Activity.RESULT_OK && activityResult.data != null) {
+                val tempSessionId = activityResult.data?.getStringExtra(IntentConstants.TEMP_SESSION_ID)
+                if (tempSessionId != null) {
+                    startCameraCallbackSessionId?.invoke(tempSessionId)
+                    startCameraCallbackSessionId = null
+                }
+            }
+        }
+
+        val lbm = LocalBroadcastManager.getInstance(context)
+
+        // 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))
+
+        // Set up IR result callback
+        irResultCallback = object : IRResultAndActionsCallback {
+            override fun onCallback(
+                globalSessionId: String,
+                isSuccess: Boolean,
+                broadCastFor: ACTION_TYPE,
+                message: String
+            ) {
+                when (broadCastFor) {
+                    ACTION_TYPE.ACTION_GENERATED -> sendSessionRealTimeResultEvent(
+                        globalSessionId,
+                        message,
+                        InfivizShotsEvents.ACTION_GENERATED_EVENT.eventName
+                    )
+                    ACTION_TYPE.RESULTS_GENERATED -> sendSessionRealTimeResultEvent(
+                        globalSessionId,
+                        message,
+                        InfivizShotsEvents.SESSION_RESULT_EVENT.eventName
+                    )
+                }
+            }
+        }
+        InfiVizShotsSDK.setIRResultAndActionsCallback(irResultCallback)
+    }
+
+    override fun handleOnDestroy() {
+        val lbm = LocalBroadcastManager.getInstance(context)
+        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)
+        irResultCallback?.let { InfiVizShotsSDK.removeIRResultAndActionsCallback(it) }
+    }
+
+    // ── Plugin Methods ─────────────────────────────────────────────────
+
+    @PluginMethod
+    fun initialize(call: PluginCall) {
+        val appID = call.getString("appID")
+        val authSecret = call.getString("authSecret")
+        val accountKey = call.getString("accountKey")
+        val userID = call.getString("userID")
+        val clientID = call.getString("clientID")
+        val apiToken = call.getString("apiToken")
+        val env = call.getString("env")
+
+        val ctx = if (activity != null) activity else context
+        val environment: InfivizshotsEnvironment = when (env) {
+            "staging" -> InfivizshotsEnvironment.UAT
+            "production" -> InfivizshotsEnvironment.PROD
+            else -> InfivizshotsEnvironment.PROD
+        }
+        val platform = "CAPACITOR"
+        val isDebug = false
+
+        InfiVizShotsSDK.init(
+            ctx.applicationContext,
+            object : OnInfivizShotsSDKInitializationListener {
+                override fun onInfivizShotsSDKInitSuccess() {
+                    val result = JSObject()
+                    result.put("message", "SDK Initialized successfully!!")
+                    call.resolve(result)
+                }
+
+                override fun onInfivizShotsSDKInitFailed(exception: SDKExceptions) {
+                    call.reject("SDK Initialized Failed -> ${exception.message}", exception)
+                }
+            },
+            appID, authSecret, accountKey, userID, clientID, apiToken, environment, isDebug, platform
+        )
+    }
+
+    @PluginMethod
+    fun syncSession(call: PluginCall) {
+        val sessionId = call.getString("sessionId")
+        InfiVizShotsSDK.uploadSession(
+            activity,
+            arrayListOf(sessionId),
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    sendSyncEventToCapacitor(
+                        InfivizShotsEvents.SYNC_EVENT.eventName,
+                        response,
+                        "200",
+                        response
+                    )
+                    val result = JSObject()
+                    result.put("message", response)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    sendSyncEventToCapacitor(
+                        InfivizShotsEvents.SYNC_EVENT.eventName,
+                        exception.sessionId,
+                        exception.status.toString(),
+                        exception.message.toString()
+                    )
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun startCamera(call: PluginCall) {
+        val taskName = call.getString("taskName") ?: ""
+        val storeTitle = call.getString("storeTitle") ?: ""
+        val storeId = call.getString("storeId") ?: ""
+        val photoType = call.getString("photoType") ?: ""
+        val category = call.getString("category") ?: ""
+        val maxPhoto = call.getInt("maxPhoto") ?: 0
+        val maxPhotoOneGo = call.getInt("maxPhotoOneGo") ?: 0
+        val metaData = call.getObject("metaData", null)
+
+        startCameraCallbackSessionId = { sessionId ->
+            val result = JSObject()
+            result.put("sessionId", sessionId)
+            call.resolve(result)
+        }
+
+        val metadataMap = convertJSObjectToStringHashMap(metaData)
+
+        InfiVizShotsSDK.startCamera(
+            activity,
+            taskName,
+            storeTitle,
+            storeId,
+            photoType,
+            category,
+            maxPhoto,
+            maxPhotoOneGo,
+            22,
+            metadataMap,
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    // No Op — result comes through activity result callback
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun retakeImage(call: PluginCall) {
+        val temporarySessionId = call.getString("temporarySessionId") ?: ""
+        val imageURI = call.getString("imageURI") ?: ""
+
+        InfiVizShotsSDK.retakeImage(
+            activity,
+            temporarySessionId,
+            imageURI,
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    val result = JSObject()
+                    result.put("sessionId", response)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            },
+            32
+        )
+    }
+
+    @PluginMethod
+    fun deletePhoto(call: PluginCall) {
+        val imageURI = call.getString("imageURI") ?: ""
+        val temporarySessionId = call.getString("temporarySessionId") ?: ""
+
+        InfiVizShotsSDK.deleteImage(
+            activity,
+            temporarySessionId,
+            imageURI,
+            object : DeleteCallBack() {
+                override fun onSuccess(tempSessionId: String?, errorEnums: ErrorEnums?) {
+                    if (errorEnums != null) {
+                        call.reject(errorEnums.message, errorEnums.status.toString())
+                    } else {
+                        val result = JSObject()
+                        result.put("message", "Deleted file successfully")
+                        call.resolve(result)
+                    }
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun resumeCamera(call: PluginCall) {
+        val tempSessionId = call.getString("temporarySessionID") ?: ""
+        val metaData = call.getObject("metaData", null)
+        val metadataMap = convertJSObjectToStringHashMap(metaData)
+
+        InfiVizShotsSDK.resumeCamera(
+            activity,
+            tempSessionId,
+            22,
+            metadataMap,
+            object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    Log.d(TAG, "RESUME CAMERA: $response")
+                    val result = JSObject()
+                    result.put("sessionId", response)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun uploadSessions(call: PluginCall) {
+        val sessionIdsArray = call.getArray("temporarySessionIDs")
+        val sessionIds = ArrayList<String>()
+        if (sessionIdsArray != null) {
+            for (i in 0 until sessionIdsArray.length()) {
+                sessionIds.add(sessionIdsArray.optString(i, ""))
+            }
+        }
+
+        InfiVizShotsSDK.uploadSession(
+            context,
+            sessionIds,
+            object : UploadCallback() {
+                override fun onError(sdkExceptions: SDKExceptions) {
+                    call.reject(sdkExceptions.message, sdkExceptions)
+                }
+
+                override fun onSuccess(tempId: String?) {
+                    val result = JSObject()
+                    result.put("sessionId", tempId)
+                    call.resolve(result)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun dataArchival(call: PluginCall) {
+        InfiVizShotsSDK.dataArchival_v1(activity)
+        val result = JSObject()
+        result.put("message", "Data archival initiated")
+        call.resolve(result)
+    }
+
+    @PluginMethod
+    fun fetchSessionDetails(call: PluginCall) {
+        val temporarySessionID = call.getString("temporarySessionID") ?: ""
+
+        InfiVizShotsSDK.fetchSessionDetails(
+            activity,
+            temporarySessionID,
+            object : SDKCallback<InfiSession> {
+                override fun onSuccess(response: InfiSession) {
+                    val responseJson = Gson().toJson(response)
+                    val result = JSObject()
+                    result.put("data", responseJson)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun fetchUniversalSessionId(call: PluginCall) {
+        val temporarySessionID = call.getString("temporarySessionID") ?: ""
+
+        InfiVizShotsSDK.fetchUniversalSessionId(
+            activity,
+            temporarySessionID,
+            object : SDKCallback<String> {
+                override fun onSuccess(sessionId: String) {
+                    val result = JSObject()
+                    result.put("sessionId", sessionId)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun viewIRResults(call: PluginCall) {
+        val sessionId = call.getString("sessionId") ?: ""
+
+        InfiVizShotsSDK.viewIRResults(
+            activity,
+            sessionId,
+            object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    val result = JSObject()
+                    result.put("response", response)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun startActionsWorkFlow(call: PluginCall) {
+        val storeId = call.getString("storeId") ?: ""
+        val sessionId = call.getString("sessionId") ?: ""
+        val latitude = call.getString("latitude") ?: "0"
+        val longitude = call.getString("longitude") ?: "0"
+        val dateTimeStamp = call.getString("dateTimeStamp") ?: ""
+
+        InfiVizShotsSDK.startActionsWorkFlow(
+            activity,
+            storeId,
+            sessionId,
+            latitude.toLong(),
+            longitude.toLong(),
+            dateTimeStamp,
+            object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    val result = JSObject()
+                    result.put("response", response)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun logout(call: PluginCall) {
+        InfiVizShotsSDK.logoutSDK(
+            context,
+            object : OnInfivizShotsSDKLogoutListener {
+                override fun onInfivizShotsSDKLogoutSuccess() {
+                    val result = JSObject()
+                    result.put("message", "From Callback: SDK Logout success")
+                    call.resolve(result)
+                }
+
+                override fun onInfivizShotsSDKLogoutFailed(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun getIrResult(call: PluginCall) {
+        val sessionId = call.getString("sessionId") ?: ""
+
+        InfiVizShotsSDK.getIRResult(
+            context,
+            sessionId,
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    val result = JSObject()
+                    result.put("result", response)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun getActionsResult(call: PluginCall) {
+        val sessionId = call.getString("sessionId") ?: ""
+
+        InfiVizShotsSDK.getActionsResult(
+            context,
+            sessionId,
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    val result = JSObject()
+                    result.put("result", response)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun getSessionStatus(call: PluginCall) {
+        val sessionId = call.getString("sessionId") ?: ""
+
+        InfiVizShotsSDK.getSessionStatus(
+            context,
+            sessionId,
+            object : SessionStateListener {
+                override fun sessionState(status: Int, message: String) {
+                    val result = JSObject()
+                    result.put("data", Gson().toJson(SessionStatus(status, message)))
+                    call.resolve(result)
+                }
+
+                override fun error(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun checkTokenValidity(call: PluginCall) {
+        val clientID = call.getString("clientID") ?: ""
+        val userID = call.getString("userID") ?: ""
+
+        InfiVizShotsSDK.checkTokenValidity(
+            context,
+            clientID,
+            userID,
+            object : SDKCallback<Boolean> {
+                override fun onSuccess(isValid: Boolean) {
+                    val result = JSObject()
+                    result.put("isValid", isValid)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception.status.toString())
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun fetchLatestSdkStatus(call: PluginCall) {
+        val ctx = if (activity != null) activity else context
+
+        InfiVizShotsSDK.fetchLatestSdkStatus(
+            ctx,
+            object : SDKCallback<infilect.infiviz.models.SDKStatus> {
+                override fun onSuccess(status: infilect.infiviz.models.SDKStatus) {
+                    val jsonString = Gson().toJson(status)
+                    val jsonObject = JSONObject(jsonString)
+                    val result = JSObject.fromJSONObject(jsonObject)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun fetchSdkStatusLogs(call: PluginCall) {
+        val days = call.getInt("days") ?: 7
+        val ctx = if (activity != null) activity else context
+
+        InfiVizShotsSDK.fetchSdkStatusLogs(
+            ctx,
+            days,
+            object : SDKCallback<List<infilect.infiviz.models.SDKStatus>> {
+                override fun onSuccess(statusList: List<infilect.infiviz.models.SDKStatus>) {
+                    val jsonArray = JSONArray()
+                    for (status in statusList) {
+                        val jsonString = Gson().toJson(status)
+                        val jsonObject = JSONObject(jsonString)
+                        jsonArray.put(jsonObject)
+                    }
+                    val result = JSObject()
+                    result.put("logs", jsonArray)
+                    call.resolve(result)
+                }
+
+                override fun onError(exception: SDKExceptions) {
+                    call.reject(exception.message, exception)
+                }
+            }
+        )
+    }
+
+    // ── Helper class ───────────────────────────────────────────────────
+
+    private data class SessionStatus(var status: Int, var message: String?)
+
+    companion object {
+        private const val TAG = "InfivizShotsPlugin"
+    }
+}