@infilectorg/infiviz-shots-react-sdk 1.0.2

package/README.md

@@ -0,0 +1,9 @@
+** Important Note**
+
+- 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.0.0** <br/>
+1. [RN SDK Wrapper Phase 1](https://infilect.atlassian.net/browse/ISS-4810)
+   Completed RN Wrapper Phase 1

package/android/build.gradle

@@ -0,0 +1,121 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['InfivizShotsReactSdk_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+    mavenLocal()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+    classpath 'com.google.dagger:hilt-android-gradle-plugin:2.42'
+    classpath("com.facebook.react:react-native-gradle-plugin")
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: 'kotlin-kapt'
+apply plugin: 'dagger.hilt.android.plugin'
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["InfivizShotsReactSdk_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.infilect.infivizshotsreactsdk"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+    dataBinding true
+    viewBinding true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android:0.79.1"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+
+  implementation 'androidx.appcompat:appcompat:1.7.0'
+  implementation 'com.google.android.material:material:1.12.0'
+  implementation 'androidx.constraintlayout:constraintlayout:2.2.1'
+
+
+  implementation 'com.infilect:infivizshots-sdk:2.2.5'
+
+  testImplementation 'junit:junit:4.13.2'
+  implementation 'com.github.bumptech.glide:glide:4.14.2'
+  androidTestImplementation 'androidx.test.ext:junit:1.2.1'
+  implementation 'com.google.code.gson:gson:2.12.1'
+  androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1'
+  implementation 'com.facebook.stetho:stetho:1.5.1'
+  implementation "androidx.core:core-ktx:1.16.0"
+
+  // HIlt
+  implementation "com.google.dagger:hilt-android:2.42"
+  kapt "com.google.dagger:hilt-compiler:2.42"
+}
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "InfivizShotsReactSdk"
+  codegenJavaPackageName = "com.infilect.infivizshotsreactsdk"
+}

package/android/gradle.properties

@@ -0,0 +1,6 @@
+InfivizShotsReactSdk_kotlinVersion=2.0.21
+InfivizShotsReactSdk_minSdkVersion=26
+InfivizShotsReactSdk_targetSdkVersion=34
+InfivizShotsReactSdk_compileSdkVersion=35
+InfivizShotsReactSdk_ndkVersion=27.1.12297006
+android.useAndroidX=true

package/android/settings.gradle

@@ -0,0 +1,18 @@
+pluginManagement { includeBuild("../node_modules/@react-native/gradle-plugin") }
+dependencyResolutionManagement {
+  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+  repositories {
+    google()
+    mavenCentral()
+    mavenLocal()
+    maven { url 'https://jitpack.io' }
+    maven {
+      url "https://developer.infilect.com/android-sdk/repository/sdk.infivizshots"
+      credentials {
+        username 'android_developer'
+        password '1qwerty'
+      }
+    }
+  }
+}
+includeBuild('../node_modules/@react-native/gradle-plugin')

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.infilect.infivizshotsreactsdk">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+</manifest>

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

@@ -0,0 +1,502 @@
+package com.infilect.infivizshotsreactsdk
+
+import android.Manifest
+import android.R.id.message
+import android.app.Activity
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+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 okhttp3.internal.notify
+import kotlin.jvm.java
+
+@ReactModule(name = InfivizShotsReactSdkModule.NAME)
+class InfivizShotsReactSdkModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+    init {
+        reactContext.addActivityEventListener(this)
+    }
+
+    private lateinit var irResultCallback: IRResultAndActionsCallback
+
+    private fun showCustomNotification(context: Context, sessionId: String) {
+        val channelId = "real_time_results_channel"
+        val name = "Real Time Results"
+        val descriptionText = "Notifications for real-time result updates"
+
+        // Step 1: Create the channel (required for Android 8+)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val importance = NotificationManager.IMPORTANCE_HIGH
+            val channel = NotificationChannel(channelId, name, importance).apply {
+                description = descriptionText
+            }
+
+            val notificationManager: NotificationManager =
+                context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.createNotificationChannel(channel)
+        }
+
+
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(infilect.infiviz.R.drawable.infiviz)
+            .setContentTitle("Real-Time Results Received. Click To View!")
+            .setStyle(NotificationCompat.BigTextStyle().bigText("$sessionId is processed!"))
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+
+        // Step 4: Show the notification
+        with(NotificationManagerCompat.from(context)) {
+            if (ActivityCompat.checkSelfPermission(
+                    reactContext,
+                    Manifest.permission.POST_NOTIFICATIONS
+                ) != PackageManager.PERMISSION_GRANTED
+            ) { return }
+            notify(2001, builder.build())
+        }
+    }
+
+    fun createNotificationChannel(context: Context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val name = "MyChannel"
+            val descriptionText = "Channel for general notifications"
+            val importance = NotificationManager.IMPORTANCE_DEFAULT
+            val channel = NotificationChannel("CHANNEL_ID", name, importance).apply {
+                description = descriptionText
+            }
+            val notificationManager: NotificationManager =
+                context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun sendNotificationForResult() {
+
+    }
+
+    private val syncCallbackBroadcast = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            val status = intent!!.getStringExtra(IntentConstants.STATUS)
+            val message = intent.getStringExtra(IntentConstants.MESSAGE)
+            val sessionId = intent.getStringExtra(IntentConstants.SESSION_ID)
+
+            sendEventToReact(SDKEvent.SYNC_EVENT, sessionId!!, status!!, message!!)
+        }
+    }
+
+    private fun sendEventToReact(
+        eventName: SDKEvent, sessionId: String, status: String, message: String
+    ) {
+        val params = Arguments.createMap().apply {
+            putString("sessionId", sessionId)
+            putString("status", status)
+            putString("message", message)
+        }
+
+        if (reactContext.hasActiveReactInstance()) {
+            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName.name, params)
+        }
+    }
+
+    private fun sendEventToReact(eventName: SDKEvent, sessionId: String) {
+        if (reactContext.hasActiveReactInstance()) {
+            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName.name, sessionId)
+        }
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+
+    @ReactMethod
+    fun initialize(
+        appID: String,
+        authSecret: String,
+        accountKey: String,
+        userID: String,
+        clientID: String,
+        apiToken: String,
+        env: String,
+        promise: Promise
+    ) {
+        val context = currentActivity ?: reactApplicationContext
+        val environment: InfivizshotsEnvironment = when (env) {
+            "staging" -> InfivizshotsEnvironment.UAT
+            "production" -> InfivizshotsEnvironment.PROD
+            else -> InfivizshotsEnvironment.PROD  // Asked last time for default config.
+        }
+        InfiVizShotsSDK.init(
+            context.applicationContext, object : OnInfivizShotsSDKInitializationListener {
+                override fun onInfivizShotsSDKInitSuccess() {
+                    promise.resolve("SDK Initialized successfully!!")
+                }
+
+                override fun onInfivizShotsSDKInitFailed(p0: SDKExceptions) {
+                    promise.reject("SDK Initialized Failed -> ${p0.message}")
+                }
+            }, appID, authSecret, accountKey, userID, clientID, apiToken, environment
+        )
+    }
+
+    @ReactMethod
+    fun syncSession(sessionId: String) {
+        InfiVizShotsSDK.uploadSession(
+            currentActivity!!, arrayListOf(sessionId), object : SDKCallback<String> {
+                override fun onSuccess(p0: String) {
+                    sendEventToReact(SDKEvent.SYNC_EVENT, p0, "200", p0)
+                }
+
+                override fun onError(p0: SDKExceptions) {
+                    sendEventToReact(
+                        SDKEvent.SYNC_EVENT,
+                        p0.sessionId,
+                        p0.status.toString(),
+                        p0.message.toString()
+                    )
+                }
+            })
+    }
+
+    @ReactMethod
+    fun startCamera(
+        taskName: String,
+        storeTitle: String,
+        storeId: String,
+        photoType: String,
+        category: String,
+        maxPhoto: Double,
+        maxPhotoOneGo: Double,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.startCamera(
+            currentActivity!!,
+            taskName,
+            storeTitle,
+            storeId,
+            photoType,
+            category,
+            maxPhoto.toInt(),
+            maxPhotoOneGo.toInt(),
+            22,
+            object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject(e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun retakeImage(
+        temporarySessionId: String,
+        imageURI: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.retakeImage(
+            currentActivity!!,
+            temporarySessionId,
+            imageURI, object : SDKCallback<String> {
+                override fun onSuccess(response: String) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject(e)
+                }
+            }, 32
+        )
+    }
+
+    @ReactMethod
+    fun deletePhoto(
+        temporarySessionId: String,
+        imageURI: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.deleteImage(
+            currentActivity!!,
+            temporarySessionId,
+            imageURI, object : DeleteCallBack() {
+                override fun onSuccess(tempSessionId: String?, errorEnums: ErrorEnums?) {
+                    if (errorEnums != null) {
+                        promise.reject(errorEnums.status.toString(), errorEnums.message)
+                    }
+                    promise.resolve("Deleted file successfully")
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject(e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun resumeCamera(
+        tempSessionId: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.resumeCamera(
+            currentActivity!!,
+            tempSessionId, 22, object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject(e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun uploadSession(
+        temporarySessionID: ReadableArray,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.uploadSession(
+            reactContext,
+            temporarySessionID.toStringList(), object : UploadCallback() {
+                override fun onError(sdkExceptions: SDKExceptions) {
+                    promise.reject(sdkExceptions)
+                }
+
+                override fun onSuccess(tempId: String?) {
+                    promise.resolve(tempId)
+                }
+            })
+    }
+
+    private fun ReadableArray.toStringList(): ArrayList<String> {
+        val list = ArrayList<String>()
+        for (i in 0 until this.size()) {
+            list.add(this.getString(i) ?: "")
+        }
+        return list
+    }
+
+    @ReactMethod
+    fun fetchSessionDetails(
+        temporarySessionID: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.fetchSessionDetails(
+            currentActivity!!,
+            temporarySessionID, object : SDKCallback<InfiSession> {
+                override fun onSuccess(response: InfiSession) {
+                    val responseJson = Gson().toJson(response)
+                    promise.resolve(responseJson)
+                }
+
+                override fun onError(e: SDKExceptions) {
+                    promise.reject(e)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun fetchUniversalSessionId(
+        temporarySessionID: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.fetchUniversalSessionId(
+            currentActivity,
+            temporarySessionID, object : SDKCallback<String> {
+                override fun onSuccess(sessionId: String) {
+                    promise.resolve(sessionId)
+                }
+
+                override fun onError(sdkExceptions: SDKExceptions) {
+                    promise.reject(sdkExceptions)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun viewIRResults(
+        sessionId: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.viewIRResults(
+            reactContext, sessionId,
+            object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(exceptions: SDKExceptions) {
+                    promise.reject(exceptions)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun startActionsWorkFlow(
+        storeId: String,
+        sessionId: String,
+        latitude: String,
+        longitude: String,
+        dateTimeStamp: String,
+        promise: Promise
+    ) {
+        InfiVizShotsSDK.startActionsWorkFlow(
+            currentActivity,
+            storeId,
+            sessionId,
+            latitude.toLong(),
+            longitude.toLong(),
+            dateTimeStamp,
+            object : SDKCallback<String?> {
+                override fun onSuccess(response: String?) {
+                    promise.resolve(response)
+                }
+
+                override fun onError(exceptions: SDKExceptions) {
+                    promise.reject(exceptions)
+                }
+            })
+
+    }
+
+    @ReactMethod
+    fun logout(promise: Promise) {
+        InfiVizShotsSDK.logoutSDK(
+            reactContext,
+            object : OnInfivizShotsSDKLogoutListener {
+                override fun onInfivizShotsSDKLogoutSuccess() {
+                    promise.resolve("From Callback: SDK Logout success")
+                }
+
+                override fun onInfivizShotsSDKLogoutFailed(jsonObject: SDKExceptions) {
+                    promise.reject(jsonObject)
+                }
+            })
+    }
+
+    @ReactMethod
+    fun getIrResult(sessionId: String, promise: Promise) {
+        InfiVizShotsSDK.getIRResult(
+            reactContext,
+            sessionId,
+            object : SDKCallback<String> {
+                override fun onSuccess(p0: String) {
+                    promise.resolve(p0)
+                }
+
+                override fun onError(p0: SDKExceptions) {
+                    promise.reject(p0)
+                }
+            }
+        )
+    }
+
+    @ReactMethod
+    fun getActionsResult(sessionId: String, promise: Promise) {
+        InfiVizShotsSDK.getActionsResult(
+            reactContext,
+            sessionId,
+            object : SDKCallback<String> {
+                override fun onSuccess(p0: String) {
+                    promise.resolve(p0)
+                }
+
+                override fun onError(p0: SDKExceptions) {
+                    promise.reject(p0)
+                }
+            }
+        )
+    }
+
+    @ReactMethod
+    fun getSessionStatus(sessionId: String, promise: Promise) {
+        InfiVizShotsSDK.getSessionStatus(reactContext, sessionId, object : SessionStateListener {
+            override fun sessionState(p0: Int, p1: String) {
+                promise.resolve(Gson().toJson(SessionStatus(p0, p1)))
+            }
+
+            override fun error(p0: SDKExceptions) {
+                promise.reject(p0)
+            }
+        })
+    }
+
+    override fun initialize() {
+        val filter = IntentFilter("sync_callback_broadcast")
+        LocalBroadcastManager.getInstance(reactContext).registerReceiver(
+            syncCallbackBroadcast, filter
+        )
+        irResultCallback = object : IRResultAndActionsCallback {
+            override fun onCallback(
+                globalSessionId: String,
+                isSuccess: Boolean,
+                broadCastFor: ACTION_TYPE,
+                message: String
+            ) {
+                showCustomNotification(reactContext, globalSessionId)
+            }
+
+        }
+        InfiVizShotsSDK.setIRResultAndActionsCallback(irResultCallback)
+    }
+
+    override fun canOverrideExistingModule(): Boolean = true
+
+    override fun invalidate() {
+        LocalBroadcastManager.getInstance(reactContext).unregisterReceiver(syncCallbackBroadcast)
+        InfiVizShotsSDK.removeIRResultAndActionsCallback(irResultCallback)
+    }
+
+    override fun onActivityResult(
+        activity: Activity, requestCode: Int, resultCode: Int, data: Intent?
+    ) {
+        if (requestCode == 22 && resultCode == Activity.RESULT_OK) {
+            val tempSessionId = data!!.getStringExtra(IntentConstants.TEMP_SESSION_ID)
+            sendEventToReact(SDKEvent.CAMERA_EVENT, tempSessionId!!)
+        }
+    }
+
+    override fun onNewIntent(p0: Intent?) {
+    }
+
+
+    companion object {
+        const val NAME = "InfivizShotsReactSdk"
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.infilect.infivizshotsreactsdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import java.util.HashMap
+
+class InfivizShotsReactSdkPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(InfivizShotsReactSdkModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

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

@@ -0,0 +1,9 @@
+package com.infilect.infivizshotsreactsdk
+
+
+sealed class SDKEvent(val name: String) {
+
+    data object SYNC_EVENT : SDKEvent("SyncEvent")
+    data object RESULT_EVENT: SDKEvent("ResultEvent")
+    data object CAMERA_EVENT: SDKEvent("CameraEvent")
+}