@infilectorg/infiviz-shots-react-sdk 1.2.12 → 1.2.13

package/README.md

@@ -3,7 +3,13 @@
 - Always update this file when ever a new pr is raised. Log the features/bugs/improvements tickets in this file with newest on top.
 
 Following are the versions for **React Native SDK**
-- **V 1.2.11** <br/>
+- **V 1.2.13** <br />
+1. Image Processing SLA Breach Notification (Tiered SLA)
+2. Slow Photo Upload Detection (Per Image)
+3. Fetch Latest status of SDK 
+4. Session Upload Timeout (Very Poor Network) IOS
+
+- **V 1.2.12** <br/>
 1. Updated the default timeout config
 
 - **V 1.2.11** <br/>

package/android/build.gradle

@@ -108,7 +108,7 @@ dependencies {
   implementation 'androidx.constraintlayout:constraintlayout:2.2.1'
 
 
-  implementation 'com.infilect:infivizshots-sdk:RN-1.2.12'
+  implementation 'com.infilect:infivizshots-sdk:RN-1.2.13'
 
   testImplementation 'junit:junit:4.13.2'
   implementation 'com.github.bumptech.glide:glide:4.14.2'

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

@@ -56,10 +56,150 @@ class InfivizShotsReactSdkModule(private val reactContext: ReactApplicationConte
             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){
@@ -548,11 +688,74 @@ class InfivizShotsReactSdkModule(private val reactContext: ReactApplicationConte
         )
     }
 
+    @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 filter = IntentFilter("sync_callback_broadcast")
-        LocalBroadcastManager.getInstance(reactContext).registerReceiver(
-            syncCallbackBroadcast, filter
-        )
+        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,
@@ -577,7 +780,16 @@ class InfivizShotsReactSdkModule(private val reactContext: ReactApplicationConte
     override fun canOverrideExistingModule(): Boolean = true
 
     override fun invalidate() {
-        LocalBroadcastManager.getInstance(reactContext).unregisterReceiver(syncCallbackBroadcast)
+        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)
     }
 
@@ -596,5 +808,6 @@ class InfivizShotsReactSdkModule(private val reactContext: ReactApplicationConte
 
     companion object {
         const val NAME = "InfivizShotsReactSdk"
+        private const val TAG = "InfivizShotsRNBridge"
     }
 }

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

@@ -1,8 +1,15 @@
 package com.infilect.infivizshotsreactsdk
 
-
 sealed class SDKEvent(val name: String) {
      object SYNC_EVENT : SDKEvent("SyncEvent")
      object SESSION_RESULT_EVENT: SDKEvent("SessionRealTimeResultEvent")
      object ACTION_GENERATED_EVENT: SDKEvent("ActionsGeneratedEvent")
+     object IMAGE_UPLOAD_FAILED_EVENT: SDKEvent("ImageUploadFailedEvent")
+     object SESSION_UPLOAD_FAILED_EVENT: SDKEvent("SessionUploadFailedEvent")
+     object SESSION_PROCESSING_SLA_BREACHED_EVENT: SDKEvent("SESSION_PROCESSING_SLA_BREACHED")
+     object IMAGE_SLOW_UPLOAD_EVENT: SDKEvent("IMAGE_SLOW_UPLOAD")
+     object HIGH_CPU_USAGE_EVENT: SDKEvent("HighCpuUsageEvent")
+     object HIGH_DEVICE_TEMPERATURE_EVENT: SDKEvent("HighDeviceTemperatureEvent")
+     object LOW_DEVICE_STORAGE_EVENT: SDKEvent("LowDeviceStorageEvent")
+     object LOW_BATTERY_EVENT: SDKEvent("LowBatteryEvent")
 }