@infilect-sdk/capacitor-infiviz-shots 1.0.2

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

@@ -0,0 +1,1118 @@
+//package com.infilectcapacitordev.capacitor.infivizshots
+//
+//import android.util.Log
+//import android.content.Context
+//import android.content.Intent
+//import android.content.BroadcastReceiver
+//import android.content.IntentFilter
+//import androidx.activity.result.contract.ActivityResultContracts
+//import androidx.activity.result.ActivityResult
+//import androidx.activity.result.ActivityResultLauncher
+//import androidx.localbroadcastmanager.content.LocalBroadcastManager
+//import com.getcapacitor.Plugin
+//import com.getcapacitor.PluginCall
+//import com.getcapacitor.PluginMethod
+//import com.getcapacitor.annotation.CapacitorPlugin
+//import com.getcapacitor.JSObject
+//import infilect.infiviz.InfiVizShotsSDK
+//import infilect.infiviz.infilect_client.SDKCallbacks.OnInfivizShotsSDKLogoutListener
+//import infilect.infiviz.infilect_client.SDKCallbacks.OnInfivizShotsSDKInitializationListener
+//import infilect.infiviz.error.SDKExceptions
+//import infilect.infiviz.sdkEnvironment.InfivizshotsEnvironment
+//import infilect.infiviz.App
+//import infilect.infiviz.IntentConstants
+//import infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences
+//import infilect.infiviz.infilect_client.model.ivyresponse.SDKCallback
+//import com.infilect.actions.ACTION_TYPE
+//import com.infilect.actions.IRResultAndActionsCallback
+//import android.Manifest
+//import androidx.core.content.ContextCompat
+//import android.content.pm.PackageManager
+//import android.os.Build
+//import android.app.Activity
+//import com.google.gson.Gson
+//import infilect.infiviz.infilect_client.model.ivyresponse.InfiSession
+//import infilect.infiviz.infilect_client.model.ivyresponse.DeleteCallBack
+//import infilect.infiviz.error.ErrorEnums
+//
+//@CapacitorPlugin(name = "SamplePlugin")
+//class SamplePlugin : Plugin() {
+//
+//
+//    // Callback for startCamera session ID
+//    private var startCameraCallbackSessionId: ((String) -> Unit)? = null
+//
+//
+//    // Method to handle camera result from MainActivity
+//    fun onCameraResult(sessionId: String?, imageDetails: String?) {
+//        if (sessionId != null) {
+//            startCameraCallbackSessionId?.invoke(sessionId)
+//        } else {
+//            Log.e("SamplePlugin", "SessionId is null in onCameraResult")
+//        }
+//    }
+//
+//    private var irResultCallback: IRResultAndActionsCallback? = null
+//
+//    private var cameraLauncher: ActivityResultLauncher<Intent>? = null
+//    private var permissionLauncher: ActivityResultLauncher<Array<String>>? = null
+//    private var pendingCameraCall: PluginCall? = null
+//
+//    private val syncCallbackBroadcast: BroadcastReceiver = 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)
+//
+//            InfiVizShotsSDK.fetchUniversalSessionId(
+//                getActivity(),
+//                sessionId,
+//                object : SDKCallback<String?> {
+//                    override fun onSuccess(universalSessionId: String?) {
+//                        sendEventToCapacitor(
+//                            "SyncCompleted",
+//                            sessionId,
+//                            universalSessionId,
+//                            status,
+//                            message
+//                        )
+//                    }
+//
+//                    override fun onError(exception: SDKExceptions) {
+//                        sendEventToCapacitor(
+//                            "SyncCompleted",
+//                            exception.getSessionId(),
+//                            "",
+//                            exception.getStatus().toString(),
+//                            exception.message
+//                        )
+//                    }
+//                })
+//        }
+//    }
+//
+//    override fun load() {
+//        super.load()
+//
+//        // Register permission launcher
+//        permissionLauncher = activity.registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
+//            val allGranted = permissions.values.all { it }
+//            if (allGranted) {
+//                pendingCameraCall?.let { call ->
+//                    startCameraInternal(call)
+//                }
+//            } else {
+//                Log.e("SamplePlugin", "Permissions denied")
+//                pendingCameraCall?.let { call ->
+//                    call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_PERMISSION_DENIED, PluginConstants.MESSAGE_PERMISSION_DENIED))
+//                }
+//            }
+//            pendingCameraCall = null
+//        }
+//
+//        cameraLauncher = activity.registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { activityResult: ActivityResult ->
+//
+//            when (activityResult.resultCode) {
+//                Activity.RESULT_OK, PluginConstants.CAMERA_REQUEST_CODE -> { // RESULT_OK or custom request code for camera
+//                    if (activityResult.data != null) {
+//                        val tempSessionId: String? = activityResult.data?.getStringExtra(IntentConstants.TEMP_SESSION_ID)
+//                        val sessionId: String? = activityResult.data?.getStringExtra(IntentConstants.SESSION_ID)
+//                        val imageDetails: String? = activityResult.data?.getStringExtra(IntentConstants.IMAGE_DETAILS)
+//
+//                        Log.i("SamplePlugin", "Camera success - tempSessionId: $tempSessionId, sessionId: $sessionId, imageDetails: $imageDetails")
+//
+//                        // Use tempSessionId first, fallback to sessionId
+//                        val finalSessionId = tempSessionId ?: sessionId
+//                        if (finalSessionId != null) {
+//                            Log.i("SamplePlugin", "Invoking callback with sessionId: $finalSessionId")
+//                            startCameraCallbackSessionId?.invoke(finalSessionId)
+//                        } else {
+//                            Log.e("SamplePlugin", "No session ID found in camera result")
+//                            // Try to get sessionId from the intent extras if not found in data
+//                            val intentSessionId = activityResult.data?.getStringExtra("sessionId")
+//                            if (intentSessionId != null) {
+//                                Log.i("SamplePlugin", "Found sessionId in intent extras: $intentSessionId")
+//                                startCameraCallbackSessionId?.invoke(intentSessionId)
+//                            } else {
+//                                Log.e("SamplePlugin", "No session ID found anywhere in camera result")
+//                            }
+//                        }
+//                    } else {
+//                        Log.e("SamplePlugin", "Camera result data is null")
+//                    }
+//                }
+//                Activity.RESULT_CANCELED -> { // RESULT_CANCELED
+//                    Log.w("SamplePlugin", "Camera was canceled by user")
+//                }
+//                else -> {
+//                    Log.w("SamplePlugin", "Camera returned unexpected result code: ${activityResult.resultCode}")
+//                }
+//            }
+//        }
+//
+//        // Register broadcast receiver
+//        val filter = IntentFilter("sync_callback_broadcast")
+//        LocalBroadcastManager.getInstance(context)
+//            .registerReceiver(syncCallbackBroadcast, filter)
+//
+//        // 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,
+//                        "ActionsGeneratedEvent"
+//                    )
+//
+//                    ACTION_TYPE.RESULTS_GENERATED -> sendSessionRealTimeResultEvent(
+//                        globalSessionId,
+//                        message,
+//                        "SessionRealTimeResultEvent"
+//                    )
+//                }
+//            }
+//        }
+//        InfiVizShotsSDK.setIRResultAndActionsCallback(irResultCallback)
+//    }
+//
+//    private fun sendEventToCapacitor(
+//        eventName: String?,
+//        sessionId: String?,
+//        universalSessionId: String?,
+//        status: String?,
+//        message: String?
+//    ) {
+//        val params = JSObject()
+//        params.put("temporarySessionId", sessionId)
+//        params.put("universalSessionId", universalSessionId)
+//        params.put("status", status)
+//        params.put("message", message)
+//        notifyListeners(eventName, params)
+//    }
+//
+//    private fun sendEventToCapacitor(eventName: String?, sessionId: String?) {
+//        val params = JSObject()
+//        params.put("sessionId", sessionId)
+//        notifyListeners(eventName, params)
+//    }
+//
+//    private fun sendSessionRealTimeResultEvent(
+//        sessionId: String?,
+//        message: String?,
+//        sdkEvent: String?
+//    ) {
+//        val params = JSObject()
+//        params.put("sessionId", sessionId)
+//        params.put("message", message)
+//        notifyListeners(sdkEvent, params)
+//    }
+//
+//    @PluginMethod
+//    fun echo(call: PluginCall) {
+//        val value = call.getString("value") ?: "Default Value"
+//
+//        val ret = JSObject()
+//        ret.put("value", value)
+//        call.resolve(ret)
+//    }
+//
+//    @PluginMethod
+//    fun initialize(call: PluginCall) {
+//        try {
+//            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 context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            val appContext = context.applicationContext
+//
+//            if (infilect.infiviz.App.appInstance == null) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            val environment = if ("staging" == env) InfivizshotsEnvironment.UAT else InfivizshotsEnvironment.PROD
+//
+//            InfiVizShotsSDK.init(appContext, object : OnInfivizShotsSDKInitializationListener {
+//                override fun onInfivizShotsSDKInitSuccess() {
+//                    val result = JSObject()
+//                    result.put("message", "SDK initialized successfully!")
+//                    result.put("status", "723")
+//                    call.resolve(result)
+//                }
+//
+//                override fun onInfivizShotsSDKInitFailed(exception: SDKExceptions) {
+//                    val err = JSObject()
+//                    err.put("message", exception.message)
+//                    err.put("status", exception.getStatus()?.toString())
+//                    err.put("sessionId", exception.getSessionId())
+//                    call.resolve(err)
+//                }
+//            }, appID, authSecret, accountKey, userID, clientID, apiToken, environment, false)
+//
+//        } catch (e: Exception) {
+//            call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "SDK Initialization Failed: ${e.message}"))
+//        }
+//    }
+//
+//    private fun isAppInitialized(): Boolean {
+//        return try {
+//            infilect.infiviz.App.appInstance != null
+//        } catch (e: Exception) {
+//            false
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun checkSDKStatus(call: PluginCall) {
+//        try {
+//            // Get context safely - use the plugin's context which is always available
+//            val context = this.context
+//            if (context == null) {
+//                val result = JSObject()
+//                result.put("isAppInitialized", false)
+//                result.put("isSDKInitialized", false)
+//                result.put("message", PluginConstants.MESSAGE_CONTEXT_NULL)
+//                call.resolve(result)
+//                return
+//            }
+//
+//            // Use Application context for SDK operations
+//            val appContext = context.applicationContext
+//
+//            // Check App initialization
+//            val isAppInit = isAppInitialized()
+//
+//            // Check SDK initialization by looking for auth key
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(appContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            val isSDKInit = !authKey.isNullOrEmpty()
+//
+//            val result = JSObject()
+//            result.put("isAppInitialized", isAppInit)
+//            result.put("isSDKInitialized", isSDKInit)
+//            result.put("appInstance", infilect.infiviz.App.appInstance?.toString() ?: "null")
+//            result.put("message", "SDK Status checked successfully")
+//
+//            call.resolve(result)
+//
+//        } catch (e: Exception) {
+//            val result = JSObject()
+//            result.put("isAppInitialized", false)
+//            result.put("isSDKInitialized", false)
+//            result.put("message", "SDK Status check failed: ${e.message}")
+//            call.resolve(result)
+//        }
+//    }
+//    @PluginMethod
+//    fun startCamera(call: PluginCall) {
+//        // Check permissions first
+//        if (!checkCameraPermissions()) {
+//            pendingCameraCall = call
+//            requestCameraPermissions()
+//            return
+//        }
+//
+//        startCameraInternal(call)
+//    }
+//
+//    private fun checkCameraPermissions(): Boolean {
+//        val permissions = getRequiredCameraPermissions()
+//        return permissions.all { permission ->
+//            ContextCompat.checkSelfPermission(getContext(), permission) == PackageManager.PERMISSION_GRANTED
+//        }
+//    }
+//
+//    private fun getRequiredCameraPermissions(): Array<String> {
+//        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+//            arrayOf(
+//                Manifest.permission.CAMERA,
+//                Manifest.permission.READ_PHONE_STATE,
+//                Manifest.permission.ACCESS_FINE_LOCATION,
+//                Manifest.permission.POST_NOTIFICATIONS
+//            )
+//        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+//            arrayOf(
+//                Manifest.permission.CAMERA,
+//                Manifest.permission.READ_PHONE_STATE,
+//                Manifest.permission.ACCESS_FINE_LOCATION
+//            )
+//        } else {
+//            arrayOf(
+//                Manifest.permission.CAMERA,
+//                Manifest.permission.READ_PHONE_STATE,
+//                Manifest.permission.WRITE_EXTERNAL_STORAGE,
+//                Manifest.permission.ACCESS_FINE_LOCATION
+//            )
+//        }
+//    }
+//
+//    private fun requestCameraPermissions() {
+//        val permissions = getRequiredCameraPermissions()
+//        permissionLauncher?.launch(permissions)
+//    }
+//
+//    private fun startCameraInternal(call: PluginCall) {
+//        try {
+//            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 env = call.getString("env")
+//
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            val appContext = context.applicationContext
+//
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(appContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            val environment = if ("staging" == env) InfivizshotsEnvironment.UAT else InfivizshotsEnvironment.PROD
+//
+//            if (cameraLauncher == null) {
+//                call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_CAMERA_LAUNCHER_NULL, PluginConstants.MESSAGE_CAMERA_LAUNCHER_NULL))
+//                return
+//            }
+//
+//            startCameraCallbackSessionId = { sessionId ->
+//                val result = JSObject()
+//                result.put("sessionId", sessionId)
+//                call.resolve(result)
+//            }
+//
+//            InfiVizShotsSDK.startCamera(
+//                getActivity(),
+//                taskName,
+//                storeTitle,
+//                storeId,
+//                photoType,
+//                category,
+//                maxPhoto,
+//                maxPhotoOneGo,
+//                PluginConstants.CAMERA_REQUEST_CODE,
+//                object : SDKCallback<String> {
+//                    override fun onSuccess(response: String) {
+//                    }
+//
+//                    override fun onError(exception: SDKExceptions) {
+//                        val err = JSObject()
+//                        err.put("message", exception.message)
+//                        err.put("status", exception.getStatus()?.toString())
+//                        err.put("sessionId", exception.getSessionId())
+//                        call.resolve(err)
+//                    }
+//                },
+//                cameraLauncher
+//            )
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Start camera failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun logout(call: PluginCall) {
+//        try {
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_CONTEXT, "SDK Logout failed: ${PluginConstants.MESSAGE_CONTEXT_NULL}"))
+//                return
+//            }
+//
+//            val appContext = context.applicationContext
+//
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_APP_NOT_INITIALIZED, "SDK Logout failed: ${PluginConstants.MESSAGE_APP_NOT_INIT}"))
+//                return
+//            }
+//
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(appContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_SDK_NOT_INITIALIZED, "SDK Logout failed: InfiViz Shots SDK is not initialized properly. Please re-initialize"))
+//                return
+//            }
+//
+//            InfiVizShotsSDK.logoutSDK(appContext, object : OnInfivizShotsSDKLogoutListener {
+//                override fun onInfivizShotsSDKLogoutSuccess() {
+//                    val result = JSObject()
+//                    result.put("message", "SDK Logout success")
+//                    result.put("status", "723")
+//                    call.resolve(result)
+//                }
+//
+//                override fun onInfivizShotsSDKLogoutFailed(exception: SDKExceptions) {
+//                    val err = JSObject()
+//                    err.put("message", exception.message)
+//                    err.put("status", exception.getStatus()?.toString())
+//                    err.put("sessionId", exception.getSessionId())
+//                    call.resolve(err)
+//                }
+//            })
+//
+//        } catch (e: Exception) {
+//            call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "SDK Logout failed: ${e.message}"))
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun syncSession(call: PluginCall) {
+//        try {
+//            val sessionId = call.getString("sessionId")
+//
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            if (!isAppInitialized()) {
+//                val result = JSObject()
+//                result.put("message", "App instance not initialized. Please check MainApplication setup.")
+//                result.put("error", "APP_NOT_INITIALIZED")
+//                call.resolve(result)
+//                return
+//            }
+//
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                val result = JSObject()
+//                result.put("message", "InfiViz Shots SDK is not initialized properly. Please re-initialize")
+//                result.put("error", "SDK_NOT_INITIALIZED")
+//                result.put("status", 706)
+//                call.resolve(result)
+//                return
+//            }
+//
+//            val sessionIds = ArrayList<String?>()
+//            sessionIds.add(sessionId)
+//
+//            InfiVizShotsSDK.uploadSession(getActivity(), sessionIds, object : SDKCallback<String?> {
+//                override fun onSuccess(syncedSession: String?) {
+//                    InfiVizShotsSDK.fetchUniversalSessionId(
+//                        getActivity(),
+//                        sessionId,
+//                        object : SDKCallback<String?> {
+//                            override fun onSuccess(universalSessionId: String?) {
+//                                sendEventToCapacitor(
+//                                    "SyncCompleted",
+//                                    syncedSession,
+//                                    universalSessionId,
+//                                    "200",
+//                                    syncedSession
+//                                )
+//
+//                                val data = JSObject()
+//                                data.put("syncedSession", syncedSession)
+//                                data.put("universalSessionId", universalSessionId)
+//                                call.resolve(ResponseUtils.createSuccessResponse(PluginConstants.MESSAGE_SESSION_SYNCED, data))
+//                            }
+//
+//                            override fun onError(exception: SDKExceptions) {
+//                                sendEventToCapacitor(
+//                                    "SyncCompleted",
+//                                    syncedSession,
+//                                    "",
+//                                    exception.getStatus().toString(),
+//                                    exception.message
+//                                )
+//
+//                                val data = JSObject()
+//                                data.put("syncedSession", syncedSession)
+//                                call.resolve(ResponseUtils.createSuccessResponse("Session synced but failed to get universal session ID: ${exception.message}", data))
+//                            }
+//                        })
+//                }
+//
+//                override fun onError(exception: SDKExceptions) {
+//                    sendEventToCapacitor(
+//                        "SyncCompleted",
+//                        exception.getSessionId(),
+//                        "",
+//                        exception.getStatus().toString(),
+//                        exception.message
+//                    )
+//
+//                    call.resolve(ResponseUtils.createErrorResponse(PluginConstants.ERROR_SDK_ERROR, "${exception.message}", exception.getStatus().toString()))
+//                }
+//            })
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Sync session failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun fetchSessionDetails(call: PluginCall) {
+//        try {
+//            val temporarySessionID = call.getString("temporarySessionID") ?: ""
+//
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            InfiVizShotsSDK.fetchSessionDetails(
+//                getActivity(),
+//                temporarySessionID,
+//                object : SDKCallback<String?> {
+//                    override fun onSuccess(response: String?) {
+//                        try {
+//                            val jsonResponse = org.json.JSONObject(response ?: "{}")
+//                            val out = JSObject().apply {
+//                                put("data", jsonResponse.optString("data"))
+//                                put("status", jsonResponse.optString("status"))
+//                                put("message", jsonResponse.optString("message"))
+//                            }
+//                            call.resolve(out)
+//                        } catch (e: Exception) {
+//                            val err = JSObject()
+//                            err.put("message", e.message)
+//                            call.resolve(err)
+//                        }
+//                    }
+//
+//                    override fun onError(exception: SDKExceptions) {
+//                        val err = JSObject()
+//                        err.put("message", exception.message)
+//                        err.put("status", exception.getStatus()?.toString())
+//                        err.put("sessionId", exception.getSessionId())
+//                        call.resolve(err)
+//                    }
+//                })
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Fetch session details failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//    @PluginMethod
+//    fun deletePhoto(call: PluginCall) {
+//        try {
+//            val temporarySessionId = call.getString("temporarySessionId")?: ""
+//            val imageURI = call.getString("imageURI")?: ""
+//
+////            if (temporarySessionId.isNullOrEmpty() || imageURI.isNullOrEmpty()) {
+////                val missingFields = listOf(
+////                    if (temporarySessionId.isNullOrEmpty()) "temporarySessionId" else null,
+////                    if (imageURI.isNullOrEmpty()) "imageURI" else null
+////                ).filterNotNull()
+////                call.resolve(
+////                    ResponseUtils.createValidationErrorResponse(
+////                        "${PluginConstants.MESSAGE_MISSING_PARAMS} for deletePhoto",
+////                        missingFields
+////                    )
+////                )
+////                return
+////            }
+//
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            InfiVizShotsSDK.deleteImage(
+//                getActivity(),
+//                temporarySessionId,
+//                imageURI,
+//                object : DeleteCallBack() {
+//                    override fun onSuccess(tempSessionId: String?, errorEnums: ErrorEnums?) {
+//                        if (errorEnums != null) {
+//                            val err = JSObject()
+//                            err.put("message", errorEnums.getMessage())
+//                            err.put("status", errorEnums.getStatus()?.toString())
+//                            call.resolve(err)
+//                        } else {
+//                            call.resolve(JSObject())
+//                        }
+//                    }
+//
+//                    override fun onError(exception: SDKExceptions) {
+//                        val err = JSObject()
+//                        err.put("message", exception.message)
+//                        err.put("status", exception.getStatus()?.toString())
+//                        err.put("sessionId", exception.getSessionId())
+//                        call.resolve(err)
+//                    }
+//                }
+//            )
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(
+//                PluginConstants.ERROR_EXCEPTION,
+//                "Delete photo failed: ${e.message}"
+//            )
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun retakeImage(call: PluginCall) {
+//        try {
+//            val temporarySessionId = call.getString("temporarySessionId") ?: ""
+//            val imageURI = call.getString("imageURI") ?: ""
+////
+////            // Validate required parameters
+////            if (temporarySessionId.isNullOrEmpty() || imageURI.isNullOrEmpty()) {
+////                val missingFields = listOf(
+////                    if (temporarySessionId.isNullOrEmpty()) "temporarySessionId" else null,
+////                    if (imageURI.isNullOrEmpty()) "imageURI" else null
+////                ).filterNotNull()
+////                call.resolve(ResponseUtils.createValidationErrorResponse("${PluginConstants.MESSAGE_MISSING_PARAMS} for retakeImage", missingFields))
+////                return
+////            }
+//
+//            // Get context safely
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            // Verify App instance is available
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            // Check if SDK is initialized
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            InfiVizShotsSDK.retakeImage(
+//                getActivity(),
+//                temporarySessionId,
+//                imageURI,
+//                object : SDKCallback<String?> {
+//                    override fun onSuccess(response: String?) {
+//                        val data = JSObject()
+//                        data.put("response", response)
+//                        call.resolve(data)
+//                    }
+//
+//                    override fun onError(exception: SDKExceptions) {
+//                        val err = JSObject()
+//                        err.put("message", exception.message)
+//                        err.put("status", exception.getStatus()?.toString())
+//                        err.put("sessionId", exception.getSessionId())
+//                        call.resolve(err)
+//                    }
+//                },
+//                PluginConstants.CAMERA_REQUEST_CODE
+//            )
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Retake image failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun getIrResult(call: PluginCall) {
+//        try {
+//            val sessionId = call.getString("sessionId") ?: ""
+//
+////            // Validate required parameters
+////            if (sessionId.isNullOrEmpty()) {
+////                call.resolve(ResponseUtils.createValidationErrorResponse("sessionId is required for getIrResult"))
+////                return
+////            }
+////
+//            // Get context safely
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            // Verify App instance is available
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            // Check if SDK is initialized
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            InfiVizShotsSDK.getIRResult(getContext(), sessionId, object : SDKCallback<String?> {
+//                override fun onSuccess(result: String?) {
+//                    val data = JSObject()
+//                    data.put("result", result)
+//                    call.resolve(data)
+//                }
+//
+//                override fun onError(exception: SDKExceptions) {
+//                    val err = JSObject()
+//                    err.put("message", exception.message)
+//                    err.put("status", exception.getStatus()?.toString())
+//                    err.put("sessionId", exception.getSessionId())
+//                    call.resolve(err)
+//                }
+//            })
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Get IR result failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun getActionsResult(call: PluginCall) {
+//        try {
+//            val sessionId = call.getString("sessionId") ?: ""
+//
+////            // Validate required parameters
+////            if (sessionId.isNullOrEmpty()) {
+////                call.resolve(ResponseUtils.createValidationErrorResponse("sessionId is required for getActionsResult"))
+////                return
+////            }
+////
+//            // Get context safely
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            // Verify App instance is available
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            // Check if SDK is initialized
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            InfiVizShotsSDK.getActionsResult(getContext(), sessionId, object : SDKCallback<String?> {
+//                override fun onSuccess(result: String?) {
+//                    val data = JSObject()
+//                    data.put("result", result)
+//                    call.resolve(data)
+//                }
+//
+//                override fun onError(exception: SDKExceptions) {
+//                    val err = JSObject()
+//                    err.put("message", exception.message)
+//                    err.put("status", exception.getStatus()?.toString())
+//                    err.put("sessionId", exception.getSessionId())
+//                    call.resolve(err)
+//                }
+//            })
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Get actions result failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//
+//    @PluginMethod
+//    fun fetchUniversalSessionId(call: PluginCall) {
+//        try {
+//            val tempID = call.getString("tempID") ?: ""
+//            Log.i("SamplePlugin", "fetchUniversalSessionId called with tempID: '$tempID'")
+//
+//            val context = this.context
+//            if (context == null) {
+//                Log.e("SamplePlugin", "fetchUniversalSessionId: Context is null")
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            InfiVizShotsSDK.fetchUniversalSessionId(
+//                getActivity(),
+//                tempID,
+//                object : SDKCallback<String?> {
+//                    override fun onSuccess(response: String?) {
+//                        try {
+//                            val jsonResponse = org.json.JSONObject(response ?: "{}")
+//
+//                            val dataObject = jsonResponse.optJSONObject("data")
+//
+//                            val sessionIdFromData = dataObject?.optString("sessionId")
+//
+//                            val out = JSObject().apply {
+//                                put("data", dataObject?.toString())
+//                                put("status", jsonResponse.optString("status"))
+//                                put("message", jsonResponse.optString("message"))
+//                            }
+//
+//                            call.resolve(out)
+//                        } catch (e: Exception) {
+//                            e.printStackTrace()
+//                            val err = JSObject()
+//                            err.put("message", e.message)
+//                            call.resolve(err)
+//                        }
+//                    }
+//
+//                    override fun onError(exception: SDKExceptions) {
+//                        val err = JSObject()
+//                        err.put("message", exception.message)
+//                        err.put("status", exception.getStatus()?.toString())
+//                        err.put("sessionId", exception.getSessionId())
+//                        call.resolve(err)
+//                    }
+//                })
+//
+//        } catch (e: Exception) {
+//            e.printStackTrace()
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Fetch universal session ID failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun fetchSessionID(call: PluginCall) {
+//        try {
+//            val taskCategory = call.getString("taskCategory")
+//            val storeID = call.getString("storeID")
+//            val taskPhotoType = call.getString("taskPhotoType")
+//
+//            // Validate required parameters
+//            if (taskCategory.isNullOrEmpty() || storeID.isNullOrEmpty() || taskPhotoType.isNullOrEmpty()) {
+//                val missingFields = listOf(
+//                    if (taskCategory.isNullOrEmpty()) "taskCategory" else null,
+//                    if (storeID.isNullOrEmpty()) "storeID" else null,
+//                    if (taskPhotoType.isNullOrEmpty()) "taskPhotoType" else null
+//                ).filterNotNull()
+//                call.resolve(ResponseUtils.createValidationErrorResponse("${PluginConstants.MESSAGE_MISSING_PARAMS} for fetchSessionID", missingFields))
+//                return
+//            }
+//
+//            // Get context safely
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            // Verify App instance is available
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            // Check if SDK is initialized
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            // Generate a temporary session ID
+//            // Note: This appears to be a placeholder implementation
+//            // In a real implementation, this should call the SDK to generate a proper session ID
+//            val tempSessionID = "session_" + System.currentTimeMillis()
+//
+//            val data = JSObject()
+//            data.put("tempSessionID", tempSessionID)
+//            call.resolve(ResponseUtils.createSuccessResponse("Temporary session ID generated successfully", data))
+//
+//        } catch (e: Exception) {
+//            val result = ResponseUtils.createErrorResponse(PluginConstants.ERROR_EXCEPTION, "Fetch session ID failed: ${e.message}")
+//            result.put("errorType", e.javaClass.simpleName)
+//            call.resolve(result)
+//        }
+//    }
+//
+//    @PluginMethod
+//    fun resumeCamera(call: PluginCall) {
+//        try {
+//            val tempSessionId = call.getString("temporarySessionID") ?: ""
+//            val requestCodeInt: Int = call.getInt("requestCode") ?: PluginConstants.CAMERA_REQUEST_CODE
+//
+//            val context = this.context
+//            if (context == null) {
+//                call.resolve(ResponseUtils.createContextErrorResponse())
+//                return
+//            }
+//
+//            if (!isAppInitialized()) {
+//                call.resolve(ResponseUtils.createAppNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            val authKey = try {
+//                infilect.infiviz.infilect_client.SecuredSharedPref.SecuredInfilectSDKPreferences.getAuthKey(context.applicationContext)
+//            } catch (e: Exception) {
+//                null
+//            }
+//
+//            if (authKey.isNullOrEmpty()) {
+//                call.resolve(ResponseUtils.createSDKNotInitializedErrorResponse())
+//                return
+//            }
+//
+//            startCameraCallbackSessionId = { sessionId ->
+//                val result = JSObject()
+//                result.put("sessionId", sessionId)
+//                call.resolve(result)
+//            }
+//
+//            InfiVizShotsSDK.resumeCamera(
+//                getActivity(),
+//                tempSessionId,
+//                requestCodeInt,
+//                object : SDKCallback<String?> {
+//                    override fun onSuccess(response: String?) {
+//                    }
+//
+//                    override fun onError(exception: SDKExceptions) {
+//                        val err = JSObject()
+//                        err.put("message", exception.message)
+//                        err.put("status", exception.getStatus()?.toString())
+//                        err.put("sessionId", exception.getSessionId())
+//                        call.resolve(err)
+//                    }
+//                })
+//
+//        } catch (e: Exception) {
+//            val err = JSObject()
+//            err.put("message", e.message)
+//            err.put("errorType", e.javaClass.simpleName)
+//            call.resolve(err)
+//        }
+//    }
+//
+//
+//}